chrome/browser/instant/instant_controller.cc

// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/browser/instant/instant_controller.h"

#include "base/command_line.h"
#include "base/i18n/case_conversion.h"
#include "base/metrics/histogram.h"
#include "base/time.h"
#include "base/utf_string_conversions.h"
#include "chrome/browser/autocomplete/autocomplete_provider.h"
#include "chrome/browser/favicon/favicon_service_factory.h"
#include "chrome/browser/history/history.h"
#include "chrome/browser/history/history_service_factory.h"
#include "chrome/browser/history/history_tab_helper.h"
#include "chrome/browser/instant/instant_controller_delegate.h"
#include "chrome/browser/instant/instant_loader.h"
#include "chrome/browser/platform_util.h"
#include "chrome/browser/prefs/pref_service.h"
#include "chrome/browser/search_engines/template_url_service.h"
#include "chrome/browser/search_engines/template_url_service_factory.h"
#include "chrome/browser/ui/search/search.h"
#include "chrome/browser/ui/tab_contents/tab_contents.h"
#include "chrome/common/chrome_notification_types.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/common/pref_names.h"
#include "content/public/browser/favicon_status.h"
#include "content/public/browser/navigation_entry.h"
#include "content/public/browser/notification_service.h"
#include "content/public/browser/render_widget_host_view.h"
#include "content/public/browser/web_contents.h"

#if defined(TOOLKIT_VIEWS)
#include "ui/views/widget/widget.h"
#endif

namespace {

enum PreviewUsageType {
  PREVIEW_CREATED = 0,
  PREVIEW_DELETED,
  PREVIEW_LOADED,
  PREVIEW_SHOWED,
  PREVIEW_COMMITTED,
  PREVIEW_NUM_TYPES,
};

// An artificial delay (in milliseconds) we introduce before telling the Instant
// page about the new omnibox bounds, in cases where the bounds shrink. This is
// to avoid the page jumping up/down very fast in response to bounds changes.
const int kUpdateBoundsDelayMS = 1000;

// The maximum number of times we'll load a non-Instant-supporting search engine
// before we give up and blacklist it for the rest of the browsing session.
const int kMaxInstantSupportFailures = 10;

// If an Instant page has not been used in these many milliseconds, it is
// reloaded so that the page does not become stale.
const int kStaleLoaderTimeoutMS = 3 * 3600 * 1000;

std::string ModeToString(InstantController::Mode mode) {
  switch (mode) {
    case InstantController::EXTENDED: return "_Extended";
    case InstantController::INSTANT:  return "_Instant";
    case InstantController::SUGGEST:  return "_Suggest";
    case InstantController::HIDDEN:   return "_Hidden";
    case InstantController::SILENT:   return "_Silent";
    case InstantController::DISABLED: return "_Disabled";
  }

  NOTREACHED();
  return std::string();
}

void AddPreviewUsageForHistogram(InstantController::Mode mode,
                                 PreviewUsageType usage) {
  DCHECK(0 <= usage && usage < PREVIEW_NUM_TYPES) << usage;
  base::Histogram* histogram = base::LinearHistogram::FactoryGet(
      "Instant.Previews" + ModeToString(mode), 1, PREVIEW_NUM_TYPES,
      PREVIEW_NUM_TYPES + 1, base::Histogram::kUmaTargetedHistogramFlag);
  histogram->Add(usage);
}

void AddSessionStorageHistogram(InstantController::Mode mode,
                                const TabContents* tab1,
                                const TabContents* tab2) {
  base::Histogram* histogram = base::BooleanHistogram::FactoryGet(
      "Instant.SessionStorageNamespace" + ModeToString(mode),
      base::Histogram::kUmaTargetedHistogramFlag);
  const content::SessionStorageNamespaceMap& session_storage_map1 =
      tab1->web_contents()->GetController().GetSessionStorageNamespaceMap();
  const content::SessionStorageNamespaceMap& session_storage_map2 =
      tab2->web_contents()->GetController().GetSessionStorageNamespaceMap();
  bool is_session_storage_the_same =
      session_storage_map1.size() == session_storage_map2.size();
  if (is_session_storage_the_same) {
    // The size is the same, so let's check that all entries match.
    for (content::SessionStorageNamespaceMap::const_iterator
             it1 = session_storage_map1.begin(),
             it2 = session_storage_map2.begin();
         it1 != session_storage_map1.end() &&
             it2 != session_storage_map2.end();
         ++it1, ++it2) {
      if (it1->first != it2->first || it1->second != it2->second) {
        is_session_storage_the_same = false;
        break;
      }
    }
  }
  histogram->AddBoolean(is_session_storage_the_same);
}

InstantController::Mode GetModeForProfile(Profile* profile) {
  if (!profile || profile->IsOffTheRecord() || !profile->GetPrefs() ||
      !profile->GetPrefs()->GetBoolean(prefs::kInstantEnabled))
    return InstantController::DISABLED;

  return chrome::search::IsInstantExtendedAPIEnabled(profile) ?
      InstantController::EXTENDED : InstantController::INSTANT;
}

}  // namespace

