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/test_completion_callback.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_proxy_client_socket.h"
+#include "net/http/http_proxy_tunnel_delegate.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"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
@@ skipping 27 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 HttpProxyClientSocketPoolTest
-    : public ::testing::TestWithParam<HttpProxyClientSocketPoolTestParams> {
+    : public ::testing::TestWithParam<HttpProxyClientSocketPoolTestParams>,
+      public net::HttpProxyTunnelDelegate {
  protected:
   HttpProxyClientSocketPoolTest()
       : session_deps_(GetParam().protocol),
         tcp_histograms_("MockTCP"),
         transport_socket_pool_(
             kMaxSockets,
             kMaxSocketsPerGroup,
             &tcp_histograms_,
             session_deps_.deterministic_socket_factory.get()),
         ssl_histograms_("MockSSL"),
         ssl_socket_pool_(kMaxSockets,
                          kMaxSocketsPerGroup,
                          &ssl_histograms_,
                          session_deps_.host_resolver.get(),
                          session_deps_.cert_verifier.get(),
                          NULL /* channel_id_store */,
                          NULL /* transport_security_state */,
                          NULL /* cert_transparency_verifier */,
                          std::string() /* ssl_session_cache_shard */,
                          session_deps_.deterministic_socket_factory.get(),
                          &transport_socket_pool_,
                          NULL,
                          NULL,
                          session_deps_.ssl_config_service.get(),
                          false,
                          BoundNetLog().net_log()),
         session_(CreateNetworkSession()),
         http_proxy_histograms_("HttpProxyUnitTest"),
+        on_before_proxy_tunnel_request_called_(false),
+        on_before_proxy_tunnel_headers_received_called_(false),
         spdy_util_(GetParam().protocol),
         pool_(kMaxSockets,
               kMaxSocketsPerGroup,
               &http_proxy_histograms_,
               NULL,
               &transport_socket_pool_,
               &ssl_socket_pool_,
+              this,
               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 39 matching lines @@
   scoped_refptr<HttpProxySocketParams> CreateParams(bool tunnel) {
     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,
+        this));
   }
 
   scoped_refptr<HttpProxySocketParams> CreateTunnelParams() {
     return CreateParams(true);
   }
 
   scoped_refptr<HttpProxySocketParams> CreateNoTunnelParams() {
     return CreateParams(false);
   }
 
@@ skipping 33 matching lines @@
 
   HttpNetworkSession* CreateNetworkSession() {
     return SpdySessionDependencies::SpdyCreateSessionDeterministic(
         &session_deps_);
   }
 
   RequestPriority GetLastTransportRequestPriority() const {
     return transport_socket_pool_.last_request_priority();
   }
 
+  virtual void OnBeforeRequest(
+      const net::HostPortPair& proxy_server,
+      net::HttpRequestHeaders* extra_headers) OVERRIDE {
+    on_before_proxy_tunnel_request_called_ = true;
+  }
+
+  virtual void OnHeadersReceived(
+      const net::HostPortPair& origin,
+      const net::HostPortPair& proxy_server,
+      const net::HttpResponseHeaders& response_headers) OVERRIDE {
+    on_before_proxy_tunnel_headers_received_called_ = true;
+  }
+
+  bool on_before_proxy_tunnel_request_called() {
+    return on_before_proxy_tunnel_request_called_;
+  }
+
+  bool on_before_proxy_tunnel_headers_received_called() {
+    return on_before_proxy_tunnel_headers_received_called_;
+  }
+
  private:
   SpdySessionDependencies session_deps_;
 
   ClientSocketPoolHistograms tcp_histograms_;
   MockTransportClientSocketPool transport_socket_pool_;
   ClientSocketPoolHistograms ssl_histograms_;
   MockHostResolver host_resolver_;
   scoped_ptr<CertVerifier> cert_verifier_;
   SSLClientSocketPool ssl_socket_pool_;
 
   const scoped_refptr<HttpNetworkSession> session_;
   ClientSocketPoolHistograms http_proxy_histograms_;
+  bool on_before_proxy_tunnel_request_called_;
+  bool on_before_proxy_tunnel_headers_received_called_;
 
  protected:
   SpdyTestUtil spdy_util_;
   scoped_ptr<SSLSocketDataProvider> ssl_data_;
   scoped_ptr<DeterministicSocketData> data_;
   HttpProxyClientSocketPool pool_;
   ClientSocketHandle handle_;
   TestCompletionCallback callback_;
 };
 
@@ skipping 24 matching lines @@
   Initialize(NULL, 0, NULL, 0, NULL, 0, NULL, 0);
 
   int rv = handle_.Init("a", CreateNoTunnelParams(), 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(on_before_proxy_tunnel_request_called());
+  EXPECT_FALSE(on_before_proxy_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,
                          CompletionCallback(), &pool_, BoundNetLog()));
   EXPECT_EQ(HIGHEST, GetLastTransportRequestPriority());
@@ skipping 79 matching lines @@
   AddAuthToCache();
 
   int rv = handle_.Init("a", CreateTunnelParams(), 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());
+  EXPECT_TRUE(on_before_proxy_tunnel_request_called());
+  EXPECT_TRUE(on_before_proxy_tunnel_headers_received_called());
 }
 
 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[] = {
@@ skipping 337 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