Adds a UMA histogram to monitor omnibox suggest requests.

chrome/browser/autocomplete/search_provider.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/search_provider.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/callback.h"
@@ skipping 35 matching lines @@
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_status.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using base::Time;
 using base::TimeDelta;
 
 namespace {
 
+// We keep track in a histogram how many suggest requests we send, how
+// many suggest requests we invalidate (e.g., due to a user typing
+// another character), and how many replies we receive.
+// *** ADD NEW ENUMS AFTER ALL PREVIOUSLY DEFINED ONES! ***
+//     (excluding the end-of-list enum value)
+// We do not want values of existing enums to change or else it screws
+// up the statistics.
+enum SuggestRequestsHistogramValue {
+  REQUEST_SENT = 1,
+  REQUEST_INVALIDATED,
+  REPLY_RECEIVED,
+  MAX_SUGGEST_REQUEST_HISTOGRAM_VALUE
+};
+
+// Increments the appropriate value in the histogram by one.
+void LogOmniboxSuggestRequest(
+    SuggestRequestsHistogramValue request_value) {
+  UMA_HISTOGRAM_ENUMERATION("Omnibox.SuggestRequests", request_value,
+                            MAX_SUGGEST_REQUEST_HISTOGRAM_VALUE);
+}
+
 bool HasMultipleWords(const string16& text) {
   base::i18n::BreakIterator i(text, base::i18n::BreakIterator::BREAK_WORD);
   bool found_word = false;
   if (i.Init()) {
     while (i.Advance()) {
       if (i.IsWord()) {
         if (found_word)
           return true;
         found_word = true;
       }
@@ skipping 220 matching lines @@
 };
 
 void SearchProvider::Run() {
   // Start a new request with the current input.
   DCHECK(!done_);
   suggest_results_pending_ = 0;
   time_suggest_request_sent_ = base::TimeTicks::Now();
   const TemplateURL* default_url = providers_.GetDefaultProviderURL();
   if (default_url && !default_url->suggestions_url().empty()) {
     suggest_results_pending_++;
+    LogOmniboxSuggestRequest(REQUEST_SENT);
     default_fetcher_.reset(CreateSuggestFetcher(kDefaultProviderURLFetcherID,
         default_url->suggestions_url_ref(), input_.text()));
   }
   const TemplateURL* keyword_url = providers_.GetKeywordProviderURL();
   if (keyword_url && !keyword_url->suggestions_url().empty()) {
     suggest_results_pending_++;
+    LogOmniboxSuggestRequest(REQUEST_SENT);
     keyword_fetcher_.reset(CreateSuggestFetcher(kKeywordProviderURLFetcherID,
         keyword_url->suggestions_url_ref(), keyword_input_text_));
   }
 
   // Both the above can fail if the providers have been modified or deleted
   // since the query began.
   if (suggest_results_pending_ == 0) {
     UpdateDone();
     // We only need to update the listener if we're actually done.
     if (done_)
@@ skipping 13 matching lines @@
 void SearchProvider::AddProviderInfo(ProvidersInfo* provider_info) const {
   provider_info->push_back(metrics::OmniboxEventProto_ProviderInfo());
   metrics::OmniboxEventProto_ProviderInfo& new_entry = provider_info->back();
   new_entry.set_provider(AsOmniboxEventProviderType());
   new_entry.set_provider_done(done_);
 }
 
 void SearchProvider::OnURLFetchComplete(const net::URLFetcher* source) {
   DCHECK(!done_);
   suggest_results_pending_--;
+  LogOmniboxSuggestRequest(REPLY_RECEIVED);
   DCHECK_GE(suggest_results_pending_, 0);  // Should never go negative.
   const net::HttpResponseHeaders* const response_headers =
       source->GetResponseHeaders();
   std::string json_data;
   source->GetResponseAsString(&json_data);
   // JSON is supposed to be UTF-8, but some suggest service providers send JSON
   // files in non-UTF-8 encodings.  The actual encoding is usually specified in
   // the Content-Type header field.
   if (response_headers) {
     std::string charset;
@@ skipping 197 matching lines @@
   // because they are visible when the TCP connection is established, but the
   // specific path may reveal private information.
   if (LowerCaseEqualsASCII(input_.scheme(), chrome::kHttpsScheme) &&
       parts.path.is_nonempty())
     return false;
 
   return true;
 }
 
 void SearchProvider::StopSuggest() {
+  // Increment the appropriate field in the histogram by the number of
+  // pending requests that were invalidated.
+  for (int i = 0; i < suggest_results_pending_; i++)
+    LogOmniboxSuggestRequest(REQUEST_INVALIDATED);
   suggest_results_pending_ = 0;
   timer_.Stop();
   // Stop any in-progress URL fetches.
   keyword_fetcher_.reset();
   default_fetcher_.reset();
 }
 
 void SearchProvider::ClearResults() {
   keyword_suggest_results_.clear();
   default_suggest_results_.clear();
@@ skipping 650 matching lines @@
       ACMatchClassification::NONE, &match.description_class);
   return match;
 }
 
 void SearchProvider::UpdateDone() {
   // We're done when there are no more suggest queries pending (this is set to 1
   // when the timer is started) and we're not waiting on instant.
   done_ = ((suggest_results_pending_ == 0) &&
            (instant_finalized_ || !InstantController::IsEnabled(profile_)));
 }