Add embedder-specific headers to HTTP CONNECT tunnel request

net/http/http_proxy_client_socket_pool_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_proxy_client_socket_pool.h"
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/net_errors.h"
+#include "net/base/proxy_delegate.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_proxy_client_socket.h"
 #include "net/http/http_response_headers.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/client_socket_pool_histograms.h"
 #include "net/socket/next_proto.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_test_util_common.h"
@@ skipping 29 matching lines @@
 
   HttpProxyType proxy_type;
   NextProto protocol;
 };
 
 typedef ::testing::TestWithParam<HttpProxyType> TestWithHttpParam;
 
 const char kHttpProxyHost[] = "httpproxy.example.com";
 const char kHttpsProxyHost[] = "httpsproxy.example.com";
 
+class TestProxyDelegate : public ProxyDelegate {
+ public:
+  TestProxyDelegate()
+      : on_before_tunnel_request_called_(false),
+        on_tunnel_headers_received_called_(false) {
+  }
+
+  virtual ~TestProxyDelegate() OVERRIDE {
+  }
+
+  bool on_before_tunnel_request_called() const {
+    return on_before_tunnel_request_called_;
+  }
+
+  bool on_tunnel_headers_received_called() const {
+    return on_tunnel_headers_received_called_;
+  }
+
+  void VerifyOnTunnelHeadersReceived(const std::string& origin,
+                                     const std::string& proxy_server,
+                                     const std::string& status_line) const {
+    EXPECT_TRUE(on_tunnel_headers_received_called_);
+    EXPECT_TRUE(HostPortPair::FromString(origin).Equals(
+                    on_tunnel_headers_received_origin_));
+    EXPECT_TRUE(HostPortPair::FromString(proxy_server).Equals(
+                    on_tunnel_headers_received_proxy_server_));
+    EXPECT_EQ(status_line, on_tunnel_headers_received_status_line_);
+  }
+
+  // ProxyDelegate:
+  virtual void OnResolveProxy(const GURL& url,
+                              int load_flags,
+                              const ProxyService& proxy_service,
+                              ProxyInfo* result) OVERRIDE {
+  }
+
+  virtual void OnFallback(const ProxyServer& bad_proxy,
+                          int net_error) OVERRIDE {
+  }
+
+  virtual void OnBeforeSendHeaders(URLRequest* request,
+                                   const ProxyInfo& proxy_info,
+                                   HttpRequestHeaders* headers) OVERRIDE {
+  }
+
+  virtual void OnBeforeTunnelRequest(
+      const net::HostPortPair& proxy_server,
+      net::HttpRequestHeaders* extra_headers) OVERRIDE {
+    on_before_tunnel_request_called_ = true;
+    if (extra_headers) {
+      extra_headers->SetHeader("Foo", proxy_server.ToString());
+    }
+  }
+
+  virtual void OnTunnelHeadersReceived(
+      const net::HostPortPair& origin,
+      const net::HostPortPair& proxy_server,
+      const net::HttpResponseHeaders& response_headers) OVERRIDE {
+    on_tunnel_headers_received_called_ = true;
+    on_tunnel_headers_received_origin_ = origin;
+    on_tunnel_headers_received_proxy_server_ = proxy_server;
+    on_tunnel_headers_received_status_line_ = response_headers.GetStatusLine();
+  }
+
+ private:
+  bool on_before_tunnel_request_called_;
+  bool on_tunnel_headers_received_called_;
+  HostPortPair on_tunnel_headers_received_origin_;
+  HostPortPair on_tunnel_headers_received_proxy_server_;
+  std::string on_tunnel_headers_received_status_line_;
+};
+
+
 class HttpProxyClientSocketPoolTest
     : public ::testing::TestWithParam<HttpProxyClientSocketPoolTestParams> {
  protected:
   HttpProxyClientSocketPoolTest()
       : session_deps_(GetParam().protocol),
         tcp_histograms_("MockTCP"),
         transport_socket_pool_(
             kMaxSockets,
             kMaxSocketsPerGroup,
             &tcp_histograms_,
@@ skipping 17 matching lines @@
                          BoundNetLog().net_log()),
         session_(CreateNetworkSession()),
         http_proxy_histograms_("HttpProxyUnitTest"),
         spdy_util_(GetParam().protocol),
         pool_(kMaxSockets,
               kMaxSocketsPerGroup,
               &http_proxy_histograms_,
               NULL,
               &transport_socket_pool_,
               &ssl_socket_pool_,
+              NULL,
               NULL) {}
 
   virtual ~HttpProxyClientSocketPoolTest() {
   }
 
   void AddAuthToCache() {
     const base::string16 kFoo(base::ASCIIToUTF16("foo"));
     const base::string16 kBar(base::ASCIIToUTF16("bar"));
     GURL proxy_url(GetParam().proxy_type == HTTP ?
                    (std::string("http://") + kHttpProxyHost) :
@@ skipping 29 matching lines @@
         HostPortPair(kHttpsProxyHost, 443),
         SSLConfig(),
         PRIVACY_MODE_DISABLED,
         0,
         false,
         false);
   }
 
   // Returns the a correctly constructed HttpProxyParms
   // for the HTTP or HTTPS proxy.
-  scoped_refptr<HttpProxySocketParams> CreateParams(bool tunnel) {
+  scoped_refptr<HttpProxySocketParams> CreateParams(
+      bool tunnel,
+      ProxyDelegate* proxy_delegate) {
     return scoped_refptr<HttpProxySocketParams>(new HttpProxySocketParams(
         CreateHttpProxyParams(),
         CreateHttpsProxyParams(),
         GURL(tunnel ? "https://www.google.com/" : "http://www.google.com"),
         std::string(),
         HostPortPair("www.google.com", tunnel ? 443 : 80),
         session_->http_auth_cache(),
         session_->http_auth_handler_factory(),
         session_->spdy_session_pool(),
-        tunnel));
+        tunnel,
+        proxy_delegate));
   }
 
