A working implementation of AQS (Assisted Query Stats).

chrome/browser/autocomplete/autocomplete.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/autocomplete/autocomplete.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/i18n/number_formatting.h"
 #include "base/metrics/histogram.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_controller_delegate.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/autocomplete/builtin_provider.h"
 #include "chrome/browser/autocomplete/extension_app_provider.h"
 #include "chrome/browser/autocomplete/history_contents_provider.h"
 #include "chrome/browser/autocomplete/history_quick_provider.h"
 #include "chrome/browser/autocomplete/history_url_provider.h"
 #include "chrome/browser/autocomplete/keyword_provider.h"
 #include "chrome/browser/autocomplete/search_provider.h"
@@ skipping 19 matching lines @@
 #include "googleurl/src/url_util.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "net/base/net_util.h"
 #include "net/base/registry_controlled_domain.h"
 #include "net/url_request/url_request.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using base::TimeDelta;
 
+
 // AutocompleteInput ----------------------------------------------------------
 
 AutocompleteInput::AutocompleteInput()
   : type_(INVALID),
     prevent_inline_autocomplete_(false),
     prefer_keyword_(false),
     allow_exact_keyword_match_(true),
     matches_requested_(ALL_MATCHES) {
 }
 
@@ skipping 713 matching lines @@
 AutocompleteResult::iterator AutocompleteResult::end() {
   return matches_.end();
 }
 
 // Returns the match at the given index.
 const AutocompleteMatch& AutocompleteResult::match_at(size_t index) const {
   DCHECK(index < matches_.size());
   return matches_[index];
 }
 
+AutocompleteMatch* AutocompleteResult::match_at(size_t index) {
+  DCHECK(index < matches_.size());
+  return &matches_[index];
+}
+
 void AutocompleteResult::Reset() {
   matches_.clear();
   default_match_ = end();
 }
 
 void AutocompleteResult::Swap(AutocompleteResult* other) {
   const size_t default_match_offset = default_match_ - begin();
   const size_t other_default_match_offset =
       other->default_match_ - other->begin();
   matches_.swap(other->matches_);
@@ skipping 46 matching lines @@
       match.relevance = std::min(max_relevance, match.relevance);
       match.from_previous = true;
       AddMatch(match);
       delta--;
     }
   }
 }
 
 // AutocompleteController -----------------------------------------------------
 
