Upstreaming mechanism to add query refinement to omnibox searches.

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 "base/format_macros.h"
 #include "base/guid.h"
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/icu_string_conversions.h"
@@ skipping 220 matching lines @@
   for (Replacements::iterator i = replacements_.begin();
        i != replacements_.end(); ++i) {
     if (i->type == SEARCH_TERMS) {
       string16::size_type query_start = parsed_url_.find('?');
       is_in_query = query_start != string16::npos &&
           (static_cast<string16::size_type>(i->index) > query_start);
       break;
     }
   }
 
+  std::string input_encoding;
   string16 encoded_terms;
   string16 encoded_original_query;
-  std::string input_encoding;
-  // Encode the search terms so that we know the encoding.
-  for (std::vector<std::string>::const_iterator i(
-           owner_->input_encodings().begin());
-       i != owner_->input_encodings().end(); ++i) {
-    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;
-      break;
-    }
-  }
-  if (input_encoding.empty()) {
-    input_encoding = "UTF-8";
-    if (!TryEncoding(search_terms_args.search_terms,
-                     search_terms_args.original_query,
-                     input_encoding.c_str(), is_in_query, &encoded_terms,
-                     &encoded_original_query))
-      NOTREACHED();
-  }
+  owner_->EncodeSearchTerms(search_terms_args, is_in_query, &input_encoding,
+      &encoded_terms, &encoded_original_query);
 
   std::string url = parsed_url_;
 
   // replacements_ is ordered in ascending order, as such we need to iterate
   // from the back.
   for (Replacements::reverse_iterator i = replacements_.rbegin();
        i != replacements_.rend(); ++i) {
     switch (i->type) {
       case ENCODING:
         url.insert(i->index, input_encoding);
@@ skipping 197 matching lines @@
     if ((replacements_[i].type == GOOGLE_BASE_URL) ||
         (replacements_[i].type == GOOGLE_BASE_SUGGEST_URL))
       return true;
   }
   return false;
 }
 
 bool TemplateURLRef::ExtractSearchTermsFromURL(
     const GURL& url,
     string16* search_terms,
-    const SearchTermsData& search_terms_data) const {
+    const SearchTermsData& search_terms_data,
+    url_parse::Parsed::ComponentType* search_terms_component,
+    url_parse::Component* search_terms_position) const {
   DCHECK(search_terms);
   search_terms->clear();
 
   ParseIfNecessaryUsingTermsData(search_terms_data);
 
   // We need a search term in the template URL to extract something.
   if (search_term_key_.empty())
     return false;
 
   // TODO(beaudoin): Support patterns of the form http://foo/{searchTerms}/
@@ skipping 21 matching lines @@
                                          &value)) {
     if (key.is_nonempty()) {
       if (params.substr(key.begin, key.len) == search_term_key_) {
         // Extract the search term.
         *search_terms = net::UnescapeAndDecodeUTF8URLComponent(
             params.substr(value.begin, value.len),
             net::UnescapeRule::SPACES |
                 net::UnescapeRule::URL_SPECIAL_CHARS |
                 net::UnescapeRule::REPLACE_PLUS_WITH_SPACE,
             NULL);
+        if (search_terms_component)
+          *search_terms_component = search_term_key_location_;
+        if (search_terms_position)
+          *search_terms_position = value;
         return true;
       }
     }
   }
   return false;
 }
 
 void TemplateURLRef::InvalidateCachedValues() const {
   supports_replacements_ = valid_ = parsed_ = false;
   host_.clear();
@@ skipping 312 matching lines @@
     string16* search_terms) {
   UIThreadSearchTermsData search_terms_data(profile_);
   return ExtractSearchTermsFromURLUsingTermsData(url, search_terms,
                                                  search_terms_data);
 }
 
 bool TemplateURL::ExtractSearchTermsFromURLUsingTermsData(
     const GURL& url,
     string16* search_terms,
     const SearchTermsData& search_terms_data) {
-  DCHECK(search_terms);
-  search_terms->clear();
+  return FindSearchTermsInURL(url, search_terms_data, search_terms, NULL, NULL);
+}
 
