Remove unused / unnecessary stuff from Instant.

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/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete_provider.h"
 #include "chrome/browser/google/google_util.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/browser_instant_controller.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"
@@ skipping 26 matching lines @@
 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;
@@ skipping 70 matching lines @@
 }  // namespace
 
 InstantController::~InstantController() {
   if (GetPreviewContents())
     AddPreviewUsageForHistogram(mode_, PREVIEW_DELETED);
 }
 
 // static
 InstantController* InstantController::CreateInstant(
     Profile* profile,
-    InstantControllerDelegate* delegate) {
+    chrome::BrowserInstantController* browser) {
   const Mode mode = GetModeForProfile(profile);
-  return mode == DISABLED ? NULL : new InstantController(delegate, mode);
+  return mode == DISABLED ? NULL : new InstantController(browser, 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);
 }
 
 bool InstantController::Update(const AutocompleteMatch& match,
                                const string16& user_text,
                                const string16& full_text,
                                bool verbatim) {
-  const TabContents* active_tab = delegate_->GetActiveTabContents();
+  const TabContents* active_tab = browser_->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();
 
@@ skipping 23 matching lines @@
   // 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_->SetInstantSuggestion(last_suggestion_);
+    browser_->SetInstantSuggestion(last_suggestion_);
 
     // 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))
+    if (loader_processed_last_update_)
       Show(100, INSTANT_SIZE_PERCENT);
     return true;
   }
 
   last_verbatim_ = verbatim;
   loader_processed_last_update_ = false;
   last_suggestion_ = InstantSuggestion();
 
-  if (mode_ != SILENT) {
-    loader_->Update(query_text, verbatim);
+  loader_->Update(query_text, verbatim);
 
-    content::NotificationService::current()->Notify(
-        chrome::NOTIFICATION_INSTANT_CONTROLLER_UPDATED,
-        content::Source<InstantController>(this),
-        content::NotificationService::NoDetails());
-  }
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_INSTANT_CONTROLLER_UPDATED,
+      content::Source<InstantController>(this),
+      content::NotificationService::NoDetails());
 
   // We don't have suggestions yet, but need to reset any existing "gray text".
-  delegate_->SetInstantSuggestion(InstantSuggestion());
+  browser_->SetInstantSuggestion(InstantSuggestion());
 
   // Though we may have handled a URL match above, we return false here, so that
   // omnibox prerendering can kick in. TODO(sreeram): Remove this (and always
   // return true) once we are able to commit URLs as well.
   return last_match_was_search_;
 }
 
 // TODO(tonyg): This method only fires when the omnibox bounds change. It also
 // needs to fire when the preview bounds change (e.g.: open/close info bar).
 void InstantController::SetOmniboxBounds(const gfx::Rect& bounds) {
-  if (omnibox_bounds_ == bounds || (mode_ != INSTANT && mode_ != EXTENDED))
+  if (omnibox_bounds_ == bounds)
     return;
 
   omnibox_bounds_ = bounds;
   if (omnibox_bounds_.height() > last_omnibox_bounds_.height()) {
     update_bounds_timer_.Stop();
     SendBoundsToPage();
   } else if (!update_bounds_timer_.IsRunning()) {
     update_bounds_timer_.Start(FROM_HERE,
         base::TimeDelta::FromMilliseconds(kUpdateBoundsDelayMS), this,
         &InstantController::SendBoundsToPage);
@@ skipping 113 matching lines @@
   // still be on the stack. So, schedule a destruction for later.
   MessageLoop::current()->DeleteSoon(FROM_HERE, loader_.release());
 
   // This call is here to reset view state. It won't actually delete |loader_|
   // because it was just released to DeleteSoon().
   DeleteLoader();
 
   preview->web_contents()->GetController().PruneAllButActive();
 
   if (type != INSTANT_COMMIT_PRESSED_ALT_ENTER) {
-    const TabContents* active_tab = delegate_->GetActiveTabContents();
+    const TabContents* active_tab = browser_->GetActiveTabContents();
     AddSessionStorageHistogram(mode_, active_tab, preview);
     preview->web_contents()->GetController().CopyStateFromAndPrune(
         &active_tab->web_contents()->GetController());
   }
 
-  // Delegate takes ownership of the preview.
-  delegate_->CommitInstant(preview, type == INSTANT_COMMIT_PRESSED_ALT_ENTER);
+  // Browser takes ownership of the preview.
+  browser_->CommitInstant(preview, type == INSTANT_COMMIT_PRESSED_ALT_ENTER);
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_INSTANT_COMMITTED,
       content::Source<content::WebContents>(preview->web_contents()),
       content::NotificationService::NoDetails());
 
   // Try to create another loader immediately so that it is ready for the next
   // user interaction.
   CreateDefaultLoader();
 }
