Move instant support to SearchTabHelper.

chrome/browser/ui/search/search_tab_helper.cc

Index: chrome/browser/ui/search/search_tab_helper.cc
diff --git a/chrome/browser/ui/search/search_tab_helper.cc b/chrome/browser/ui/search/search_tab_helper.cc
index 5086f81134839ebe362d9dfa161dbb4a6af203d6..29e0e83cdfddb38ac4ec2aadd333089cb4038adc 100644
--- a/chrome/browser/ui/search/search_tab_helper.cc
+++ b/chrome/browser/ui/search/search_tab_helper.cc
@@ -4,12 +4,14 @@
 
 #include "chrome/browser/ui/search/search_tab_helper.h"
 
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search/search.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
+#include "content/public/browser/web_contents.h"
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(SearchTabHelper);
 
@@ -30,6 +32,14 @@ bool IsSearchResults(const content::WebContents* contents) {
   return !chrome::GetSearchTerms(contents).empty();
 }
 
+// TODO(kmadhusu): Move this helper from anonymous namespace to chrome
+// namespace and remove InstantPage::IsLocal().
+bool IsLocal(const content::WebContents* contents) {
+  return contents &&
+      (contents->GetURL() == GURL(chrome::kChromeSearchLocalNtpUrl) ||
+       contents->GetURL() == GURL(chrome::kChromeSearchLocalGoogleNtpUrl));
+}
+
 }  // namespace
 
 SearchTabHelper::SearchTabHelper(content::WebContents* web_contents)
@@ -75,6 +85,13 @@ void SearchTabHelper::NavigationEntryUpdated() {
   UpdateMode();
 }
 
+void SearchTabHelper::InstantSupportChanged(bool supports_instant) {
+  if (!is_search_enabled_)
+    return;
+
+  model_.SetSupportsInstant(supports_instant);
+}
+
 void SearchTabHelper::Observe(
     int type,
     const content::NotificationSource& source,
@@ -90,11 +107,22 @@ bool SearchTabHelper::OnMessageReceived(const IPC::Message& message) {
                         OnSearchBoxShowBars)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_SearchBoxHideBars,
                         OnSearchBoxHideBars)
+    IPC_MESSAGE_HANDLER(ChromeViewHostMsg_InstantSupportDetermined,
+                        OnInstantSupportDetermined)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
+void SearchTabHelper::DidFinishLoad(
+    int64 /* frame_id */,
+    const GURL& /* validated_url */,
+    bool is_main_frame,
+    content::RenderViewHost* /* render_view_host */) {
+  if (is_main_frame)
+    DetermineIfPageSupportsInstant();
+}
+
 void SearchTabHelper::UpdateMode() {
   SearchMode::Type type = SearchMode::MODE_DEFAULT;
   SearchMode::Origin origin = SearchMode::ORIGIN_DEFAULT;
@@ -117,12 +145,33 @@ void SearchTabHelper::UpdateMode() {
     // OmniboxEditModel::SetInputInProgress() which is called from
     // OmniboxEditModel::Revert().
     model_.SetState(SearchModel::State(SearchMode(type, origin),
-                                       model_.state().top_bars_visible));
+                                       model_.state().top_bars_visible,
+                                       model_.instant_support()));
   } else {
     model_.SetMode(SearchMode(type, origin));
   }
 }
 
+void SearchTabHelper::DetermineIfPageSupportsInstant() {
+  Profile* profile =
+      Profile::FromBrowserContext(web_contents_->GetBrowserContext());
+  if (!chrome::ShouldAssignURLToInstantRenderer(web_contents_->GetURL(),

[samarth, 2013/05/13 20:19:03]

This seems reasonable but any particular reason you had to add this.

[kmadhusu, 2013/05/14 00:01:27]

During a discussion, Sreeram mentioned about this function and pointed out that
if we know that the URL doesn't belong to an instant renderer, we can
immediately return from this function and avoid dispatching an IPC message to
the renderer.

[sreeram, 2013/05/14 01:49:17]

The idea is that if you send a message to a page that's NOT in the Instant
process, it will never receive it, and will never respond. (In my proposal to
@kmadhusu, the process I recommended was: No need for a tri-state. Keep the
current supports_instant_ state until the response comes back.)

PS: I have yet to review the CL. So I don't know if in fact my proposal is being
implemented (in which case, you do need to perform this check; since otherwise
supports_instant_ will never be updated).

I'll take a look once Samarth is done reviewing.

[samarth, 2013/05/15 17:43:21]

Ok, this check makes sense.

Sreeram: the reason I recommended using a tri-state was so that if you switch to
a tab that we already know to not support instant, we can sever InstantTab
without having to make another IPC.

+                                                profile)) {
+    InstantSupportChanged(false);
+  } else if (IsLocal(web_contents_)) {
+    // Local pages always support Instant.
+    InstantSupportChanged(true);
+  } else {
+    Send(new ChromeViewMsg_DetermineIfPageSupportsInstant(routing_id()));
+  }
+}
+
+void SearchTabHelper::OnInstantSupportDetermined(int page_id,
+                                                 bool supports_instant) {
+  if (web_contents()->IsActiveEntry(page_id))
+    InstantSupportChanged(supports_instant);
+}
+
 void SearchTabHelper::OnSearchBoxShowBars(int page_id) {
   if (web_contents()->IsActiveEntry(page_id))
     model_.SetTopBarsVisible(true);