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

net/http/http_stream_factory_impl_unittest.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/http/http_stream_factory_impl.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "net/base/net_log.h"
@@ skipping 134 matching lines @@
   scoped_ptr<HttpAuthHandlerFactory> http_auth_handler_factory;
   HttpServerPropertiesImpl http_server_properties;
   NetLog* net_log;
 };
 
 HttpNetworkSession* CreateSession(SessionDependencies* session_deps) {
   HttpNetworkSession::Params params;
   params.host_resolver = session_deps->host_resolver.get();
   params.cert_verifier = session_deps->cert_verifier.get();
   params.proxy_service = session_deps->proxy_service.get();
-  params.ssl_config_service = session_deps->ssl_config_service;
+  params.ssl_config_service = session_deps->ssl_config_service.get();
   params.client_socket_factory = &session_deps->socket_factory;
   params.http_auth_handler_factory =
       session_deps->http_auth_handler_factory.get();
   params.net_log = session_deps->net_log;
   params.http_server_properties = &session_deps->http_server_properties;
   return new HttpNetworkSession(params);
 }
 
 struct TestCase {
   int num_streams;
@@ skipping 148 matching lines @@
             session_deps.cert_verifier.get());
     CapturePreconnectsSSLSocketPool* ssl_conn_pool =
         new CapturePreconnectsSSLSocketPool(
             session_deps.host_resolver.get(),
             session_deps.cert_verifier.get());
     MockClientSocketPoolManager* mock_pool_manager =
         new MockClientSocketPoolManager;
     mock_pool_manager->SetTransportSocketPool(transport_conn_pool);
     mock_pool_manager->SetSSLSocketPool(ssl_conn_pool);
     peer.SetClientSocketPoolManager(mock_pool_manager);
