Move instant support to SearchTabHelper.

chrome/browser/ui/search/instant_page.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.

[Jered, 2013/05/08 00:16:27]

Excitingly, this file now has unit tests. Consider testing new code.

[samarth, 2013/05/08 02:38:48]

Yes, please.

 // 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,

[samarth, 2013/05/08 02:38:48]

As I mentioned before, if you wait for Sreeram's change (crrev.com/14855014),
you can get rid of this IPC handler here and the associated logic.

[kmadhusu, 2013/05/09 02:40:40]

Sure. I will wait for that CL to get committed.

                         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);
@@ skipping 33 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);
+    SetSupportsInstant(true);

[samarth, 2013/05/08 02:38:48]

So in general, we consider a page to support Instant if we can any
instant-related IPC from the page.  I wasn't really handling this correctly
before in that the bit got updated here and not in SearchTabHelper.  It probably
makes sense here to call into a
SearchTabHelper::FromWebContents(..)->SetSupportsInstant(true) function (or
maybe call it InstantIPCReceied() to be consistent with the other public
functions).  That in turn will set the bit correctly here.

Same goes for all the other ipc handlers here that call SetSupportsInstant.

[kmadhusu, 2013/05/09 02:40:40]

Done.

     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);
+  // 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);
+    SetSupportsInstant(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);
+    SetSupportsInstant(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);
+    SetSupportsInstant(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();
 }