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

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 82 matching lines @@
 }
 
 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(chrome::kHttpsScheme) &&
            other_url.SchemeIs(chrome::kHttpScheme)));
 }
 
-bool IsCommandLineInstantURL(const GURL& url) {
-  const CommandLine* cl = CommandLine::ForCurrentProcess();
-  const GURL instant_url(cl->GetSwitchValueASCII(switches::kInstantURL));
-  return instant_url.is_valid() && MatchesOrigin(url, instant_url);
-}
-
 bool MatchesAnySearchURL(const GURL& url, TemplateURL* template_url) {
   GURL search_url =
       TemplateURLRefToGURL(template_url->url_ref(), kDisableStartMargin);
   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, kDisableStartMargin);
@@ skipping 70 matching lines @@
   const InstantService* instant_service =
       InstantServiceFactory::GetForProfile(profile);
   if (!instant_service)
     return false;
 
   return instant_service->IsInstantProcess(process_host->GetID());
 }
 
 // Returns true if |url| can be used as an Instant URL for |profile|.
 bool IsInstantURL(const GURL& url, Profile* profile) {
+  if (!url.is_valid())
+    return false;
+
   TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
   if (!template_url)
     return false;
 
-  const TemplateURLRef& instant_url_ref = template_url->instant_url_ref();
   const bool extended_api_enabled = IsInstantExtendedAPIEnabled();
-  GURL effective_url = url;
-
-  if (IsCommandLineInstantURL(url))
-    effective_url = CoerceCommandLineURLToTemplateURL(url, instant_url_ref,
-                                                      kDisableStartMargin);
-
-  if (!effective_url.is_valid())
-    return false;
-
-  if (extended_api_enabled && !effective_url.SchemeIsSecure())
+  if (extended_api_enabled && !url.SchemeIsSecure())

[samarth, 2013/06/17 20:39:37]

I ran into two issues while trying out your patch:

(1) We should bypass the https check here if we're using the Google engine
--google-base-url is set. That was one of the uses of --instant-url and always
requiring https would make development much more onerous.

(2) While testing changes with local servers, we often need to add some extra
debug query parameters to the instant/search URLs. Based on our discussion last
week, I thought we'd be able to stick them at the beginning of the
{google:baseURL} but that doesn't include the request path, so that won't work.
You end up with something like:
mytestserver.google.com/webhp?debugparam=1&webhp?....
I see a couple of options. We could:
a. Do nothing. Always require people to edit template url by hand.
b. Add a new {extraParams} field in the template url for Google that can be set
via a flag.
c. Add a more generic --search-extra-params flag that will append debug params
to whatever URL you happen to use .
Thoughts? I really think option (a) would represent a big loss in productivity.
I'm especially worried about cases where a search server release is breaking
something and someone needs to debug quickly. Having to rebuild Chrome or have
to muck around with the profile in sqlite would be a big hindrance.

     return false;
 
   if (extended_api_enabled &&
-      !template_url->HasSearchTermsReplacementKey(effective_url))
+      !template_url->HasSearchTermsReplacementKey(url))
     return false;
 
+  const TemplateURLRef& instant_url_ref = template_url->instant_url_ref();
   const GURL instant_url =
       TemplateURLRefToGURL(instant_url_ref, kDisableStartMargin);
   if (!instant_url.is_valid())
     return false;
 
-  if (MatchesOriginAndPath(effective_url, instant_url))
+  if (MatchesOriginAndPath(url, instant_url))
     return true;
 
-  if (extended_api_enabled && MatchesAnySearchURL(effective_url, template_url))
+  if (extended_api_enabled && MatchesAnySearchURL(url, template_url))
     return true;
 
   return false;
 }
 
 string16 GetSearchTermsImpl(const content::WebContents* contents,
                             const content::NavigationEntry* entry) {
   // For security reasons, don't extract search terms if the page is not being
   // rendered in the privileged Instant renderer process. This is to protect
   // against a malicious page somehow scripting the search results page and
@@ skipping 65 matching lines @@
 
   FieldTrialFlags flags;
   if (GetFieldTrialInfo(
           base::FieldTrialList::FindFullName(kInstantExtendedFieldTrialName),
           &flags, NULL)) {
     return GetBoolValueForFlagWithDefault(kLocalOnlyFlagName, false, flags);
   }
   return false;
 }
 
