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

net/socket/ssl_client_socket_pool.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/socket/ssl_client_socket_pool.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
@@ skipping 105 matching lines @@
       return LOAD_STATE_SSL_HANDSHAKE;
     default:
       NOTREACHED();
       return LOAD_STATE_IDLE;
   }
 }
 
 void SSLConnectJob::GetAdditionalErrorState(ClientSocketHandle* handle) {
   // Headers in |error_response_info_| indicate a proxy tunnel setup
   // problem. See DoTunnelConnectComplete.
-  if (error_response_info_.headers) {
+  if (error_response_info_.headers.get()) {
     handle->set_pending_http_proxy_connection(
         transport_socket_handle_.release());
   }
   handle->set_ssl_error_response_info(error_response_info_);
   if (!connect_timing_.ssl_start.is_null())
     handle->set_is_ssl_error(true);
 }
 
 void SSLConnectJob::OnIOComplete(int result) {
   int rv = DoLoop(result);
@@ skipping 239 matching lines @@
                                    base::TimeDelta::FromMinutes(1),
                                    100);
       }
     }
   }
 
   if (result == OK || IsCertificateError(result)) {
     set_socket(ssl_socket_.release());
   } else if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED) {
     error_response_info_.cert_request_info = new SSLCertRequestInfo;
-    ssl_socket_->GetSSLCertRequestInfo(error_response_info_.cert_request_info);
+    ssl_socket_->GetSSLCertRequestInfo(
+        error_response_info_.cert_request_info.get());
   }
 
   return result;
 }
 
 int SSLConnectJob::ConnectInternal() {
   switch (params_->proxy()) {
     case ProxyServer::SCHEME_DIRECT:
       next_state_ = STATE_TRANSPORT_CONNECT;
       break;
@@ skipping 71 matching lines @@
                                      http_proxy_pool,
                                      client_socket_factory,
                                      host_resolver,
                                      SSLClientSocketContext(
                                          cert_verifier,
                                          server_bound_cert_service,
                                          transport_security_state,
                                          ssl_session_cache_shard),
                                      net_log)),
       ssl_config_service_(ssl_config_service) {
-  if (ssl_config_service_)
+  if (ssl_config_service_.get())
     ssl_config_service_->AddObserver(this);
   if (transport_pool_)
     transport_pool_->AddLayeredPool(this);
   if (socks_pool_)
     socks_pool_->AddLayeredPool(this);
   if (http_proxy_pool_)
     http_proxy_pool_->AddLayeredPool(this);
 }
 
 SSLClientSocketPool::~SSLClientSocketPool() {
   if (http_proxy_pool_)
     http_proxy_pool_->RemoveLayeredPool(this);
   if (socks_pool_)
     socks_pool_->RemoveLayeredPool(this);
   if (transport_pool_)
     transport_pool_->RemoveLayeredPool(this);
-  if (ssl_config_service_)
+  if (ssl_config_service_.get())
     ssl_config_service_->RemoveObserver(this);
 }
 
 ConnectJob* SSLClientSocketPool::SSLConnectJobFactory::NewConnectJob(
     const std::string& group_name,
     const PoolBase::Request& request,
     ConnectJob::Delegate* delegate) const {
   return new SSLConnectJob(group_name, request.params(), ConnectionTimeout(),
                            transport_pool_, socks_pool_, http_proxy_pool_,
                            client_socket_factory_, host_resolver_,
@@ skipping 115 matching lines @@
   FlushWithError(ERR_NETWORK_CHANGED);
 }
 
 bool SSLClientSocketPool::CloseOneIdleConnection() {
   if (base_.CloseOneIdleSocket())
     return true;
   return base_.CloseOneIdleConnectionInLayeredPool();
 }
 
 }  // namespace net