InstantController::~InstantController() {
  if (GetPreviewContents())
    AddPreviewUsageForHistogram(mode_, PREVIEW_DELETED);
}

// static
InstantController* InstantController::CreateInstant(
    Profile* profile,
    InstantControllerDelegate* delegate) {
  const Mode mode = GetModeForProfile(profile);
  return mode == DISABLED ? NULL : new InstantController(delegate, mode);
}

// static
bool InstantController::IsExtendedAPIEnabled(Profile* profile) {
  return GetModeForProfile(profile) == EXTENDED;
}

// static
bool InstantController::IsInstantEnabled(Profile* profile) {
  const Mode mode = GetModeForProfile(profile);
  return mode == EXTENDED || mode == INSTANT;
}

// static
bool InstantController::IsSuggestEnabled(Profile* profile) {
  const Mode mode = GetModeForProfile(profile);
  return mode == EXTENDED || mode == INSTANT || mode == SUGGEST;
}

// static
void InstantController::RegisterUserPrefs(PrefService* prefs) {
  prefs->RegisterBooleanPref(prefs::kInstantConfirmDialogShown, false,
                             PrefService::SYNCABLE_PREF);
  prefs->RegisterBooleanPref(prefs::kInstantEnabled, false,
                             PrefService::SYNCABLE_PREF);

  // TODO(jamescook): Move this to search controller.
  prefs->RegisterDoublePref(prefs::kInstantAnimationScaleFactor, 1.0,
                            PrefService::UNSYNCABLE_PREF);
}

bool InstantController::Update(const AutocompleteMatch& match,
                               const string16& user_text,
                               const string16& full_text,
                               bool verbatim) {
  const TabContents* active_tab = delegate_->GetActiveTabContents();

  // We could get here with no active tab if the Browser is closing.
  if (!active_tab) {
    Hide();
    return false;
  }

  std::string instant_url;
  Profile* profile = active_tab->profile();

  // If the match's TemplateURL is valid, it's a search query; use it. If it's
  // not valid, it's likely a URL; in EXTENDED mode, try using the default
  // search engine's TemplateURL instead.
  const GURL& tab_url = active_tab->web_contents()->GetURL();
  if (GetInstantURL(match.GetTemplateURL(profile), tab_url, &instant_url)) {
    ResetLoader(instant_url, active_tab);
  } else if (mode_ != EXTENDED || !CreateDefaultLoader()) {
    Hide();
    return false;
  }

  if (full_text.empty()) {
    Hide();
    return false;
  }

  // Track the non-Instant search URL for this query.
  url_for_history_ = match.destination_url;
  last_transition_type_ = match.transition;
  last_active_tab_ = active_tab;
  last_match_was_search_ = AutocompleteMatch::IsSearchType(match.type);

  // In EXTENDED mode, we send only |user_text| as the query text. In all other
  // modes, we use the entire |full_text|.
  const string16& query_text = mode_ == EXTENDED ? user_text : full_text;
  string16 last_query_text = mode_ == EXTENDED ?
      last_user_text_ : last_full_text_;
  last_user_text_ = user_text;
  last_full_text_ = full_text;

  // Don't send an update to the loader if the query text hasn't changed.
  if (query_text == last_query_text && verbatim == last_verbatim_) {
    // Reuse the last suggestion, as it's still valid.
    delegate_->SetSuggestedText(last_suggestion_.text,
                                last_suggestion_.behavior);

    // We need to call Show() here because of this:
    // 1. User has typed a query (say Q). Instant overlay is showing results.
    // 2. User arrows-down to a URL entry or erases all omnibox text. Both of
    //    these cause the overlay to Hide().
    // 3. User arrows-up to Q or types Q again. The last text we processed is
    //    still Q, so we don't Update() the loader, but we do need to Show().
    if (loader_processed_last_update_ &&
        (mode_ == INSTANT || mode_ == EXTENDED))
      Show(100, INSTANT_SIZE_PERCENT);
    return true;
  }

  last_verbatim_ = verbatim;
  loader_processed_last_update_ = false;