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 1010 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();
       }
     }
   }
 }
 
+namespace {

[msw, 2012/06/13 22:39:33]

anon namespaces and contents belong at the top of the file; ~line 57

[Bart N, 2012/06/13 23:17:13]

Done.

+
+// Converts the given type to an integer based on the AQS specification.

[msw, 2012/06/13 22:39:33]

Are these magic numbers really necessary? Why not use the existing
AutocompleteMatch::Type values?

[Bart N, 2012/06/13 23:17:13]

These values must map to existing enum on the server side. I can't reuse
existing values. One question though - should I create constants for these
values and put it somewhere in anon namespace?

[msw, 2012/06/13 23:42:08]

I wouldn't bother, but maybe add a vague statement about where they map from.
(can't link to server code, but you can say "These numbers match those in server
code, see <enum name>." or similar.

+int AutocompletMatchToAssistedQueryType(const AutocompleteMatch::Type& type) {

[msw, 2012/06/13 22:39:33]

Spelling: Autocomplet*e*MatchToAssistedQueryType

[Bart N, 2012/06/13 23:17:13]

Done.

+  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 query stats of the given type and number to the existing AQS string.
+void AppendQueryStats(int type, int count, std::string* aqs) {
+  if (!aqs->empty())
+    aqs->append("j");
+  base::StringAppendF(aqs, "%d", type);
+  if (count > 1)
+    base::StringAppendF(aqs, "l%d", count);
+}
+
+}  // namespace
+
+void AutocompleteController::UpdateAssistedQueryStats(
+    AutocompleteResult* result) {
+  if (result->empty())
+    return;
+
+  // Build the impressions string (the AQS part after ".").
+  std::string aqs;

[msw, 2012/06/13 22:39:33]

Use string16 if possible.

[Bart N, 2012/06/13 23:17:13]

Hmmm.. a few methods broke when I switched to string16. For instance, I'm using
StringAppendF which doesn't support string16, is there any alternative for that?

[msw, 2012/06/13 23:42:08]

Use + and += operators, IIRC. See base/string16.h and base/string_util.h, etc.
for more as needed. 

+  int count = 0;
+  int last_type = -1;
+  for (ACMatches::iterator match(result->begin()); match != result->end();

[msw, 2012/06/13 22:39:33]

Is there a reason for combining consecutive matches by type here? Does it make
sense to just list each match type here and analyze them as needed offline?

[Bart N, 2012/06/13 23:17:13]

Yes, it's required by the spec. For instance, instead of 0j0j0, we have to send
0l3 (length=3).

[msw, 2012/06/13 23:42:08]

Fair enough.

+       ++match) {
+    int type = AutocompletMatchToAssistedQueryType(match->type);
+    if (last_type != -1 && type != last_type) {
+      AppendQueryStats(last_type, count, &aqs);
+      count = 1;
+    } else {
+      count++;
+    }
+    last_type = type;
+  }
+  AppendQueryStats(last_type, count, &aqs);

[msw, 2012/06/13 22:39:33]

Should this be done even if there were no matches?

[Bart N, 2012/06/13 23:17:13]

There is always at least one. See the check at the top of this function.

[msw, 2012/06/13 23:42:08]

Doh! Thanks for the heads up on the empty check.

+
+  // Go over all matches and set AQS if the match supports it.
+  int index = 0;
+  for (AutocompleteResult::iterator i = result->begin(); i != result->end();

[msw, 2012/06/13 22:39:33]

nit: consistency is nice, consider matching your loop above.

[Bart N, 2012/06/13 23:17:13]

Ah yes, done.

+       ++i, ++index) {
+    if (i->provider != search_provider_)

[msw, 2012/06/13 22:39:33]

It'd be nice if we could put this logic in SearchProvider match generation
itself, but I guess that doesn't work if we need to know the final aggregated
ordering of all the match types from all the providers.

[Bart N, 2012/06/13 23:17:13]

Currently, I rely on the fact that we check for SupportsAssistedQueryStats.
Actually,  this check may be entirely unnecessary, because only Google Provider,
which is a SearchProvider, will have it set. Anyway, let me know.

[msw, 2012/06/13 23:42:08]

So, I'm not terribly familiar with AQS or what you're trying to achieve. It
looks like you need data about all the aggregated matches from various
providers, right? If so, then this seems to be the right place for this code. If
you only need to know about the matches that the SearchProvider creates (and not
know for example, that a history match listed above/between them, or some search
matches weren't included in the displayed set, etc.), then move this code to
SearchProvider.

+      continue;
+    const TemplateURL* template_url = i->GetTemplateURL(profile_);
+    if (!template_url || !template_url->url_ref().SupportsAssistedQueryStats())
+      continue;
+    std::string url(i->destination_url.spec());
+    if (url.find("&aqs=") != std::string::npos)
+      continue;
+    url.append(base::StringPrintf("&aqs=%d", index)).append(".").append(aqs);

[msw, 2012/06/13 22:39:33]

Whoa, we're sending the ordered list of match types to the search provider? Has
that gone through privacy review?

[Bart N, 2012/06/13 23:17:13]

Yes. It was approved today, I can forward an email if you are interested in.

[msw, 2012/06/13 23:42:08]

You should link this CL to a chromium bug (set BUG=###### in the CL
description). In my experience, there's security/privacy review tags there (or
in a corresponding bug) as needed; that'd bring peace of mind to your reviewers
:)

+    i->destination_url = GURL(url);
+
+    VLOG(1) << "[" << i->provider->name() << "] URL = " << i->destination_url;

[msw, 2012/06/13 22:39:33]

Will this LOG help end users? if not, please remove.

[Bart N, 2012/06/13 23:17:13]

Removed.

+  }
+}
+
 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() {
 }