Move instant support to SearchTabHelper.

chrome/browser/ui/search/instant_page.cc

 // Copyright 2013 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/ui/search/instant_page.h"
 
 #include "base/utf_string_conversions.h"
+#include "chrome/browser/search/search.h"
+#include "chrome/browser/ui/search/search_model.h"
+#include "chrome/browser/ui/search/search_tab_helper.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/frame_navigate_params.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/font.h"
 
 InstantPage::Delegate::~Delegate() {
 }
 
 InstantPage::~InstantPage() {
+  if (extended_enabled_ && contents())
+    GetSearchModel()->RemoveObserver(this);
 }
 
 bool InstantPage::IsLocal() const {
   return contents() &&
       (contents()->GetURL() == GURL(chrome::kChromeSearchLocalNtpUrl) ||
        contents()->GetURL() == GURL(chrome::kChromeSearchLocalGoogleNtpUrl));
 }
 
 void InstantPage::Update(const string16& text,
                          size_t selection_start,
@@ skipping 82 matching lines @@
 }
 
 void InstantPage::SendMostVisitedItems(
     const std::vector<InstantMostVisitedItemIDPair>& items) {
   Send(new ChromeViewMsg_SearchBoxMostVisitedItemsChanged(routing_id(), items));
 }
 
 InstantPage::InstantPage(Delegate* delegate, const std::string& instant_url)
     : delegate_(delegate),
       instant_url_(instant_url),
+      extended_enabled_(chrome::IsInstantExtendedAPIEnabled()),
       supports_instant_(false),
       instant_support_determined_(false) {
 }
 
 void InstantPage::SetContents(content::WebContents* contents) {
+  if (extended_enabled_ && web_contents())
+    GetSearchModel()->RemoveObserver(this);
+
   Observe(contents);
+
+  if (extended_enabled_ && contents) {
+    SearchModel* model = GetSearchModel();
+    model->AddObserver(this);
+
+    // Already know whether the page supports instant.
+    if (model->instant_support() != INSTANT_SUPPORT_UNKNOWN)
+      SetSupportsInstant(model->instant_support() == INSTANT_SUPPORT_YES);
+  }
 }
 
 bool InstantPage::ShouldProcessRenderViewCreated() {
   return false;
 }
 
 bool InstantPage::ShouldProcessRenderViewGone() {
   return false;
 }
 
@@ skipping 20 matching lines @@
 void InstantPage::RenderViewCreated(content::RenderViewHost* render_view_host) {
   if (ShouldProcessRenderViewCreated())
     delegate_->InstantPageRenderViewCreated(contents());
 }
 
 void InstantPage::DidFinishLoad(
     int64 /* frame_id */,
     const GURL& /* validated_url */,
     bool is_main_frame,
     content::RenderViewHost* /* render_view_host */) {
-  if (is_main_frame && !supports_instant_)
+  // For Instant Extended, SearchTabHelper keeps track of Instant support.
+  if (!extended_enabled_ && is_main_frame && !supports_instant_)
     DetermineIfPageSupportsInstant();
 }
 
 bool InstantPage::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(InstantPage, message)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_SetSuggestions, OnSetSuggestions)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_InstantSupportDetermined,
                         OnInstantSupportDetermined)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_ShowInstantOverlay,
@@ skipping 41 matching lines @@
     int64 /* frame_id */,
     bool is_main_frame,
     const GURL& /* validated_url */,
     int /* error_code */,
     const string16& /* error_description */,
     content::RenderViewHost* /* render_view_host */) {
   if (is_main_frame)
     delegate_->InstantPageLoadFailed(contents());
 }
 
