Partially componentize //chrome/browser/search/search.{h,cc}

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"
@@ skipping 23 matching lines @@
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 
 #if defined(ENABLE_SUPERVISED_USERS)
 #include "chrome/browser/supervised_user/supervised_user_service.h"
 #include "chrome/browser/supervised_user/supervised_user_service_factory.h"
 #include "chrome/browser/supervised_user/supervised_user_url_filter.h"
 #endif
 
-namespace chrome {
+namespace search {
 
 namespace {
 
 const char kPrefetchSearchResultsOnSRP[] = "prefetch_results_srp";
-const char kAllowPrefetchNonDefaultMatch[] = "allow_prefetch_non_default_match";
 const char kPrerenderInstantUrlOnOmniboxFocus[] =
     "prerender_instant_url_on_omnibox_focus";
 
-#if defined(OS_ANDROID)
-const char kPrefetchSearchResultsFlagName[] = "prefetch_results";
-
-// Controls whether to reuse prerendered Instant Search base page to commit any
-// search query.
-const char kReuseInstantSearchBasePage[] = "reuse_instant_search_base_page";
-#endif
-
 // Controls whether to use the alternate Instant search base URL. This allows
 // experimentation of Instant search.
 const char kUseAltInstantURL[] = "use_alternate_instant_url";
 const char kUseSearchPathForInstant[] = "use_search_path_for_instant";
 const char kAltInstantURLPath[] = "search";
 const char kAltInstantURLQueryParams[] = "&qbp=1";
 
-#if !defined(OS_IOS) && !defined(OS_ANDROID)
-const char kEnableQueryExtractionFlagName[] = "query_extraction";
-#endif
 const char kShouldShowGoogleLocalNTPFlagName[] = "google_local_ntp";
 
 // Status of the New Tab URL for the default Search provider. NOTE: Used in a
 // UMA histogram so values should only be added at the end and not reordered.
 enum NewTabURLState {
   // Valid URL that should be used.
   NEW_TAB_URL_VALID = 0,
 
   // Corrupt state (e.g. no profile or template url).
   NEW_TAB_URL_BAD = 1,
@@ skipping 64 matching lines @@
   search_terms_args.append_extra_query_params = append_extra_query_params;
   search_terms_args.force_instant_results = force_instant_results;
   return GURL(ref.ReplaceSearchTerms(search_terms_args, search_terms_data));
 }
 
 bool MatchesAnySearchURL(const GURL& url,
                          TemplateURL* template_url,
                          const SearchTermsData& search_terms_data) {
   GURL search_url = TemplateURLRefToGURL(template_url->url_ref(),
                                          search_terms_data, false, false);
-  if (search_url.is_valid() &&
-      search::MatchesOriginAndPath(url, search_url))
+  if (search_url.is_valid() && 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, search_terms_data, false, false);
-    if (search_url.is_valid() &&
-        search::MatchesOriginAndPath(url, search_url))
+    if (search_url.is_valid() && MatchesOriginAndPath(url, search_url))
       return true;
   }
 
   return false;
 }
 
-
-
-// |url| should either have a secure scheme or have a non-HTTPS base URL that
-// the user specified using --google-base-url. (This allows testers to use
-// --google-base-url to point at non-HTTPS servers, which eases testing.)
-bool IsSuitableURLForInstant(const GURL& url, const TemplateURL* template_url) {
-  return template_url->HasSearchTermsReplacementKey(url) &&
-         (url.SchemeIsCryptographic() ||
-          google_util::StartsWithCommandLineGoogleBaseURL(url));
-}
-
 // 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() &&
-      search::MatchesOriginAndPath(url, new_tab_url))
+  if (new_tab_url.is_valid() && 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();
   UIThreadSearchTermsData search_terms_data(profile);
   const GURL instant_url = TemplateURLRefToGURL(
       instant_url_ref, search_terms_data, false, false);
   if (!instant_url.is_valid())
     return false;
 
-  if (search::MatchesOriginAndPath(url, instant_url))
+  if (MatchesOriginAndPath(url, instant_url))
     return true;
 
   return IsQueryExtractionEnabled() &&
       MatchesAnySearchURL(url, template_url, search_terms_data);
 }
 
 base::string16 GetSearchTermsImpl(const content::WebContents* contents,
                                   const content::NavigationEntry* entry) {
   if (!contents || !IsQueryExtractionEnabled())
     return base::string16();
@@ skipping 79 matching lines @@
         return NewTabURLDetails(local_url, state);
     }
   }
 
   GURL url;
   NewTabURLState state;
 };
 
 }  // namespace
 