-    PreconnectHelper(kTests[i], session);
+    PreconnectHelper(kTests[i], session.get());
     if (kTests[i].ssl)
       EXPECT_EQ(kTests[i].num_streams, ssl_conn_pool->last_num_streams());
     else
       EXPECT_EQ(kTests[i].num_streams, transport_conn_pool->last_num_streams());
   }
 }
 
 TEST(HttpStreamFactoryTest, PreconnectHttpProxy) {
   for (size_t i = 0; i < arraysize(kTests); ++i) {
     SessionDependencies session_deps(ProxyService::CreateFixed("http_proxy"));
     scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
     HttpNetworkSessionPeer peer(session);
     HostPortPair proxy_host("http_proxy", 80);
     CapturePreconnectsHttpProxySocketPool* http_proxy_pool =
         new CapturePreconnectsHttpProxySocketPool(
             session_deps.host_resolver.get(),
             session_deps.cert_verifier.get());
     CapturePreconnectsSSLSocketPool* ssl_conn_pool =
         new CapturePreconnectsSSLSocketPool(
             session_deps.host_resolver.get(),
             session_deps.cert_verifier.get());
     MockClientSocketPoolManager* mock_pool_manager =
         new MockClientSocketPoolManager;
     mock_pool_manager->SetSocketPoolForHTTPProxy(proxy_host, http_proxy_pool);
     mock_pool_manager->SetSocketPoolForSSLWithProxy(proxy_host, ssl_conn_pool);
     peer.SetClientSocketPoolManager(mock_pool_manager);
-    PreconnectHelper(kTests[i], session);
+    PreconnectHelper(kTests[i], session.get());
     if (kTests[i].ssl)
       EXPECT_EQ(kTests[i].num_streams, ssl_conn_pool->last_num_streams());
     else
       EXPECT_EQ(kTests[i].num_streams, http_proxy_pool->last_num_streams());
   }
 }
 
 TEST(HttpStreamFactoryTest, PreconnectSocksProxy) {
   for (size_t i = 0; i < arraysize(kTests); ++i) {
     SessionDependencies session_deps(
         ProxyService::CreateFixed("socks4://socks_proxy:1080"));
     scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
     HttpNetworkSessionPeer peer(session);
     HostPortPair proxy_host("socks_proxy", 1080);
     CapturePreconnectsSOCKSSocketPool* socks_proxy_pool =
         new CapturePreconnectsSOCKSSocketPool(
             session_deps.host_resolver.get(),
             session_deps.cert_verifier.get());
     CapturePreconnectsSSLSocketPool* ssl_conn_pool =
         new CapturePreconnectsSSLSocketPool(
             session_deps.host_resolver.get(),
             session_deps.cert_verifier.get());
     MockClientSocketPoolManager* mock_pool_manager =
         new MockClientSocketPoolManager;
     mock_pool_manager->SetSocketPoolForSOCKSProxy(proxy_host, socks_proxy_pool);
     mock_pool_manager->SetSocketPoolForSSLWithProxy(proxy_host, ssl_conn_pool);
     peer.SetClientSocketPoolManager(mock_pool_manager);
-    PreconnectHelper(kTests[i], session);
+    PreconnectHelper(kTests[i], session.get());
     if (kTests[i].ssl)
       EXPECT_EQ(kTests[i].num_streams, ssl_conn_pool->last_num_streams());
     else
       EXPECT_EQ(kTests[i].num_streams, socks_proxy_pool->last_num_streams());
   }
 }
 
 TEST(HttpStreamFactoryTest, PreconnectDirectWithExistingSpdySession) {
   for (size_t i = 0; i < arraysize(kTests); ++i) {
     SessionDependencies session_deps(ProxyService::CreateDirect());
@@ skipping 13 matching lines @@
             session_deps.cert_verifier.get());
     CapturePreconnectsSSLSocketPool* ssl_conn_pool =
         new CapturePreconnectsSSLSocketPool(
             session_deps.host_resolver.get(),
             session_deps.cert_verifier.get());
     MockClientSocketPoolManager* mock_pool_manager =
         new MockClientSocketPoolManager;
     mock_pool_manager->SetTransportSocketPool(transport_conn_pool);
     mock_pool_manager->SetSSLSocketPool(ssl_conn_pool);
     peer.SetClientSocketPoolManager(mock_pool_manager);
-    PreconnectHelper(kTests[i], session);
+    PreconnectHelper(kTests[i], session.get());
     // We shouldn't be preconnecting if we have an existing session, which is
     // the case for https://www.google.com.
     if (kTests[i].ssl)
       EXPECT_EQ(-1, ssl_conn_pool->last_num_streams());
     else
       EXPECT_EQ(kTests[i].num_streams, transport_conn_pool->last_num_streams());
   }
 }
 
 // Verify that preconnects to unsafe ports are cancelled before they reach
 // the SocketPool.
 TEST(HttpStreamFactoryTest, PreconnectUnsafePort) {
   ASSERT_FALSE(IsPortAllowedByDefault(7));
   ASSERT_FALSE(IsPortAllowedByOverride(7));
 
   SessionDependencies session_deps(ProxyService::CreateDirect());
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   HttpNetworkSessionPeer peer(session);
   CapturePreconnectsTransportSocketPool* transport_conn_pool =
       new CapturePreconnectsTransportSocketPool(
           session_deps.host_resolver.get(),
           session_deps.cert_verifier.get());
   MockClientSocketPoolManager* mock_pool_manager =
       new MockClientSocketPoolManager;
   mock_pool_manager->SetTransportSocketPool(transport_conn_pool);
   peer.SetClientSocketPoolManager(mock_pool_manager);
 
-  PreconnectHelperForURL(1, GURL("http://www.google.com:7"), session);
+  PreconnectHelperForURL(1, GURL("http://www.google.com:7"), session.get());
 
   EXPECT_EQ(-1, transport_conn_pool->last_num_streams());
 }
 
 TEST(HttpStreamFactoryTest, JobNotifiesProxy) {
   const char* kProxyString = "PROXY bad:99; PROXY maybe:80; DIRECT";
   SessionDependencies session_deps(
       ProxyService::CreateFixedFromPacResult(kProxyString));
 
   // First connection attempt fails
@@ skipping 154 matching lines @@
           &waiter, BoundNetLog()));
 
   EXPECT_EQ(LOAD_STATE_RESOLVING_HOST, request->GetLoadState());
 
   waiter.WaitForStream();
 }
 
 }  // namespace
 
 }  // namespace net