+void InstantPage::ModelChanged(const SearchModel::State& old_state,
+                               const SearchModel::State& new_state) {
+  if (old_state.instant_support != new_state.instant_support)
+    SetSupportsInstant(new_state.instant_support == INSTANT_SUPPORT_YES);
+}
+
+SearchModel* InstantPage::GetSearchModel() {
+  return contents() ?
+      SearchTabHelper::FromWebContents(contents())->model() : NULL;
+}
+
+void InstantPage::SetSupportsInstant(bool supports_instant) {
+  if (supports_instant_ == supports_instant)
+    return;
+
+  supports_instant_ = supports_instant;
+  delegate_->InstantSupportDetermined(contents(), supports_instant);
+
+  // If the page doesn't support Instant, stop listening to it.
+  if (!supports_instant)
+    SetContents(NULL);
+}
+
 void InstantPage::OnSetSuggestions(
     int page_id,
     const std::vector<InstantSuggestion>& suggestions) {
   if (contents()->IsActiveEntry(page_id)) {
-    OnInstantSupportDetermined(page_id, true);
+    SearchTabHelper::FromWebContents(contents())->
+        OnInstantSupportDeterminedMsgReceived(page_id, true);
     if (ShouldProcessSetSuggestions())
       delegate_->SetSuggestions(contents(), suggestions);
   }
 }
 
 void InstantPage::OnInstantSupportDetermined(int page_id,
                                              bool supports_instant) {
-  if (!contents()->IsActiveEntry(page_id) || supports_instant_) {
-    // Nothing to do if the page already supports Instant.
-    return;
-  }
-
-  instant_support_determined_ = true;
-  supports_instant_ = supports_instant;
-  delegate_->InstantSupportDetermined(contents(), supports_instant);
-
-  // If the page doesn't support Instant, stop listening to it.
-  if (!supports_instant)
-    Observe(NULL);
+  // TODO(kmadhusu): Get rid of this handler and the assoicated logic after
+  // committing crrev.com/14855014.
+  // For Instant Extended, SearchTabHelper keeps track of Instant support.
+  if (!extended_enabled_ && contents()->IsActiveEntry(page_id))
+    SetSupportsInstant(supports_instant);
 }
 
 void InstantPage::OnShowInstantOverlay(int page_id,
                                        int height,
                                        InstantSizeUnits units) {
   if (contents()->IsActiveEntry(page_id)) {
-    OnInstantSupportDetermined(page_id, true);
+    SearchTabHelper::FromWebContents(contents())->
+        OnInstantSupportDeterminedMsgReceived(page_id, true);
     if (ShouldProcessShowInstantOverlay())
       delegate_->ShowInstantOverlay(contents(), height, units);
   }
 }
 
 void InstantPage::OnFocusOmnibox(int page_id, OmniboxFocusState state) {
   if (contents()->IsActiveEntry(page_id)) {
-    OnInstantSupportDetermined(page_id, true);
+    SearchTabHelper::FromWebContents(contents())->
+        OnInstantSupportDeterminedMsgReceived(page_id, true);
     if (ShouldProcessFocusOmnibox())
       delegate_->FocusOmnibox(contents(), state);
   }
 }
 
 void InstantPage::OnSearchBoxNavigate(int page_id,
                                       const GURL& url,
                                       content::PageTransition transition,
                                       WindowOpenDisposition disposition) {
   if (contents()->IsActiveEntry(page_id)) {
-    OnInstantSupportDetermined(page_id, true);
+    SearchTabHelper::FromWebContents(contents())->
+        OnInstantSupportDeterminedMsgReceived(page_id, true);
     if (ShouldProcessNavigateToURL())
       delegate_->NavigateToURL(contents(), url, transition, disposition);
   }
 }
 
 void InstantPage::OnDeleteMostVisitedItem(InstantRestrictedID restricted_id) {
   delegate_->DeleteMostVisitedItem(restricted_id);
 }
 
 void InstantPage::OnUndoMostVisitedDeletion(InstantRestrictedID restricted_id) {
   delegate_->UndoMostVisitedDeletion(restricted_id);
 }
 
 void InstantPage::OnUndoAllMostVisitedDeletions() {
   delegate_->UndoAllMostVisitedDeletions();
 }