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

net/proxy/multi_threaded_proxy_resolver.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/proxy/multi_threaded_proxy_resolver.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
@@ skipping 307 matching lines @@
   // Start up the thread.
   // Note that it is safe to pass a temporary C-String to Thread(), as it will
   // make a copy.
   std::string thread_name =
       base::StringPrintf("PAC thread #%d", thread_number);
   thread_.reset(new base::Thread(thread_name.c_str()));
   CHECK(thread_->Start());
 }
 
 void MultiThreadedProxyResolver::Executor::StartJob(Job* job) {
-  DCHECK(!outstanding_job_);
+  DCHECK(!outstanding_job_.get());
   outstanding_job_ = job;
 
   // Run the job. Once it has completed (regardless of whether it was
   // cancelled), it will invoke OnJobCompleted() on this thread.
   job->set_executor(this);
   job->FinishedWaitingForThread();
   thread_->message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&Job::Run, job, base::MessageLoopProxy::current()));
 }
 
 void MultiThreadedProxyResolver::Executor::OnJobCompleted(Job* job) {
   DCHECK_EQ(job, outstanding_job_.get());
   outstanding_job_ = NULL;
   coordinator_->OnExecutorReady(this);
 }
 
 void MultiThreadedProxyResolver::Executor::Destroy() {
   DCHECK(coordinator_);
 
   {
     // See http://crbug.com/69710.
     base::ThreadRestrictions::ScopedAllowIO allow_io;
 
     // Join the worker thread.
     thread_.reset();
   }
 
   // Cancel any outstanding job.
-  if (outstanding_job_) {
+  if (outstanding_job_.get()) {
     outstanding_job_->Cancel();
     // Orphan the job (since this executor may be deleted soon).
     outstanding_job_->set_executor(NULL);
   }
 
   // It is now safe to free the ProxyResolver, since all the tasks that
   // were using it on the resolver thread have completed.
   resolver_.reset();
 
   // Null some stuff as a precaution.
   coordinator_ = NULL;
   outstanding_job_ = NULL;
 }
 
 void MultiThreadedProxyResolver::Executor::PurgeMemory() {
   thread_->message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&ProxyResolver::PurgeMemory,
                  base::Unretained(resolver_.get())));
 }
 
 MultiThreadedProxyResolver::Executor::~Executor() {
   // The important cleanup happens as part of Destroy(), which should always be
   // called first.
   DCHECK(!coordinator_) << "Destroy() was not called";
   DCHECK(!thread_.get());
   DCHECK(!resolver_.get());
-  DCHECK(!outstanding_job_);
+  DCHECK(!outstanding_job_.get());
 }
 
 // MultiThreadedProxyResolver --------------------------------------------------
 
 MultiThreadedProxyResolver::MultiThreadedProxyResolver(
     ProxyResolverFactory* resolver_factory,
     size_t max_num_threads)
     : ProxyResolver(resolver_factory->resolvers_expect_pac_bytes()),
       resolver_factory_(resolver_factory),
       max_num_threads_(max_num_threads) {
@@ skipping 19 matching lines @@
 
   // Completion will be notified through |callback|, unless the caller cancels
   // the request using |request|.
   if (request)
     *request = reinterpret_cast<RequestHandle>(job.get());
 
   // If there is an executor that is ready to run this request, submit it!
   Executor* executor = FindIdleExecutor();
   if (executor) {
     DCHECK_EQ(0u, pending_jobs_.size());
-    executor->StartJob(job);
+    executor->StartJob(job.get());
     return ERR_IO_PENDING;
   }
 
   // Otherwise queue this request. (We will schedule it to a thread once one
   // becomes available).
   job->WaitingForThread();
   pending_jobs_.push_back(job);
 
   // If we haven't already reached the thread limit, provision a new thread to
   // drain the requests more quickly.
@@ skipping 43 matching lines @@
   // anymore.
   current_script_data_ = NULL;
 
   ReleaseAllExecutors();
 }
 
 void MultiThreadedProxyResolver::PurgeMemory() {
   DCHECK(CalledOnValidThread());
   for (ExecutorList::iterator it = executors_.begin();
        it != executors_.end(); ++it) {
-    Executor* executor = *it;
+    Executor* executor = it->get();
     executor->PurgeMemory();
   }
 }
 
 int MultiThreadedProxyResolver::SetPacScript(
     const scoped_refptr<ProxyResolverScriptData>& script_data,
     const CompletionCallback&callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(!callback.is_null());
 
@@ skipping 13 matching lines @@
   executor->StartJob(new SetPacScriptJob(script_data, callback));
   return ERR_IO_PENDING;
 }
 
 void MultiThreadedProxyResolver::CheckNoOutstandingUserRequests() const {
   DCHECK(CalledOnValidThread());
   CHECK_EQ(0u, pending_jobs_.size());
 
   for (ExecutorList::const_iterator it = executors_.begin();
        it != executors_.end(); ++it) {
-    const Executor* executor = *it;
+    const Executor* executor = it->get();
     Job* job = executor->outstanding_job();
     // The "has_user_callback()" is to exclude jobs for which the callback
     // has already been invoked, or was not user-initiated (as in the case of
     // lazy thread provisions). User-initiated jobs may !has_user_callback()
     // when the callback has already been run. (Since we only clear the
     // outstanding job AFTER the callback has been invoked, it is possible
     // for a new request to be started from within the callback).
     CHECK(!job || job->was_cancelled() || !job->has_user_callback());
   }
 }
 
 void MultiThreadedProxyResolver::ReleaseAllExecutors() {
   DCHECK(CalledOnValidThread());
   for (ExecutorList::iterator it = executors_.begin();
        it != executors_.end(); ++it) {
-    Executor* executor = *it;
+    Executor* executor = it->get();
     executor->Destroy();
   }
   executors_.clear();
 }
 
 MultiThreadedProxyResolver::Executor*
 MultiThreadedProxyResolver::FindIdleExecutor() {
   DCHECK(CalledOnValidThread());
   for (ExecutorList::iterator it = executors_.begin();
        it != executors_.end(); ++it) {
-    Executor* executor = *it;
+    Executor* executor = it->get();
     if (!executor->outstanding_job())
       return executor;
   }
   return NULL;
 }
 
 MultiThreadedProxyResolver::Executor*
 MultiThreadedProxyResolver::AddNewExecutor() {
   DCHECK(CalledOnValidThread());
   DCHECK_LT(executors_.size(), max_num_threads_);
   // The "thread number" is used to give the thread a unique name.
   int thread_number = executors_.size();
   ProxyResolver* resolver = resolver_factory_->CreateProxyResolver();
   Executor* executor = new Executor(
       this, resolver, thread_number);
   executors_.push_back(make_scoped_refptr(executor));
   return executor;
 }
 
 void MultiThreadedProxyResolver::OnExecutorReady(Executor* executor) {
   DCHECK(CalledOnValidThread());
   if (pending_jobs_.empty())
     return;
 
   // Get the next job to process (FIFO). Transfer it from the pending queue
   // to the executor.
   scoped_refptr<Job> job = pending_jobs_.front();
   pending_jobs_.pop_front();
-  executor->StartJob(job);
+  executor->StartJob(job.get());
 }
 
 }  // namespace net