InstantExtended: Send search URLs to renderers.

chrome/browser/search/search.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/search/search.h"
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/search/instant_service.h"
 #include "chrome/browser/search/instant_service_factory.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_instant_controller.h"
 #include "chrome/browser/ui/browser_iterator.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
+#include "chrome/common/search_urls.h"
 #include "chrome/common/url_constants.h"
 #include "components/sessions/serialized_navigation_entry.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace chrome {
@@ skipping 84 matching lines @@
 GURL TemplateURLRefToGURL(const TemplateURLRef& ref,
                           int start_margin,
                           bool append_extra_query_params) {
   TemplateURLRef::SearchTermsArgs search_terms_args =
       TemplateURLRef::SearchTermsArgs(string16());
   search_terms_args.omnibox_start_margin = start_margin;
   search_terms_args.append_extra_query_params = append_extra_query_params;
   return GURL(ref.ReplaceSearchTerms(search_terms_args));
 }
 
-bool MatchesOrigin(const GURL& my_url, const GURL& other_url) {
-  return my_url.host() == other_url.host() &&
-         my_url.port() == other_url.port() &&
-         (my_url.scheme() == other_url.scheme() ||
-          (my_url.SchemeIs(content::kHttpsScheme) &&
-           other_url.SchemeIs(content::kHttpScheme)));
-}
-
 bool MatchesAnySearchURL(const GURL& url, TemplateURL* template_url) {
   GURL search_url =
       TemplateURLRefToGURL(template_url->url_ref(), kDisableStartMargin, false);
-  if (search_url.is_valid() && MatchesOriginAndPath(url, search_url))
+  if (search_url.is_valid() &&
+      search::MatchesOriginAndPath(url, search_url))
     return true;
 
   // "URLCount() - 1" because we already tested url_ref above.
   for (size_t i = 0; i < template_url->URLCount() - 1; ++i) {
     TemplateURLRef ref(template_url, i);
     search_url = TemplateURLRefToGURL(ref, kDisableStartMargin, false);
-    if (search_url.is_valid() && MatchesOriginAndPath(url, search_url))
+    if (search_url.is_valid() &&
+        search::MatchesOriginAndPath(url, search_url))
       return true;
   }
 
   return false;
 }
 
 void RecordInstantExtendedOptInState() {
   if (instant_extended_opt_in_state_gate)
     return;
 
@@ skipping 41 matching lines @@
 
 // Returns true if |url| can be used as an Instant URL for |profile|.
 bool IsInstantURL(const GURL& url, Profile* profile) {
   if (!IsInstantExtendedAPIEnabled())
     return false;
 
   if (!url.is_valid())
     return false;
 
   const GURL new_tab_url(GetNewTabPageURL(profile));
-  if (new_tab_url.is_valid() && MatchesOriginAndPath(url, new_tab_url))
+  if (new_tab_url.is_valid() &&
+      search::MatchesOriginAndPath(url, new_tab_url))
     return true;
 
   TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
   if (!template_url)
     return false;
 
   if (!IsSuitableURLForInstant(url, template_url))
     return false;
 
   const TemplateURLRef& instant_url_ref = template_url->instant_url_ref();
   const GURL instant_url =
       TemplateURLRefToGURL(instant_url_ref, kDisableStartMargin, false);
   if (!instant_url.is_valid())
     return false;
 
-  if (MatchesOriginAndPath(url, instant_url))
+  if (search::MatchesOriginAndPath(url, instant_url))
     return true;
 
   return !ShouldSuppressInstantExtendedOnSRP() &&
       MatchesAnySearchURL(url, template_url);
 }
 
 string16 GetSearchTermsImpl(const content::WebContents* contents,
                             const content::NavigationEntry* entry) {
   if (!contents || !IsQueryExtractionEnabled())
     return string16();
@@ skipping 148 matching lines @@
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
   if (!IsRenderedInInstantProcess(contents, profile))
     return false;
 
   if (entry->GetVirtualURL() == GetLocalInstantURL(profile))
     return true;
 
   if (ShouldUseCacheableNTP()) {
     GURL new_tab_url(GetNewTabPageURL(profile));
     return new_tab_url.is_valid() &&
-        MatchesOriginAndPath(entry->GetURL(), new_tab_url);
+        search::MatchesOriginAndPath(entry->GetURL(), new_tab_url);
   }
 
   return IsInstantURL(entry->GetVirtualURL(), profile) &&
       GetSearchTermsImpl(contents, entry).empty();
 }
 
 bool IsSuggestPrefEnabled(Profile* profile) {
   return profile && !profile->IsOffTheRecord() && profile->GetPrefs() &&
          profile->GetPrefs()->GetBoolean(prefs::kSearchSuggestEnabled);
 }
@@ skipping 17 matching lines @@
   // IsSuitableURLForInstant()).
   if (instant_url.SchemeIsSecure() ||
       google_util::StartsWithCommandLineGoogleBaseURL(instant_url))
     return instant_url;
   GURL::Replacements replacements;
   const std::string secure_scheme(content::kHttpsScheme);
   replacements.SetSchemeStr(secure_scheme);
   return instant_url.ReplaceComponents(replacements);
 }
 