-// Negative start-margin values prevent the "es_sm" parameter from being used.
-const int kDisableStartMargin = -1;
-
-std::string InstantExtendedEnabledParam(bool for_search) {
-  if (for_search && !chrome::IsQueryExtractionEnabled())
-    return std::string();
-  return std::string(google_util::kInstantExtendedAPIParam) + "=" +
-      base::Uint64ToString(EmbeddedSearchPageVersion()) + "&";
-}
-
-std::string ForceInstantResultsParam(bool for_prerender) {
-  return (for_prerender || !IsInstantExtendedAPIEnabled()) ?
-      "ion=1&" : std::string();
-}
-
-bool IsQueryExtractionEnabled() {
-#if defined(OS_IOS) || defined(OS_ANDROID)
-  return true;
-#else
-  if (!IsInstantExtendedAPIEnabled())
-    return false;
-
-  const base::CommandLine* command_line =
-      base::CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(switches::kEnableQueryExtraction))
-    return true;
-
-  FieldTrialFlags flags;
-  return GetFieldTrialInfo(&flags) && GetBoolValueForFlagWithDefault(
-      kEnableQueryExtractionFlagName, false, flags);
-#endif  // defined(OS_IOS) || defined(OS_ANDROID)
-}
-
 base::string16 ExtractSearchTermsFromURL(Profile* profile, const GURL& url) {
   if (url.is_valid() && url == GetSearchResultPrefetchBaseURL(profile)) {
     // InstantSearchPrerenderer has the search query for the Instant search base
     // page.
     InstantSearchPrerenderer* prerenderer =
         InstantSearchPrerenderer::GetForProfile(profile);
     // TODO(kmadhusu): Remove this CHECK after the investigation of
     // crbug.com/367204.
     CHECK(prerenderer);
     return prerenderer->get_last_query();
@@ skipping 96 matching lines @@
 
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
   if (!IsRenderedInInstantProcess(contents, profile))
     return false;
 
   if (entry->GetURL() == GetLocalInstantURL(profile))
     return true;
 
   GURL new_tab_url(GetNewTabPageURL(profile));
   return new_tab_url.is_valid() &&
-      search::MatchesOriginAndPath(entry->GetURL(), new_tab_url);
+         MatchesOriginAndPath(entry->GetURL(), new_tab_url);
 }
 
 bool IsSuggestPrefEnabled(Profile* profile) {
   return profile && !profile->IsOffTheRecord() && profile->GetPrefs() &&
          profile->GetPrefs()->GetBoolean(prefs::kSearchSuggestEnabled);
 }
 
 GURL GetInstantURL(Profile* profile, bool force_instant_results) {
   if (!IsInstantExtendedAPIEnabled() || !IsSuggestPrefEnabled(profile))
     return GURL();
@@ skipping 51 matching lines @@
 }
 
 GURL GetNewTabPageURL(Profile* profile) {
   return NewTabURLDetails::ForProfile(profile).url;
 }
 
 GURL GetSearchResultPrefetchBaseURL(Profile* profile) {
   return ShouldPrefetchSearchResults() ? GetInstantURL(profile, true) : GURL();
 }
 
-bool ShouldPrefetchSearchResults() {
-  if (!IsInstantExtendedAPIEnabled())
-    return false;
-
-#if defined(OS_ANDROID)
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kPrefetchSearchResults)) {
-    return true;
-  }
-
-  FieldTrialFlags flags;
-  return GetFieldTrialInfo(&flags) && GetBoolValueForFlagWithDefault(
-      kPrefetchSearchResultsFlagName, false, flags);
-#else
-  return true;
-#endif
-}
-
-bool ShouldAllowPrefetchNonDefaultMatch() {
-  if (!ShouldPrefetchSearchResults())
-    return false;
-
-  FieldTrialFlags flags;
-  return GetFieldTrialInfo(&flags) && GetBoolValueForFlagWithDefault(
-      kAllowPrefetchNonDefaultMatch, false, flags);
-}
-
 bool ShouldPrerenderInstantUrlOnOmniboxFocus() {
   if (!ShouldPrefetchSearchResults())
     return false;
 
   FieldTrialFlags flags;
   return GetFieldTrialInfo(&flags) && GetBoolValueForFlagWithDefault(
       kPrerenderInstantUrlOnOmniboxFocus, false, flags);
 }
 