-  // Then try to match with every pattern.
-  for (size_t i = 0; i < URLCount(); ++i) {
-    TemplateURLRef ref(this, i);
-    if (ref.ExtractSearchTermsFromURL(url, search_terms, search_terms_data)) {
-      // If ExtractSearchTermsFromURL() returns true and |search_terms| is empty
-      // it means the pattern matched but no search terms were present. In this
-      // case we fail immediately without looking for matches in subsequent
-      // 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;
-}
 
 bool TemplateURL::IsSearchURL(const GURL& url) {
   UIThreadSearchTermsData search_terms_data(profile_);
   return IsSearchURLUsingTermsData(url, search_terms_data);
 }
 
 bool TemplateURL::IsSearchURLUsingTermsData(
     const GURL& url,
     const SearchTermsData& search_terms_data) {
   string16 search_terms;
@@ skipping 13 matching lines @@
       if (key.is_nonempty() &&
           params[i].substr(key.begin, key.len) ==
               search_terms_replacement_key()) {
         return true;
       }
     }
   }
   return false;
 }
 
+bool TemplateURL::ReplaceSearchTermsInURL(
+    const GURL& url,
+    const TemplateURLRef::SearchTermsArgs& search_terms_args,
+    GURL* result) {
+  UIThreadSearchTermsData search_terms_data(profile_);
+  // TODO(beaudoin): Use AQS from |search_terms_args| too.
+  url_parse::Parsed::ComponentType search_term_component;
+  url_parse::Component search_terms_position;
+  string16 search_terms;
+  if (!FindSearchTermsInURL(url, search_terms_data, &search_terms,
+                            &search_term_component, &search_terms_position)) {
+    return false;
+  }
+  DCHECK(search_terms_position.is_nonempty());
+
+  // FindSearchTermsInURL only returns true for search terms in the query or
+  // ref, so we can call EncodeSearchTerm with |is_in_query| = true, since query
+  // and ref are encoded in the same way.
+  std::string input_encoding;
+  string16 encoded_terms;
+  string16 encoded_original_query;
+  EncodeSearchTerms(search_terms_args, true, &input_encoding,
+                    &encoded_terms, &encoded_original_query);
+
+  std::string old_params((search_term_component == url_parse::Parsed::REF) ?
+      url.ref() : url.query());
+  std::string new_params(old_params, 0, search_terms_position.begin);
+  new_params += UTF16ToUTF8(search_terms_args.search_terms);
+  new_params += old_params.substr(search_terms_position.end());
+  url_canon::StdStringReplacements<std::string> replacements;
+  if (search_term_component == url_parse::Parsed::REF)
+    replacements.SetRefStr(new_params);
+  else
+    replacements.SetQueryStr(new_params);
+  *result = url.ReplaceComponents(replacements);
+  return true;
+}
+
+void TemplateURL::EncodeSearchTerms(
+    const TemplateURLRef::SearchTermsArgs& search_terms_args,
+    bool is_in_query,
+    std::string* input_encoding,
+    string16* encoded_terms,
+    string16* encoded_original_query) const {
+
+  std::vector<std::string> encodings(input_encodings());
+  if (std::find(encodings.begin(), encodings.end(), "UTF-8") == encodings.end())
+    encodings.push_back("UTF-8");
+  for (std::vector<std::string>::const_iterator i(encodings.begin());
+       i != encodings.end(); ++i) {
+    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();
+}
+
 void TemplateURL::CopyFrom(const TemplateURL& other) {
   if (this == &other)
     return;
 
   profile_ = other.profile_;
   data_ = other.data_;
   url_ref_.InvalidateCachedValues();
   suggestions_url_ref_.InvalidateCachedValues();
   instant_url_ref_.InvalidateCachedValues();
   SetPrepopulateId(other.data_.prepopulate_id);
@@ skipping 13 matching lines @@
 }
 
 void TemplateURL::ResetKeywordIfNecessary(bool force) {
   if (IsGoogleSearchURLWithReplaceableKeyword() || force) {
     DCHECK(!IsExtensionKeyword());
     GURL url(TemplateURLService::GenerateSearchURL(this));
     if (url.is_valid())
       data_.SetKeyword(TemplateURLService::GenerateKeyword(url));
   }
 }
+
+bool TemplateURL::FindSearchTermsInURL(
+    const GURL& url,
+    const SearchTermsData& search_terms_data,
+    string16* search_terms,
+    url_parse::Parsed::ComponentType* search_term_component,
+    url_parse::Component* search_terms_position) {
+  DCHECK(search_terms);
+  search_terms->clear();
+
+  // Try to match with every pattern.
+  for (size_t i = 0; i < URLCount(); ++i) {
+    TemplateURLRef ref(this, i);
+    if (ref.ExtractSearchTermsFromURL(url, search_terms, search_terms_data,
+        search_term_component, search_terms_position)) {
+      // If ExtractSearchTermsFromURL() returns true and |search_terms| is empty
+      // it means the pattern matched but no search terms were present. In this
+      // case we fail immediately without looking for matches in subsequent
+      // 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;
+}