NetLogEventParameter to Callback refactoring 8.

net/base/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/base/multi_threaded_cert_verifier.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 74 matching lines @@
 
 // Represents the output and result callback of a request.
 class CertVerifierRequest {
  public:
   CertVerifierRequest(const CompletionCallback& callback,
                       CertVerifyResult* verify_result,
                       const BoundNetLog& net_log)
       : callback_(callback),
         verify_result_(verify_result),
         net_log_(net_log) {
-    net_log_.BeginEvent(NetLog::TYPE_CERT_VERIFIER_REQUEST, NULL);
+    net_log_.BeginEvent(NetLog::TYPE_CERT_VERIFIER_REQUEST);
   }
 
   ~CertVerifierRequest() {
   }
 
   // Ensures that the result callback will never be made.
   void Cancel() {
     callback_.Reset();
     verify_result_ = NULL;
-    net_log_.AddEvent(NetLog::TYPE_CANCELLED, NULL);
-    net_log_.EndEvent(NetLog::TYPE_CERT_VERIFIER_REQUEST, NULL);
+    net_log_.AddEvent(NetLog::TYPE_CANCELLED);
+    net_log_.EndEvent(NetLog::TYPE_CERT_VERIFIER_REQUEST);
   }
 
   // Copies the contents of |verify_result| to the caller's
   // CertVerifyResult and calls the callback.
   void Post(const MultiThreadedCertVerifier::CachedResult& verify_result) {
     if (!callback_.is_null()) {
-      net_log_.EndEvent(NetLog::TYPE_CERT_VERIFIER_REQUEST, NULL);
+      net_log_.EndEvent(NetLog::TYPE_CERT_VERIFIER_REQUEST);
       *verify_result_ = verify_result.result;
       callback_.Run(verify_result.error);
     }
     delete this;
   }
 
   bool canceled() const { return callback_.is_null(); }
 
   const BoundNetLog& net_log() const { return net_log_; }
 
@@ skipping 140 matching lines @@
         worker_(worker),
         net_log_(net_log) {
     net_log_.BeginEvent(
         NetLog::TYPE_CERT_VERIFIER_JOB,
         base::Bind(&NetLogX509CertificateCallback,
                    base::Unretained(worker_->certificate())));
   }
 
   ~CertVerifierJob() {
     if (worker_) {
-      net_log_.AddEvent(NetLog::TYPE_CANCELLED, NULL);
-      net_log_.EndEvent(NetLog::TYPE_CERT_VERIFIER_JOB, NULL);
+      net_log_.AddEvent(NetLog::TYPE_CANCELLED);
+      net_log_.EndEvent(NetLog::TYPE_CERT_VERIFIER_JOB);
       worker_->Cancel();
       DeleteAllCanceled();
     }
   }
 
   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) {
     worker_ = NULL;
-    net_log_.EndEvent(NetLog::TYPE_CERT_VERIFIER_JOB, NULL);
+    net_log_.EndEvent(NetLog::TYPE_CERT_VERIFIER_JOB);
     UMA_HISTOGRAM_CUSTOM_TIMES("Net.CertVerifier_Job_Latency",
                                base::TimeTicks::Now() - start_time_,
                                base::TimeDelta::FromMilliseconds(1),
                                base::TimeDelta::FromMinutes(10),
                                100);
     PostAll(verify_result);
   }
 
  private:
   void PostAll(const MultiThreadedCertVerifier::CachedResult& verify_result) {
@@ skipping 145 matching lines @@
   DCHECK(CalledOnValidThread());
 
   ClearCache();
 }
 
 void MultiThreadedCertVerifier::SetCertVerifyProc(CertVerifyProc* verify_proc) {
   verify_proc_ = verify_proc;
 }
 
 }  // namespace net