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())

[samarth, 2013/05/10 01:32:38]

No reason to both checking extended_enabled_ now.

[kmadhusu, 2013/05/13 17:13:24]

Done.

+    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 28 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 24 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()),

[samarth, 2013/05/10 01:32:38]

Not necessary anymore not that regular Instant is gone.

[kmadhusu, 2013/05/13 17:13:24]

Done.

       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 15 matching lines @@
 
 bool InstantPage::ShouldProcessNavigateToURL() {
   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::OnSetSuggestions(
-    int page_id,
-    const std::vector<InstantSuggestion>& suggestions) {
-  if (contents()->IsActiveEntry(page_id)) {
-    OnInstantSupportDetermined(page_id, true);
-    if (ShouldProcessSetSuggestions())
-      delegate_->SetSuggestions(contents(), suggestions);
-  }
+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);
 }
 
-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.
+SearchModel* InstantPage::GetSearchModel() {
+  return contents() ?
+      SearchTabHelper::FromWebContents(contents())->model() : NULL;
+}
+
+void InstantPage::SetSupportsInstant(bool supports_instant) {
+  if (instant_support_determined_ && supports_instant_ == supports_instant)
     return;
-  }
 
   instant_support_determined_ = true;
   supports_instant_ = supports_instant;

[samarth, 2013/05/10 01:32:38]

Currently, once an InstantPage supports instant, we assume it will continue to
for its existence.  We should either:

(1) Keep this assumption (in which case, move that logic to SearchTabHelper).

(2) Fix this assumption.  This is really only an issue for InstantTab, because
with InstantOverlay and InstantNTP, we simply delete the contents and reload new
ones if instant support comes back as false.  But for InstantTab, we can handle
this gracefully because we're already listening to SearchModelChanged in
BrowserInstantController.  So we can have it trigger a ResetInstantTab in
InstantController.

I definitely prefer (2) but Sreeram may have other concerns here, so you should
probably run that by him before doing all that work.

[samarth, 2013/05/10 14:45:56]

Thinking about this some more, doing (2) is still a good idea but will require
some more changes (in particular with how and when we switch between using and
an InstantTab vs an Overlay).  Let's do it in a follow-up CL.

[kmadhusu, 2013/05/13 17:13:24]

ok.

   delegate_->InstantSupportDetermined(contents(), supports_instant);
 
   // If the page doesn't support Instant, stop listening to it.
   if (!supports_instant)
-    Observe(NULL);
+    SetContents(NULL);
+}
+
+void InstantPage::OnSetSuggestions(
+    int page_id,
+    const std::vector<InstantSuggestion>& suggestions) {
+  if (contents()->IsActiveEntry(page_id)) {
+    SearchTabHelper::FromWebContents(contents())->
+        OnInstantSupportDeterminedMsgReceived(page_id, true);
+    if (ShouldProcessSetSuggestions())
+      delegate_->SetSuggestions(contents(), suggestions);
+  }
 }
 
 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();
 }