Introduces a search term extraction mechanism working for arbitrary search providers.

chrome/browser/google/google_util.cc

 // Copyright (c) 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/google/google_util.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/google/google_url_tracker.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/net/url_util.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "googleurl/src/gurl.h"
 #include "googleurl/src/url_parse.h"
-#include "net/base/escape.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 
 #if defined(OS_MACOSX)
 #include "chrome/browser/mac/keystone_glue.h"
 #endif
 
 #if defined(GOOGLE_CHROME_BUILD)
 #include "chrome/browser/google/linkdoctor_internal/linkdoctor_internal.h"
 #endif
 
@@ skipping 16 matching lines @@
        itr != parameters.end();
        ++itr) {
     if (StartsWithASCII(*itr, "q=", false) && itr->size() > 2)
       return true;
   }
   return false;
 }
 
 bool gUseMockLinkDoctorBaseURLForTesting = false;
 
-// Finds the first key-value pair where the key matches |query_key|. Returns
-// true if a match is found and sets |search_terms| to the value.
-bool ExtractSearchTermsFromComponent(const std::string& url,
-                                     url_parse::Component* component,
-                                     string16* search_terms) {
-  const std::string query_key = "q";
-  url_parse::Component key, value;
-
-  while (url_parse::ExtractQueryKeyValue(url.c_str(), component,
-                                         &key, &value)) {
-    if (url.compare(key.begin, key.len, query_key) != 0)
-      continue;
-    std::string value_str = url.substr(value.begin, value.len);
-    *search_terms = net::UnescapeAndDecodeUTF8URLComponent(
-        value_str,
-        net::UnescapeRule::SPACES |
-            net::UnescapeRule::URL_SPECIAL_CHARS |
-            net::UnescapeRule::REPLACE_PLUS_WITH_SPACE,
-        NULL);
-    return true;
-  }
-  return false;
-}
-
 }  // anonymous namespace
 
 namespace google_util {
 
 GURL LinkDoctorBaseURL() {
   if (gUseMockLinkDoctorBaseURLForTesting)
     return GURL("http://mock.linkdoctor.url/for?testing");
   return GURL(LINKDOCTOR_SERVER_REQUEST_URL);
 }
 
@@ skipping 78 matching lines @@
   return true;
 }
 
 bool GetReactivationBrand(std::string* brand) {
   brand->clear();
   return true;
 }
 
 #endif
 
-string16 GetSearchTermsFromGoogleSearchURL(const std::string& url) {
-  if (!IsInstantExtendedAPIGoogleSearchUrl(url))
-    return string16();
-
-  url_parse::Parsed parsed_url;
-  url_parse::ParseStandardURL(url.c_str(), url.length(), &parsed_url);
-
-  string16 search_terms;
-  // The search terms can be in either the query or ref component - for
-  // instance, in a regular Google search they'll be in the query but in a
-  // Google Instant search they can be in both. The ref is the correct one to
-  // return in this case, so test the ref component first.
-  if (ExtractSearchTermsFromComponent(url, &parsed_url.ref, &search_terms) ||
-      ExtractSearchTermsFromComponent(url, &parsed_url.query, &search_terms)) {
-    return search_terms;
-  }
-  return string16();
-}
-
 bool IsGoogleDomainUrl(const std::string& url,
                        SubdomainPermission subdomain_permission,
                        PortPermission port_permission) {
   GURL original_url(url);
   if (!original_url.is_valid() ||
       !(original_url.SchemeIs("http") || original_url.SchemeIs("https")))
     return false;
 
   // If we have the Instant URL overridden with a command line flag, accept
   // its domain/port combination as well.
@@ skipping 65 matching lines @@
     return false;
 
   // Check for query parameter in URL parameter and hash fragment, depending on
   // the path type.
   std::string query(original_url.query());
   std::string ref(original_url.ref());
   return HasQueryParameter(ref) ||
       (!is_home_page_base && HasQueryParameter(query));
 }
 
-bool IsInstantExtendedAPIGoogleSearchUrl(const std::string& url) {
-  if (!IsGoogleSearchUrl(url))
-    return false;
-
-  const std::string embedded_search_key = kInstantExtendedAPIParam;
-
-  url_parse::Parsed parsed_url;
-  url_parse::ParseStandardURL(url.c_str(), url.length(), &parsed_url);
-  url_parse::Component key, value;
-  while (url_parse::ExtractQueryKeyValue(
-      url.c_str(), &parsed_url.query, &key, &value)) {
-    // If the parameter key is |embedded_search_key| and the value is not 0 this
-    // is an Instant Extended API Google search URL.
-    if (!url.compare(key.begin, key.len, embedded_search_key)) {
-      int int_value = 0;
-      if (value.is_nonempty())
-        base::StringToInt(url.substr(value.begin, value.len), &int_value);
-      return int_value != 0;
-    }
-  }
-  return false;
-}
-
 bool IsOrganic(const std::string& brand) {
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kOrganicInstall))
     return true;
 
 #if defined(OS_MACOSX)
   if (brand.empty()) {
     // An empty brand string on Mac is used for channels other than stable,
     // which are always organic.
     return true;
@@ skipping 42 matching lines @@
   const char* const kBrands[] = {
     "CHIQ", "CHSG", "HLJY", "NTMO", "OOBA", "OOBB", "OOBC", "OOBD", "OOBE",
     "OOBF", "OOBG", "OOBH", "OOBI", "OOBJ", "IDCM",
   };
   const char* const* end = &kBrands[arraysize(kBrands)];
   const char* const* found = std::find(&kBrands[0], end, brand);
   return found != end;
 }
 
 }  // namespace google_util