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

net/proxy/proxy_service.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/proxy_service.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 459 matching lines @@
       return result;
 
     effective_config_ = decider_->effective_config();
     script_data_ = decider_->script_data();
 
     next_state_ = STATE_SET_PAC_SCRIPT;
     return OK;
   }
 
   int DoSetPacScript() {
-    DCHECK(script_data_);
+    DCHECK(script_data_.get());
     // TODO(eroman): Should log this latency to the NetLog.
     next_state_ = STATE_SET_PAC_SCRIPT_COMPLETE;
     return proxy_resolver_->SetPacScript(
         script_data_,
         base::Bind(&InitProxyResolver::OnIOCompletion, base::Unretained(this)));
   }
 
   int DoSetPacScriptComplete(int result) {
     return result;
   }
@@ skipping 176 matching lines @@
 
     if (result != OK) {
       // If it failed last time and failed again with the same error code this
       // time, then nothing has actually changed.
       return false;
     }
 
     // Otherwise if it succeeded both this time and last time, we need to look
     // closer and see if we ended up downloading different content for the PAC
     // script.
-    return !script_data->Equals(last_script_data_);
+    return !script_data->Equals(last_script_data_.get());
   }
 
   void NotifyProxyServiceOfChange(
       int result,
       const scoped_refptr<ProxyResolverScriptData>& script_data,
       const ProxyConfig& effective_config) {
     // Note that |this| may be deleted after calling into the ProxyService.
-    change_callback_.Run(result, script_data, effective_config);
+    change_callback_.Run(result, script_data.get(), effective_config);
   }
 
   base::WeakPtrFactory<ProxyScriptDeciderPoller> weak_factory_;
 
   ChangeCallback change_callback_;
   ProxyConfig config_;
   bool proxy_resolver_expects_pac_bytes_;
   ProxyScriptFetcher* proxy_script_fetcher_;
   DhcpProxyScriptFetcher* dhcp_proxy_script_fetcher_;
 
@@ skipping 290 matching lines @@
   if (current_state_ == STATE_READY) {
     // Start the resolve request.
     rv = req->Start();
     if (rv != ERR_IO_PENDING)
       return req->QueryDidComplete(rv);
   } else {
     req->net_log()->BeginEvent(NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC);
   }
 
   DCHECK_EQ(ERR_IO_PENDING, rv);
-  DCHECK(!ContainsPendingRequest(req));
+  DCHECK(!ContainsPendingRequest(req.get()));
   pending_requests_.push_back(req);
 
   // Completion will be notified through |callback|, unless the caller cancels
   // the request using |pac_request|.
   if (pac_request)
     *pac_request = req.get();
   return rv;  // ERR_IO_PENDING
 }
 
 int ProxyService::TryToCompleteSynchronously(const GURL& url,
@@ skipping 351 matching lines @@
       base::ThreadTaskRunnerHandle::Get();
 
   // The file loop should be a MessageLoopForIO on Linux.
   DCHECK_EQ(base::MessageLoop::TYPE_IO, file_loop->type());
 
   // Synchronously fetch the current proxy config (since we are
   // running on glib_default_loop). Additionally register for
   // notifications (delivered in either |glib_default_loop| or
   // |file_loop|) to keep us updated when the proxy config changes.
   linux_config_service->SetupAndFetchInitialConfig(
-      glib_thread_task_runner,
+      glib_thread_task_runner.get(),
       io_thread_task_runner,
       static_cast<base::MessageLoopForIO*>(file_loop));
 
   return linux_config_service;
 #elif defined(OS_ANDROID)
   return new ProxyConfigServiceAndroid(
       io_thread_task_runner,
       base::MessageLoop::current()->message_loop_proxy());
 #else
   LOG(WARNING) << "Failed to choose a system proxy settings fetcher "
@@ skipping 188 matching lines @@
     OnCompletion(result_);
   }
 }
 
 void SyncProxyServiceHelper::OnCompletion(int rv) {
   result_ = rv;
   event_.Signal();
 }
 
 }  // namespace net