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/strings/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 (contents())
+    GetSearchModel()->RemoveObserver(this);
 }
 
 bool InstantPage::supports_instant() const {
-  return supports_instant_;
+  return contents() ?
+      SearchTabHelper::FromWebContents(contents())->SupportsInstant() : false;
 }
 
 const std::string& InstantPage::instant_url() const {
   return instant_url_;
 }
 
 bool InstantPage::IsLocal() const {
   return contents() &&
       (contents()->GetURL() == GURL(chrome::kChromeSearchLocalNtpUrl) ||
        contents()->GetURL() == GURL(chrome::kChromeSearchLocalGoogleNtpUrl));
@@ skipping 32 matching lines @@
   const gfx::Font& omnibox_font =
       ui::ResourceBundle::GetSharedInstance().GetFont(
           ui::ResourceBundle::MediumFont);
 #endif
   string16 omnibox_font_name = UTF8ToUTF16(omnibox_font.GetFontName());
   size_t omnibox_font_size = omnibox_font.GetFontSize();
   Send(new ChromeViewMsg_SearchBoxFontInformation(
       routing_id(), omnibox_font_name, omnibox_font_size));
 }
 
-void InstantPage::DetermineIfPageSupportsInstant() {
-  if (IsLocal()) {
-    // Local pages always support Instant. That's why we keep them around.
-    int page_id = contents()->GetController().GetActiveEntry()->GetPageID();
-    OnInstantSupportDetermined(page_id, true);
-  } else {
-    Send(new ChromeViewMsg_DetermineIfPageSupportsInstant(routing_id()));
-  }
-}
-
 void InstantPage::SendAutocompleteResults(
     const std::vector<InstantAutocompleteResult>& results) {
   Send(new ChromeViewMsg_SearchBoxAutocompleteResults(routing_id(), results));
 }
 
 void InstantPage::UpOrDownKeyPressed(int count) {
   Send(new ChromeViewMsg_SearchBoxUpOrDownKeyPressed(routing_id(), count));
 }
 
 void InstantPage::EscKeyPressed() {
@@ skipping 32 matching lines @@
     const std::vector<InstantMostVisitedItem>& items) {
   Send(new ChromeViewMsg_SearchBoxMostVisitedItemsChanged(routing_id(), items));
 }
 
 void InstantPage::ToggleVoiceSearch() {
   Send(new ChromeViewMsg_SearchBoxToggleVoiceSearch(routing_id()));
 }
 
 InstantPage::InstantPage(Delegate* delegate, const std::string& instant_url)
     : delegate_(delegate),
-      instant_url_(instant_url),
-      supports_instant_(false),
-      instant_support_determined_(false) {
+      instant_url_(instant_url) {
 }
 
-void InstantPage::SetContents(content::WebContents* contents) {
-  Observe(contents);
+void InstantPage::SetContents(content::WebContents* web_contents) {
+  if (contents())
+    GetSearchModel()->RemoveObserver(this);
+
+  Observe(web_contents);
+
+  if (!web_contents)
+    return;
+
+  SearchModel* model = GetSearchModel();

[Jered, 2013/06/19 17:58:17]

nit: Remove GetSearchModel() and inline it. It would make it clearer that the
model is associated with a different WebContents here.

[kmadhusu, 2013/06/19 18:41:28]

Done.

+  model->AddObserver(this);
+
+  // Already know whether the page supports instant.
+  if (model->instant_support() != INSTANT_SUPPORT_UNKNOWN)
+    InstantSupportDetermined(model->instant_support() == INSTANT_SUPPORT_YES);

[Jered, 2013/06/19 17:58:17]

nit: It's confusing that SetContents() calls InstantSupportDetermined()  which
calls SetContents() again to undo what it just did. Instead, either make the
logic linear here (bind the observers only in the case where we want to), or add

void InstantPage::ClearContents() {
  if (contents())
    SearchTabHelper::FromWebContents(contents())->model()->RemoveObserver(this);
  Observe(NULL);
}

SetContents() would go:

  ClearContents();
  if (web_contents) {
    Observe(web_contents);
    SearchModel* model =
SearchTabHelper::FromWebContents(web_contents)->model();
    ...
  }

and InstantSupportDetermined() would go:

if (!supports_instant)
  ClearContents();

[kmadhusu, 2013/06/19 18:41:28]

Done.

 }
 
 bool InstantPage::ShouldProcessRenderViewCreated() {
   return false;
 }
 
 bool InstantPage::ShouldProcessRenderViewGone() {
   return false;
 }
 
@@ skipping 27 matching lines @@
 
 bool InstantPage::ShouldProcessUndoAllMostVisitedDeletions() {
   return false;
 }
 
 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_)
-    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,
                         OnShowInstantOverlay)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_FocusOmnibox, OnFocusOmnibox)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_SearchBoxNavigate,
                         OnSearchBoxNavigate);
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_SearchBoxDeleteMostVisitedItem,
                         OnDeleteMostVisitedItem);
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_SearchBoxUndoMostVisitedDeletion,
                         OnUndoMostVisitedDeletion);
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_SearchBoxUndoAllMostVisitedDeletions,
@@ skipping 32 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)
+    InstantSupportDetermined(new_state.instant_support == INSTANT_SUPPORT_YES);
+}
+
+SearchModel* InstantPage::GetSearchModel() {
+  return contents() ?
+      SearchTabHelper::FromWebContents(contents())->model() : NULL;
+}
+
+void InstantPage::InstantSupportDetermined(bool 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))
     return;
 
