Upstream rewrite of 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 <string>
+
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/i18n/case_conversion.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
+#include "base/string16.h"
 #include "build/build_config.h"
 #include "chrome/browser/autocomplete/autocomplete_match.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/search/search_model.h"
+#include "chrome/browser/ui/search/search_tab_helper.h"
+#include "chrome/browser/ui/search/search_types.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),
-      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);
+      mode_(mode),
+      last_tab_contents_(NULL),
+      last_verbatim_(false),
+      last_complete_behavior_(INSTANT_COMPLETE_NOW),
+      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);
+  UMA_HISTOGRAM_BOOLEAN("Instant.Status", IsEnabled(profile));
 }
 
 // static
 bool InstantController::IsEnabled(Profile* profile) {
   const PrefService* prefs = profile->GetPrefs();
   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);
+  if (prefs) {
+    prefs->SetBoolean(prefs::kInstantEnabled, true);
+    prefs->SetBoolean(prefs::kInstantConfirmDialogShown, true);
+    UMA_HISTOGRAM_BOOLEAN("Instant.Preference", true);
+  }
 }
 
 // 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);
+  if (prefs) {
+    prefs->SetBoolean(prefs::kInstantEnabled, false);
+    UMA_HISTOGRAM_BOOLEAN("Instant.Preference", false);
+  }
 }
 
 bool InstantController::Update(const AutocompleteMatch& match,
                                const string16& user_text,
                                bool verbatim,
-                               string16* suggested_text) {
+                               string16* suggested_text,
+                               InstantCompleteBehavior* complete_behavior) {
+  const TabContents* tab_contents = delegate_->GetInstantHostTabContents();
+  DCHECK(tab_contents);
+
+  GURL instant_url;
+  Profile* profile = tab_contents->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;
+  }
+
+  // Strip leading "?", which indicates forced query mode.
+  string16 new_user_text = !user_text.empty() && user_text[0] == '?' ?
+      user_text.substr(1) : user_text;
+
+  if (new_user_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, tab_contents);
+
+  // Track the full omnibox text, so we can send it on commit.
+  last_full_text_ = new_user_text + *suggested_text;
+
+  // Don't send an update to the loader if the |user_text| hasn't changed.
+  if (new_user_text == last_user_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. |last_user_text_| is still Q, so
+    //    we don't need to Update() the loader, but we do need to Show().
+    if (loader_processed_last_update_ && mode_ == INSTANT)
+      Show();
+    return true;
+  }
+
+  last_user_text_ = new_user_text;
+  last_verbatim_ = verbatim;
+  loader_processed_last_update_ = false;
+
+  // Reset the last suggestion, as it's no longer valid.
   suggested_text->clear();
-
-  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) {
-    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()) {
-    Hide();
-    return false;
-  }
-
-  if (!loader_.get() || loader_->template_url_id() != template_url->id())
-    loader_.reset(new InstantLoader(this, template_url->id(), std::string()));
-
-  if (mode_ == SILENT) {
-    // For the SILENT mode, we process |user_text| at commit time.
-    loader_->MaybeLoadInstantURL(tab_contents, template_url);
-    return true;
-  }
-
-  UpdateLoader(tab_contents, template_url, match.destination_url,
-               match.transition, user_text, verbatim, suggested_text);
-
-  content::NotificationService::current()->Notify(
-      chrome::NOTIFICATION_INSTANT_CONTROLLER_UPDATED,
-      content::Source<InstantController>(this),
-      content::NotificationService::NoDetails());
+  last_suggestion_.clear();
+  *complete_behavior = last_complete_behavior_ = INSTANT_COMPLETE_NOW;
+
+  if (mode_ != SILENT) {
+    loader_->Update(last_user_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)
-    return;
-
-  // Always track the omnibox bounds. That way if Update is later invoked the
-  // bounds are in sync.
+  if (omnibox_bounds_ == bounds || mode_ != INSTANT)
+    return;
+
   omnibox_bounds_ = bounds;
-
-  if (loader_.get() && !is_out_of_date_ && mode_ == INSTANT)
-    loader_->SetOmniboxBounds(bounds);
-}
-
-void InstantController::DestroyPreviewContents() {
-  if (!loader_.get()) {
-    // We're not showing anything, nothing to do.
-    return;
-  }
-
-  if (is_displayable_) {
-    is_displayable_ = false;
+  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);
+  }
+}
+
+TabContents* InstantController::GetPreviewContents() const {
+  return loader_.get() ? loader_->preview_contents() : NULL;
+}
+
+void InstantController::Hide() {
+  last_tab_contents_ = NULL;
+  if (is_showing_) {
+    is_showing_ = false;
     delegate_->HideInstant();
   }
-  delete ReleasePreviewContents(INSTANT_COMMIT_DESTROY, NULL);
-}
-
-void InstantController::Hide() {
-  is_out_of_date_ = true;
-  commit_on_pointer_release_ = false;
-  if (is_displayable_) {
-    is_displayable_ = 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() || loader_.get());
+  return !IsOutOfDate() && loader_.get() && loader_->supports_instant() &&
+         !last_full_text_.empty();
 }
 
 TabContents* InstantController::CommitCurrentPreview(InstantCommitType type) {
-  DCHECK(loader_.get());
-  TabContents* tab_contents = delegate_->GetInstantHostTabContents();
-  DCHECK(tab_contents);
-  TabContents* preview = ReleasePreviewContents(type, tab_contents);
+  const TabContents* tab_contents = delegate_->GetInstantHostTabContents();
+  TabContents* preview = ReleasePreviewContents(type);
   preview->web_contents()->GetController().CopyStateFromAndPrune(
       &tab_contents->web_contents()->GetController());
   delegate_->CommitInstant(preview);
-  CompleteRelease(preview);
   return preview;
 }
 
