A working implementation of AQS (Assisted Query Stats).

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/guid.h"
 #include "base/i18n/case_conversion.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/string_number_conversions.h"
+#include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete_field_trial.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/search_engines/search_terms_data.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/common/url_constants.h"
 #include "net/base/escape.h"
 #include "ui/base/l10n/l10n_util.h"
 
@@ skipping 11 matching lines @@
 const char kSearchTermsParameter[] = "searchTerms";
 const char kSearchTermsParameterFull[] = "{searchTerms}";
 const char kCountParameter[] = "count";
 const char kStartIndexParameter[] = "startIndex";
 const char kStartPageParameter[] = "startPage";
 const char kLanguageParameter[] = "language";
 const char kInputEncodingParameter[] = "inputEncoding";
 const char kOutputEncodingParameter[] = "outputEncoding";
 
 const char kGoogleAcceptedSuggestionParameter[] = "google:acceptedSuggestion";
+const char kGoogleAssistedQueryStatsParameter[] = "google:assistedQueryStats";
 // Host/Domain Google searches are relative to.
 const char kGoogleBaseURLParameter[] = "google:baseURL";
 const char kGoogleBaseURLParameterFull[] = "{google:baseURL}";
 // Like google:baseURL, but for the Search Suggest capability.
 const char kGoogleBaseSuggestURLParameter[] = "google:baseSuggestURL";
 const char kGoogleBaseSuggestURLParameterFull[] = "{google:baseSuggestURL}";
 const char kGoogleInstantEnabledParameter[] = "google:instantEnabledParameter";
 const char kGoogleOriginalQueryForSuggestionParameter[] =
     "google:originalQueryForSuggestion";
 const char kGoogleRLZParameter[] = "google:RLZ";
@@ skipping 44 matching lines @@
       base::OnStringConversionError::SKIP, &encoded_original_query))
     return false;
   *escaped_original_query =
       UTF8ToUTF16(net::EscapeQueryParamValue(encoded_original_query, true));
   return true;
 }
 
 }  // namespace
 
 
+// TemplateURLRef::SearchTermsArgs --------------------------------------------
+
+TemplateURLRef::SearchTermsArgs::SearchTermsArgs(const string16& search_terms)
+    : search_terms(search_terms),
+      accepted_suggestion(NO_SUGGESTIONS_AVAILABLE) {
+}
+
+
 // TemplateURLRef -------------------------------------------------------------
 
 TemplateURLRef::TemplateURLRef(TemplateURL* owner, Type type)
     : owner_(owner),
       type_(type),
       parsed_(false),
       valid_(false),
       supports_replacements_(false),
       prepopulated_(false) {
   DCHECK(owner_);
@@ skipping 16 matching lines @@
   return SupportsReplacementUsingTermsData(search_terms_data);
 }
 
 bool TemplateURLRef::SupportsReplacementUsingTermsData(
     const SearchTermsData& search_terms_data) const {
   ParseIfNecessaryUsingTermsData(search_terms_data);
   return valid_ && supports_replacements_;
 }
 
 std::string TemplateURLRef::ReplaceSearchTerms(
-    const string16& terms,
-    int accepted_suggestion,
-    const string16& original_query_for_suggestion) const {
+    const SearchTermsArgs& search_terms_args) const {
   UIThreadSearchTermsData search_terms_data(owner_->profile());
-  return ReplaceSearchTermsUsingTermsData(terms, accepted_suggestion,
-      original_query_for_suggestion, search_terms_data);
+  return ReplaceSearchTermsUsingTermsData(search_terms_args, search_terms_data);
 }
 
 std::string TemplateURLRef::ReplaceSearchTermsUsingTermsData(
-    const string16& terms,
-    int accepted_suggestion,
-    const string16& original_query_for_suggestion,
+    const SearchTermsArgs& search_terms_args,
     const SearchTermsData& search_terms_data) const {
   ParseIfNecessaryUsingTermsData(search_terms_data);
   if (!valid_)
     return std::string();
 
   if (replacements_.empty())
     return parsed_url_;
 
   // Determine if the search terms are in the query or before. We're escaping
   // space as '+' in the former case and as '%20' in the latter case.
   bool is_in_query = true;
   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;
     }
   }
 
   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(terms, original_query_for_suggestion, i->c_str(),
+    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(terms, original_query_for_suggestion,
+    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();
   }
 
   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);
         break;
 