-string16 GetSearchTermsFromURL(Profile* profile, const GURL& in_url) {
-  GURL url(in_url);
+string16 GetSearchTermsFromURL(Profile* profile, const GURL& url) {
   string16 search_terms;
-
   TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
-  if (!template_url)
-    return string16();
-
-  if (IsCommandLineInstantURL(url))
-    url = CoerceCommandLineURLToTemplateURL(url, template_url->url_ref(),
-                                            kDisableStartMargin);
-
-  if (url.SchemeIsSecure() && template_url->HasSearchTermsReplacementKey(url))
+  if (template_url && url.SchemeIsSecure() &&
+      template_url->HasSearchTermsReplacementKey(url))
     template_url->ExtractSearchTermsFromURL(url, &search_terms);
-
   return search_terms;
 }
 
 string16 GetSearchTermsFromNavigationEntry(
     const content::NavigationEntry* entry) {
   string16 search_terms;
   if (entry)
     entry->GetExtraData(sessions::kSearchTermsKey, &search_terms);
   return search_terms;
 }
@@ skipping 143 matching lines @@
   if (!IsInstantCheckboxEnabled(profile))
     return GURL();
 
   const bool extended_api_enabled = IsInstantExtendedAPIEnabled();
 
   // In non-extended mode, the checkbox must be checked.
   if (!extended_api_enabled && !IsInstantCheckboxChecked(profile))
     return GURL();
 
   TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
-  CommandLine* cl = CommandLine::ForCurrentProcess();
-  if (cl->HasSwitch(switches::kInstantURL)) {
-    GURL instant_url(cl->GetSwitchValueASCII(switches::kInstantURL));
-    if (extended_api_enabled) {
-      // Extended mode won't work if the search terms replacement key is absent.
-      GURL coerced_url = CoerceCommandLineURLToTemplateURL(
-          instant_url, template_url->instant_url_ref(), start_margin);
-      if (!template_url->HasSearchTermsReplacementKey(coerced_url))
-        return GURL();
-    }
-    return instant_url;
-  }
-
   GURL instant_url =
       TemplateURLRefToGURL(template_url->instant_url_ref(), start_margin);
   if (extended_api_enabled && !instant_url.SchemeIsSecure()) {
     // Extended mode requires HTTPS. Force it if necessary.
     const std::string secure_scheme = chrome::kHttpsScheme;
     GURL::Replacements replacements;
     replacements.SetSchemeStr(secure_scheme);
     instant_url = instant_url.ReplaceComponents(replacements);
   }
 
@@ skipping 184 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);
 }
 
-// Coerces the commandline Instant URL to look like a template URL, so that we
-// can extract search terms from it.
-GURL CoerceCommandLineURLToTemplateURL(const GURL& instant_url,
-                                       const TemplateURLRef& ref,
-                                       int start_margin) {
-  GURL search_url = TemplateURLRefToGURL(ref, start_margin);
-
-  // NOTE(samarth): GURL returns temporaries which we must save because
-  // GURL::Replacements expects the replacements to live until
-  // ReplaceComponents is called.
-  const std::string search_scheme = chrome::kHttpsScheme;
-  const std::string search_host = search_url.host();
-  const std::string search_port = search_url.port();
-
-  GURL::Replacements replacements;
-  replacements.SetSchemeStr(search_scheme);
-  replacements.SetHostStr(search_host);
-  replacements.SetPortStr(search_port);
-  return instant_url.ReplaceComponents(replacements);
-}
-
 bool DefaultSearchProviderSupportsInstant(Profile* profile) {
   TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
   if (!template_url)
     return false;
 
   GURL instant_url = TemplateURLRefToGURL(template_url->instant_url_ref(),
                                           kDisableStartMargin);
   // Extended mode instant requires a search terms replacement key.
   return instant_url.is_valid() &&
          (!IsInstantExtendedAPIEnabled() ||
@@ skipping 13 matching lines @@
   for (size_t i = 0; i < items_b.size(); ++i) {
     if (items_b[i].url != items_a[i].url ||
         items_b[i].title != items_a[i].title) {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace chrome