@@ skipping 96 matching lines @@
     loader_->OnActiveTabModeChanged(active_tab_is_ntp_);
 }
 
 bool InstantController::commit_on_pointer_release() const {
   return GetPreviewContents() && loader_->IsPointerDownFromActivate();
 }
 
 void InstantController::SetSuggestions(
     InstantLoader* loader,
     const std::vector<InstantSuggestion>& suggestions) {
-  if (loader_ != loader || IsOutOfDate() || mode_ == SILENT || mode_ == HIDDEN)
+  if (loader_ != loader || IsOutOfDate())
     return;
 
   loader_processed_last_update_ = true;
 
   InstantSuggestion suggestion;
   if (!suggestions.empty())
     suggestion = suggestions[0];
 
   if (suggestion.behavior == INSTANT_COMPLETE_REPLACE) {
     // We don't get an Update() when changing the omnibox due to a REPLACE
     // suggestion (so that we don't inadvertently cause the preview to change
     // what it's showing, as the user arrows up/down through the page-provided
     // suggestions). So, update these state variables here.
     last_full_text_ = suggestion.text;
     last_user_text_.clear();
     last_verbatim_ = true;
     last_suggestion_ = InstantSuggestion();
     last_match_was_search_ = suggestion.type == INSTANT_SUGGESTION_SEARCH;
-    delegate_->SetInstantSuggestion(suggestion);
+    browser_->SetInstantSuggestion(suggestion);
   } else {
     // Suggestion text should be a full URL for URL suggestions, or the
     // completion of a query for query suggestions.
     if (suggestion.type == INSTANT_SUGGESTION_URL) {
       if (!StartsWith(suggestion.text, ASCIIToUTF16("http://"), false) &&
           !StartsWith(suggestion.text, ASCIIToUTF16("https://"), false))
         suggestion.text = ASCIIToUTF16("http://") + suggestion.text;
     } else if (StartsWith(suggestion.text, last_user_text_, true)) {
       // The user typed an exact prefix of the suggestion.
       suggestion.text.erase(0, last_user_text_.size());
     } else if (!NormalizeAndStripPrefix(&suggestion.text, last_user_text_)) {
       // Unicode normalize and case-fold the user text and suggestion. If the
       // user text is a prefix, suggest the normalized, case-folded completion;
       // for instance, if the user types 'i' and the suggestion is 'INSTANT',
       // suggestion 'nstant'. Otherwise, the user text really isn't a prefix,
       // so suggest nothing.
       suggestion.text.clear();
     }
 
     last_suggestion_ = suggestion;
 
     // Set the suggested text if the suggestion behavior is
     // INSTANT_COMPLETE_NEVER irrespective of verbatim because in this case
     // the suggested text does not get committed if the user presses enter.
     if (suggestion.behavior == INSTANT_COMPLETE_NEVER || !last_verbatim_)
-      delegate_->SetInstantSuggestion(suggestion);
+      browser_->SetInstantSuggestion(suggestion);
   }
 
-  if (mode_ != SUGGEST)
-    Show(100, INSTANT_SIZE_PERCENT);
+  Show(100, INSTANT_SIZE_PERCENT);
 }
 
 void InstantController::CommitInstantLoader(InstantLoader* loader) {
   if (loader_ != loader || !model_.is_ready() || IsOutOfDate())
     return;
 
   CommitCurrentPreview(INSTANT_COMMIT_FOCUS_LOST);
 }
 
 void InstantController::ShowInstantPreview(InstantLoader* loader,
@@ skipping 39 matching lines @@
 void InstantController::SwappedTabContents(InstantLoader* loader) {
   if (loader_ == loader)
     model_.SetPreviewContents(GetPreviewContents());
 }
 
 void InstantController::InstantLoaderContentsFocused(InstantLoader* loader) {
 #if defined(USE_AURA)
   // On aura the omnibox only receives a focus lost if we initiate the focus
   // change. This does that.
   if (model_.is_ready() && !IsOutOfDate())
-    delegate_->InstantPreviewFocused();
+    browser_->InstantPreviewFocused();
 #endif
 }
 
-InstantController::InstantController(InstantControllerDelegate* delegate,
+InstantController::InstantController(chrome::BrowserInstantController* browser,
                                      Mode mode)
-    : delegate_(delegate),
+    : browser_(browser),
       model_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       mode_(mode),
       last_active_tab_(NULL),
       last_verbatim_(false),
       last_transition_type_(content::PAGE_TRANSITION_LINK),
       last_match_was_search_(false),
       loader_processed_last_update_(false),
       is_omnibox_focused_(false),
       active_tab_is_ntp_(false) {
 }
@@ skipping 17 matching lines @@
     // Reset the loader timer.
     stale_loader_timer_.Stop();
     stale_loader_timer_.Start(
         FROM_HERE,
         base::TimeDelta::FromMilliseconds(kStaleLoaderTimeoutMS), this,
         &InstantController::OnStaleLoader);
   }
 }
 
 bool InstantController::CreateDefaultLoader() {
-  const TabContents* active_tab = delegate_->GetActiveTabContents();
+  const TabContents* active_tab = browser_->GetActiveTabContents();
 
   // We could get here with no active tab if the Browser is closing.
   if (!active_tab)
     return false;
 
   const TemplateURL* template_url =
       TemplateURLServiceFactory::GetForProfile(active_tab->profile())->
                                  GetDefaultSearchProvider();
   const GURL& tab_url = active_tab->web_contents()->GetURL();
   std::string instant_url;
@@ skipping 41 matching lines @@
     AddPreviewUsageForHistogram(mode_, PREVIEW_SHOWED);
   model_.SetDisplayState(InstantModel::QUERY_RESULTS, height, units);
 }
 
 void InstantController::SendBoundsToPage() {
   if (last_omnibox_bounds_ == omnibox_bounds_ || IsOutOfDate() ||
       !GetPreviewContents() || loader_->IsPointerDownFromActivate())
     return;
 
   last_omnibox_bounds_ = omnibox_bounds_;
-  gfx::Rect preview_bounds = delegate_->GetInstantBounds();
+  gfx::Rect preview_bounds = browser_->GetInstantBounds();
   gfx::Rect intersection = omnibox_bounds_;
   intersection.Intersect(preview_bounds);
 
   // Translate into window coordinates.
   if (!intersection.IsEmpty()) {
     intersection.Offset(-preview_bounds.origin().x(),
                         -preview_bounds.origin().y());
   }
 
   // In the current Chrome UI, these must always be true so they sanity check
@@ skipping 56 matching lines @@
       blacklisted_urls_.find(*instant_url);
   if (iter != blacklisted_urls_.end() &&
       iter->second > kMaxInstantSupportFailures)
     return false;
 
   return true;
 }
 
 bool InstantController::IsOutOfDate() const {
   return !last_active_tab_ ||
-         last_active_tab_ != delegate_->GetActiveTabContents();
+         last_active_tab_ != browser_->GetActiveTabContents();
 }