Centralize logic around Instant modes.

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/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"
 #include "ui/gfx/codec/png_codec.h"
@@ skipping 21 matching lines @@
 // 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::EXTENDED: return "_Extended";
+    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(
@@ skipping 24 matching lines @@
          ++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)) {
+    if (chrome::search::IsInstantExtendedAPIEnabled(profile))
+      return InstantController::EXTENDED;
+    return InstantController::INSTANT;
+  }
+  return InstantController::DISABLED;
+}
+
+
 }  // namespace
 
-InstantController::InstantController(InstantControllerDelegate* delegate,
-                                     Mode mode)
-    : delegate_(delegate),
-      mode_(mode),
-      last_active_tab_(NULL),
-      last_verbatim_(false),
-      last_transition_type_(content::PAGE_TRANSITION_LINK),
-      is_showing_(false),
-      loader_processed_last_update_(false) {
-}
-
-InstantController::~InstantController() {
-  if (GetPreviewContents())
-    AddPreviewUsageForHistogram(mode_, PREVIEW_DELETED);
+// static
+bool InstantController::IsExtendedAPIEnabled(Profile* profile) {
+  const Mode mode = GetModeForProfile(profile);

[sky, 2012/08/30 22:33:13]

nit: combine these two lines, eg return GetM... == EXTENDED

[sreeram, 2012/08/30 23:23:51]

Done.

+  return mode == 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,
+  prefs->RegisterDoublePref(prefs::kInstantAnimationScaleFactor, 1.0,
                             PrefService::UNSYNCABLE_PREF);
 }
 
 // static
-bool InstantController::IsEnabled(Profile* profile) {
-  const PrefService* prefs = profile ? profile->GetPrefs() : NULL;
-  return prefs && prefs->GetBoolean(prefs::kInstantEnabled);
+InstantController* InstantController::GetInstance(
+    Profile* profile,
+    InstantControllerDelegate* delegate) {
+  const Mode mode = GetModeForProfile(profile);
+  return mode == DISABLED ? NULL : new InstantController(delegate, mode);
+}
+
+InstantController::~InstantController() {
+  if (GetPreviewContents())
+    AddPreviewUsageForHistogram(mode_, PREVIEW_DELETED);
 }
 
 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) {
@@ skipping 18 matching lines @@
   ResetLoader(instant_url, active_tab);
   last_active_tab_ = active_tab;
 
   // Track the non-Instant search URL for this query.
   url_for_history_ = match.destination_url;
   last_transition_type_ = match.transition;
 
   // 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_;
+  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:
@@ skipping 330 matching lines @@
   DCHECK_EQ(loader_.get(), loader);
   DCHECK(is_showing_ && !IsOutOfDate()) << is_showing_;
 #if defined(USE_AURA)
   // On aura the omnibox only receives a focus lost if we initiate the focus
   // change. This does that.
   if (is_showing_ && !IsOutOfDate())
     delegate_->InstantPreviewFocused();
 #endif
 }
 
+InstantController::InstantController(InstantControllerDelegate* delegate,
+                                     Mode mode)
+    : delegate_(delegate),
+      mode_(mode),
+      last_active_tab_(NULL),
+      last_verbatim_(false),
+      last_transition_type_(content::PAGE_TRANSITION_LINK),
+      is_showing_(false),
+      loader_processed_last_update_(false) {
+}
+
 void InstantController::ResetLoader(const std::string& instant_url,
                                     const TabContents* active_tab) {
   if (GetPreviewContents() && loader_->instant_url() != instant_url)
     DeleteLoader();
 
   if (!GetPreviewContents()) {
     DCHECK(!loader_.get());
     loader_.reset(new InstantLoader(this, instant_url, active_tab));
     loader_->Init();
     AddPreviewUsageForHistogram(mode_, PREVIEW_CREATED);
@@ skipping 139 matching lines @@
     return false;
   }
 
   return true;
 }
 
 bool InstantController::IsOutOfDate() const {
   return !last_active_tab_ ||
          last_active_tab_ != delegate_->GetActiveTabContents();
 }