Add SBClientDownload.DownloadRequestNetworkDuration and DownloadRequestTimeoutDuration histograms.

chrome/browser/safe_browsing/download_protection_service.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/safe_browsing/download_protection_service.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 337 matching lines @@
   }
 
   // Start a timeout to cancel the request if it takes too long.
   // This should only be called after we have finished accessing the file.
   void StartTimeout() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (!service_) {
       // Request has already been cancelled.
       return;
     }
+    timeout_start_time_ = base::TimeTicks::Now();
     BrowserThread::PostDelayedTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&CheckClientDownloadRequest::Cancel,
                    weakptr_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(
             service_->download_request_timeout_ms()));
   }
 
   // Canceling a request will cause us to always report the result as SAFE
@@ skipping 75 matching lines @@
                     << response.verdict();
         reason = REASON_INVALID_RESPONSE_VERDICT;
       }
       DownloadFeedbackService::MaybeStorePingsForDownload(
           result, item_, client_download_request_data_, data);
     }
     // We don't need the fetcher anymore.
     fetcher_.reset();
     UMA_HISTOGRAM_TIMES("SBClientDownload.DownloadRequestDuration",
                         base::TimeTicks::Now() - start_time_);
+    UMA_HISTOGRAM_TIMES("SBClientDownload.DownloadRequestNetworkDuration",
+                        base::TimeTicks::Now() - request_start_time_);
     FinishRequest(result, reason);
   }
 
   static bool IsSupportedDownload(const content::DownloadItem& item,
                                   const base::FilePath& target_path,
                                   DownloadCheckResultReason* reason,
                                   ClientDownloadRequest::DownloadType* type) {
     if (item.GetUrlChain().empty()) {
       *reason = REASON_EMPTY_URL_CHAIN;
       return false;
@@ skipping 263 matching lines @@
             << item_->GetUrlChain().back();
     fetcher_.reset(net::URLFetcher::Create(0 /* ID used for testing */,
                                            GetDownloadRequestUrl(),
                                            net::URLFetcher::POST,
                                            this));
     fetcher_->SetLoadFlags(net::LOAD_DISABLE_CACHE);
     fetcher_->SetAutomaticallyRetryOn5xx(false);  // Don't retry on error.
     fetcher_->SetRequestContext(service_->request_context_getter_.get());
     fetcher_->SetUploadData("application/octet-stream",
                             client_download_request_data_);
+    request_start_time_ = base::TimeTicks::Now();
     UMA_HISTOGRAM_COUNTS("SBClientDownload.DownloadRequestPayloadSize",
                          client_download_request_data_.size());
     fetcher_->Start();
   }
 
   void PostFinishTask(DownloadCheckResult result,
                       DownloadCheckResultReason reason) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&CheckClientDownloadRequest::FinishRequest, this, result,
                    reason));
   }
 
   void FinishRequest(DownloadCheckResult result,
                      DownloadCheckResultReason reason) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (finished_) {
       return;
     }
     finished_ = true;
     // Ensure the timeout task is cancelled while we still have a non-zero
     // refcount. (crbug.com/240449)
     weakptr_factory_.InvalidateWeakPtrs();
+    if (!request_start_time_.is_null()) {
+      UMA_HISTOGRAM_ENUMERATION("SBClientDownload.DownloadRequestNetworkStats",
+                                reason,
+                                REASON_MAX);
+    }
+    if (!timeout_start_time_.is_null()) {
+      UMA_HISTOGRAM_ENUMERATION("SBClientDownload.DownloadRequestTimeoutStats",
+                                reason,
+                                REASON_MAX);
+      if (reason != REASON_REQUEST_CANCELED) {
+        UMA_HISTOGRAM_TIMES("SBClientDownload.DownloadRequestTimeoutDuration",
+                            base::TimeTicks::Now() - timeout_start_time_);
+      }
+    }
     if (service_) {
       VLOG(2) << "SafeBrowsing download verdict for: "
               << item_->DebugString(true) << " verdict:" << reason;
       UMA_HISTOGRAM_ENUMERATION("SBClientDownload.CheckDownloadStats",
                                 reason,
                                 REASON_MAX);
       callback_.Run(result);
       item_->RemoveObserver(this);
       item_ = NULL;
       DownloadProtectionService* service = service_;
@@ skipping 70 matching lines @@
   const bool pingback_enabled_;
   scoped_ptr<net::URLFetcher> fetcher_;
   scoped_refptr<SandboxedZipAnalyzer> analyzer_;
   base::TimeTicks zip_analysis_start_time_;
   bool finished_;
   ClientDownloadRequest::DownloadType type_;
   std::string client_download_request_data_;
   CancelableRequestConsumer request_consumer_;  // For HistoryService lookup.
   base::WeakPtrFactory<CheckClientDownloadRequest> weakptr_factory_;
   base::TimeTicks start_time_;  // Used for stats.
+  base::TimeTicks timeout_start_time_;
+  base::TimeTicks request_start_time_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckClientDownloadRequest);
 };
 
 DownloadProtectionService::DownloadProtectionService(
     SafeBrowsingService* sb_service,
     net::URLRequestContextGetter* request_context_getter)
     : request_context_getter_(request_context_getter),
       enabled_(false),
       binary_feature_extractor_(new BinaryFeatureExtractor()),
@@ skipping 180 matching lines @@
 GURL DownloadProtectionService::GetDownloadRequestUrl() {
   GURL url(kDownloadRequestUrl);
   std::string api_key = google_apis::GetAPIKey();
   if (!api_key.empty())
     url = url.Resolve("?key=" + net::EscapeQueryParamValue(api_key, true));
 
   return url;
 }
 
 }  // namespace safe_browsing