Replace --google-base-suggest-url and --instant-url with --google-base-url.

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"
@@ skipping 134 matching lines @@
   return true;
 }
 
 bool GetReactivationBrand(std::string* brand) {
   brand->clear();
   return true;
 }
 
 #endif
 
-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.
-  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
-  if (command_line.HasSwitch(switches::kInstantURL)) {
-    GURL custom_instant_url(
-        command_line.GetSwitchValueASCII(switches::kInstantURL));
-    if (original_url.host() == custom_instant_url.host() &&
-        original_url.port() == custom_instant_url.port())
-      return true;
-  }
-
-  return (original_url.port().empty() ||
-      port_permission == ALLOW_NON_STANDARD_PORTS) &&
-      google_util::IsGoogleHostname(original_url.host(), subdomain_permission);
+bool StartsWithCommandLineGoogleBaseURL(const GURL& url) {
+  const std::string base_url(CommandLine::ForCurrentProcess()->
+      GetSwitchValueASCII(switches::kGoogleBaseURL));
+  return !base_url.empty() &&
+      StartsWithASCII(url.possibly_invalid_spec(), base_url, true);
 }
 
 bool IsGoogleHostname(const std::string& host,
                       SubdomainPermission subdomain_permission) {
+  const std::string base_url(CommandLine::ForCurrentProcess()->
+      GetSwitchValueASCII(switches::kGoogleBaseURL));
+  if (!base_url.empty()) {
+    GURL base_gurl(base_url);
+    if (base_gurl.is_valid() && (host == base_gurl.host()))
+      return true;
+  }
+
   size_t tld_length = net::registry_controlled_domains::GetRegistryLength(
       host,
       net::registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES,
       net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
   if ((tld_length == 0) || (tld_length == std::string::npos))
     return false;
   std::string host_minus_tld(host, 0, host.length() - tld_length);
   if (LowerCaseEqualsASCII(host_minus_tld, "google."))
     return true;
   if (subdomain_permission == ALLOW_SUBDOMAIN)
     return EndsWith(host_minus_tld, ".google.", false);
   return LowerCaseEqualsASCII(host_minus_tld, "www.google.");
 }
 
-bool IsGoogleHomePageUrl(const std::string& url) {
-  GURL original_url(url);
+bool IsGoogleDomainUrl(const GURL& url,
+                       SubdomainPermission subdomain_permission,
+                       PortPermission port_permission) {
+  return url.is_valid() && (url.SchemeIs("http") || url.SchemeIs("https")) &&
+      (url.port().empty() || (port_permission == ALLOW_NON_STANDARD_PORTS)) &&
+      google_util::IsGoogleHostname(url.host(), subdomain_permission);
+}
 
+bool IsGoogleHomePageUrl(const GURL& url) {
   // First check to see if this has a Google domain.
   if (!IsGoogleDomainUrl(url, DISALLOW_SUBDOMAIN, DISALLOW_NON_STANDARD_PORTS))
     return false;
 
   // Make sure the path is a known home page path.
-  std::string path(original_url.path());
-  if (path != "/" && path != "/webhp" &&
-      !StartsWithASCII(path, "/ig", false)) {
-    return false;
-  }
-
-  return true;
+  std::string path(url.path());
+  return (path == "/") || (path == "/webhp") ||
+      StartsWithASCII(path, "/ig", false);
 }
 
-bool IsGoogleSearchUrl(const std::string& url) {
-  GURL original_url(url);
-
+bool IsGoogleSearchUrl(const GURL& url) {
   // First check to see if this has a Google domain.
   if (!IsGoogleDomainUrl(url, DISALLOW_SUBDOMAIN, DISALLOW_NON_STANDARD_PORTS))
     return false;
 
   // Make sure the path is a known search path.
-  std::string path(original_url.path());
-  bool has_valid_path = false;
+  std::string path(url.path());
   bool is_home_page_base = false;

[Jered, 2013/06/26 00:32:16]

bool is_home_page_base = path == "/webhp" || path == "/";
if (!is_home_page_base && path != "/search")
  return false;

[Peter Kasting, 2013/06/26 00:40:27]

Nice :)

-  if (path == "/search") {
-    has_valid_path = true;
-  } else if (path == "/webhp" || path == "/") {
-    // Note that we allow both "/" and "" paths, but GURL spits them
-    // both out as just "/".
-    has_valid_path = true;
+  if (path != "/search") {
+    if ((path != "/webhp") && (path != "/"))
+      return false;
     is_home_page_base = true;
   }
-  if (!has_valid_path)
-    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 HasGoogleSearchQueryParam(ref) ||
-      (!is_home_page_base && HasGoogleSearchQueryParam(query));
+  return HasGoogleSearchQueryParam(url.ref()) ||
+      (!is_home_page_base && HasGoogleSearchQueryParam(url.query()));
 }
 
 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,
@@ skipping 44 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