+// Returns URLs associated with the default search engine for |profile|.
+std::vector<GURL> GetSearchURLs(Profile* profile) {
+  std::vector<GURL> result;
+  TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
+  for (size_t i = 0; i < template_url->URLCount(); ++i) {
+    TemplateURLRef ref(template_url, i);
+    result.push_back(TemplateURLRefToGURL(ref, kDisableStartMargin, false));
+  }
+  return result;
+}
+
+GURL GetNewTabPageURL(Profile* profile) {
+  if (!ShouldUseCacheableNTP())
+    return GURL();
+
+  if (!profile || !IsSuggestPrefEnabled(profile))
+    return GURL();
+
+  TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
+  if (!template_url)
+    return GURL();
+
+  return TemplateURLRefToGURL(template_url->new_tab_url_ref(),
+                              kDisableStartMargin, false);
+}
+
 GURL GetLocalInstantURL(Profile* profile) {
   return GURL(chrome::kChromeSearchLocalNtpUrl);
 }
 
 bool ShouldPreferRemoteNTPOnStartup() {
   // Check the command-line/about:flags setting first, which should have
   // precedence and allows the trial to not be reported (if it's never queried).
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kDisableInstantExtendedAPI) ||
       command_line->HasSwitch(switches::kEnableLocalFirstLoadNTP)) {
@@ skipping 56 matching lines @@
 bool ShouldSuppressInstantExtendedOnSRP() {
   FieldTrialFlags flags;
   if (GetFieldTrialInfo(&flags, NULL)) {
     return GetBoolValueForFlagWithDefault(
         kSuppressInstantExtendedOnSRPFlagName, false, flags);
   }
 
   return false;
 }
 
-bool MatchesOriginAndPath(const GURL& my_url, const GURL& other_url) {
-  return MatchesOrigin(my_url, other_url) && my_url.path() == other_url.path();
-}
-
 GURL GetEffectiveURLForInstant(const GURL& url, Profile* profile) {
   CHECK(ShouldAssignURLToInstantRenderer(url, profile))
       << "Error granting Instant access.";
 
   if (url.SchemeIs(chrome::kChromeSearchScheme))
     return url;
 
   GURL effective_url(url);
 
   // Replace the scheme with "chrome-search:".
   url_canon::Replacements<char> replacements;
   std::string search_scheme(chrome::kChromeSearchScheme);
   replacements.SetScheme(search_scheme.data(),
                          url_parse::Component(0, search_scheme.length()));
 
   // If the URL corresponds to an online NTP, replace the host with
   // "online-ntp".
   std::string online_ntp_host(chrome::kChromeSearchOnlineNtpHost);
   TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
   if (template_url) {
     const GURL instant_url = TemplateURLRefToGURL(
         template_url->instant_url_ref(), kDisableStartMargin, false);
-    if (instant_url.is_valid() && MatchesOriginAndPath(url, instant_url)) {
+    if (instant_url.is_valid() &&
+        search::MatchesOriginAndPath(url, instant_url)) {
       replacements.SetHost(online_ntp_host.c_str(),
                            url_parse::Component(0, online_ntp_host.length()));
     }
   }
 
   effective_url = effective_url.ReplaceComponents(replacements);
   return effective_url;
 }
 
 int GetInstantLoaderStalenessTimeoutSec() {
@@ skipping 51 matching lines @@
   return true;
 }
 
 bool HandleNewTabURLReverseRewrite(GURL* url,
                                    content::BrowserContext* browser_context) {
   if (!IsInstantExtendedAPIEnabled())
     return false;
 
   Profile* profile = Profile::FromBrowserContext(browser_context);
   GURL new_tab_url(GetNewTabPageURL(profile));
-  if (!new_tab_url.is_valid() || !MatchesOriginAndPath(new_tab_url, *url))
+  if (!new_tab_url.is_valid() ||
+      !search::MatchesOriginAndPath(new_tab_url, *url))
     return false;
 
   *url = GURL(chrome::kChromeUINewTabURL);
   return true;
 }
 
 void SetInstantSupportStateInNavigationEntry(InstantSupportState state,
                                              content::NavigationEntry* entry) {
   if (!entry)
     return;
@@ skipping 112 matching lines @@
 }
 
 // Given a FieldTrialFlags object, returns the boolean value of the provided
 // flag.
 bool GetBoolValueForFlagWithDefault(const std::string& flag,
                                     bool default_value,
                                     const FieldTrialFlags& flags) {
   return !!GetUInt64ValueForFlagWithDefault(flag, default_value ? 1 : 0, flags);
 }
 
-GURL GetNewTabPageURL(Profile* profile) {
-  if (!ShouldUseCacheableNTP())
-    return GURL();
-
-  if (!profile || !IsSuggestPrefEnabled(profile))
-    return GURL();
-
-  TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
-  if (!template_url)
-    return GURL();
-
-  return TemplateURLRefToGURL(template_url->new_tab_url_ref(),
-                              kDisableStartMargin, false);
-}
-
 void ResetInstantExtendedOptInStateGateForTest() {
   instant_extended_opt_in_state_gate = false;
 }
 
 }  // namespace chrome