-  scoped_refptr<HttpProxySocketParams> CreateTunnelParams() {
-    return CreateParams(true);
+  scoped_refptr<HttpProxySocketParams> CreateTunnelParams(
+      ProxyDelegate* proxy_delegate) {
+    return CreateParams(true, proxy_delegate);
   }
 
-  scoped_refptr<HttpProxySocketParams> CreateNoTunnelParams() {
-    return CreateParams(false);
+  scoped_refptr<HttpProxySocketParams> CreateNoTunnelParams(
+      ProxyDelegate* proxy_delegate) {
+    return CreateParams(false, proxy_delegate);
   }
 
   DeterministicMockClientSocketFactory* socket_factory() {
     return session_deps_.deterministic_socket_factory.get();
   }
 
   void Initialize(MockRead* reads, size_t reads_count,
                   MockWrite* writes, size_t writes_count,
                   MockRead* spdy_reads, size_t spdy_reads_count,
                   MockWrite* spdy_writes, size_t spdy_writes_count) {
@@ skipping 73 matching lines @@
         HttpProxyClientSocketPoolTestParams(HTTP, kProtoSPDY31),
         HttpProxyClientSocketPoolTestParams(HTTPS, kProtoSPDY31),
         HttpProxyClientSocketPoolTestParams(SPDY, kProtoSPDY31),
         HttpProxyClientSocketPoolTestParams(HTTP, kProtoSPDY4),
         HttpProxyClientSocketPoolTestParams(HTTPS, kProtoSPDY4),
         HttpProxyClientSocketPoolTestParams(SPDY, kProtoSPDY4)));
 
 TEST_P(HttpProxyClientSocketPoolTest, NoTunnel) {
   Initialize(NULL, 0, NULL, 0, NULL, 0, NULL, 0);
 
-  int rv = handle_.Init("a", CreateNoTunnelParams(), LOW, CompletionCallback(),
-                        &pool_, BoundNetLog());
+  scoped_ptr<TestProxyDelegate> proxy_delegate(new TestProxyDelegate());
+  int rv = handle_.Init("a", CreateNoTunnelParams(proxy_delegate.get()), LOW,
+                        CompletionCallback(), &pool_, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(handle_.is_initialized());
   ASSERT_TRUE(handle_.socket());
   HttpProxyClientSocket* tunnel_socket =
           static_cast<HttpProxyClientSocket*>(handle_.socket());
   EXPECT_TRUE(tunnel_socket->IsConnected());
+  EXPECT_FALSE(proxy_delegate->on_before_tunnel_request_called());
+  EXPECT_FALSE(proxy_delegate->on_tunnel_headers_received_called());
 }
 
 // Make sure that HttpProxyConnectJob passes on its priority to its
 // (non-SSL) socket request on Init.
 TEST_P(HttpProxyClientSocketPoolTest, SetSocketRequestPriorityOnInit) {
   Initialize(NULL, 0, NULL, 0, NULL, 0, NULL, 0);
   EXPECT_EQ(OK,
-            handle_.Init("a", CreateNoTunnelParams(), HIGHEST,
+            handle_.Init("a", CreateNoTunnelParams(NULL), HIGHEST,
                          CompletionCallback(), &pool_, BoundNetLog()));
   EXPECT_EQ(HIGHEST, GetLastTransportRequestPriority());
 }
 
 TEST_P(HttpProxyClientSocketPoolTest, NeedAuth) {
   MockWrite writes[] = {
     MockWrite(ASYNC, 0, "CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),
   };
@@ skipping 21 matching lines @@
   MockRead spdy_reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 3)
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes),
              spdy_reads, arraysize(spdy_reads), spdy_writes,
              arraysize(spdy_writes));
 
   data_->StopAfter(4);
-  int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
-                        &pool_, BoundNetLog());
+  int rv = handle_.Init("a", CreateTunnelParams(NULL), LOW,
+                        callback_.callback(), &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 
   data_->RunFor(GetParam().proxy_type == SPDY ? 2 : 4);
   rv = callback_.WaitForResult();
   EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, rv);
   EXPECT_TRUE(handle_.is_initialized());
   ASSERT_TRUE(handle_.socket());
   ProxyClientSocket* tunnel_socket =
       static_cast<ProxyClientSocket*>(handle_.socket());
   if (GetParam().proxy_type == SPDY) {
     EXPECT_TRUE(tunnel_socket->IsConnected());
     EXPECT_TRUE(tunnel_socket->IsUsingSpdy());
   } else {
     EXPECT_FALSE(tunnel_socket->IsConnected());
     EXPECT_FALSE(tunnel_socket->IsUsingSpdy());
   }
 }
 
 TEST_P(HttpProxyClientSocketPoolTest, HaveAuth) {
   // It's pretty much impossible to make the SPDY case behave synchronously
   // so we skip this test for SPDY
   if (GetParam().proxy_type == SPDY)
     return;
+  std::string proxy_host_port =
+      GetParam().proxy_type == HTTP ?
+          (kHttpProxyHost + std::string(":80")) :
+          (kHttpsProxyHost + std::string(":443"));
+  std::string request =
+      "CONNECT www.google.com:443 HTTP/1.1\r\n"
+      "Host: www.google.com\r\n"
+      "Proxy-Connection: keep-alive\r\n"
+      "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n"
+      "Foo: " + proxy_host_port + "\r\n\r\n";
   MockWrite writes[] = {
-    MockWrite(SYNCHRONOUS, 0,
-              "CONNECT www.google.com:443 HTTP/1.1\r\n"
-              "Host: www.google.com\r\n"
-              "Proxy-Connection: keep-alive\r\n"
-              "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
+    MockWrite(SYNCHRONOUS, 0, request.c_str()),
   };
   MockRead reads[] = {
     MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 Connection Established\r\n\r\n"),
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes), NULL, 0,
              NULL, 0);
   AddAuthToCache();
 
-  int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
-                        &pool_, BoundNetLog());
+  scoped_ptr<TestProxyDelegate> proxy_delegate(new TestProxyDelegate());
+  int rv = handle_.Init("a", CreateTunnelParams(proxy_delegate.get()), LOW,
+                        callback_.callback(), &pool_, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(handle_.is_initialized());
   ASSERT_TRUE(handle_.socket());
   HttpProxyClientSocket* tunnel_socket =
           static_cast<HttpProxyClientSocket*>(handle_.socket());
   EXPECT_TRUE(tunnel_socket->IsConnected());
+  proxy_delegate->VerifyOnTunnelHeadersReceived(
+      "www.google.com:443",
+      proxy_host_port.c_str(),
+      "HTTP/1.1 200 Connection Established");
 }
 
 TEST_P(HttpProxyClientSocketPoolTest, AsyncHaveAuth) {
   MockWrite writes[] = {
     MockWrite(ASYNC, 0, "CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n"
               "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(ASYNC, 1, "HTTP/1.1 200 Connection Established\r\n\r\n"),
   };
 
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyConnect(kAuthHeaders, kAuthHeadersSize, 1, LOW));
   MockWrite spdy_writes[] = {
     CreateMockWrite(*req, 0, ASYNC)
   };
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 2)
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes),
              spdy_reads, arraysize(spdy_reads), spdy_writes,
              arraysize(spdy_writes));
   AddAuthToCache();
 
