Remove Instant v1 API.

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/bind.h"
 #include "base/command_line.h"
-#include "base/message_loop.h"
+#include "base/i18n/case_conversion.h"
 #include "base/metrics/histogram.h"
-#include "build/build_config.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
+#include "chrome/browser/history/history.h"
+#include "chrome/browser/history/history_service_factory.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/profiles/profile.h"
-#include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
-#include "chrome/browser/ui/blocked_content/blocked_content_tab_helper.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/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/focus/focus_manager.h"
-#include "ui/views/view.h"
 #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;
+
+std::string ModeToString(InstantController::Mode mode) {
+  switch (mode) {
+    case InstantController::INSTANT:  return "Instant";
+    case InstantController::SUGGEST:  return "Suggest";
+    case InstantController::HIDDEN:   return "Hidden";
+    case InstantController::SILENT:   return "Silent";
+  }
+
+  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);
+}
+
+}  // namespace
+
 InstantController::InstantController(InstantControllerDelegate* delegate,
                                      Mode mode)
     : delegate_(delegate),
-      is_displayable_(false),
-      is_out_of_date_(true),
-      commit_on_pointer_release_(false),
+      mode_(mode),
+      last_active_tab_(NULL),
+      last_verbatim_(false),
+      last_complete_behavior_(INSTANT_COMPLETE_NOW),
       last_transition_type_(content::PAGE_TRANSITION_LINK),
