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))
+    return InstantController::DISABLED;
+
+  return chrome::search::IsInstantExtendedAPIEnabled(profile) ?
+      InstantController::EXTENDED : InstantController::INSTANT;
+}
+
 }  // 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
+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,
+  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);
-}
-
 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;
@@ skipping 16 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:
     // 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)) {
+        (mode_ == INSTANT || mode_ == EXTENDED))
       Show();
-    }
     return true;
   }
 
   last_verbatim_ = verbatim;
   loader_processed_last_update_ = false;
   last_suggestion_ = InstantSuggestion();
 
   if (mode_ != SILENT) {
     loader_->Update(query_text, verbatim);
 
@@ skipping 242 matching lines @@
 
   loader_processed_last_update_ = true;
 
   InstantSuggestion suggestion;
   if (!suggestions.empty())
     suggestion = suggestions[0];
 
   string16 suggestion_lower = base::i18n::ToLower(suggestion.text);
   string16 user_text_lower = base::i18n::ToLower(last_user_text_);
   if (user_text_lower.size() >= suggestion_lower.size() ||
-      suggestion_lower.compare(0, user_text_lower.size(), user_text_lower)) {
+      suggestion_lower.compare(0, user_text_lower.size(), user_text_lower))
     suggestion.text.clear();
-  } else {
+  else
     suggestion.text.erase(0, last_user_text_.size());
-  }
 
   last_suggestion_ = suggestion;
   if (!last_verbatim_)
     delegate_->SetSuggestedText(suggestion.text, suggestion.behavior);
 
   if (mode_ != SUGGEST)
     Show();
 }
 
 void InstantController::CommitInstantLoader(InstantLoader* loader) {
@@ skipping 44 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 56 matching lines @@
 void InstantController::Show() {
   if (!is_showing_) {
     is_showing_ = true;
     delegate_->ShowInstant();
     AddPreviewUsageForHistogram(mode_, PREVIEW_SHOWED);
   }
 }
 
 void InstantController::SendBoundsToPage() {
   if (last_omnibox_bounds_ == omnibox_bounds_ || IsOutOfDate() ||
-      !GetPreviewContents() || loader_->IsPointerDownFromActivate()) {
+      !GetPreviewContents() || loader_->IsPointerDownFromActivate())
     return;
-  }
 
   last_omnibox_bounds_ = omnibox_bounds_;
   gfx::Rect preview_bounds = delegate_->GetInstantBounds();
   gfx::Rect intersection = omnibox_bounds_.Intersect(preview_bounds);
 
   // Translate into window coordinates.
   if (!intersection.IsEmpty()) {
     intersection.Offset(-preview_bounds.origin().x(),
                         -preview_bounds.origin().y());
   }
@@ skipping 49 matching lines @@
       if (!url_obj.is_valid())
         return false;
 
       *instant_url = url_obj.spec();
     }
   }
 
   std::map<std::string, int>::const_iterator iter =
       blacklisted_urls_.find(*instant_url);
   if (iter != blacklisted_urls_.end() &&
-      iter->second > kMaxInstantSupportFailures) {
+      iter->second > kMaxInstantSupportFailures)
     return false;
-  }
 
   return true;
 }
 
 bool InstantController::IsOutOfDate() const {
   return !last_active_tab_ ||
          last_active_tab_ != delegate_->GetActiveTabContents();
 }