Update net/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

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 186 matching lines @@
         crl_set_(crl_set),
         additional_trust_anchors_(additional_trust_anchors),
         origin_loop_(base::MessageLoop::current()),
         cert_verifier_(cert_verifier),
         canceled_(false),
         error_(ERR_FAILED) {
   }
 
   // Returns the certificate being verified. May only be called /before/
   // Start() is called.
-  X509Certificate* certificate() const { return cert_; }
+  X509Certificate* certificate() const { return cert_.get(); }
 
   bool Start() {
     DCHECK_EQ(base::MessageLoop::current(), origin_loop_);
 
     return base::WorkerPool::PostTask(
         FROM_HERE, base::Bind(&CertVerifierWorker::Run, base::Unretained(this)),
         true /* task is slow */);
   }
 
   // Cancel is called from the origin loop when the MultiThreadedCertVerifier is
   // getting deleted.
   void Cancel() {
     DCHECK_EQ(base::MessageLoop::current(), origin_loop_);
     base::AutoLock locked(lock_);
     canceled_ = true;
   }
 
  private:
   void Run() {
     // Runs on a worker thread.
-    error_ = verify_proc_->Verify(cert_, hostname_, flags_, crl_set_,
-                                  additional_trust_anchors_, &verify_result_);
+    error_ = verify_proc_->Verify(cert_.get(),
+                                  hostname_,
+                                  flags_,
+                                  crl_set_.get(),
+                                  additional_trust_anchors_,
+                                  &verify_result_);
 #if defined(USE_NSS) || defined(OS_IOS)
     // Detach the thread from NSPR.
     // Calling NSS functions attaches the thread to NSPR, which stores
     // the NSPR thread ID in thread-specific data.
     // The threads in our thread pool terminate after we have called
     // PR_Cleanup.  Unless we detach them from NSPR, net_unittests gets
     // segfaults on shutdown when the threads' thread-specific data
     // destructors run.
     PR_DetachThread();
 #endif
     Finish();
   }
 
   // DoReply runs on the origin thread.
   void DoReply() {
     DCHECK_EQ(base::MessageLoop::current(), origin_loop_);
     {
       // We lock here because the worker thread could still be in Finished,
       // after the PostTask, but before unlocking |lock_|. If we do not lock in
       // this case, we will end up deleting a locked Lock, which can lead to
       // memory leaks or worse errors.
       base::AutoLock locked(lock_);
       if (!canceled_) {
-        cert_verifier_->HandleResult(cert_, hostname_, flags_,
-                                     additional_trust_anchors_, error_,
+        cert_verifier_->HandleResult(cert_.get(),
+                                     hostname_,
+                                     flags_,
+                                     additional_trust_anchors_,
+                                     error_,
                                      verify_result_);
       }
     }
     delete this;
   }
 
   void Finish() {
     // Runs on the worker thread.
     // We assume that the origin loop outlives the MultiThreadedCertVerifier. If
     // the MultiThreadedCertVerifier is deleted, it will call Cancel on us. If
@@ skipping 176 matching lines @@
   std::map<RequestParams, CertVerifierJob*>::const_iterator j;
   j = inflight_.find(key);
   if (j != inflight_.end()) {
     // An identical request is in flight already. We'll just attach our
     // callback.
     inflight_joins_++;
     job = j->second;
   } else {
     // Need to make a new request.
     CertVerifierWorker* worker =
-        new CertVerifierWorker(verify_proc_, cert, hostname, flags, crl_set,
-                               additional_trust_anchors, this);
+        new CertVerifierWorker(verify_proc_.get(),
+                               cert,
+                               hostname,
+                               flags,
+                               crl_set,
+                               additional_trust_anchors,
+                               this);
     job = new CertVerifierJob(
         worker,
         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.
@@ skipping 82 matching lines @@
 }
 
 void MultiThreadedCertVerifier::OnCertTrustChanged(
     const X509Certificate* cert) {
   DCHECK(CalledOnValidThread());
 
   ClearCache();
 }
 
 }  // namespace net