Reference count ProxyService....

net/http/http_network_transaction_unittest.cc

 // Copyright (c) 2006-2008 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 <math.h>  // ceil
 
 #include "base/compiler_specific.h"
 #include "net/base/completion_callback.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/ssl_info.h"
@@ skipping 25 matching lines @@
  public:
   // Default set of dependencies -- "null" proxy service.
   SessionDependencies() : host_resolver(new MockHostResolver),
       proxy_service(CreateNullProxyService()) {}
 
   // Custom proxy service dependency.
   explicit SessionDependencies(ProxyService* proxy_service)
       : host_resolver(new MockHostResolver), proxy_service(proxy_service) {}
 
   scoped_refptr<MockHostResolverBase> host_resolver;
-  scoped_ptr<ProxyService> proxy_service;
+  scoped_refptr<ProxyService> proxy_service;
   MockClientSocketFactory socket_factory;
 };
 
 ProxyService* CreateFixedProxyService(const std::string& proxy) {
   net::ProxyConfig proxy_config;
   proxy_config.proxy_rules.ParseFromString(proxy);
   return ProxyService::CreateFixed(proxy_config);
 }
 
 
 HttpNetworkSession* CreateSession(SessionDependencies* session_deps) {
   return new HttpNetworkSession(session_deps->host_resolver,
-                                session_deps->proxy_service.get(),
+                                session_deps->proxy_service,
                                 &session_deps->socket_factory);
 }
 
 class HttpNetworkTransactionTest : public PlatformTest {
  public:
   virtual void TearDown() {
     // Empty the current queue.
     MessageLoop::current()->RunAllPending();
     PlatformTest::TearDown();
   }
@@ skipping 2976 matching lines @@
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
 TEST_F(HttpNetworkTransactionTest, SOCKS4_HTTP_GET) {
-  SessionDependencies session_deps;
-  session_deps.proxy_service.reset(CreateFixedProxyService(
-      "socks4://myproxy:1080"));
+  SessionDependencies session_deps(
+      CreateFixedProxyService("socks4://myproxy:1080"));
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(
           CreateSession(&session_deps),
           &session_deps.socket_factory));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
@@ skipping 30 matching lines @@
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   std::string response_text;
   rv = ReadTransaction(trans.get(), &response_text);
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("Payload", response_text);
 }
 
 TEST_F(HttpNetworkTransactionTest, SOCKS4_SSL_GET) {
-  SessionDependencies session_deps;
-  session_deps.proxy_service.reset(CreateFixedProxyService(
-      "socks4://myproxy:1080"));
+  SessionDependencies session_deps(
+      CreateFixedProxyService("socks4://myproxy:1080"));
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(
           CreateSession(&session_deps),
           &session_deps.socket_factory));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
@@ skipping 35 matching lines @@
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   std::string response_text;
   rv = ReadTransaction(trans.get(), &response_text);
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("Payload", response_text);
 }
 
 TEST_F(HttpNetworkTransactionTest, SOCKS5_HTTP_GET) {
-  SessionDependencies session_deps;
-  session_deps.proxy_service.reset(CreateFixedProxyService(
-      "socks5://myproxy:1080"));
+  SessionDependencies session_deps(
+      CreateFixedProxyService("socks5://myproxy:1080"));
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(
           CreateSession(&session_deps),
           &session_deps.socket_factory));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
@@ skipping 36 matching lines @@
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   std::string response_text;
   rv = ReadTransaction(trans.get(), &response_text);
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("Payload", response_text);
 }
 
 TEST_F(HttpNetworkTransactionTest, SOCKS5_SSL_GET) {
-  SessionDependencies session_deps;
-  session_deps.proxy_service.reset(CreateFixedProxyService(
-      "socks5://myproxy:1080"));
+  SessionDependencies session_deps(
+      CreateFixedProxyService("socks5://myproxy:1080"));
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(
           CreateSession(&session_deps),
           &session_deps.socket_factory));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
@@ skipping 81 matching lines @@
       "proxy/http_proxy:80/https://www.google.com/",
     },
     {
       "socks4://socks_proxy:1080",
       "https://www.google.com/socks4_ssl",
       "proxy/socks4://socks_proxy:1080/https://www.google.com/",
     },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    SessionDependencies session_deps;
-    session_deps.proxy_service.reset(CreateFixedProxyService(
-        tests[i].proxy_server));
+    SessionDependencies session_deps(
+        CreateFixedProxyService(tests[i].proxy_server));
 
     scoped_refptr<CaptureGroupNameSocketPool> conn_pool(
         new CaptureGroupNameSocketPool());
 
     scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
     session->connection_pool_ = conn_pool.get();
 
     scoped_ptr<HttpTransaction> trans(
         new HttpNetworkTransaction(
             session.get(),
@@ skipping 231 matching lines @@
   // Extract the unescaped identity.
   std::wstring username, password;
   HttpNetworkTransaction::GetIdentifyFromUrl(url, &username, &password);
 
   // Verify that it was decoded as UTF8.
   EXPECT_EQ(L"foo", username);
   EXPECT_EQ(L"\x4f60\x597d", password);
 }
 
 }  // namespace net