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

net/proxy/proxy_resolver_v8_tracing.cc

 // Copyright (c) 2013 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/proxy_resolver_v8_tracing.h"
 
 #include "base/bind.h"
 #include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/stringprintf.h"
@@ skipping 1059 matching lines @@
   DCHECK(host_resolver);
   // Start up the thread.
   thread_.reset(new base::Thread("Proxy resolver"));
   CHECK(thread_->Start());
 
   v8_resolver_.reset(new ProxyResolverV8);
 }
 
 ProxyResolverV8Tracing::~ProxyResolverV8Tracing() {
   // Note, all requests should have been cancelled.
-  CHECK(!set_pac_script_job_);
+  CHECK(!set_pac_script_job_.get());
   CHECK_EQ(0, num_outstanding_callbacks_);
 
   // Join the worker thread. See http://crbug.com/69710. Note that we call
   // Stop() here instead of simply clearing thread_ since there may be pending
   // callbacks on the worker thread which want to dereference thread_.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
   thread_->Stop();
 }
 
 int ProxyResolverV8Tracing::GetProxyForURL(const GURL& url,
                                            ProxyInfo* results,
                                            const CompletionCallback& callback,
                                            RequestHandle* request,
                                            const BoundNetLog& net_log) {
   DCHECK(CalledOnValidThread());
   DCHECK(!callback.is_null());
-  DCHECK(!set_pac_script_job_);
+  DCHECK(!set_pac_script_job_.get());
 
   scoped_refptr<Job> job = new Job(this);
 
   if (request)
     *request = job.get();
 
   job->StartGetProxyForURL(url, results, net_log, callback);
   return ERR_IO_PENDING;
 }
 
 void ProxyResolverV8Tracing::CancelRequest(RequestHandle request) {
   Job* job = reinterpret_cast<Job*>(request);
   job->Cancel();
 }
 
 LoadState ProxyResolverV8Tracing::GetLoadState(RequestHandle request) const {
   Job* job = reinterpret_cast<Job*>(request);
   return job->GetLoadState();
 }
 
 void ProxyResolverV8Tracing::CancelSetPacScript() {
-  DCHECK(set_pac_script_job_);
+  DCHECK(set_pac_script_job_.get());
   set_pac_script_job_->Cancel();
   set_pac_script_job_ = NULL;
 }
 
 void ProxyResolverV8Tracing::PurgeMemory() {
   thread_->message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&ProxyResolverV8::PurgeMemory,
                  // The use of unretained is safe, since the worker thread
                  // cannot outlive |this|.
                  base::Unretained(v8_resolver_.get())));
 }
 
 int ProxyResolverV8Tracing::SetPacScript(
     const scoped_refptr<ProxyResolverScriptData>& script_data,
     const CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   // Note that there should not be any outstanding (non-cancelled) Jobs when
   // setting the PAC script (ProxyService should guarantee this). If there are,
   // then they might complete in strange ways after the new script is set.
-  DCHECK(!set_pac_script_job_);
+  DCHECK(!set_pac_script_job_.get());
   CHECK_EQ(0, num_outstanding_callbacks_);
 
   set_pac_script_job_ = new Job(this);
   set_pac_script_job_->StartSetPacScript(script_data, callback);
 
   return ERR_IO_PENDING;
 }
 
 }  // namespace net