net/http/http_proxy_client_socket_pool_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/http/http_proxy_client_socket_pool.h"
   6
   7 #include "base/callback.h"
   8 #include "base/compiler_specific.h"
   9 #include "base/strings/string_util.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "net/base/net_errors.h"
  12 #include "net/base/test_completion_callback.h"
  13 #include "net/http/http_network_session.h"
  14 #include "net/http/http_proxy_client_socket.h"
  15 #include "net/http/http_response_headers.h"
  16 #include "net/socket/client_socket_handle.h"
  17 #include "net/socket/client_socket_pool_histograms.h"
  18 #include "net/socket/next_proto.h"
  19 #include "net/socket/socket_test_util.h"
  20 #include "net/spdy/spdy_protocol.h"
  21 #include "net/spdy/spdy_test_util_common.h"
  22 #include "testing/gtest/include/gtest/gtest.h"
  23
  24 namespace net {
  25
  26 namespace {
  27
  28 const int kMaxSockets = 32;
  29 const int kMaxSocketsPerGroup = 6;
  30 const char * const kAuthHeaders[] = {
  31   "proxy-authorization", "Basic Zm9vOmJhcg=="
  32 };
  33 const int kAuthHeadersSize = arraysize(kAuthHeaders) / 2;
  34
  35 enum HttpProxyType {
  36   HTTP,
  37   HTTPS,
  38   SPDY
  39 };
  40
  41 struct HttpProxyClientSocketPoolTestParams {
  42   HttpProxyClientSocketPoolTestParams()
  43       : proxy_type(HTTP),
  44         protocol(kProtoSPDY3) {}
  45
  46   HttpProxyClientSocketPoolTestParams(
  47       HttpProxyType proxy_type,
  48       NextProto protocol)
  49       : proxy_type(proxy_type),
  50         protocol(protocol) {}
  51
  52   HttpProxyType proxy_type;
  53   NextProto protocol;
  54 };
  55
  56 typedef ::testing::TestWithParam<HttpProxyType> TestWithHttpParam;
  57
  58 const char kHttpProxyHost[] = "httpproxy.example.com";
  59 const char kHttpsProxyHost[] = "httpsproxy.example.com";
  60
  61 class HttpProxyClientSocketPoolTest
  62     : public ::testing::TestWithParam<HttpProxyClientSocketPoolTestParams> {
  63  protected:
  64   HttpProxyClientSocketPoolTest()
  65       : session_deps_(GetParam().protocol),
  66         tcp_histograms_("MockTCP"),
  67         transport_socket_pool_(
  68             kMaxSockets,
  69             kMaxSocketsPerGroup,
  70             &tcp_histograms_,
  71             session_deps_.deterministic_socket_factory.get()),
  72         ssl_histograms_("MockSSL"),
  73         ssl_socket_pool_(kMaxSockets,
  74                          kMaxSocketsPerGroup,
  75                          &ssl_histograms_,
  76                          session_deps_.host_resolver.get(),
  77                          session_deps_.cert_verifier.get(),
  78                          NULL /* server_bound_cert_store */,
  79                          NULL /* transport_security_state */,
  80                          NULL /* cert_transparency_verifier */,
  81                          std::string() /* ssl_session_cache_shard */,
  82                          session_deps_.deterministic_socket_factory.get(),
  83                          &transport_socket_pool_,
  84                          NULL,
  85                          NULL,
  86                          session_deps_.ssl_config_service.get(),
  87                          BoundNetLog().net_log()),
  88         session_(CreateNetworkSession()),
  89         http_proxy_histograms_("HttpProxyUnitTest"),
  90         spdy_util_(GetParam().protocol),
  91         pool_(kMaxSockets,
  92               kMaxSocketsPerGroup,
  93               &http_proxy_histograms_,
  94               NULL,
  95               &transport_socket_pool_,
  96               &ssl_socket_pool_,
  97               NULL) {}
  98
  99   virtual ~HttpProxyClientSocketPoolTest() {
 100   }
 101
 102   void AddAuthToCache() {
 103     const base::string16 kFoo(base::ASCIIToUTF16("foo"));
 104     const base::string16 kBar(base::ASCIIToUTF16("bar"));
 105     GURL proxy_url(GetParam().proxy_type == HTTP ?
 106                    (std::string("http://") + kHttpProxyHost) :
 107                    (std::string("https://") + kHttpsProxyHost));
 108     session_->http_auth_cache()->Add(proxy_url,
 109                                      "MyRealm1",
 110                                      HttpAuth::AUTH_SCHEME_BASIC,
 111                                      "Basic realm=MyRealm1",
 112                                      AuthCredentials(kFoo, kBar),
 113                                      "/");
 114   }
 115
 116   scoped_refptr<TransportSocketParams> CreateHttpProxyParams() const {
 117     if (GetParam().proxy_type != HTTP)
 118       return NULL;
 119     return new TransportSocketParams(HostPortPair(kHttpProxyHost, 80),
 120                                      false,
 121                                      false,
 122                                      OnHostResolutionCallback());
 123   }
 124
 125   scoped_refptr<SSLSocketParams> CreateHttpsProxyParams() const {
 126     if (GetParam().proxy_type == HTTP)
 127       return NULL;
 128     return new SSLSocketParams(
 129         new TransportSocketParams(
 130             HostPortPair(kHttpsProxyHost, 443),
 131             false,
 132             false,
 133             OnHostResolutionCallback()),
 134         NULL,
 135         NULL,
 136         HostPortPair(kHttpsProxyHost, 443),
 137         SSLConfig(),
 138         PRIVACY_MODE_DISABLED,
 139         0,
 140         false,
 141         false);
 142   }
 143
 144   // Returns the a correctly constructed HttpProxyParms
 145   // for the HTTP or HTTPS proxy.
 146   scoped_refptr<HttpProxySocketParams> CreateParams(bool tunnel) {
 147     return scoped_refptr<HttpProxySocketParams>(new HttpProxySocketParams(
 148         CreateHttpProxyParams(),
 149         CreateHttpsProxyParams(),
 150         GURL(tunnel ? "https://www.google.com/" : "http://www.google.com"),
 151         std::string(),
 152         HostPortPair("www.google.com", tunnel ? 443 : 80),
 153         session_->http_auth_cache(),
 154         session_->http_auth_handler_factory(),
 155         session_->spdy_session_pool(),
 156         tunnel));
 157   }
 158
 159   scoped_refptr<HttpProxySocketParams> CreateTunnelParams() {
 160     return CreateParams(true);
 161   }
 162
 163   scoped_refptr<HttpProxySocketParams> CreateNoTunnelParams() {
 164     return CreateParams(false);
 165   }
 166
 167   DeterministicMockClientSocketFactory* socket_factory() {
 168     return session_deps_.deterministic_socket_factory.get();
 169   }
 170
 171   void Initialize(MockRead* reads, size_t reads_count,
 172                   MockWrite* writes, size_t writes_count,
 173                   MockRead* spdy_reads, size_t spdy_reads_count,
 174                   MockWrite* spdy_writes, size_t spdy_writes_count) {
 175     if (GetParam().proxy_type == SPDY) {
 176       data_.reset(new DeterministicSocketData(spdy_reads, spdy_reads_count,
 177                                               spdy_writes, spdy_writes_count));
 178     } else {
 179       data_.reset(new DeterministicSocketData(reads, reads_count, writes,
 180                                               writes_count));
 181     }
 182
 183     data_->set_connect_data(MockConnect(SYNCHRONOUS, OK));
 184     data_->StopAfter(2);  // Request / Response
 185
 186     socket_factory()->AddSocketDataProvider(data_.get());
 187
 188     if (GetParam().proxy_type != HTTP) {
 189       ssl_data_.reset(new SSLSocketDataProvider(SYNCHRONOUS, OK));
 190       if (GetParam().proxy_type == SPDY) {
 191         InitializeSpdySsl();
 192       }
 193       socket_factory()->AddSSLSocketDataProvider(ssl_data_.get());
 194     }
 195   }
 196
 197   void InitializeSpdySsl() {
 198     ssl_data_->SetNextProto(GetParam().protocol);
 199   }
 200
 201   HttpNetworkSession* CreateNetworkSession() {
 202     return SpdySessionDependencies::SpdyCreateSessionDeterministic(
 203         &session_deps_);
 204   }
 205
 206   RequestPriority GetLastTransportRequestPriority() const {
 207     return transport_socket_pool_.last_request_priority();
 208   }
 209
 210  private:
 211   SpdySessionDependencies session_deps_;
 212
 213   ClientSocketPoolHistograms tcp_histograms_;
 214   MockTransportClientSocketPool transport_socket_pool_;
 215   ClientSocketPoolHistograms ssl_histograms_;
 216   MockHostResolver host_resolver_;
 217   scoped_ptr<CertVerifier> cert_verifier_;
 218   SSLClientSocketPool ssl_socket_pool_;
 219
 220   const scoped_refptr<HttpNetworkSession> session_;
 221   ClientSocketPoolHistograms http_proxy_histograms_;
 222
 223  protected:
 224   SpdyTestUtil spdy_util_;
 225   scoped_ptr<SSLSocketDataProvider> ssl_data_;
 226   scoped_ptr<DeterministicSocketData> data_;
 227   HttpProxyClientSocketPool pool_;
 228   ClientSocketHandle handle_;
 229   TestCompletionCallback callback_;
 230 };
 231
 232 //-----------------------------------------------------------------------------
 233 // All tests are run with three different proxy types: HTTP, HTTPS (non-SPDY)
 234 // and SPDY.
 235 //
 236 // TODO(akalin): Use ::testing::Combine() when we are able to use
 237 // <tr1/tuple>.
 238 INSTANTIATE_TEST_CASE_P(
 239     HttpProxyClientSocketPoolTests,
 240     HttpProxyClientSocketPoolTest,
 241     ::testing::Values(
 242         HttpProxyClientSocketPoolTestParams(HTTP, kProtoDeprecatedSPDY2),
 243         HttpProxyClientSocketPoolTestParams(HTTPS, kProtoDeprecatedSPDY2),
 244         HttpProxyClientSocketPoolTestParams(SPDY, kProtoDeprecatedSPDY2),
 245         HttpProxyClientSocketPoolTestParams(HTTP, kProtoSPDY3),
 246         HttpProxyClientSocketPoolTestParams(HTTPS, kProtoSPDY3),
 247         HttpProxyClientSocketPoolTestParams(SPDY, kProtoSPDY3),
 248         HttpProxyClientSocketPoolTestParams(HTTP, kProtoSPDY31),
 249         HttpProxyClientSocketPoolTestParams(HTTPS, kProtoSPDY31),
 250         HttpProxyClientSocketPoolTestParams(SPDY, kProtoSPDY31),
 251         HttpProxyClientSocketPoolTestParams(HTTP, kProtoSPDY4a2),
 252         HttpProxyClientSocketPoolTestParams(HTTPS, kProtoSPDY4a2),
 253         HttpProxyClientSocketPoolTestParams(SPDY, kProtoSPDY4a2),
 254         HttpProxyClientSocketPoolTestParams(HTTP, kProtoHTTP2Draft04),
 255         HttpProxyClientSocketPoolTestParams(HTTPS, kProtoHTTP2Draft04),
 256         HttpProxyClientSocketPoolTestParams(SPDY, kProtoHTTP2Draft04)));
 257
 258 TEST_P(HttpProxyClientSocketPoolTest, NoTunnel) {
 259   Initialize(NULL, 0, NULL, 0, NULL, 0, NULL, 0);
 260
 261   int rv = handle_.Init("a", CreateNoTunnelParams(), LOW, CompletionCallback(),
 262                         &pool_, BoundNetLog());
 263   EXPECT_EQ(OK, rv);
 264   EXPECT_TRUE(handle_.is_initialized());
 265   ASSERT_TRUE(handle_.socket());
 266   HttpProxyClientSocket* tunnel_socket =
 267           static_cast<HttpProxyClientSocket*>(handle_.socket());
 268   EXPECT_TRUE(tunnel_socket->IsConnected());
 269 }
 270
 271 // Make sure that HttpProxyConnectJob passes on its priority to its
 272 // (non-SSL) socket request on Init.
 273 TEST_P(HttpProxyClientSocketPoolTest, SetSocketRequestPriorityOnInit) {
 274   Initialize(NULL, 0, NULL, 0, NULL, 0, NULL, 0);
 275   EXPECT_EQ(OK,
 276             handle_.Init("a", CreateNoTunnelParams(), HIGHEST,
 277                          CompletionCallback(), &pool_, BoundNetLog()));
 278   EXPECT_EQ(HIGHEST, GetLastTransportRequestPriority());
 279 }
 280
 281 TEST_P(HttpProxyClientSocketPoolTest, NeedAuth) {
 282   MockWrite writes[] = {
 283     MockWrite(ASYNC, 0, "CONNECT www.google.com:443 HTTP/1.1\r\n"
 284               "Host: www.google.com\r\n"
 285               "Proxy-Connection: keep-alive\r\n\r\n"),
 286   };
 287   MockRead reads[] = {
 288     // No credentials.
 289     MockRead(ASYNC, 1, "HTTP/1.1 407 Proxy Authentication Required\r\n"),
 290     MockRead(ASYNC, 2, "Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
 291     MockRead(ASYNC, 3, "Content-Length: 10\r\n\r\n"),
 292     MockRead(ASYNC, 4, "0123456789"),
 293   };
 294   scoped_ptr<SpdyFrame> req(
 295       spdy_util_.ConstructSpdyConnect(NULL, 0, 1, LOW));
 296   scoped_ptr<SpdyFrame> rst(
 297       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
 298   MockWrite spdy_writes[] = {
 299     CreateMockWrite(*req, 0, ASYNC),
 300     CreateMockWrite(*rst, 2, ASYNC),
 301   };
 302   const char* const kAuthChallenge[] = {
 303     spdy_util_.GetStatusKey(), "407 Proxy Authentication Required",
 304     spdy_util_.GetVersionKey(), "HTTP/1.1",
 305     "proxy-authenticate", "Basic realm=\"MyRealm1\"",
 306   };
 307   scoped_ptr<SpdyFrame> resp(
 308       spdy_util_.ConstructSpdyControlFrame(NULL,
 309                                            0,
 310                                            false,
 311                                            1,
 312                                            LOW,
 313                                            SYN_REPLY,
 314                                            CONTROL_FLAG_NONE,
 315                                            kAuthChallenge,
 316                                            arraysize(kAuthChallenge),
 317                                            0));
 318   MockRead spdy_reads[] = {
 319     CreateMockRead(*resp, 1, ASYNC),
 320     MockRead(ASYNC, 0, 3)
 321   };
 322
 323   Initialize(reads, arraysize(reads), writes, arraysize(writes),
 324              spdy_reads, arraysize(spdy_reads), spdy_writes,
 325              arraysize(spdy_writes));
 326
 327   data_->StopAfter(4);
 328   int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
 329                         &pool_, BoundNetLog());
 330   EXPECT_EQ(ERR_IO_PENDING, rv);
 331   EXPECT_FALSE(handle_.is_initialized());
 332   EXPECT_FALSE(handle_.socket());
 333
 334   data_->RunFor(GetParam().proxy_type == SPDY ? 2 : 4);
 335   rv = callback_.WaitForResult();
 336   EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, rv);
 337   EXPECT_TRUE(handle_.is_initialized());
 338   ASSERT_TRUE(handle_.socket());
 339   ProxyClientSocket* tunnel_socket =
 340       static_cast<ProxyClientSocket*>(handle_.socket());
 341   if (GetParam().proxy_type == SPDY) {
 342     EXPECT_TRUE(tunnel_socket->IsConnected());
 343     EXPECT_TRUE(tunnel_socket->IsUsingSpdy());
 344   } else {
 345     EXPECT_FALSE(tunnel_socket->IsConnected());
 346     EXPECT_FALSE(tunnel_socket->IsUsingSpdy());
 347   }
 348 }
 349
 350 TEST_P(HttpProxyClientSocketPoolTest, HaveAuth) {
 351   // It's pretty much impossible to make the SPDY case behave synchronously
 352   // so we skip this test for SPDY
 353   if (GetParam().proxy_type == SPDY)
 354     return;
 355   MockWrite writes[] = {
 356     MockWrite(SYNCHRONOUS, 0,
 357               "CONNECT www.google.com:443 HTTP/1.1\r\n"
 358               "Host: www.google.com\r\n"
 359               "Proxy-Connection: keep-alive\r\n"
 360               "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
 361   };
 362   MockRead reads[] = {
 363     MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 Connection Established\r\n\r\n"),
 364   };
 365
 366   Initialize(reads, arraysize(reads), writes, arraysize(writes), NULL, 0,
 367              NULL, 0);
 368   AddAuthToCache();
 369
 370   int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
 371                         &pool_, BoundNetLog());
 372   EXPECT_EQ(OK, rv);
 373   EXPECT_TRUE(handle_.is_initialized());
 374   ASSERT_TRUE(handle_.socket());
 375   HttpProxyClientSocket* tunnel_socket =
 376           static_cast<HttpProxyClientSocket*>(handle_.socket());
 377   EXPECT_TRUE(tunnel_socket->IsConnected());
 378 }
 379
 380 TEST_P(HttpProxyClientSocketPoolTest, AsyncHaveAuth) {
 381   MockWrite writes[] = {
 382     MockWrite(ASYNC, 0, "CONNECT www.google.com:443 HTTP/1.1\r\n"
 383               "Host: www.google.com\r\n"
 384               "Proxy-Connection: keep-alive\r\n"
 385               "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
 386   };
 387   MockRead reads[] = {
 388     MockRead(ASYNC, 1, "HTTP/1.1 200 Connection Established\r\n\r\n"),
 389   };
 390
 391   scoped_ptr<SpdyFrame> req(
 392       spdy_util_.ConstructSpdyConnect(kAuthHeaders, kAuthHeadersSize, 1, LOW));
 393   MockWrite spdy_writes[] = {
 394     CreateMockWrite(*req, 0, ASYNC)
 395   };
 396   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
 397   MockRead spdy_reads[] = {
 398     CreateMockRead(*resp, 1, ASYNC),
 399     MockRead(ASYNC, 0, 2)
 400   };
 401
 402   Initialize(reads, arraysize(reads), writes, arraysize(writes),
 403              spdy_reads, arraysize(spdy_reads), spdy_writes,
 404              arraysize(spdy_writes));
 405   AddAuthToCache();
 406
 407   int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
 408                         &pool_, BoundNetLog());
 409   EXPECT_EQ(ERR_IO_PENDING, rv);
 410   EXPECT_FALSE(handle_.is_initialized());
 411   EXPECT_FALSE(handle_.socket());
 412
 413   data_->RunFor(2);
 414   EXPECT_EQ(OK, callback_.WaitForResult());
 415   EXPECT_TRUE(handle_.is_initialized());
 416   ASSERT_TRUE(handle_.socket());
 417   HttpProxyClientSocket* tunnel_socket =
 418           static_cast<HttpProxyClientSocket*>(handle_.socket());
 419   EXPECT_TRUE(tunnel_socket->IsConnected());
 420 }
 421
 422 // Make sure that HttpProxyConnectJob passes on its priority to its
 423 // SPDY session's socket request on Init (if applicable).
 424 TEST_P(HttpProxyClientSocketPoolTest,
 425        SetSpdySessionSocketRequestPriorityOnInit) {
 426   if (GetParam().proxy_type != SPDY)
 427     return;
 428
 429   scoped_ptr<SpdyFrame> req(
 430       spdy_util_.ConstructSpdyConnect(kAuthHeaders, kAuthHeadersSize,
 431                                       1, MEDIUM));
 432   MockWrite spdy_writes[] = {
 433     CreateMockWrite(*req, 0, ASYNC)
 434   };
 435   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
 436   MockRead spdy_reads[] = {
 437     CreateMockRead(*resp, 1, ASYNC),
 438     MockRead(ASYNC, 0, 2)
 439   };
 440
 441   Initialize(NULL, 0, NULL, 0,
 442              spdy_reads, arraysize(spdy_reads),
 443              spdy_writes, arraysize(spdy_writes));
 444   AddAuthToCache();
 445
 446   EXPECT_EQ(ERR_IO_PENDING,
 447             handle_.Init("a", CreateTunnelParams(), MEDIUM,
 448                          callback_.callback(), &pool_, BoundNetLog()));
 449   EXPECT_EQ(MEDIUM, GetLastTransportRequestPriority());
 450
 451   data_->RunFor(2);
 452   EXPECT_EQ(OK, callback_.WaitForResult());
 453 }
 454
 455 TEST_P(HttpProxyClientSocketPoolTest, TCPError) {
 456   if (GetParam().proxy_type == SPDY) return;
 457   data_.reset(new DeterministicSocketData(NULL, 0, NULL, 0));
 458   data_->set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_CLOSED));
 459
 460   socket_factory()->AddSocketDataProvider(data_.get());
 461
 462   int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
 463                         &pool_, BoundNetLog());
 464   EXPECT_EQ(ERR_IO_PENDING, rv);
 465   EXPECT_FALSE(handle_.is_initialized());
 466   EXPECT_FALSE(handle_.socket());
 467
 468   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, callback_.WaitForResult());
 469
 470   EXPECT_FALSE(handle_.is_initialized());
 471   EXPECT_FALSE(handle_.socket());
 472 }
 473
 474 TEST_P(HttpProxyClientSocketPoolTest, SSLError) {
 475   if (GetParam().proxy_type == HTTP) return;
 476   data_.reset(new DeterministicSocketData(NULL, 0, NULL, 0));
 477   data_->set_connect_data(MockConnect(ASYNC, OK));
 478   socket_factory()->AddSocketDataProvider(data_.get());
 479
 480   ssl_data_.reset(new SSLSocketDataProvider(ASYNC,
 481                                             ERR_CERT_AUTHORITY_INVALID));
 482   if (GetParam().proxy_type == SPDY) {
 483     InitializeSpdySsl();
 484   }
 485   socket_factory()->AddSSLSocketDataProvider(ssl_data_.get());
 486
 487   int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
 488                         &pool_, BoundNetLog());
 489   EXPECT_EQ(ERR_IO_PENDING, rv);
 490   EXPECT_FALSE(handle_.is_initialized());
 491   EXPECT_FALSE(handle_.socket());
 492
 493   EXPECT_EQ(ERR_PROXY_CERTIFICATE_INVALID, callback_.WaitForResult());
 494
 495   EXPECT_FALSE(handle_.is_initialized());
 496   EXPECT_FALSE(handle_.socket());
 497 }
 498
 499 TEST_P(HttpProxyClientSocketPoolTest, SslClientAuth) {
 500   if (GetParam().proxy_type == HTTP) return;
 501   data_.reset(new DeterministicSocketData(NULL, 0, NULL, 0));
 502   data_->set_connect_data(MockConnect(ASYNC, OK));
 503   socket_factory()->AddSocketDataProvider(data_.get());
 504
 505   ssl_data_.reset(new SSLSocketDataProvider(ASYNC,
 506                                             ERR_SSL_CLIENT_AUTH_CERT_NEEDED));
 507   if (GetParam().proxy_type == SPDY) {
 508     InitializeSpdySsl();
 509   }
 510   socket_factory()->AddSSLSocketDataProvider(ssl_data_.get());
 511
 512   int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
 513                         &pool_, BoundNetLog());
 514   EXPECT_EQ(ERR_IO_PENDING, rv);
 515   EXPECT_FALSE(handle_.is_initialized());
 516   EXPECT_FALSE(handle_.socket());
 517
 518   EXPECT_EQ(ERR_SSL_CLIENT_AUTH_CERT_NEEDED, callback_.WaitForResult());
 519
 520   EXPECT_FALSE(handle_.is_initialized());
 521   EXPECT_FALSE(handle_.socket());
 522 }
 523
 524 TEST_P(HttpProxyClientSocketPoolTest, TunnelUnexpectedClose) {
 525   MockWrite writes[] = {
 526     MockWrite(ASYNC, 0,
 527               "CONNECT www.google.com:443 HTTP/1.1\r\n"
 528               "Host: www.google.com\r\n"
 529               "Proxy-Connection: keep-alive\r\n"
 530               "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
 531   };
 532   MockRead reads[] = {
 533     MockRead(ASYNC, 1, "HTTP/1.1 200 Conn"),
 534     MockRead(ASYNC, ERR_CONNECTION_CLOSED, 2),
 535   };
 536   scoped_ptr<SpdyFrame> req(
 537       spdy_util_.ConstructSpdyConnect(kAuthHeaders, kAuthHeadersSize, 1, LOW));
 538   MockWrite spdy_writes[] = {
 539     CreateMockWrite(*req, 0, ASYNC)
 540   };
 541   MockRead spdy_reads[] = {
 542     MockRead(ASYNC, ERR_CONNECTION_CLOSED, 1),
 543   };
 544
 545   Initialize(reads, arraysize(reads), writes, arraysize(writes),
 546              spdy_reads, arraysize(spdy_reads), spdy_writes,
 547              arraysize(spdy_writes));
 548   AddAuthToCache();
 549
 550   int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
 551                         &pool_, BoundNetLog());
 552   EXPECT_EQ(ERR_IO_PENDING, rv);
 553   EXPECT_FALSE(handle_.is_initialized());
 554   EXPECT_FALSE(handle_.socket());
 555
 556   data_->RunFor(3);
 557   if (GetParam().proxy_type == SPDY) {
 558     // SPDY cannot process a headers block unless it's complete and so it
 559     // returns ERR_CONNECTION_CLOSED in this case.
 560     EXPECT_EQ(ERR_CONNECTION_CLOSED, callback_.WaitForResult());
 561   } else {
 562     EXPECT_EQ(ERR_RESPONSE_HEADERS_TRUNCATED, callback_.WaitForResult());
 563   }
 564   EXPECT_FALSE(handle_.is_initialized());
 565   EXPECT_FALSE(handle_.socket());
 566 }
 567
 568 TEST_P(HttpProxyClientSocketPoolTest, Tunnel1xxResponse) {
 569   // Tests that 1xx responses are rejected for a CONNECT request.
 570   if (GetParam().proxy_type == SPDY) {
 571     // SPDY doesn't have 1xx responses.
 572     return;
 573   }
 574
 575   MockWrite writes[] = {
 576     MockWrite(ASYNC, 0,
 577               "CONNECT www.google.com:443 HTTP/1.1\r\n"
 578               "Host: www.google.com\r\n"
 579               "Proxy-Connection: keep-alive\r\n\r\n"),
 580   };
 581   MockRead reads[] = {
 582     MockRead(ASYNC, 1, "HTTP/1.1 100 Continue\r\n\r\n"),
 583     MockRead(ASYNC, 2, "HTTP/1.1 200 Connection Established\r\n\r\n"),
 584   };
 585
 586   Initialize(reads, arraysize(reads), writes, arraysize(writes),
 587              NULL, 0, NULL, 0);
 588
 589   int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
 590                         &pool_, BoundNetLog());
 591   EXPECT_EQ(ERR_IO_PENDING, rv);
 592   EXPECT_FALSE(handle_.is_initialized());
 593   EXPECT_FALSE(handle_.socket());
 594
 595   data_->RunFor(2);
 596   EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, callback_.WaitForResult());
 597 }
 598
 599 TEST_P(HttpProxyClientSocketPoolTest, TunnelSetupError) {
 600   MockWrite writes[] = {
 601     MockWrite(ASYNC, 0,
 602               "CONNECT www.google.com:443 HTTP/1.1\r\n"
 603               "Host: www.google.com\r\n"
 604               "Proxy-Connection: keep-alive\r\n"
 605               "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
 606   };
 607   MockRead reads[] = {
 608     MockRead(ASYNC, 1, "HTTP/1.1 304 Not Modified\r\n\r\n"),
 609   };
 610   scoped_ptr<SpdyFrame> req(
 611       spdy_util_.ConstructSpdyConnect(kAuthHeaders, kAuthHeadersSize, 1, LOW));
 612   scoped_ptr<SpdyFrame> rst(
 613       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
 614   MockWrite spdy_writes[] = {
 615     CreateMockWrite(*req, 0, ASYNC),
 616     CreateMockWrite(*rst, 2, ASYNC),
 617   };
 618   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdySynReplyError(1));
 619   MockRead spdy_reads[] = {
 620     CreateMockRead(*resp, 1, ASYNC),
 621     MockRead(ASYNC, 0, 3),
 622   };
 623
 624   Initialize(reads, arraysize(reads), writes, arraysize(writes),
 625              spdy_reads, arraysize(spdy_reads), spdy_writes,
 626              arraysize(spdy_writes));
 627   AddAuthToCache();
 628
 629   int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
 630                         &pool_, BoundNetLog());
 631   EXPECT_EQ(ERR_IO_PENDING, rv);
 632   EXPECT_FALSE(handle_.is_initialized());
 633   EXPECT_FALSE(handle_.socket());
 634
 635   data_->RunFor(2);
 636
 637   rv = callback_.WaitForResult();
 638   // All Proxy CONNECT responses are not trustworthy
 639   EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv);
 640   EXPECT_FALSE(handle_.is_initialized());
 641   EXPECT_FALSE(handle_.socket());
 642 }
 643
 644 TEST_P(HttpProxyClientSocketPoolTest, TunnelSetupRedirect) {
 645   const std::string redirectTarget = "https://foo.google.com/";
 646
 647   const std::string responseText = "HTTP/1.1 302 Found\r\n"
 648                                    "Location: " + redirectTarget + "\r\n"
 649                                    "Set-Cookie: foo=bar\r\n"
 650                                    "\r\n";
 651   MockWrite writes[] = {
 652     MockWrite(ASYNC, 0,
 653               "CONNECT www.google.com:443 HTTP/1.1\r\n"
 654               "Host: www.google.com\r\n"
 655               "Proxy-Connection: keep-alive\r\n"
 656               "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
 657   };
 658   MockRead reads[] = {
 659     MockRead(ASYNC, 1, responseText.c_str()),
 660   };
 661   scoped_ptr<SpdyFrame> req(
 662       spdy_util_.ConstructSpdyConnect(kAuthHeaders, kAuthHeadersSize, 1, LOW));
 663   scoped_ptr<SpdyFrame> rst(
 664       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
 665
 666   MockWrite spdy_writes[] = {
 667     CreateMockWrite(*req, 0, ASYNC),
 668     CreateMockWrite(*rst, 3, ASYNC),
 669   };
 670
 671   const char* const responseHeaders[] = {
 672     "location", redirectTarget.c_str(),
 673     "set-cookie", "foo=bar",
 674   };
 675   const int responseHeadersSize = arraysize(responseHeaders) / 2;
 676   scoped_ptr<SpdyFrame> resp(
 677       spdy_util_.ConstructSpdySynReplyError(
 678           "302 Found",
 679           responseHeaders, responseHeadersSize,
 680           1));
 681   MockRead spdy_reads[] = {
 682     CreateMockRead(*resp, 1, ASYNC),
 683     MockRead(ASYNC, 0, 2),
 684   };
 685
 686   Initialize(reads, arraysize(reads), writes, arraysize(writes),
 687              spdy_reads, arraysize(spdy_reads), spdy_writes,
 688              arraysize(spdy_writes));
 689   AddAuthToCache();
 690
 691   int rv = handle_.Init("a", CreateTunnelParams(), LOW, callback_.callback(),
 692                         &pool_, BoundNetLog());
 693   EXPECT_EQ(ERR_IO_PENDING, rv);
 694   EXPECT_FALSE(handle_.is_initialized());
 695   EXPECT_FALSE(handle_.socket());
 696
 697   data_->RunFor(2);
 698
 699   rv = callback_.WaitForResult();
 700
 701   if (GetParam().proxy_type == HTTP) {
 702     // We don't trust 302 responses to CONNECT from HTTP proxies.
 703     EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv);
 704     EXPECT_FALSE(handle_.is_initialized());
 705     EXPECT_FALSE(handle_.socket());
 706   } else {
 707     // Expect ProxyClientSocket to return the proxy's response, sanitized.
 708     EXPECT_EQ(ERR_HTTPS_PROXY_TUNNEL_RESPONSE, rv);
 709     EXPECT_TRUE(handle_.is_initialized());
 710     ASSERT_TRUE(handle_.socket());
 711
 712     const ProxyClientSocket* tunnel_socket =
 713         static_cast<ProxyClientSocket*>(handle_.socket());
 714     const HttpResponseInfo* response = tunnel_socket->GetConnectResponseInfo();
 715     const HttpResponseHeaders* headers = response->headers.get();
 716
 717     // Make sure Set-Cookie header was stripped.
 718     EXPECT_FALSE(headers->HasHeader("set-cookie"));
 719
 720     // Make sure Content-Length: 0 header was added.
 721     EXPECT_TRUE(headers->HasHeaderValue("content-length", "0"));
 722
 723     // Make sure Location header was included and correct.
 724     std::string location;
 725     EXPECT_TRUE(headers->IsRedirect(&location));
 726     EXPECT_EQ(location, redirectTarget);
 727   }
 728 }
 729
 730 // It would be nice to also test the timeouts in HttpProxyClientSocketPool.
 731
 732 }  // namespace
 733
 734 }  // namespace net