Split ProxyResolver into two interfaces:...

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/client_socket_factory.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_network_transaction.h"
 #include "net/http/http_transaction_unittest.h"
-#include "net/proxy/proxy_resolver_fixed.h"
-#include "net/proxy/proxy_resolver_null.h"
+#include "net/proxy/proxy_config_service_fixed.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 //-----------------------------------------------------------------------------
 
 
 struct MockConnect {
   // Asynchronous connection success.
   MockConnect() : async(true), result(net::OK) { }
 
@@ skipping 169 matching lines @@
       const std::string& hostname,
       const net::SSLConfig& ssl_config) {
     return NULL;
   }
 };
 
 MockClientSocketFactory mock_socket_factory;
 
 // Create a proxy service which fails on all requests (falls back to direct).
 net::ProxyService* CreateNullProxyService() {
-  return new net::ProxyService(new net::ProxyResolverNull);
+  return net::ProxyService::CreateNull();
 }
 
+net::ProxyService* CreateFixedProxyService(const std::string& proxy) {
+  net::ProxyInfo proxy_info;
+  proxy_info.UseNamedProxy(proxy);
+  return new net::ProxyService(
+      new net::ProxyConfigServiceFixed(proxy_info), NULL);
+}
+
+
 net::HttpNetworkSession* CreateSession(net::ProxyService* proxy_service) {
   return new net::HttpNetworkSession(proxy_service);
 }
 
 class HttpNetworkTransactionTest : public PlatformTest {
  public:
   virtual void SetUp() {
     PlatformTest::SetUp();
     mock_sockets[0] = NULL;
     mock_sockets_index = 0;
@@ skipping 484 matching lines @@
   response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(100, response->headers->GetContentLength());
 }
 
 // Test the flow when both the proxy server AND origin server require
 // authentication. Again, this uses basic auth for both since that is
 // the simplest to mock.
 TEST_F(HttpNetworkTransactionTest, BasicAuthProxyThenServer) {
-  net::ProxyInfo proxy_info;
-  proxy_info.UseNamedProxy("myproxy:70");
-  net::ProxyService proxy_service(new net::ProxyResolverFixed(proxy_info));
+  scoped_ptr<net::ProxyService> proxy_service(
+      CreateFixedProxyService("myproxy:70"));
 
   // Configure against proxy server "myproxy:70".
   scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
-      CreateSession(&proxy_service),
+      CreateSession(proxy_service.get()),
       &mock_socket_factory));
 
   net::HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   MockWrite data_writes1[] = {
     MockWrite("GET http://www.google.com/ HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
@@ skipping 153 matching lines @@
 
   const net::HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response == NULL);
 }
 
 // Make sure that we don't try to reuse a TCPClientSocket when failing to
 // establish tunnel.
 // http://code.google.com/p/chromium/issues/detail?id=3772
 TEST_F(HttpNetworkTransactionTest, DontRecycleTCPSocketForSSLTunnel) {
   // Configure against proxy server "myproxy:70".
-  net::ProxyInfo proxy_info;
-  proxy_info.UseNamedProxy("myproxy:70");
-  net::ProxyService proxy_service(new net::ProxyResolverFixed(proxy_info));
+  scoped_ptr<net::ProxyService> proxy_service(
+      CreateFixedProxyService("myproxy:70"));
 
   scoped_refptr<net::HttpNetworkSession> session(
-      CreateSession(&proxy_service));
+      CreateSession(proxy_service.get()));
 
   scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
       session.get(), &mock_socket_factory));
 
   net::HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   // Since we have proxy, should try to establish tunnel.
@@ skipping 606 matching lines @@
 
     rv = callback2.WaitForResult();
     EXPECT_EQ(net::OK, rv);
 
     response = trans->GetResponseInfo();
     EXPECT_FALSE(response == NULL);
     EXPECT_TRUE(response->auth_challenge.get() == NULL);
     EXPECT_EQ(100, response->headers->GetContentLength());
   }
 }