Add UMA stats to track whitelist download latency.

components/autofill/browser/autocheckout/whitelist_manager.cc

 // Copyright (c) 2013 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 "components/autofill/browser/autocheckout/whitelist_manager.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
@@ skipping 37 matching lines @@
 }
 
 WhitelistManager::~WhitelistManager() {}
 
 void WhitelistManager::Init(net::URLRequestContextGetter* context_getter) {
   DCHECK(context_getter);
   context_getter_ = context_getter;
   ScheduleDownload(kInitialDownloadDelaySeconds);
 }
 
+const AutofillMetrics& WhitelistManager::GetMetricLogger() const {
+  return metrics_logger_;
+}

[Ilya Sherman, 2013/04/17 05:01:48]

nit: Please order this so that its sorted the same in the header and in the
implementation file.

[benquan, 2013/04/17 05:48:18]

Done.

+
 void WhitelistManager::ScheduleDownload(size_t interval_seconds) {
   if (!experimental_form_filling_enabled_) {
     // The feature is not enabled: do not do the request.
     return;
   }
   if (download_timer_.IsRunning() || callback_is_pending_) {
     // A download activity is already scheduled or happening.
     return;
   }
   StartDownloadTimer(interval_seconds);
 }
 
 void WhitelistManager::StartDownloadTimer(size_t interval_seconds) {
   download_timer_.Start(FROM_HERE,
                         base::TimeDelta::FromSeconds(interval_seconds),
                         this,
                         &WhitelistManager::TriggerDownload);
 }
 
 void WhitelistManager::TriggerDownload() {
   callback_is_pending_ = true;
 
+  request_started_timestamp_ = base::Time::Now();
+
   request_.reset(net::URLFetcher::Create(
       0, GURL(kWhitelistUrl), net::URLFetcher::GET, this));
   request_->SetRequestContext(context_getter_);
   request_->SetAutomaticallyRetryOn5xx(false);
   request_->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES |
                          net::LOAD_DO_NOT_SEND_COOKIES);
   request_->Start();
 }
 
 void WhitelistManager::StopDownloadTimer() {
   download_timer_.Stop();
   callback_is_pending_ = false;
 }
 
 void WhitelistManager::OnURLFetchComplete(
     const net::URLFetcher* source) {
   DCHECK(callback_is_pending_);
   callback_is_pending_ = false;
   scoped_ptr<net::URLFetcher> old_request = request_.Pass();
   DCHECK_EQ(source, old_request.get());
 
   if (source->GetResponseCode() == net::HTTP_OK) {
+    GetMetricLogger().LogAutocheckoutWhitelistDownloadDuration(
+        base::Time::Now() - request_started_timestamp_,
+        AutofillMetrics::AUTOCHECKOUT_WHITELIST_DOWNLOAD_SUCCEEDED);
     std::string data;
     source->GetResponseAsString(&data);
     BuildWhitelist(data);
+  } else {
+    GetMetricLogger().LogAutocheckoutWhitelistDownloadDuration(
+        base::Time::Now() - request_started_timestamp_,
+        AutofillMetrics::AUTOCHECKOUT_WHITELIST_DOWNLOAD_FAILED);
   }
 
   ScheduleDownload(kDownloadIntervalSeconds);
 }
 
 std::string WhitelistManager::GetMatchedURLPrefix(const GURL& url) const {
   if (!experimental_form_filling_enabled_ || url.is_empty())
     return std::string();
 
   for (std::vector<std::string>::const_iterator it = url_prefixes_.begin();
@@ skipping 25 matching lines @@
       // Chrome can ignore them and continue to work.
       if (!fields[0].empty())
         new_url_prefixes.push_back(fields[0]);
     }
   }
   url_prefixes_ = new_url_prefixes;
 }
 
 }  // namespace autocheckout
 }  // namespace autofill