+namespace {
+
+// Converts the given type to an integer based on the AQS specification.
+// For more details, See http://goto.google.com/binary-clients-logging .
+int AutocompleteMatchToAssistedQueryType(const AutocompleteMatch::Type& type) {
+  switch (type) {
+    case AutocompleteMatch::SEARCH_SUGGEST:        return 0;
+    case AutocompleteMatch::NAVSUGGEST:            return 5;
+    case AutocompleteMatch::SEARCH_WHAT_YOU_TYPED: return 57;
+    case AutocompleteMatch::URL_WHAT_YOU_TYPED:    return 58;
+    case AutocompleteMatch::SEARCH_HISTORY:        return 59;
+    case AutocompleteMatch::HISTORY_URL:           return 60;
+    case AutocompleteMatch::HISTORY_TITLE:         return 61;
+    case AutocompleteMatch::HISTORY_BODY:          return 62;
+    case AutocompleteMatch::HISTORY_KEYWORD:       return 63;
+    default:                                       return 64;
+  }
+}
+
+// Appends available autocompletion of the given type and number to the existing
+// available autocompletions string, encoding according to the spec.
+void AppendAvailableAutocompletion(int type,
+                                   int count,
+                                   std::string* autocompletions) {
+  if (!autocompletions->empty())
+    autocompletions->append("j");
+  base::StringAppendF(autocompletions, "%d", type);
+  if (count > 1)
+    base::StringAppendF(autocompletions, "l%d", count);
+}
+
+// Constructs the final form of AQS param.
+std::string ConstructAssistedQueryStatsString(
+    const std::string& client,
+    int query_index,

[Peter Kasting, 2012/06/18 19:45:52]

Taking an int here results in a typecast (bad anyway + may warn on other OSes). 
Take a size_t, and make the StringPrintf() format string be:

  "%s.%" PRIuS ".%s"

If this macro isn't defined you can get it from base/format_macros.h.

Note: I still think it'd be just as clear -- and shorter overall -- to inline
this StringPrintf() call in the caller and aliminate this helper function.

[Bart N, 2012/06/18 20:34:18]

Ah thanks, I was searching on the web and couldn't find a good way.
Done.

+    const std::string& available_autocompletions) {
+  return base::StringPrintf("%s.%d.%s", client.c_str(), query_index,
+                            available_autocompletions.c_str());
+}
+
+}  // namespace
+
 const int AutocompleteController::kNoItemSelected = -1;
 
 // Amount of time (in ms) between when the user stops typing and when we remove
 // any copied entries. We do this from the time the user stopped typing as some
 // providers (such as SearchProvider) wait for the user to stop typing before
 // they initiate a query.
 static const int kExpireTimeMS = 500;
 
 AutocompleteController::AutocompleteController(
     Profile* profile,
@@ skipping 172 matching lines @@
 #endif
 
   if (!done_) {
     // This conditional needs to match the conditional in Start that invokes
     // StartExpireTimer.
     result_.CopyOldMatches(input_, last_result);
   }
 
   UpdateKeywordDescriptions(&result_);
   UpdateAssociatedKeywords(&result_);
+  UpdateAssistedQueryStats(&result_);
 
   bool notify_default_match = is_synchronous_pass;
   if (!is_synchronous_pass) {
     const bool last_default_was_valid =
         last_result.default_match() != last_result.end();
     const bool default_is_valid = result_.default_match() != result_.end();
     // We've gotten async results. Send notification that the default match
     // updated if fill_into_edit differs or associated_keyword differ.  (The
     // latter can change if we've just started Chrome and the keyword database
     // finishes loading while processing this request.) We don't check the URL
@@ skipping 36 matching lines @@
           match->associated_keyword.reset(new AutocompleteMatch(
               keyword_provider_->CreateAutocompleteMatch(match->fill_into_edit,
                   keyword, input_)));
       } else {
         match->associated_keyword.reset();
       }
     }
   }
 }
 
+void AutocompleteController::UpdateAssistedQueryStats(
+    AutocompleteResult* result) {
+  if (result->empty())
+    return;
+
+  // Build the impressions string (the AQS part after ".").
+  std::string autocompletions;
+  int count = 0;
+  int last_type = -1;
+  for (ACMatches::iterator match(result->begin()); match != result->end();
+       ++match) {
+    int type = AutocompleteMatchToAssistedQueryType(match->type);
+    if (last_type != -1 && type != last_type) {
+      AppendAvailableAutocompletion(last_type, count, &autocompletions);
+      count = 1;
+    } else {
+      count++;
+    }
+    last_type = type;
+  }
+  AppendAvailableAutocompletion(last_type, count, &autocompletions);
+
+  // Go over all matches and set AQS if the match supports it.
+  for (size_t index = 0; index < result->size(); ++index) {
+    AutocompleteMatch* match = result->match_at(index);
+    const TemplateURL* template_url = match->GetTemplateURL(profile_);
+    if (!template_url || !match->search_terms_args.get())
+      continue;
+    match->search_terms_args->assisted_query_stats =
+        ConstructAssistedQueryStatsString("chrome", index, autocompletions);
+    match->destination_url = GURL(template_url->url_ref().ReplaceSearchTerms(
+        *match->search_terms_args));
+  }
+}
+
 void AutocompleteController::UpdateKeywordDescriptions(
     AutocompleteResult* result) {
   string16 last_keyword;
   for (AutocompleteResult::iterator i = result->begin(); i != result->end();
        ++i) {
     if (((i->provider == keyword_provider_) && !i->keyword.empty()) ||
         ((i->provider == search_provider_) &&
          (i->type == AutocompleteMatch::SEARCH_WHAT_YOU_TYPED ||
           i->type == AutocompleteMatch::SEARCH_HISTORY ||
           i->type == AutocompleteMatch::SEARCH_SUGGEST))) {
@@ skipping 66 matching lines @@
       current_page_classification(current_page_classification),
       elapsed_time_since_user_first_modified_omnibox(
           elapsed_time_since_user_first_modified_omnibox),
       inline_autocompleted_length(inline_autocompleted_length),
       result(result),
       providers_info() {
 }
 
 AutocompleteLog::~AutocompleteLog() {
 }