Move instant support to SearchTabHelper.

chrome/browser/ui/search/search_tab_helper.cc

 // Copyright 2012 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/search_tab_helper.h"
 
+#include "chrome/browser/google/google_util.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_controller.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);
 
 namespace {
 
 bool IsNTP(const content::WebContents* contents) {
   // We can't use WebContents::GetURL() because that uses the active entry,
   // whereas we want the visible entry.
   const content::NavigationEntry* entry =
       contents->GetController().GetVisibleEntry();
   if (entry && entry->GetVirtualURL() == GURL(chrome::kChromeUINewTabURL))
     return true;
 
   return chrome::IsInstantNTP(contents);
 }
 
 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)
     : WebContentsObserver(web_contents),
       is_search_enabled_(chrome::IsInstantExtendedAPIEnabled()),
       user_input_in_progress_(false),
       popup_is_open_(false),
       user_text_is_empty_(true),
       web_contents_(web_contents) {
   if (!is_search_enabled_)
     return;
 
+  // Observe for NOTIFICATION_NAV_ENTRY_COMMITTED event to reset the local
+  // states (such as mode, last known most visited items, instant support state,
+  // etc).
   registrar_.Add(
       this,
       content::NOTIFICATION_NAV_ENTRY_COMMITTED,
       content::Source<content::NavigationController>(
           &web_contents->GetController()));
 }
 
 SearchTabHelper::~SearchTabHelper() {
 }
 
@@ skipping 22 matching lines @@
 
 bool SearchTabHelper::UpdateLastKnownMostVisitedItems(
     const std::vector<InstantMostVisitedItem>& items) {
   if (chrome::AreMostVisitedItemsEqual(items, last_known_most_visited_items_))
     return false;
 
   last_known_most_visited_items_ = items;
   return true;
 }
 
+void SearchTabHelper::InstantSupportChanged(bool instant_support) {
+  if (!is_search_enabled_)
+    return;
+
+  model_.SetInstantSupportState(instant_support ? INSTANT_SUPPORT_YES :
+                                                  INSTANT_SUPPORT_NO);
+}
+
+bool SearchTabHelper::SupportsInstant() const {
+  return model_.instant_support() == INSTANT_SUPPORT_YES;
+}
+
 void SearchTabHelper::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_EQ(content::NOTIFICATION_NAV_ENTRY_COMMITTED, type);
+

[samarth, 2013/06/18 04:33:17]

The notification details tell you whether this notification is for a navigation
in the main frame.  We should check for that and return early if not.

[kmadhusu, 2013/06/18 20:58:23]

Done.

   UpdateMode();
+
+  content::NavigationController* controller =

[samarth, 2013/06/18 04:33:17]

I played with this and is_in_page is generally the correct thing to check.  The
only case where I found it not to work is:
1) Search for [a] in Web mode
2) Switch to News mode
3) Hit back
At step 3, this isn't set correctly.  However at this step, type ==
TYPE_IN_PAGE.  So, in my test, if you skip the resetting if either is_in_page ||
type == TYPE_IN_PAGE, things seem to work correctly.  I want to investigate some
more why those don't always agree, but this feels more correct to me (and a more
general fix) and to special case google modes.

[kmadhusu, 2013/06/18 20:58:23]

Done.

+      content::Source<content::NavigationController>(source).ptr();
+  content::NavigationEntry *entry = controller->GetActiveEntry();
+  if (!entry)
+    return;
+
+  // If the commit is a GENERATED commit with a Google search URL, then it is an
+  // Omnibox search.
+  //
+  // Do not reset instant support state if the navigation entry is a Google
+  // search url and it is not from the Omnibox.
+  //
+  // For e.g. When an user switches mode in the search result page, we generate
+  // a Google search url which is not an omnibox search url. Since we have
+  // already determined the instant support state for that page, do not reset
+  // the instant support state.
+  if (google_util::IsGoogleSearchUrl(entry->GetURL().spec()) &&
+      !google_util::IsOmniboxGoogleSearchNavigation(*entry)) {
+    return;
+  }
+
+  model_.SetInstantSupportState(INSTANT_SUPPORT_UNKNOWN);
 }
 
 bool SearchTabHelper::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(SearchTabHelper, message)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_SearchBoxShowBars,
                         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;
   if (IsNTP(web_contents_)) {
     type = SearchMode::MODE_NTP;
     origin = SearchMode::ORIGIN_NTP;
   } else if (IsSearchResults(web_contents_)) {
     type = SearchMode::MODE_SEARCH_RESULTS;
     origin = SearchMode::ORIGIN_SEARCH;
   }
   if (user_input_in_progress_)
     type = SearchMode::MODE_SEARCH_SUGGESTIONS;
 
   if (type == SearchMode::MODE_NTP && origin == SearchMode::ORIGIN_NTP &&
       !popup_is_open_ && !user_text_is_empty_) {
     // We're switching back (|popup_is_open_| is false) to an NTP (type and
     // mode are |NTP|) with suggestions (|user_text_is_empty_| is false), don't
     // modify visibility of top bars.  This specific omnibox state is set when
     // OmniboxEditModelChanged() is called from
     // 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(),
+                                                profile)) {
+    // The page is not in the Instant process. This page does not support
+    // instant. If we send an IPC message to a page that is not in the Instant
+    // process, it will never receive it and will never respond. Therefore,
+    // return immediately.
+    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 instant_support) {
+  if (!web_contents()->IsActiveEntry(page_id))
+    return;
+
+  InstantSupportChanged(instant_support);
+}
+
 void SearchTabHelper::OnSearchBoxShowBars(int page_id) {
   if (web_contents()->IsActiveEntry(page_id))
     model_.SetTopBarsVisible(true);
 }
 
 void SearchTabHelper::OnSearchBoxHideBars(int page_id) {
   if (web_contents()->IsActiveEntry(page_id)) {
     model_.SetTopBarsVisible(false);
     Send(new ChromeViewMsg_SearchBoxBarsHidden(routing_id()));
   }
 }