Add Net.CertVerifier_First_Job_Latency metric.

net/cert/multi_threaded_cert_verifier.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 "net/cert/multi_threaded_cert_verifier.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 330 matching lines @@
 
   void AddRequest(CertVerifierRequest* request) {
     request->net_log().AddEvent(
         NetLog::TYPE_CERT_VERIFIER_REQUEST_BOUND_TO_JOB,
         net_log_.source().ToEventParametersCallback());
 
     requests_.push_back(request);
   }
 
   void HandleResult(
-      const MultiThreadedCertVerifier::CachedResult& verify_result) {
+      const MultiThreadedCertVerifier::CachedResult& verify_result,
+      bool is_first_job) {
     worker_ = NULL;
     net_log_.EndEvent(NetLog::TYPE_CERT_VERIFIER_JOB);
+    base::TimeDelta latency = base::TimeTicks::Now() - start_time_;
     UMA_HISTOGRAM_CUSTOM_TIMES("Net.CertVerifier_Job_Latency",
-                               base::TimeTicks::Now() - start_time_,
+                               latency,
                                base::TimeDelta::FromMilliseconds(1),
                                base::TimeDelta::FromMinutes(10),
                                100);
+    if (is_first_job) {
+      UMA_HISTOGRAM_CUSTOM_TIMES("Net.CertVerifier_First_Job_Latency",
+                                 latency,
+                                 base::TimeDelta::FromMilliseconds(1),
+                                 base::TimeDelta::FromMinutes(10),
+                                 100);
+    }
     PostAll(verify_result);
   }
 
  private:
   void PostAll(const MultiThreadedCertVerifier::CachedResult& verify_result) {
     std::vector<CertVerifierRequest*> requests;
     requests_.swap(requests);
 
     for (std::vector<CertVerifierRequest*>::iterator
          i = requests.begin(); i != requests.end(); i++) {
@@ skipping 15 matching lines @@
 
   const base::TimeTicks start_time_;
   std::vector<CertVerifierRequest*> requests_;
   CertVerifierWorker* worker_;
   const BoundNetLog net_log_;
 };
 
 MultiThreadedCertVerifier::MultiThreadedCertVerifier(
     CertVerifyProc* verify_proc)
     : cache_(kMaxCacheEntries),
+      first_job_(NULL),
       requests_(0),
       cache_hits_(0),
       inflight_joins_(0),
       verify_proc_(verify_proc),
       trust_anchor_provider_(NULL) {
   CertDatabase::GetInstance()->AddObserver(this);
 }
 
 MultiThreadedCertVerifier::~MultiThreadedCertVerifier() {
   STLDeleteValues(&inflight_);
@@ skipping 63 matching lines @@
         BoundNetLog::Make(net_log.net_log(), NetLog::SOURCE_CERT_VERIFIER_JOB));
     if (!worker->Start()) {
       delete job;
       delete worker;
       *out_req = NULL;
       // TODO(wtc): log to the NetLog.
       LOG(ERROR) << "CertVerifierWorker couldn't be started.";
       return ERR_INSUFFICIENT_RESOURCES;  // Just a guess.
     }
     inflight_.insert(std::make_pair(key, job));
+    if (requests_ == 1) {
+      // Cleared in HandleResult.
+      first_job_ = job;
+    }
   }
 
   CertVerifierRequest* request =
       new CertVerifierRequest(callback, verify_result, net_log);
   job->AddRequest(request);
   *out_req = request;
   return ERR_IO_PENDING;
 }
 
 void MultiThreadedCertVerifier::CancelRequest(RequestHandle req) {
@@ skipping 57 matching lines @@
       CacheValidityPeriod(now, now + base::TimeDelta::FromSeconds(kTTLSecs)));
 
   std::map<RequestParams, CertVerifierJob*>::iterator j;
   j = inflight_.find(key);
   if (j == inflight_.end()) {
     NOTREACHED();
     return;
   }
   CertVerifierJob* job = j->second;
   inflight_.erase(j);
+  bool is_first_job = false;
+  if (first_job_ == job) {
+    is_first_job = true;
+    first_job_ = NULL;
+  }
 
-  job->HandleResult(cached_result);
+  job->HandleResult(cached_result, is_first_job);
   delete job;
 }
 
 void MultiThreadedCertVerifier::OnCACertChanged(
     const X509Certificate* cert) {
   DCHECK(CalledOnValidThread());
 
   ClearCache();
 }
 
 }  // namespace net