net: rename BoundNetLog to NetLogWithSource

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 <memory>
 #include <utility>
 
@@ skipping 109 matching lines @@
 
 // Represents the output and result callback of a request. The
 // CertVerifierRequest is owned by the caller that initiated the call to
 // CertVerifier::Verify().
 class CertVerifierRequest : public base::LinkNode<CertVerifierRequest>,
                             public CertVerifier::Request {
  public:
   CertVerifierRequest(CertVerifierJob* job,
                       const CompletionCallback& callback,
                       CertVerifyResult* verify_result,
-                      const BoundNetLog& net_log)
+                      const NetLogWithSource& net_log)
       : job_(job),
         callback_(callback),
         verify_result_(verify_result),
         net_log_(net_log) {
     net_log_.BeginEvent(NetLogEventType::CERT_VERIFIER_REQUEST);
   }
 
   // Cancels the request.
   ~CertVerifierRequest() override {
     if (job_) {
@@ skipping 18 matching lines @@
     *verify_result_ = verify_result.result;
 
     base::ResetAndReturn(&callback_).Run(verify_result.error);
   }
 
   void OnJobCancelled() {
     job_ = nullptr;
     callback_.Reset();
   }
 
-  const BoundNetLog& net_log() const { return net_log_; }
+  const NetLogWithSource& net_log() const { return net_log_; }
 
  private:
   CertVerifierJob* job_;  // Not owned.
   CompletionCallback callback_;
   CertVerifyResult* verify_result_;
-  const BoundNetLog net_log_;
+  const NetLogWithSource net_log_;
 };
 
 // DoVerifyOnWorkerThread runs the verification synchronously on a worker
 // thread. The output parameters (error and result) must remain alive.
 void DoVerifyOnWorkerThread(const scoped_refptr<CertVerifyProc>& verify_proc,
                             const scoped_refptr<X509Certificate>& cert,
                             const std::string& hostname,
                             const std::string& ocsp_response,
                             int flags,
                             const scoped_refptr<CRLSet>& crl_set,
@@ skipping 17 matching lines @@
 }
 
 // CertVerifierJob lives only on the verifier's origin message loop.
 class CertVerifierJob {
  public:
   CertVerifierJob(const CertVerifier::RequestParams& key,
                   NetLog* net_log,
                   MultiThreadedCertVerifier* cert_verifier)
       : key_(key),
         start_time_(base::TimeTicks::Now()),
-        net_log_(
-            BoundNetLog::Make(net_log, NetLogSourceType::CERT_VERIFIER_JOB)),
+        net_log_(NetLogWithSource::Make(net_log,
+                                        NetLogSourceType::CERT_VERIFIER_JOB)),
         cert_verifier_(cert_verifier),
         is_first_job_(false),
         weak_ptr_factory_(this) {
     net_log_.BeginEvent(NetLogEventType::CERT_VERIFIER_JOB,
                         base::Bind(&NetLogX509CertificateCallback,
                                    base::Unretained(key.certificate().get())));
   }
 
   // Indicates whether this was the first job started by the CertVerifier. This
   // is only used for logging certain UMA stats.
@@ skipping 37 matching lines @@
            it != requests_.end(); it = it->next()) {
         it->value()->OnJobCancelled();
       }
     }
   }
 
   // Creates and attaches a request to the Job.
   std::unique_ptr<CertVerifierRequest> CreateRequest(
       const CompletionCallback& callback,
       CertVerifyResult* verify_result,
-      const BoundNetLog& net_log) {
+      const NetLogWithSource& net_log) {
     std::unique_ptr<CertVerifierRequest> request(
         new CertVerifierRequest(this, callback, verify_result, net_log));
 
     request->net_log().AddEvent(
         NetLogEventType::CERT_VERIFIER_REQUEST_BOUND_TO_JOB,
         net_log_.source().ToEventParametersCallback());
 
     requests_.Append(request.get());
     return request;
   }
@@ skipping 39 matching lines @@
     }
   }
 
   const CertVerifier::RequestParams key_;
   // The tick count of when the job started. This is used to measure how long
   // the job actually took to complete.
   const base::TimeTicks start_time_;
 
   RequestList requests_;  // Non-owned.
 
-  const BoundNetLog net_log_;
+  const NetLogWithSource net_log_;
   MultiThreadedCertVerifier* cert_verifier_;  // Non-owned.
 
   bool is_first_job_;
   base::WeakPtrFactory<CertVerifierJob> weak_ptr_factory_;
 };
 
 MultiThreadedCertVerifier::MultiThreadedCertVerifier(
     CertVerifyProc* verify_proc)
     : requests_(0), inflight_joins_(0), verify_proc_(verify_proc) {}
 
 MultiThreadedCertVerifier::~MultiThreadedCertVerifier() {
   base::STLDeleteElements(&inflight_);
 }
 
 int MultiThreadedCertVerifier::Verify(const RequestParams& params,
                                       CRLSet* crl_set,
                                       CertVerifyResult* verify_result,
                                       const CompletionCallback& callback,
                                       std::unique_ptr<Request>* out_req,
-                                      const BoundNetLog& net_log) {
+                                      const NetLogWithSource& net_log) {
   out_req->reset();
 
   DCHECK(CalledOnValidThread());
 
   if (callback.is_null() || !verify_result || params.hostname().empty())
     return ERR_INVALID_ARGUMENT;
 
   requests_++;
 
   // See if an identical request is currently in flight.
@@ skipping 57 matching lines @@
   // The JobSet is kept in sorted order so items can be found using binary
   // search.
   auto it = std::lower_bound(inflight_.begin(), inflight_.end(), key,
                              JobToRequestParamsComparator());
   if (it != inflight_.end() && !(key < (*it)->key()))
     return *it;
   return nullptr;
 }
 
 }  // namespace net