Move GenerateSearchURL() and GenerateKeyword() from TemplateURLService to TemplateURL

chrome/browser/search_engines/template_url.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.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/format_macros.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/search/search.h"
-#include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "components/metrics/proto/omnibox_input_type.pb.h"
 #include "components/search_engines/search_terms_data.h"
 #include "extensions/common/constants.h"
 #include "google_apis/google_api_keys.h"
 #include "net/base/escape.h"
 #include "net/base/mime_util.h"
+#include "net/base/net_util.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
 // The TemplateURLRef has any number of terms that need to be replaced. Each of
 // the terms is enclosed in braces. If the character preceeding the final
 // brace is a ?, it indicates the term is optional and can be replaced with
 // an empty string.
 const char kStartParameter = '{';
 const char kEndParameter = '}';
@@ skipping 1115 matching lines @@
 
   rep.SetPath(favicon_path, url::Component(0, favicon_path_len));
   rep.ClearUsername();
   rep.ClearPassword();
   rep.ClearQuery();
   rep.ClearRef();
   return url.ReplaceComponents(rep);
 }
 
 // static
+base::string16 TemplateURL::GenerateKeyword(const GURL& url) {
+  DCHECK(url.is_valid());
+  // Strip "www." off the front of the keyword; otherwise the keyword won't work
+  // properly.  See http://code.google.com/p/chromium/issues/detail?id=6984 .
+  // Special case: if the host was exactly "www." (not sure this can happen but
+  // perhaps with some weird intranet and custom DNS server?), ensure we at
+  // least don't return the empty string.
+  base::string16 keyword(net::StripWWWFromHost(url));
+  return keyword.empty() ? base::ASCIIToUTF16("www") : keyword;
+}
+
+// static
 bool TemplateURL::MatchesData(const TemplateURL* t_url,
                               const TemplateURLData* data,
                               const SearchTermsData& search_terms_data) {
   if (!t_url || !data)
     return !t_url && !data;
 
   return (t_url->short_name() == data->short_name) &&
       t_url->HasSameKeywordAs(*data, search_terms_data) &&
       (t_url->url() == data->url()) &&
       (t_url->suggestions_url() == data->suggestions_url) &&
@@ skipping 168 matching lines @@
     if (TryEncoding(search_terms_args.search_terms,
                     search_terms_args.original_query, i->c_str(),
                     is_in_query, encoded_terms, encoded_original_query)) {
       *input_encoding = *i;
       return;
     }
   }
   NOTREACHED();
 }
 
+GURL TemplateURL::GenerateSearchURL(
+    const SearchTermsData& search_terms_data) const {
+  if (!url_ref_.IsValid(search_terms_data))
+    return GURL();
+
+  if (!url_ref_.SupportsReplacement(search_terms_data))
+    return GURL(url());
+
+  // Use something obscure for the search terms argument so that in the rare
+  // case the term replaces the URL it's unlikely another keyword would have the
+  // same url.
+  // TODO(jnd): Add additional parameters to get post data when the search URL
+  // has post parameters.
+  return GURL(url_ref_.ReplaceSearchTerms(
+      TemplateURLRef::SearchTermsArgs(
+          base::ASCIIToUTF16("blah.blah.blah.blah.blah")),
+      search_terms_data, NULL));
+}
+
 void TemplateURL::CopyFrom(const TemplateURL& other) {
   if (this == &other)
     return;
 
   data_ = other.data_;
   url_ref_.InvalidateCachedValues();
   suggestions_url_ref_.InvalidateCachedValues();
   instant_url_ref_.InvalidateCachedValues();
   SetPrepopulateId(other.data_.prepopulate_id);
 }
 
 void TemplateURL::SetURL(const std::string& url) {
   data_.SetURL(url);
   url_ref_.InvalidateCachedValues();
 }
 
 void TemplateURL::SetPrepopulateId(int id) {
   data_.prepopulate_id = id;
   const bool prepopulated = id > 0;
   url_ref_.prepopulated_ = prepopulated;
   suggestions_url_ref_.prepopulated_ = prepopulated;
   instant_url_ref_.prepopulated_ = prepopulated;
 }
 
 void TemplateURL::ResetKeywordIfNecessary(
     const SearchTermsData& search_terms_data,
     bool force) {
   if (IsGoogleSearchURLWithReplaceableKeyword(search_terms_data) || force) {
     DCHECK(GetType() != OMNIBOX_API_EXTENSION);
-    GURL url(TemplateURLService::GenerateSearchURL(this, search_terms_data));
+    GURL url(GenerateSearchURL(search_terms_data));
     if (url.is_valid())
-      data_.SetKeyword(TemplateURLService::GenerateKeyword(url));
+      data_.SetKeyword(GenerateKeyword(url));
   }
 }
 
 bool TemplateURL::FindSearchTermsInURL(
     const GURL& url,
     const SearchTermsData& search_terms_data,
     base::string16* search_terms,
     url::Parsed::ComponentType* search_term_component,
     url::Component* search_terms_position) {
   DCHECK(search_terms);
@@ skipping 10 matching lines @@
       // patterns. This means that given patterns
       //    [ "http://foo/#q={searchTerms}", "http://foo/?q={searchTerms}" ],
       // calling ExtractSearchTermsFromURL() on "http://foo/?q=bar#q=' would
       // return false. This is important for at least Google, where such URLs
       // are invalid.
       return !search_terms->empty();
     }
   }
   return false;
 }