+      case GOOGLE_ASSISTED_QUERY_STATS:
+        if (!search_terms_args.assisted_query_stats.empty()) {
+          // Get the base URL without substituting AQS to avoid infinite
+          // recursion.  We need the URL to find out if it meets all
+          // AQS requirements.
+          SearchTermsArgs search_terms_args_without_aqs(search_terms_args);
+          search_terms_args_without_aqs.assisted_query_stats.clear();
+          const std::string& base_url = ReplaceSearchTermsUsingTermsData(
+              search_terms_args_without_aqs,
+              search_terms_data);
+          // We support sending AQS to any search provider supporting HTTPS.
+          if (StartsWithASCII(base_url, chrome::kHttpsScheme, false)) {

[Peter Kasting, 2012/06/22 23:18:11]

Nit: Safer:

          GURL base_url(ReplaceSearchTermsUsingTermsData(
              search_terms_args_without_aqs, search_terms_data);
          if (url.SchemeIs(chrome::kHttpsScheme)) { ...

[Bart N, 2012/06/23 01:06:30]

Done.

+            url.insert(i->index,
+                       "aqs=" + search_terms_args.assisted_query_stats + "&");
+          }
+        }
+        break;
+
       case GOOGLE_ACCEPTED_SUGGESTION:
-        if (accepted_suggestion == NO_SUGGESTION_CHOSEN)
+        if (search_terms_args.accepted_suggestion == NO_SUGGESTION_CHOSEN) {
           url.insert(i->index, "aq=f&");
-        else if (accepted_suggestion != NO_SUGGESTIONS_AVAILABLE)
+        } else if (search_terms_args.accepted_suggestion !=
+                   NO_SUGGESTIONS_AVAILABLE) {
           url.insert(i->index,
-                     base::StringPrintf("aq=%d&", accepted_suggestion));
+                     base::StringPrintf("aq=%d&",
+                                        search_terms_args.accepted_suggestion));
+        }
         break;
 
       case GOOGLE_BASE_URL:
         url.insert(i->index, search_terms_data.GoogleBaseURLValue());
         break;
 
       case GOOGLE_BASE_SUGGEST_URL:
         url.insert(i->index, search_terms_data.GoogleBaseSuggestURLValue());
         break;
 
       case GOOGLE_INSTANT_ENABLED:
         url.insert(i->index, search_terms_data.InstantEnabledParam());
         break;
 
       case GOOGLE_ORIGINAL_QUERY_FOR_SUGGESTION:
-        if (accepted_suggestion >= 0)
+        if (search_terms_args.accepted_suggestion >= 0 ||
+            !search_terms_args.assisted_query_stats.empty()) {
           url.insert(i->index, "oq=" + UTF16ToUTF8(encoded_original_query) +
                                "&");
+        }
         break;
 
       case GOOGLE_RLZ: {
         // On platforms that don't have RLZ, we still want this branch
         // to happen so that we replace the RLZ template with the
         // empty string.  (If we don't handle this case, we hit a
         // NOTREACHED below.)
 #if defined(ENABLE_RLZ)
         string16 rlz_string = search_terms_data.GetRlzParameterValue();
         if (!rlz_string.empty()) {
           url.insert(i->index, "rlz=" + UTF16ToUTF8(rlz_string) + "&");
         }
 #endif
         break;
       }
 
       case GOOGLE_SEARCH_FIELDTRIAL_GROUP:
         if (AutocompleteFieldTrial::InSuggestFieldTrial()) {
           // Add something like sugexp=chrome,mod=5 to the URL request.
           url.insert(i->index, "sugexp=chrome,mod=" +
               AutocompleteFieldTrial::GetSuggestGroupName() + "&");
         }
         break;
 
       case GOOGLE_UNESCAPED_SEARCH_TERMS: {
         std::string unescaped_terms;
-        base::UTF16ToCodepage(terms, input_encoding.c_str(),
+        base::UTF16ToCodepage(search_terms_args.search_terms,
+                              input_encoding.c_str(),
                               base::OnStringConversionError::SKIP,
                               &unescaped_terms);
         url.insert(i->index, std::string(unescaped_terms.begin(),
                                          unescaped_terms.end()));
         break;
       }
 
       case LANGUAGE:
         url.insert(i->index, search_terms_data.GetApplicationLocale());
         break;
@@ skipping 139 matching lines @@
       url->insert(start, "1");
   } else if (parameter == kLanguageParameter) {
     replacements->push_back(Replacement(LANGUAGE, start));
   } else if (parameter == kInputEncodingParameter) {
     replacements->push_back(Replacement(ENCODING, start));
   } else if (parameter == kOutputEncodingParameter) {
     if (!optional)
       url->insert(start, kOutputEncodingType);
   } else if (parameter == kGoogleAcceptedSuggestionParameter) {
     replacements->push_back(Replacement(GOOGLE_ACCEPTED_SUGGESTION, start));
+  } else if (parameter == kGoogleAssistedQueryStatsParameter) {
+    replacements->push_back(Replacement(GOOGLE_ASSISTED_QUERY_STATS, start));
   } else if (parameter == kGoogleBaseURLParameter) {
     replacements->push_back(Replacement(GOOGLE_BASE_URL, start));
   } else if (parameter == kGoogleBaseSuggestURLParameter) {
     replacements->push_back(Replacement(GOOGLE_BASE_SUGGEST_URL, start));
   } else if (parameter == kGoogleInstantEnabledParameter) {
     replacements->push_back(Replacement(GOOGLE_INSTANT_ENABLED, start));
   } else if (parameter == kGoogleOriginalQueryForSuggestionParameter) {
     replacements->push_back(Replacement(GOOGLE_ORIGINAL_QUERY_FOR_SUGGESTION,
                                         start));
   } else if (parameter == kGoogleRLZParameter) {
@@ skipping 249 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));
   }
 }