-bool InstantController::CommitIfCurrent() {
-  if (IsCurrent()) {
-    CommitCurrentPreview(INSTANT_COMMIT_PRESSED_ENTER);
-    return true;
-  }
-  return false;
-}
-
-void InstantController::SetCommitOnPointerRelease() {
-  commit_on_pointer_release_ = true;
-}
-
-bool InstantController::IsPointerDownFromActivate() {
-  DCHECK(loader_.get());
-  return loader_->IsPointerDownFromActivate();
-}
-
-#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();
-}
-#else
-void InstantController::OnAutocompleteLostFocus(
-    gfx::NativeView view_gaining_focus) {
-  if (!IsCurrent()) {
-    DestroyPreviewContents();
-    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();
+TabContents* InstantController::ReleasePreviewContents(InstantCommitType type) {
+  TabContents* tab_contents = loader_->ReleasePreviewContents(type,
+                                                              last_full_text_);
+  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 tab_contents;
+}
+
+void InstantController::OnAutocompleteLostFocus() {
+  DCHECK(!is_showing_ || loader_.get());
+
+  // TODO(sreeram): Since we never delete the loader except when committing
+  // Instant, the loader may have a very stale page. Reload it when stale.
+  if (is_showing_ && loader_.get() && !loader_->IsPointerDownFromActivate())
+    Hide();
+}
+
+void InstantController::OnAutocompleteGotFocus() {
+  const TabContents* tab_contents = delegate_->GetInstantHostTabContents();
+
+  // We could get here with no underlying tab if the Browser is in the process
+  // of closing.
+  if (!tab_contents)
+    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();
+
+  GURL instant_url;
+  if (!GetInstantURL(template_url, &instant_url))
+    return;
+
+  ResetLoader(instant_url, tab_contents);
+}
+
+bool InstantController::commit_on_pointer_release() const {
+  return loader_.get() && loader_->IsPointerDownFromActivate();
+}
+
+void InstantController::SetSuggestions(
+    InstantLoader* loader,
+    const std::vector<string16>& suggestions,
+    InstantCompleteBehavior behavior) {
+  DCHECK_EQ(loader_.get(), loader);
+  if (loader_ != loader || IsOutOfDate() || mode_ == SILENT || mode_ == HIDDEN)
+    return;
+
+  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);
+
+  TabContents* tab_contents = delegate_->GetInstantHostTabContents();
+  DCHECK(tab_contents);
+  if (mode_ != SUGGEST && tab_contents &&
+      !tab_contents->search_tab_helper()->model()->mode().is_ntp()) {
+    Show();
+  }
+
+  loader_processed_last_update_ = true;
+}
+
+void InstantController::CommitInstantLoader(InstantLoader* loader) {
+  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().possibly_invalid_spec());
+  } else {
+    ++blacklisted_urls_[loader->instant_url().possibly_invalid_spec()];
+    if (loader_ == loader) {
+      // Because of the state of the stack, we can't destroy the loader now.
+      if (GetPreviewContents())
+        AddPreviewUsageForHistogram(mode_, PREVIEW_DELETED);
+      MessageLoop::current()->DeleteSoon(FROM_HERE, loader_.release());
+      DeleteLoader();
     }
   }
-#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();
-    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();
-}
-#endif
-
-void InstantController::OnAutocompleteGotFocus() {
-  TabContents* tab_contents = delegate_->GetInstantHostTabContents();
-  if (!tab_contents)
-    return;
-
-  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(
-    InstantLoader* loader,
-    const string16& text,
-    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_;
-}
-
-void InstantController::CommitInstantLoader(InstantLoader* loader) {
-  if (loader_.get() && loader_.get() == loader) {
-    CommitCurrentPreview(INSTANT_COMMIT_FOCUS_LOST);
-  } 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();
 }
 
 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 GURL& instant_url,
+                                    const TabContents* tab_contents) {
+  if (loader_.get() &&
+      (loader_->instant_url().possibly_invalid_spec() !=
+       instant_url.possibly_invalid_spec()))
+    DeleteLoader();
+
+  if (!loader_.get()) {
+    loader_.reset(
+        new InstantLoader(this, instant_url, tab_contents));
+    loader_->Init();
+    AddPreviewUsageForHistogram(mode_, PREVIEW_CREATED);
+  }
+
+  last_tab_contents_ = tab_contents;
+}
+
+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_omnibox_bounds_ = gfx::Rect();
+  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,
+                                      GURL* instant_url) const {
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kInstantURL)) {
+    *instant_url =
+        GURL(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;
+
+  GURL url(instant_url_ref.ReplaceSearchTerms(
+      TemplateURLRef::SearchTermsArgs(string16())));
+
+  std::map<std::string, int>::const_iterator iter =
+      blacklisted_urls_.find(url.possibly_invalid_spec());
+  if (iter != blacklisted_urls_.end() &&
+      iter->second > kMaxInstantSupportFailures) {
+    return false;
+  }
+
+  *instant_url = url;
+  return true;
+}
+
+bool InstantController::IsOutOfDate() const {
+  return !last_tab_contents_ ||
+         last_tab_contents_ != delegate_->GetInstantHostTabContents();
+}