-  int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
-                        &pool_, BoundNetLog());
+  int rv = handle_.Init("a", CreateTunnelParams(NULL), LOW,
+                        callback_.callback(), &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 
   data_->RunFor(2);
   EXPECT_EQ(OK, callback_.WaitForResult());
   EXPECT_TRUE(handle_.is_initialized());
   ASSERT_TRUE(handle_.socket());
   HttpProxyClientSocket* tunnel_socket =
           static_cast<HttpProxyClientSocket*>(handle_.socket());
@@ skipping 18 matching lines @@
     CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 2)
   };
 
   Initialize(NULL, 0, NULL, 0,
              spdy_reads, arraysize(spdy_reads),
              spdy_writes, arraysize(spdy_writes));
   AddAuthToCache();
 
   EXPECT_EQ(ERR_IO_PENDING,
-            handle_.Init("a", CreateTunnelParams(), MEDIUM,
+            handle_.Init("a", CreateTunnelParams(NULL), MEDIUM,
                          callback_.callback(), &pool_, BoundNetLog()));
   EXPECT_EQ(MEDIUM, GetLastTransportRequestPriority());
 
   data_->RunFor(2);
   EXPECT_EQ(OK, callback_.WaitForResult());
 }
 
 TEST_P(HttpProxyClientSocketPoolTest, TCPError) {
   if (GetParam().proxy_type == SPDY) return;
   data_.reset(new DeterministicSocketData(NULL, 0, NULL, 0));
   data_->set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_CLOSED));
 
   socket_factory()->AddSocketDataProvider(data_.get());
 
