Move the query to the start of the Google search URL in hopes of being slightly more user-friendly.

chrome/browser/search_engines/template_url_prepopulate_data.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/search_engines/template_url_prepopulate_data.h"
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 #include <locale.h>
 #endif
 
 #include "base/command_line.h"
 #include "base/memory/scoped_vector.h"
 #include "base/string16.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "base/stl_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/search_engine_type.h"
 #include "chrome/browser/search_engines/search_terms_data.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
+#include "content/public/browser/browser_thread.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_WIN)
 #undef IN  // On Windows, windef.h defines this, which screws up "India" cases.
 #elif defined(OS_MACOSX)
 #include "base/mac/scoped_cftyperef.h"
 #endif
@@ skipping 1044 matching lines @@
   NULL,
   NULL,
   SEARCH_ENGINE_GOO,
   23,
 };
 
 const PrepopulatedEngine google = {
   L"Google",
   L"google.com",  // This will be dynamically updated by the TemplateURL system.
   "http://www.google.com/favicon.ico",
-  "{google:baseURL}search?{google:RLZ}{google:acceptedSuggestion}"
-      "{google:originalQueryForSuggestion}{google:searchFieldtrialParameter}"
-      "sourceid=chrome&ie={inputEncoding}&q={searchTerms}",
+  "{google:baseURL}search?q={searchTerms}&{google:RLZ}"
+      "{google:acceptedSuggestion}{google:originalQueryForSuggestion}"
+      "{google:searchFieldtrialParameter}sourceid=chrome&ie={inputEncoding}",
   "UTF-8",
   "{google:baseSuggestURL}search?{google:searchFieldtrialParameter}"
       "client=chrome&hl={language}&q={searchTerms}",
   "{google:baseURL}webhp?{google:RLZ}sourceid=chrome-instant&"
       "ie={inputEncoding}{google:instantEnabledParameter}{searchTerms}",
   SEARCH_ENGINE_GOOGLE,
   1,
 };
 
 const PrepopulatedEngine guruji = {
@@ skipping 2289 matching lines @@
   // This could be more efficient.  We are loading all the URLs to only keep
   // the first one.
   GetPrepopulatedEngines(profile, &loaded_urls.get(), &default_search_index);
   if (default_search_index < loaded_urls.size()) {
     default_search_provider = loaded_urls[default_search_index];
     loaded_urls.weak_erase(loaded_urls.begin() + default_search_index);
   }
   return default_search_provider;
 }
 
-// Finds a prepopulated engine whose origin is the same as |url|'s origin.
-static const PrepopulatedEngine* GetEngineForURL(const std::string& url) {
+SearchEngineType GetEngineType(const std::string& url) {
+  // Restricted to UI thread because ReplaceSearchTerms() is so restricted.
+  using content::BrowserThread;
+  DCHECK(!BrowserThread::IsWellKnownThread(BrowserThread::UI) ||
+         BrowserThread::CurrentlyOn(BrowserThread::UI));
+
   // We may get a valid URL, or we may get the Google prepopulate URL which
-  // can't be converted to a GURL.  Instead of forcing callers to substitute to
-  // ensure the provided URL is valid, just detect the second case directly
-  // here.
-  GURL as_gurl(url);
-  if (!as_gurl.is_valid()) {
-    // We only need to check Google, the other engines should all be valid URLs
-    // and thus won't ever string-compare successfully against |url|.
-    return (url == google.search_url) ? &google : NULL;
-  }
+  // can't be converted directly to a GURL.  To handle the latter, we first
+  // construct a TemplateURL from the provided |url|, then call
+  // ReplaceSearchTerms().  This should return a valid URL even when the input
+  // has Google base URLs.
+  TemplateURLData data;
+  data.SetURL(url);
+  TemplateURL turl(NULL, data);
+  GURL as_gurl(turl.url_ref().ReplaceSearchTerms(ASCIIToUTF16("x"),
+      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
+  if (!as_gurl.is_valid())
+    return SEARCH_ENGINE_OTHER;
 
-  // For all other cases, check using origins, in order to more aggressively
-  // match search engine types for data imported from other browsers.
+  // Check using origins, in order to more aggressively match search engine
+  // types for data imported from other browsers.
   //
   // First special-case Google, because the prepopulate URL for it will not
   // convert to a GURL and thus won't have an origin.  Instead see if the
   // incoming URL's host is "[*.]google.<TLD>".
   if (google_util::IsGoogleHostname(as_gurl.host(),
                                     google_util::DISALLOW_SUBDOMAIN))
-    return &google;
+    return google.type;
 
   // Now check the rest of the prepopulate data.
   GURL origin(as_gurl.GetOrigin());
   for (size_t i = 0; i < arraysize(kAllEngines); ++i) {
     GURL engine_url(kAllEngines[i]->search_url);
     if (engine_url.is_valid() && (origin == engine_url.GetOrigin()))
-      return kAllEngines[i];
+      return kAllEngines[i]->type;
   }
 
-  return NULL;
-}
-
-string16 GetEngineName(const std::string& url) {
-  const PrepopulatedEngine* engine = GetEngineForURL(url);
-  if (engine)
-    return WideToUTF16(engine->name);
-  GURL as_gurl(url);
-  return (as_gurl.is_valid() && !as_gurl.host().empty()) ?
-      UTF8ToUTF16(as_gurl.host()) :
-      l10n_util::GetStringUTF16(IDS_UNKNOWN_SEARCH_ENGINE_NAME);
-}
-
-SearchEngineType GetEngineType(const std::string& url) {
-  const PrepopulatedEngine* engine = GetEngineForURL(url);
-  return engine ? engine->type : SEARCH_ENGINE_OTHER;
+  return SEARCH_ENGINE_OTHER;
 }
 
 }  // namespace TemplateURLPrepopulateData