-  OnInstantSupportDetermined(page_id, true);
+  SearchTabHelper::FromWebContents(contents())->InstantSupportChanged(true);
   if (!ShouldProcessSetSuggestions())
     return;
 
   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);
-}
-
 void InstantPage::OnShowInstantOverlay(int page_id,
                                        int height,
                                        InstantSizeUnits units) {
   if (!contents()->IsActiveEntry(page_id))
     return;
 
-  OnInstantSupportDetermined(page_id, true);
+  SearchTabHelper::FromWebContents(contents())->InstantSupportChanged(true);
   delegate_->LogDropdownShown();
   if (!ShouldProcessShowInstantOverlay())
     return;
 
   delegate_->ShowInstantOverlay(contents(), height, units);
 }
 
 void InstantPage::OnFocusOmnibox(int page_id, OmniboxFocusState state) {
   if (!contents()->IsActiveEntry(page_id))
     return;
 
-  OnInstantSupportDetermined(page_id, true);
+  SearchTabHelper::FromWebContents(contents())->InstantSupportChanged(true);
   if (!ShouldProcessFocusOmnibox())
     return;
 
   delegate_->FocusOmnibox(contents(), state);
 }
 
 void InstantPage::OnSearchBoxNavigate(int page_id,
                                       const GURL& url,
                                       content::PageTransition transition,
                                       WindowOpenDisposition disposition,
                                       bool is_search_type) {
   if (!contents()->IsActiveEntry(page_id))
     return;
 
-  OnInstantSupportDetermined(page_id, true);
+  SearchTabHelper::FromWebContents(contents())->InstantSupportChanged(true);
   if (!ShouldProcessNavigateToURL())
     return;
 
   delegate_->NavigateToURL(
       contents(), url, transition, disposition, is_search_type);
 }
 
 void InstantPage::OnDeleteMostVisitedItem(int page_id, const GURL& url) {
   if (!contents()->IsActiveEntry(page_id))
     return;
 
-  OnInstantSupportDetermined(page_id, true);
+  SearchTabHelper::FromWebContents(contents())->InstantSupportChanged(true);
   if (!ShouldProcessDeleteMostVisitedItem())
     return;
 
   delegate_->DeleteMostVisitedItem(url);
 }
 
 void InstantPage::OnUndoMostVisitedDeletion(int page_id, const GURL& url) {
   if (!contents()->IsActiveEntry(page_id))
     return;
 
-  OnInstantSupportDetermined(page_id, true);
+  SearchTabHelper::FromWebContents(contents())->InstantSupportChanged(true);
   if (!ShouldProcessUndoMostVisitedDeletion())
     return;
 
   delegate_->UndoMostVisitedDeletion(url);
 }
 
 void InstantPage::OnUndoAllMostVisitedDeletions(int page_id) {
   if (!contents()->IsActiveEntry(page_id))
     return;
 
-  OnInstantSupportDetermined(page_id, true);
+  SearchTabHelper::FromWebContents(contents())->InstantSupportChanged(true);
   if (!ShouldProcessUndoAllMostVisitedDeletions())
     return;
 
   delegate_->UndoAllMostVisitedDeletions();
 }