-  int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
-                        &pool_, BoundNetLog());
+  int rv = handle_.Init("a", CreateTunnelParams(NULL), LOW,
+                        callback_.callback(), &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 
   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, callback_.WaitForResult());
 
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 }
 
 TEST_P(HttpProxyClientSocketPoolTest, SSLError) {
   if (GetParam().proxy_type == HTTP) return;
   data_.reset(new DeterministicSocketData(NULL, 0, NULL, 0));
   data_->set_connect_data(MockConnect(ASYNC, OK));
   socket_factory()->AddSocketDataProvider(data_.get());
 
   ssl_data_.reset(new SSLSocketDataProvider(ASYNC,
                                             ERR_CERT_AUTHORITY_INVALID));
   if (GetParam().proxy_type == SPDY) {
     InitializeSpdySsl();
   }
   socket_factory()->AddSSLSocketDataProvider(ssl_data_.get());
 
-  int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
-                        &pool_, BoundNetLog());
+  int rv = handle_.Init("a", CreateTunnelParams(NULL), LOW,
+                        callback_.callback(), &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 
   EXPECT_EQ(ERR_PROXY_CERTIFICATE_INVALID, callback_.WaitForResult());
 
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 }
 
 TEST_P(HttpProxyClientSocketPoolTest, SslClientAuth) {
   if (GetParam().proxy_type == HTTP) return;
   data_.reset(new DeterministicSocketData(NULL, 0, NULL, 0));
   data_->set_connect_data(MockConnect(ASYNC, OK));
   socket_factory()->AddSocketDataProvider(data_.get());
 
   ssl_data_.reset(new SSLSocketDataProvider(ASYNC,
                                             ERR_SSL_CLIENT_AUTH_CERT_NEEDED));
   if (GetParam().proxy_type == SPDY) {
     InitializeSpdySsl();
   }
   socket_factory()->AddSSLSocketDataProvider(ssl_data_.get());
 
-  int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
-                        &pool_, BoundNetLog());
+  int rv = handle_.Init("a", CreateTunnelParams(NULL), LOW,
+                        callback_.callback(), &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 
   EXPECT_EQ(ERR_SSL_CLIENT_AUTH_CERT_NEEDED, callback_.WaitForResult());
 
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 }
 