-      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
-      mode_(mode) {
-  DCHECK(mode_ == INSTANT || mode_ == SUGGEST || mode_ == HIDDEN ||
-         mode_ == SILENT);
+      is_showing_(false),
+      loader_processed_last_update_(false) {
 }
 
 InstantController::~InstantController() {
+  // We do this explicitly for two reasons: To Hide() if we are showing the
+  // preview, and for proper accounting of PREVIEW_DELETED in histograms.
+  DeleteLoader();
 }
 
 // static
 void InstantController::RegisterUserPrefs(PrefService* prefs) {
-  prefs->RegisterBooleanPref(prefs::kInstantConfirmDialogShown,
-                             false,
+  prefs->RegisterBooleanPref(prefs::kInstantConfirmDialogShown, false,
                              PrefService::SYNCABLE_PREF);
-  prefs->RegisterBooleanPref(prefs::kInstantEnabled,
-                             false,
+  prefs->RegisterBooleanPref(prefs::kInstantEnabled, false,
                              PrefService::SYNCABLE_PREF);
 
   // TODO(jamescook): Move this to search controller.
   prefs->RegisterDoublePref(prefs::kInstantAnimationScaleFactor,
                             1.0,
                             PrefService::UNSYNCABLE_PREF);
 }
 
 // static
-void InstantController::RecordMetrics(Profile* profile) {
-  UMA_HISTOGRAM_ENUMERATION("Instant.Status", IsEnabled(profile), 2);
-}
-
-// static
 bool InstantController::IsEnabled(Profile* profile) {
-  const PrefService* prefs = profile->GetPrefs();
+  const PrefService* prefs = profile ? profile->GetPrefs() : NULL;
   return prefs && prefs->GetBoolean(prefs::kInstantEnabled);
 }
 
-// static
-void InstantController::Enable(Profile* profile) {
-  PrefService* prefs = profile->GetPrefs();
-  if (!prefs)
-    return;
-
-  prefs->SetBoolean(prefs::kInstantEnabled, true);
-  prefs->SetBoolean(prefs::kInstantConfirmDialogShown, true);
-  UMA_HISTOGRAM_ENUMERATION("Instant.Preference", 1, 2);
-}
-
-// static
-void InstantController::Disable(Profile* profile) {
-  PrefService* prefs = profile->GetPrefs();
-  if (!prefs)
-    return;
-
-  prefs->SetBoolean(prefs::kInstantEnabled, false);
-  UMA_HISTOGRAM_ENUMERATION("Instant.Preference", 0, 2);
-}
-
 bool InstantController::Update(const AutocompleteMatch& match,
                                const string16& user_text,
                                bool verbatim,
-                               string16* suggested_text) {
-  suggested_text->clear();
+                               string16* suggested_text,
+                               InstantCompleteBehavior* complete_behavior) {
+  const TabContents* active_tab = delegate_->GetActiveTabContents();
 
-  is_out_of_date_ = false;
-  commit_on_pointer_release_ = false;
-  last_transition_type_ = match.transition;
-  last_url_ = match.destination_url;
-  last_user_text_ = user_text;
-
-  TabContents* tab_contents = delegate_->GetInstantHostTabContents();
-  if (!tab_contents) {
+  // We could get here with no active tab if the Browser is closing.
+  if (!active_tab) {
     Hide();
     return false;
   }
 
-  Profile* profile = tab_contents->profile();
-  const TemplateURL* template_url = match.GetTemplateURL(profile);
-  const TemplateURL* default_t_url =
-      TemplateURLServiceFactory::GetForProfile(profile)
-                                 ->GetDefaultSearchProvider();
-  if (!IsValidInstantTemplateURL(template_url) || !default_t_url ||
-      template_url->id() != default_t_url->id()) {
+  std::string instant_url;
+  Profile* profile = active_tab->profile();
+
+  // If the match's TemplateURL isn't valid, it is likely not a query.
+  if (!GetInstantURL(match.GetTemplateURL(profile), &instant_url)) {
     Hide();
     return false;
   }
 
-  if (!loader_.get() || loader_->template_url_id() != template_url->id())
-    loader_.reset(new InstantLoader(this, template_url->id(), std::string()));
+  string16 full_text = user_text + *suggested_text;
 
-  if (mode_ == SILENT) {
-    // For the SILENT mode, we process |user_text| at commit time.
-    loader_->MaybeLoadInstantURL(tab_contents, template_url);
+  if (full_text.empty()) {
+    Hide();
+    return false;
+  }
+
+  // The presence of any suggested_text implies verbatim.
+  DCHECK(suggested_text->empty() || verbatim)
+      << user_text << "|" << *suggested_text;
+
+  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;
+
+  last_user_text_ = user_text;
+
+  // Don't send an update to the loader if the query text hasn't changed.
+  if (full_text == last_full_text_ && verbatim == last_verbatim_) {
+    // Since we are updating |suggested_text|, shouldn't we also update
+    // |last_full_text_|? No. There's no guarantee that our suggestion will
+    // actually be inline autocompleted. For example, it may get trumped by
+    // a history suggestion. If our suggestion does make it, the omnibox will
+    // call Update() again, at which time we'll update |last_full_text_|.
+    *suggested_text = last_suggestion_;
+    *complete_behavior = last_complete_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)
+      Show();
     return true;
   }
 
-  UpdateLoader(tab_contents, template_url, match.destination_url,
-               match.transition, user_text, verbatim, suggested_text);
+  last_full_text_ = full_text;
+  last_verbatim_ = verbatim;
+  loader_processed_last_update_ = false;
 
-  content::NotificationService::current()->Notify(
-      chrome::NOTIFICATION_INSTANT_CONTROLLER_UPDATED,
-      content::Source<InstantController>(this),
-      content::NotificationService::NoDetails());
+  // Reset the last suggestion, as it's no longer valid.
+  suggested_text->clear();
+  last_suggestion_.clear();
+  *complete_behavior = last_complete_behavior_ = INSTANT_COMPLETE_NOW;
+
+  if (mode_ != SILENT) {
+    loader_->Update(last_full_text_, last_verbatim_);
+
+    content::NotificationService::current()->Notify(
+        chrome::NOTIFICATION_INSTANT_CONTROLLER_UPDATED,
+        content::Source<InstantController>(this),
+        content::NotificationService::NoDetails());
+  }
+
   return true;
 }
 
+// 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)
+  if (omnibox_bounds_ == bounds || mode_ != INSTANT)
     return;
 
-  // Always track the omnibox bounds. That way if Update is later invoked the
-  // bounds are in sync.
   omnibox_bounds_ = bounds;
-
-  if (loader_.get() && !is_out_of_date_ && mode_ == INSTANT)
-    loader_->SetOmniboxBounds(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);
+  }
 }
 
-void InstantController::DestroyPreviewContents() {
-  if (!loader_.get()) {
-    // We're not showing anything, nothing to do.
-    return;
-  }
-
-  if (is_displayable_) {
-    is_displayable_ = false;
-    delegate_->HideInstant();
-  }
-  delete ReleasePreviewContents(INSTANT_COMMIT_DESTROY, NULL);
+TabContents* InstantController::GetPreviewContents() const {
+  return loader_.get() ? loader_->preview_contents() : NULL;
 }
 
 void InstantController::Hide() {
-  is_out_of_date_ = true;
-  commit_on_pointer_release_ = false;
-  if (is_displayable_) {
-    is_displayable_ = false;
+  last_active_tab_ = NULL;
+  if (is_showing_) {
+    is_showing_ = false;
     delegate_->HideInstant();
   }
 }
 
 bool InstantController::IsCurrent() const {
-  // TODO(mmenke):  See if we can do something more intelligent in the
-  //                navigation pending case.
-  return is_displayable_ && !loader_->IsNavigationPending() &&
-      !loader_->needs_reload();
-}
-
-bool InstantController::PrepareForCommit() {
-  if (is_out_of_date_ || !loader_.get())
-    return false;
-
-  // If we are in the visible (INSTANT) mode, return the status of the preview.
-  if (mode_ == INSTANT)
-    return IsCurrent();
-
-  TabContents* tab_contents = delegate_->GetInstantHostTabContents();
-  if (!tab_contents)
-    return false;
-
-  const TemplateURL* template_url =
-      TemplateURLServiceFactory::GetForProfile(tab_contents->profile())
-                                 ->GetDefaultSearchProvider();
-  if (!IsValidInstantTemplateURL(template_url) ||
-      loader_->template_url_id() != template_url->id() ||
-      loader_->IsNavigationPending() ||
-      loader_->is_determining_if_page_supports_instant()) {
-    return false;
-  }
-
-  // In the SUGGEST and HIDDEN modes, we must have sent an Update() by now, so
-  // check if the loader failed to process it.
-  if ((mode_ == SUGGEST || mode_ == HIDDEN)
-      && (!loader_->ready() || !loader_->http_status_ok())) {
-    return false;
-  }
-
-  // Ignore the suggested text, as we are about to commit the verbatim query.
-  string16 suggested_text;
-  UpdateLoader(tab_contents, template_url, last_url_, last_transition_type_,
-               last_user_text_, true, &suggested_text);
-  return true;
+  DCHECK(IsOutOfDate() || GetPreviewContents());
+  return !IsOutOfDate() && GetPreviewContents() && loader_->supports_instant();
 }
 
 TabContents* InstantController::CommitCurrentPreview(InstantCommitType type) {
-  DCHECK(loader_.get());
-  TabContents* tab_contents = delegate_->GetInstantHostTabContents();
-  DCHECK(tab_contents);
-  TabContents* preview = ReleasePreviewContents(type, tab_contents);
+  const TabContents* active_tab = delegate_->GetActiveTabContents();
+  TabContents* preview = ReleasePreviewContents(type);
   preview->web_contents()->GetController().CopyStateFromAndPrune(
-      &tab_contents->web_contents()->GetController());
+      &active_tab->web_contents()->GetController());
   delegate_->CommitInstant(preview);
-  CompleteRelease(preview);
   return preview;
 }
 
-bool InstantController::CommitIfCurrent() {
-  if (IsCurrent()) {
-    CommitCurrentPreview(INSTANT_COMMIT_PRESSED_ENTER);
-    return true;
+TabContents* InstantController::ReleasePreviewContents(InstantCommitType type) {
+  TabContents* preview = loader_->ReleasePreviewContents(type, last_full_text_);
+
+  // Add a fake history entry with a non-Instant search URL, so that search
+  // terms extraction (for autocomplete history matches) works.
+  HistoryService* history = HistoryServiceFactory::GetForProfile(
+      preview->profile(), Profile::EXPLICIT_ACCESS);
+  if (history) {
+    history->AddPage(url_for_history_, NULL, 0, GURL(), last_transition_type_,

[Jered, 2012/07/31 22:36:02]

It feels weird that we add history even if this is not a commit. Why do we do
that?

[sreeram, 2012/07/31 23:13:19]

ReleasePreviewContents() is only called on a commit, either from
CommitCurrentPreview() or from BrowserInstantController::OpenInstant().

[Jered, 2012/08/01 21:56:45]

Having these two closely related methods (Commit and Release) seems confusing to
me. It seems like they both Commit, but with slightly different semantics.
Perhaps it would make sense to unify them into one Commit, or CommitAndRelease
method whose behavior is controlled by an argument.

This would make it clearer why e.g. Release* adds a preview usage tagged
PREVIEW_COMMITTED.

[sreeram, 2012/08/01 22:56:49]

Agreed. We're going to be doing just that when we land the URL previewing code
(Dominic's code). There, we pass a new "bool in_new_tab" when committing, so
that all the logic is unified into one method.

+                     history::RedirectList(), history::SOURCE_BROWSED, false);
   }
-  return false;
+
+  AddPreviewUsageForHistogram(mode_, PREVIEW_COMMITTED);
+
+  // We may have gotten here from CommitInstant(), which means the loader may
+  // still be on the stack. So, schedule a destruction for later.
+  MessageLoop::current()->DeleteSoon(FROM_HERE, loader_.release());
+
+  // This call is here to hide the preview and reset view state. It won't
+  // actually delete |loader_| because it was just released to DeleteSoon().
+  DeleteLoader();
+
+  return preview;
 }
 
-void InstantController::SetCommitOnPointerRelease() {
-  commit_on_pointer_release_ = true;
-}
+// TODO(sreeram): Since we never delete the loader except when committing
+// Instant, the loader may have a very stale page. Reload it when stale.
+void InstantController::OnAutocompleteLostFocus(
+    gfx::NativeView view_gaining_focus) {
+  DCHECK(!is_showing_ || GetPreviewContents());
 
-bool InstantController::IsPointerDownFromActivate() {
-  DCHECK(loader_.get());
-  return loader_->IsPointerDownFromActivate();
-}
+  // If the preview is not showing, nothing to do.
+  //
+  // If the preview is showing, we may get here with a NULL GetPreviewContents()
+  // in one case: When the user presses Enter, ReleasePreviewContents() is
+  // called, which releases the preview and calls delegate_->CommitInstant(),
+  // which ends up causing the omnibox to lose focus.
+  if (!is_showing_ || !GetPreviewContents())
+    return;
 
 #if defined(OS_MACOSX)
-void InstantController::OnAutocompleteLostFocus(
-    gfx::NativeView view_gaining_focus) {
-  // If |IsPointerDownFromActivate()| returns false, the RenderWidgetHostView
-  // did not receive a mouseDown event. Therefore, we should destroy the
-  // preview. Otherwise, the RWHV was clicked, so we commit the preview.
-  if (!IsCurrent() || !IsPointerDownFromActivate())
-    DestroyPreviewContents();
-  else
-    SetCommitOnPointerRelease();
-}
+  if (!loader_->IsPointerDownFromActivate())
+    Hide();
 #else
-void InstantController::OnAutocompleteLostFocus(
-    gfx::NativeView view_gaining_focus) {
-  if (!IsCurrent()) {
-    DestroyPreviewContents();
+  content::RenderWidgetHostView* rwhv =
+      GetPreviewContents()->web_contents()->GetRenderWidgetHostView();
+  if (!view_gaining_focus || !rwhv) {
+    Hide();
     return;
   }
 
-  content::RenderWidgetHostView* rwhv =
-      GetPreviewContents()->web_contents()->GetRenderWidgetHostView();
-  if (!view_gaining_focus || !rwhv) {
-    DestroyPreviewContents();
-    return;
-  }
-
 #if defined(TOOLKIT_VIEWS)
   // For views the top level widget is always focused. If the focus change
   // originated in views determine the child Widget from the view that is being
   // focused.
   views::Widget* widget =
       views::Widget::GetWidgetForNativeView(view_gaining_focus);
   if (widget) {
     views::FocusManager* focus_manager = widget->GetFocusManager();
     if (focus_manager && focus_manager->is_changing_focus() &&
         focus_manager->GetFocusedView() &&
         focus_manager->GetFocusedView()->GetWidget()) {
       view_gaining_focus =
           focus_manager->GetFocusedView()->GetWidget()->GetNativeView();
     }
   }
 #endif
 
   gfx::NativeView tab_view =
       GetPreviewContents()->web_contents()->GetNativeView();
+
   // Focus is going to the renderer.
   if (rwhv->GetNativeView() == view_gaining_focus ||
       tab_view == view_gaining_focus) {
-    if (!IsPointerDownFromActivate()) {
-      // If the mouse is not down, focus is not going to the renderer. Someone
-      // else moved focus and we shouldn't commit.
-      DestroyPreviewContents();
-      return;
-    }
 
-    // We're showing instant results. As instant results may shift when
-    // committing we commit on the mouse up. This way a slow click still works
-    // fine.
-    SetCommitOnPointerRelease();
+    // If the mouse is not down, focus is not going to the renderer. Someone
+    // else moved focus and we shouldn't commit.
+    if (!loader_->IsPointerDownFromActivate())
+      Hide();
+
     return;
   }
 
   // Walk up the view hierarchy. If the view gaining focus is a subview of the
   // WebContents view (such as a windowed plugin or http auth dialog), we want
   // to keep the preview contents. Otherwise, focus has gone somewhere else,
   // such as the JS inspector, and we want to cancel the preview.
   gfx::NativeView view_gaining_focus_ancestor = view_gaining_focus;
   while (view_gaining_focus_ancestor &&
          view_gaining_focus_ancestor != tab_view) {
     view_gaining_focus_ancestor =
         platform_util::GetParent(view_gaining_focus_ancestor);
   }
 
   if (view_gaining_focus_ancestor) {
     CommitCurrentPreview(INSTANT_COMMIT_FOCUS_LOST);
     return;
   }
 
-  DestroyPreviewContents();
-}
+  Hide();
 #endif
+}
 
 void InstantController::OnAutocompleteGotFocus() {
-  TabContents* tab_contents = delegate_->GetInstantHostTabContents();
-  if (!tab_contents)
-    return;
-
+  const TabContents* active_tab = delegate_->GetActiveTabContents();
+
+  // We could get here with no active tab if the Browser is closing.
+  if (!active_tab)
+    return;
+
+  // Since we don't have any autocomplete match to work with, we'll just use
+  // the default search provider's Instant URL.
   const TemplateURL* template_url =
-      TemplateURLServiceFactory::GetForProfile(tab_contents->profile())
-                                 ->GetDefaultSearchProvider();
-  if (!IsValidInstantTemplateURL(template_url))
-    return;
-
-  if (!loader_.get() || loader_->template_url_id() != template_url->id())
-    loader_.reset(new InstantLoader(this, template_url->id(), std::string()));
-  loader_->MaybeLoadInstantURL(tab_contents, template_url);
-}
-
-TabContents* InstantController::ReleasePreviewContents(
-    InstantCommitType type,
-    TabContents* current_tab) {
-  if (!loader_.get())
-    return NULL;
-
-  TabContents* tab = loader_->ReleasePreviewContents(type, current_tab);
-  ClearBlacklist();
-  is_out_of_date_ = true;
-  is_displayable_ = false;
-  commit_on_pointer_release_ = false;
-  omnibox_bounds_ = gfx::Rect();
-  loader_.reset();
-  return tab;
-}
-
-void InstantController::CompleteRelease(TabContents* tab) {
-  tab->blocked_content_tab_helper()->SetAllContentsBlocked(false);
-}
-
-TabContents* InstantController::GetPreviewContents() const {
-  return loader_.get() ? loader_->preview_contents() : NULL;
-}
-
-void InstantController::InstantStatusChanged(InstantLoader* loader) {
-  DCHECK(loader_.get());
-  UpdateIsDisplayable();
-}
-
-void InstantController::SetSuggestedTextFor(
+      TemplateURLServiceFactory::GetForProfile(active_tab->profile())->
+                                 GetDefaultSearchProvider();
+
+  std::string instant_url;
+  if (!GetInstantURL(template_url, &instant_url))
+    return;
+
+  ResetLoader(instant_url, active_tab);
+}
+
+bool InstantController::commit_on_pointer_release() const {
+  return GetPreviewContents() && loader_->IsPointerDownFromActivate();
+}
+
+void InstantController::SetSuggestions(
     InstantLoader* loader,
-    const string16& text,
+    const std::vector<string16>& suggestions,
     InstantCompleteBehavior behavior) {
-  if (is_out_of_date_)
-    return;
-
-  if (mode_ == INSTANT || mode_ == SUGGEST)
-    delegate_->SetSuggestedText(text, behavior);
-}
-
-gfx::Rect InstantController::GetInstantBounds() {
-  return delegate_->GetInstantBounds();
-}
-
-bool InstantController::ShouldCommitInstantOnPointerRelease() {
-  return commit_on_pointer_release_;
+  DCHECK_EQ(loader_.get(), loader);
+  if (loader_ != loader || IsOutOfDate() || mode_ == SILENT || mode_ == HIDDEN)
+    return;
+
+  loader_processed_last_update_ = true;
+
+  string16 suggestion;
+  if (!suggestions.empty()) {
+    suggestion = suggestions[0];
+  }
+
+  string16 suggestion_lower = base::i18n::ToLower(suggestion);
+  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.clear();
+  } else {
+    suggestion.erase(0, last_user_text_.size());
+  }
+
+  last_suggestion_ = suggestion;
+  last_complete_behavior_ = behavior;
+  if (!last_verbatim_)
+    delegate_->SetSuggestedText(suggestion, behavior);
+
+  if (mode_ != SUGGEST)
+    Show();
 }
 
 void InstantController::CommitInstantLoader(InstantLoader* loader) {
-  if (loader_.get() && loader_.get() == loader) {
-    CommitCurrentPreview(INSTANT_COMMIT_FOCUS_LOST);
+  DCHECK_EQ(loader_.get(), loader);
+  DCHECK(is_showing_ && !IsOutOfDate()) << is_showing_;
+  if (loader_ != loader || !is_showing_ || IsOutOfDate())
+    return;
+
+  CommitCurrentPreview(INSTANT_COMMIT_FOCUS_LOST);
+}
+
+void InstantController::InstantLoaderPreviewLoaded(InstantLoader* loader) {
+  DCHECK_EQ(loader_.get(), loader);
+  AddPreviewUsageForHistogram(mode_, PREVIEW_LOADED);
+}
+
+void InstantController::InstantSupportDetermined(InstantLoader* loader,
+                                                 bool supports_instant) {
+  DCHECK_EQ(loader_.get(), loader);
+  if (supports_instant) {
+    blacklisted_urls_.erase(loader->instant_url());
   } else {
-    // This can happen if the mouse was down, we swapped out the preview and
-    // the mouse was released. Generally this shouldn't happen, but if it does
-    // revert.
-    DestroyPreviewContents();
-  }
-}
-
-void InstantController::InstantLoaderDoesntSupportInstant(
-    InstantLoader* loader) {
-  VLOG(1) << "provider does not support instant";
-
-  // Don't attempt to use instant for this search engine again.
-  BlacklistFromInstant();
-}
-
-void InstantController::AddToBlacklist(InstantLoader* loader, const GURL& url) {
-  // Don't attempt to use instant for this search engine again.
-  BlacklistFromInstant();
+    ++blacklisted_urls_[loader->instant_url()];
+    if (loader_ == loader) {
+      if (GetPreviewContents())
+        AddPreviewUsageForHistogram(mode_, PREVIEW_DELETED);
+
+      // Because of the state of the stack, we can't destroy the loader now.
+      MessageLoop::current()->DeleteSoon(FROM_HERE, loader_.release());
+      DeleteLoader();
+    }
+  }
+
+  content::Details<const bool> details(&supports_instant);
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_INSTANT_SUPPORT_DETERMINED,
+      content::NotificationService::AllSources(),
+      details);
 }
 
 void InstantController::SwappedTabContents(InstantLoader* loader) {
-  if (is_displayable_)
-    delegate_->ShowInstant(loader->preview_contents());
-}
-
-void InstantController::InstantLoaderContentsFocused() {
+  DCHECK_EQ(loader_.get(), loader);
+  if (loader_ == loader && is_showing_)
+    delegate_->ShowInstant();
+}
+
+void InstantController::InstantLoaderContentsFocused(InstantLoader* loader) {
+  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 (mode_ == INSTANT)
+  if (is_showing_ && !IsOutOfDate())
     delegate_->InstantPreviewFocused();
 #endif
 }
 
-void InstantController::UpdateIsDisplayable() {
-  bool displayable = !is_out_of_date_ && loader_.get() && loader_->ready() &&
-                     loader_->http_status_ok();
-  if (displayable == is_displayable_ || mode_ != INSTANT)
-    return;
-
-  is_displayable_ = displayable;
-  if (!is_displayable_) {
-    delegate_->HideInstant();
-  } else {
-    delegate_->ShowInstant(loader_->preview_contents());
-    content::NotificationService::current()->Notify(
-        chrome::NOTIFICATION_INSTANT_CONTROLLER_SHOWN,
-        content::Source<InstantController>(this),
-        content::NotificationService::NoDetails());
-  }
-}
-
-void InstantController::UpdateLoader(TabContents* tab_contents,
-                                     const TemplateURL* template_url,
-                                     const GURL& url,
-                                     content::PageTransition transition_type,
-                                     const string16& user_text,
-                                     bool verbatim,
-                                     string16* suggested_text) {
-  if (mode_ == INSTANT)
-    loader_->SetOmniboxBounds(omnibox_bounds_);
-  loader_->Update(tab_contents, template_url, url, transition_type, user_text,
-                  verbatim, suggested_text);
-  UpdateIsDisplayable();
-  // For the HIDDEN and SILENT modes, don't send back suggestions.
-  if (mode_ == HIDDEN || mode_ == SILENT)
-    suggested_text->clear();
-}
-
-// Returns true if |template_url| is a valid TemplateURL for use by instant.
-bool InstantController::IsValidInstantTemplateURL(
-    const TemplateURL* template_url) {
-  return template_url && template_url->id() &&
-      template_url->instant_url_ref().SupportsReplacement() &&
-      !IsBlacklistedFromInstant(template_url->id());
-}
-
-void InstantController::BlacklistFromInstant() {
-  if (!loader_.get())
-    return;
-
-  DCHECK(loader_->template_url_id());
-  blacklisted_ids_.insert(loader_->template_url_id());
-
-  // Because of the state of the stack we can't destroy the loader now.
-  ScheduleDestroy(loader_.release());
-  UpdateIsDisplayable();
-}
-
-bool InstantController::IsBlacklistedFromInstant(TemplateURLID id) {
-  return blacklisted_ids_.count(id) > 0;
-}
-
-void InstantController::ClearBlacklist() {
-  blacklisted_ids_.clear();
-}
-
-void InstantController::ScheduleDestroy(InstantLoader* loader) {
-  loaders_to_destroy_.push_back(loader);
-  if (!weak_factory_.HasWeakPtrs()) {
-    MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(&InstantController::DestroyLoaders,
-                              weak_factory_.GetWeakPtr()));
-  }
-}
-
-void InstantController::DestroyLoaders() {
-  loaders_to_destroy_.clear();
-}
+void InstantController::ResetLoader(const std::string& instant_url,
+                                    const TabContents* active_tab) {
+  if (GetPreviewContents() && loader_->instant_url() != instant_url)
+    DeleteLoader();
+
+  if (!GetPreviewContents()) {
+    loader_.reset(new InstantLoader(this, instant_url, active_tab));
+    loader_->Init();
+    AddPreviewUsageForHistogram(mode_, PREVIEW_CREATED);
+  }
+}
+
+void InstantController::DeleteLoader() {
+  Hide();
+  last_full_text_.clear();
+  last_user_text_.clear();
+  last_verbatim_ = false;
+  last_suggestion_.clear();
+  last_complete_behavior_ = INSTANT_COMPLETE_NOW;
+  last_transition_type_ = content::PAGE_TRANSITION_LINK;
+  last_omnibox_bounds_ = gfx::Rect();
+  url_for_history_ = GURL();
+  if (GetPreviewContents())
+    AddPreviewUsageForHistogram(mode_, PREVIEW_DELETED);
+  loader_.reset();
+}
+
+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()) {
+    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());
+  }
+
+  // In the current Chrome UI, these must always be true so they sanity check
+  // the above operations. In a future UI, these may be removed or adjusted.
+  // There is no point in sanity-checking |intersection.y()| because the omnibox
+  // can be placed anywhere vertically relative to the preview (for example, in
+  // Mac fullscreen mode, the omnibox is fully enclosed by the preview bounds).
+  DCHECK_LE(0, intersection.x());
+  DCHECK_LE(0, intersection.width());
+  DCHECK_LE(0, intersection.height());
+
+  loader_->SetOmniboxBounds(intersection);
+}
+
+bool InstantController::GetInstantURL(const TemplateURL* template_url,
+                                      std::string* instant_url) const {
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kInstantURL)) {
+    *instant_url = command_line->GetSwitchValueASCII(switches::kInstantURL);
+    return true;
+  }
+
+  if (!template_url)
+    return false;
+
+  const TemplateURLRef& instant_url_ref = template_url->instant_url_ref();
+  if (!instant_url_ref.IsValid() || !instant_url_ref.SupportsReplacement())
+    return false;
+
+  *instant_url = instant_url_ref.ReplaceSearchTerms(
+      TemplateURLRef::SearchTermsArgs(string16()));
+
+  std::map<std::string, int>::const_iterator iter =
+      blacklisted_urls_.find(*instant_url);
+  if (iter != blacklisted_urls_.end() &&
+      iter->second > kMaxInstantSupportFailures) {
+    instant_url->clear();
+    return false;
+  }
+
+  return true;
+}
+
+bool InstantController::IsOutOfDate() const {
+  return !last_active_tab_ ||
+         last_active_tab_ != delegate_->GetActiveTabContents();
+}