-bool ShouldReuseInstantSearchBasePage() {
-  if (!ShouldPrefetchSearchResults())
-    return false;
-
-#if defined(OS_ANDROID)
-  FieldTrialFlags flags;
-  return GetFieldTrialInfo(&flags) && GetBoolValueForFlagWithDefault(
-      kReuseInstantSearchBasePage, false, flags);
-#else
-  return true;
-#endif
-}
-
 GURL GetLocalInstantURL(Profile* profile) {
   return GURL(chrome::kChromeSearchLocalNtpUrl);
 }
 
 bool ShouldShowGoogleLocalNTP() {
   FieldTrialFlags flags;
   return !GetFieldTrialInfo(&flags) || GetBoolValueForFlagWithDefault(
       kShouldShowGoogleLocalNTPFlagName, true, flags);
 }
 
@@ skipping 10 matching lines @@
   url::Replacements<char> replacements;
   std::string search_scheme(chrome::kChromeSearchScheme);
   replacements.SetScheme(search_scheme.data(),
                          url::Component(0, search_scheme.length()));
 
   // If this is the URL for a server-provided NTP, replace the host with
   // "remote-ntp".
   std::string remote_ntp_host(chrome::kChromeSearchRemoteNtpHost);
   NewTabURLDetails details = NewTabURLDetails::ForProfile(profile);
   if (details.state == NEW_TAB_URL_VALID &&
-      search::MatchesOriginAndPath(url, details.url)) {
+      MatchesOriginAndPath(url, details.url)) {
     replacements.SetHost(remote_ntp_host.c_str(),
                          url::Component(0, remote_ntp_host.length()));
   }
 
   effective_url = effective_url.ReplaceComponents(replacements);
   return effective_url;
 }
 
 bool HandleNewTabURLRewrite(GURL* url,
                             content::BrowserContext* browser_context) {
@@ skipping 18 matching lines @@
 bool HandleNewTabURLReverseRewrite(GURL* url,
                                    content::BrowserContext* browser_context) {
   if (!IsInstantExtendedAPIEnabled())
     return false;
 
   // Do nothing in incognito.
   Profile* profile = Profile::FromBrowserContext(browser_context);
   if (profile && profile->IsOffTheRecord())
     return false;
 
-  if (search::MatchesOriginAndPath(
-      GURL(chrome::kChromeSearchLocalNtpUrl), *url)) {
+  if (MatchesOriginAndPath(GURL(chrome::kChromeSearchLocalNtpUrl), *url)) {
     *url = GURL(chrome::kChromeUINewTabURL);
     return true;
   }
 
   GURL new_tab_url(GetNewTabPageURL(profile));
-  if (new_tab_url.is_valid() &&
-      search::MatchesOriginAndPath(new_tab_url, *url)) {
+  if (new_tab_url.is_valid() && MatchesOriginAndPath(new_tab_url, *url)) {
     *url = GURL(chrome::kChromeUINewTabURL);
     return true;
   }
 
   return false;
 }
 
 void SetInstantSupportStateInNavigationEntry(InstantSupportState state,
                                              content::NavigationEntry* entry) {
   if (!entry)
@@ skipping 11 matching lines @@
 
   return StringToInstantSupportState(value);
 }
 
 bool ShouldPrefetchSearchResultsOnSRP() {
   FieldTrialFlags flags;
   return GetFieldTrialInfo(&flags) && GetBoolValueForFlagWithDefault(
       kPrefetchSearchResultsOnSRP, false, flags);
 }
 
-void EnableQueryExtractionForTesting() {
-  base::CommandLine* cl = base::CommandLine::ForCurrentProcess();
-  cl->AppendSwitch(switches::kEnableQueryExtraction);
-}
-
 bool ShouldUseAltInstantURL() {
   FieldTrialFlags flags;
   return GetFieldTrialInfo(&flags) && GetBoolValueForFlagWithDefault(
       kUseAltInstantURL, false, flags);
 }
 
 bool ShouldUseSearchPathForInstant() {
   FieldTrialFlags flags;
   return GetFieldTrialInfo(&flags) && GetBoolValueForFlagWithDefault(
       kUseSearchPathForInstant, false, flags);
 }
 
-}  // namespace chrome
+}  // namespace search