@@ skipping 16 matching lines @@
   };
   MockRead spdy_reads[] = {
     MockRead(ASYNC, ERR_CONNECTION_CLOSED, 1),
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes),
              spdy_reads, arraysize(spdy_reads), spdy_writes,
              arraysize(spdy_writes));
   AddAuthToCache();
 
-  int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
-                        &pool_, BoundNetLog());
+  int rv = handle_.Init("a", CreateTunnelParams(NULL), LOW,
+                        callback_.callback(), &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 
   data_->RunFor(3);
   if (GetParam().proxy_type == SPDY) {
     // SPDY cannot process a headers block unless it's complete and so it
     // returns ERR_CONNECTION_CLOSED in this case.
     EXPECT_EQ(ERR_CONNECTION_CLOSED, callback_.WaitForResult());
   } else {
@@ skipping 17 matching lines @@
               "Proxy-Connection: keep-alive\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(ASYNC, 1, "HTTP/1.1 100 Continue\r\n\r\n"),
     MockRead(ASYNC, 2, "HTTP/1.1 200 Connection Established\r\n\r\n"),
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes),
              NULL, 0, NULL, 0);
 
-  int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
-                        &pool_, BoundNetLog());
+  int rv = handle_.Init("a", CreateTunnelParams(NULL), LOW,
+                        callback_.callback(), &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 
   data_->RunFor(2);
   EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, callback_.WaitForResult());
 }
 
 TEST_P(HttpProxyClientSocketPoolTest, TunnelSetupError) {
   MockWrite writes[] = {
@@ skipping 18 matching lines @@
   MockRead spdy_reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 3),
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes),
              spdy_reads, arraysize(spdy_reads), spdy_writes,
              arraysize(spdy_writes));
   AddAuthToCache();
 
-  int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
-                        &pool_, BoundNetLog());
+  int rv = handle_.Init("a", CreateTunnelParams(NULL), LOW,
+                        callback_.callback(), &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 
   data_->RunFor(2);
 
   rv = callback_.WaitForResult();
   // All Proxy CONNECT responses are not trustworthy
   EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv);
   EXPECT_FALSE(handle_.is_initialized());
@@ skipping 40 matching lines @@
   MockRead spdy_reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 2),
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes),
              spdy_reads, arraysize(spdy_reads), spdy_writes,
              arraysize(spdy_writes));
   AddAuthToCache();
 
-  int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
-                        &pool_, BoundNetLog());
+  int rv = handle_.Init("a", CreateTunnelParams(NULL), LOW,
+                        callback_.callback(), &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 
   data_->RunFor(2);
 
   rv = callback_.WaitForResult();
 
   if (GetParam().proxy_type == HTTP) {
     // We don't trust 302 responses to CONNECT from HTTP proxies.
@@ skipping 22 matching lines @@
     EXPECT_TRUE(headers->IsRedirect(&location));
     EXPECT_EQ(location, redirectTarget);
   }
 }
 
 // It would be nice to also test the timeouts in HttpProxyClientSocketPool.
 
 }  // namespace
 
 }  // namespace net