net/http/http_stream_factory_impl_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_stream_factory_impl.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "base/basictypes.h"
  11 #include "base/compiler_specific.h"
  12 #include "net/base/net_log.h"
  13 #include "net/base/test_completion_callback.h"
  14 #include "net/cert/mock_cert_verifier.h"
  15 #include "net/dns/mock_host_resolver.h"
  16 #include "net/http/http_auth_handler_factory.h"
  17 #include "net/http/http_network_session.h"
  18 #include "net/http/http_network_session_peer.h"
  19 #include "net/http/http_network_transaction.h"
  20 #include "net/http/http_request_info.h"
  21 #include "net/http/http_server_properties.h"
  22 #include "net/http/http_server_properties_impl.h"
  23 #include "net/http/http_stream.h"
  24 #include "net/http/transport_security_state.h"
  25 #include "net/proxy/proxy_info.h"
  26 #include "net/proxy/proxy_service.h"
  27 #include "net/socket/client_socket_handle.h"
  28 #include "net/socket/mock_client_socket_pool_manager.h"
  29 #include "net/socket/next_proto.h"
  30 #include "net/socket/socket_test_util.h"
  31 #include "net/spdy/spdy_session.h"
  32 #include "net/spdy/spdy_session_pool.h"
  33 #include "net/spdy/spdy_test_util_common.h"
  34 #include "net/ssl/ssl_config_service.h"
  35 #include "net/ssl/ssl_config_service_defaults.h"
  36 // This file can be included from net/http even though
  37 // it is in net/websockets because it doesn't
  38 // introduce any link dependency to net/websockets.
  39 #include "net/websockets/websocket_handshake_stream_base.h"
  40 #include "testing/gtest/include/gtest/gtest.h"
  41
  42 namespace net {
  43
  44 namespace {
  45
  46 class MockWebSocketHandshakeStream : public WebSocketHandshakeStreamBase {
  47  public:
  48   enum StreamType {
  49     kStreamTypeBasic,
  50     kStreamTypeSpdy,
  51   };
  52
  53   explicit MockWebSocketHandshakeStream(StreamType type) : type_(type) {}
  54
  55   virtual ~MockWebSocketHandshakeStream() {}
  56
  57   StreamType type() const {
  58     return type_;
  59   }
  60
  61   // HttpStreamBase methods
  62   virtual int InitializeStream(const HttpRequestInfo* request_info,
  63                                RequestPriority priority,
  64                                const BoundNetLog& net_log,
  65                                const CompletionCallback& callback) OVERRIDE {
  66     return ERR_IO_PENDING;
  67   }
  68   virtual int SendRequest(const HttpRequestHeaders& request_headers,
  69                           HttpResponseInfo* response,
  70                           const CompletionCallback& callback) OVERRIDE {
  71     return ERR_IO_PENDING;
  72   }
  73   virtual int ReadResponseHeaders(const CompletionCallback& callback) OVERRIDE {
  74     return ERR_IO_PENDING;
  75   }
  76   virtual int ReadResponseBody(IOBuffer* buf,
  77                                int buf_len,
  78                                const CompletionCallback& callback) OVERRIDE {
  79     return ERR_IO_PENDING;
  80   }
  81   virtual void Close(bool not_reusable) OVERRIDE {}
  82   virtual bool IsResponseBodyComplete() const OVERRIDE { return false; }
  83   virtual bool CanFindEndOfResponse() const OVERRIDE { return false; }
  84   virtual bool IsConnectionReused() const OVERRIDE { return false; }
  85   virtual void SetConnectionReused() OVERRIDE {}
  86   virtual bool IsConnectionReusable() const OVERRIDE { return false; }
  87   virtual int64 GetTotalReceivedBytes() const OVERRIDE { return 0; }
  88   virtual bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const
  89       OVERRIDE {
  90     return false;
  91   }
  92   virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {}
  93   virtual void GetSSLCertRequestInfo(
  94       SSLCertRequestInfo* cert_request_info) OVERRIDE {}
  95   virtual bool IsSpdyHttpStream() const OVERRIDE { return false; }
  96   virtual void Drain(HttpNetworkSession* session) OVERRIDE {}
  97   virtual void SetPriority(RequestPriority priority) OVERRIDE {}
  98
  99   virtual scoped_ptr<WebSocketStream> Upgrade() OVERRIDE {
 100     return scoped_ptr<WebSocketStream>();
 101   }
 102
 103  private:
 104   const StreamType type_;
 105 };
 106
 107 // HttpStreamFactoryImpl subclass that can wait until a preconnect is complete.
 108 class MockHttpStreamFactoryImplForPreconnect : public HttpStreamFactoryImpl {
 109  public:
 110   MockHttpStreamFactoryImplForPreconnect(HttpNetworkSession* session,
 111                                          bool for_websockets)
 112       : HttpStreamFactoryImpl(session, for_websockets),
 113         preconnect_done_(false),
 114         waiting_for_preconnect_(false) {}
 115
 116
 117   void WaitForPreconnects() {
 118     while (!preconnect_done_) {
 119       waiting_for_preconnect_ = true;
 120       base::MessageLoop::current()->Run();
 121       waiting_for_preconnect_ = false;
 122     }
 123   }
 124
 125  private:
 126   // HttpStreamFactoryImpl methods.
 127   virtual void OnPreconnectsCompleteInternal() OVERRIDE {
 128     preconnect_done_ = true;
 129     if (waiting_for_preconnect_)
 130       base::MessageLoop::current()->Quit();
 131   }
 132
 133   bool preconnect_done_;
 134   bool waiting_for_preconnect_;
 135 };
 136
 137 class StreamRequestWaiter : public HttpStreamRequest::Delegate {
 138  public:
 139   StreamRequestWaiter()
 140       : waiting_for_stream_(false),
 141         stream_done_(false) {}
 142
 143   // HttpStreamRequest::Delegate
 144
 145   virtual void OnStreamReady(
 146       const SSLConfig& used_ssl_config,
 147       const ProxyInfo& used_proxy_info,
 148       HttpStreamBase* stream) OVERRIDE {
 149     stream_done_ = true;
 150     if (waiting_for_stream_)
 151       base::MessageLoop::current()->Quit();
 152     stream_.reset(stream);
 153     used_ssl_config_ = used_ssl_config;
 154     used_proxy_info_ = used_proxy_info;
 155   }
 156
 157   virtual void OnWebSocketHandshakeStreamReady(
 158       const SSLConfig& used_ssl_config,
 159       const ProxyInfo& used_proxy_info,
 160       WebSocketHandshakeStreamBase* stream) OVERRIDE {
 161     stream_done_ = true;
 162     if (waiting_for_stream_)
 163       base::MessageLoop::current()->Quit();
 164     websocket_stream_.reset(stream);
 165     used_ssl_config_ = used_ssl_config;
 166     used_proxy_info_ = used_proxy_info;
 167   }
 168
 169   virtual void OnStreamFailed(
 170       int status,
 171       const SSLConfig& used_ssl_config) OVERRIDE {}
 172
 173   virtual void OnCertificateError(
 174       int status,
 175       const SSLConfig& used_ssl_config,
 176       const SSLInfo& ssl_info) OVERRIDE {}
 177
 178   virtual void OnNeedsProxyAuth(const HttpResponseInfo& proxy_response,
 179                                 const SSLConfig& used_ssl_config,
 180                                 const ProxyInfo& used_proxy_info,
 181                                 HttpAuthController* auth_controller) OVERRIDE {}
 182
 183   virtual void OnNeedsClientAuth(const SSLConfig& used_ssl_config,
 184                                  SSLCertRequestInfo* cert_info) OVERRIDE {}
 185
 186   virtual void OnHttpsProxyTunnelResponse(const HttpResponseInfo& response_info,
 187                                           const SSLConfig& used_ssl_config,
 188                                           const ProxyInfo& used_proxy_info,
 189                                           HttpStreamBase* stream) OVERRIDE {}
 190
 191   void WaitForStream() {
 192     while (!stream_done_) {
 193       waiting_for_stream_ = true;
 194       base::MessageLoop::current()->Run();
 195       waiting_for_stream_ = false;
 196     }
 197   }
 198
 199   const SSLConfig& used_ssl_config() const {
 200     return used_ssl_config_;
 201   }
 202
 203   const ProxyInfo& used_proxy_info() const {
 204     return used_proxy_info_;
 205   }
 206
 207   HttpStreamBase* stream() {
 208     return stream_.get();
 209   }
 210
 211   MockWebSocketHandshakeStream* websocket_stream() {
 212     return static_cast<MockWebSocketHandshakeStream*>(websocket_stream_.get());
 213   }
 214
 215   bool stream_done() const { return stream_done_; }
 216
 217  private:
 218   bool waiting_for_stream_;
 219   bool stream_done_;
 220   scoped_ptr<HttpStreamBase> stream_;
 221   scoped_ptr<WebSocketHandshakeStreamBase> websocket_stream_;
 222   SSLConfig used_ssl_config_;
 223   ProxyInfo used_proxy_info_;
 224
 225   DISALLOW_COPY_AND_ASSIGN(StreamRequestWaiter);
 226 };
 227
 228 class WebSocketSpdyHandshakeStream : public MockWebSocketHandshakeStream {
 229  public:
 230   explicit WebSocketSpdyHandshakeStream(
 231       const base::WeakPtr<SpdySession>& spdy_session)
 232       : MockWebSocketHandshakeStream(kStreamTypeSpdy),
 233         spdy_session_(spdy_session) {}
 234
 235   virtual ~WebSocketSpdyHandshakeStream() {}
 236
 237   SpdySession* spdy_session() { return spdy_session_.get(); }
 238
 239  private:
 240   base::WeakPtr<SpdySession> spdy_session_;
 241 };
 242
 243 class WebSocketBasicHandshakeStream : public MockWebSocketHandshakeStream {
 244  public:
 245   explicit WebSocketBasicHandshakeStream(
 246       scoped_ptr<ClientSocketHandle> connection)
 247       : MockWebSocketHandshakeStream(kStreamTypeBasic),
 248         connection_(connection.Pass()) {}
 249
 250   virtual ~WebSocketBasicHandshakeStream() {
 251     connection_->socket()->Disconnect();
 252   }
 253
 254   ClientSocketHandle* connection() { return connection_.get(); }
 255
 256  private:
 257   scoped_ptr<ClientSocketHandle> connection_;
 258 };
 259
 260 class WebSocketStreamCreateHelper
 261     : public WebSocketHandshakeStreamBase::CreateHelper {
 262  public:
 263   virtual ~WebSocketStreamCreateHelper() {}
 264
 265   virtual WebSocketHandshakeStreamBase* CreateBasicStream(
 266       scoped_ptr<ClientSocketHandle> connection,
 267       bool using_proxy) OVERRIDE {
 268     return new WebSocketBasicHandshakeStream(connection.Pass());
 269   }
 270
 271   virtual WebSocketHandshakeStreamBase* CreateSpdyStream(
 272       const base::WeakPtr<SpdySession>& spdy_session,
 273       bool use_relative_url) OVERRIDE {
 274     return new WebSocketSpdyHandshakeStream(spdy_session);
 275   }
 276 };
 277
 278 struct TestCase {
 279   int num_streams;
 280   bool ssl;
 281 };
 282
 283 TestCase kTests[] = {
 284   { 1, false },
 285   { 2, false },
 286   { 1, true},
 287   { 2, true},
 288 };
 289
 290 void PreconnectHelperForURL(int num_streams,
 291                             const GURL& url,
 292                             HttpNetworkSession* session) {
 293   HttpNetworkSessionPeer peer(session);
 294   MockHttpStreamFactoryImplForPreconnect* mock_factory =
 295       new MockHttpStreamFactoryImplForPreconnect(session, false);
 296   peer.SetHttpStreamFactory(scoped_ptr<HttpStreamFactory>(mock_factory));
 297   SSLConfig ssl_config;
 298   session->ssl_config_service()->GetSSLConfig(&ssl_config);
 299
 300   HttpRequestInfo request;
 301   request.method = "GET";
 302   request.url = url;
 303   request.load_flags = 0;
 304
 305   session->http_stream_factory()->PreconnectStreams(
 306       num_streams, request, DEFAULT_PRIORITY, ssl_config, ssl_config);
 307   mock_factory->WaitForPreconnects();
 308 };
 309
 310 void PreconnectHelper(const TestCase& test,
 311                       HttpNetworkSession* session) {
 312   GURL url = test.ssl ? GURL("https://www.google.com") :
 313       GURL("http://www.google.com");
 314   PreconnectHelperForURL(test.num_streams, url, session);
 315 };
 316
 317 template<typename ParentPool>
 318 class CapturePreconnectsSocketPool : public ParentPool {
 319  public:
 320   CapturePreconnectsSocketPool(HostResolver* host_resolver,
 321                                CertVerifier* cert_verifier);
 322
 323   int last_num_streams() const {
 324     return last_num_streams_;
 325   }
 326
 327   virtual int RequestSocket(const std::string& group_name,
 328                             const void* socket_params,
 329                             RequestPriority priority,
 330                             ClientSocketHandle* handle,
 331                             const CompletionCallback& callback,
 332                             const BoundNetLog& net_log) OVERRIDE {
 333     ADD_FAILURE();
 334     return ERR_UNEXPECTED;
 335   }
 336
 337   virtual void RequestSockets(const std::string& group_name,
 338                               const void* socket_params,
 339                               int num_sockets,
 340                               const BoundNetLog& net_log) OVERRIDE {
 341     last_num_streams_ = num_sockets;
 342   }
 343
 344   virtual void CancelRequest(const std::string& group_name,
 345                              ClientSocketHandle* handle) OVERRIDE {
 346     ADD_FAILURE();
 347   }
 348   virtual void ReleaseSocket(const std::string& group_name,
 349                              scoped_ptr<StreamSocket> socket,
 350                              int id) OVERRIDE {
 351     ADD_FAILURE();
 352   }
 353   virtual void CloseIdleSockets() OVERRIDE {
 354     ADD_FAILURE();
 355   }
 356   virtual int IdleSocketCount() const OVERRIDE {
 357     ADD_FAILURE();
 358     return 0;
 359   }
 360   virtual int IdleSocketCountInGroup(
 361       const std::string& group_name) const OVERRIDE {
 362     ADD_FAILURE();
 363     return 0;
 364   }
 365   virtual LoadState GetLoadState(
 366       const std::string& group_name,
 367       const ClientSocketHandle* handle) const OVERRIDE {
 368     ADD_FAILURE();
 369     return LOAD_STATE_IDLE;
 370   }
 371   virtual base::TimeDelta ConnectionTimeout() const OVERRIDE {
 372     return base::TimeDelta();
 373   }
 374
 375  private:
 376   int last_num_streams_;
 377 };
 378
 379 typedef CapturePreconnectsSocketPool<TransportClientSocketPool>
 380 CapturePreconnectsTransportSocketPool;
 381 typedef CapturePreconnectsSocketPool<HttpProxyClientSocketPool>
 382 CapturePreconnectsHttpProxySocketPool;
 383 typedef CapturePreconnectsSocketPool<SOCKSClientSocketPool>
 384 CapturePreconnectsSOCKSSocketPool;
 385 typedef CapturePreconnectsSocketPool<SSLClientSocketPool>
 386 CapturePreconnectsSSLSocketPool;
 387
 388 template<typename ParentPool>
 389 CapturePreconnectsSocketPool<ParentPool>::CapturePreconnectsSocketPool(
 390     HostResolver* host_resolver, CertVerifier* /* cert_verifier */)
 391     : ParentPool(0, 0, NULL, host_resolver, NULL, NULL),
 392       last_num_streams_(-1) {}
 393
 394 template<>
 395 CapturePreconnectsHttpProxySocketPool::CapturePreconnectsSocketPool(
 396     HostResolver* host_resolver, CertVerifier* /* cert_verifier */)
 397     : HttpProxyClientSocketPool(
 398           0, 0, NULL, host_resolver, NULL, NULL, NULL, NULL),
 399       last_num_streams_(-1) {}
 400
 401 template <>
 402 CapturePreconnectsSSLSocketPool::CapturePreconnectsSocketPool(
 403     HostResolver* host_resolver,
 404     CertVerifier* cert_verifier)
 405     : SSLClientSocketPool(0,
 406                           0,
 407                           NULL,  // ssl_histograms
 408                           host_resolver,
 409                           cert_verifier,
 410                           NULL,           // channel_id_store
 411                           NULL,           // transport_security_state
 412                           NULL,           // cert_transparency_verifier
 413                           std::string(),  // ssl_session_cache_shard
 414                           NULL,           // deterministic_socket_factory
 415                           NULL,           // transport_socket_pool
 416                           NULL,
 417                           NULL,
 418                           NULL,   // ssl_config_service
 419                           false,  // enable_ssl_connect_job_waiting
 420                           NULL),  // net_log
 421       last_num_streams_(-1) {
 422 }
 423
 424 class HttpStreamFactoryTest : public ::testing::Test,
 425                               public ::testing::WithParamInterface<NextProto> {
 426 };
 427
 428 INSTANTIATE_TEST_CASE_P(
 429     NextProto,
 430     HttpStreamFactoryTest,
 431     testing::Values(kProtoDeprecatedSPDY2,
 432                     kProtoSPDY3, kProtoSPDY31, kProtoSPDY4));
 433
 434 TEST_P(HttpStreamFactoryTest, PreconnectDirect) {
 435   for (size_t i = 0; i < arraysize(kTests); ++i) {
 436     SpdySessionDependencies session_deps(
 437         GetParam(), ProxyService::CreateDirect());
 438     scoped_refptr<HttpNetworkSession> session(
 439         SpdySessionDependencies::SpdyCreateSession(&session_deps));
 440     HttpNetworkSessionPeer peer(session);
 441     CapturePreconnectsTransportSocketPool* transport_conn_pool =
 442         new CapturePreconnectsTransportSocketPool(
 443             session_deps.host_resolver.get(),
 444             session_deps.cert_verifier.get());
 445     CapturePreconnectsSSLSocketPool* ssl_conn_pool =
 446         new CapturePreconnectsSSLSocketPool(
 447             session_deps.host_resolver.get(),
 448             session_deps.cert_verifier.get());
 449     scoped_ptr<MockClientSocketPoolManager> mock_pool_manager(
 450         new MockClientSocketPoolManager);
 451     mock_pool_manager->SetTransportSocketPool(transport_conn_pool);
 452     mock_pool_manager->SetSSLSocketPool(ssl_conn_pool);
 453     peer.SetClientSocketPoolManager(
 454         mock_pool_manager.PassAs<ClientSocketPoolManager>());
 455     PreconnectHelper(kTests[i], session.get());
 456     if (kTests[i].ssl)
 457       EXPECT_EQ(kTests[i].num_streams, ssl_conn_pool->last_num_streams());
 458     else
 459       EXPECT_EQ(kTests[i].num_streams, transport_conn_pool->last_num_streams());
 460   }
 461 }
 462
 463 TEST_P(HttpStreamFactoryTest, PreconnectHttpProxy) {
 464   for (size_t i = 0; i < arraysize(kTests); ++i) {
 465     SpdySessionDependencies session_deps(
 466         GetParam(), ProxyService::CreateFixed("http_proxy"));
 467     scoped_refptr<HttpNetworkSession> session(
 468         SpdySessionDependencies::SpdyCreateSession(&session_deps));
 469     HttpNetworkSessionPeer peer(session);
 470     HostPortPair proxy_host("http_proxy", 80);
 471     CapturePreconnectsHttpProxySocketPool* http_proxy_pool =
 472         new CapturePreconnectsHttpProxySocketPool(
 473             session_deps.host_resolver.get(),
 474             session_deps.cert_verifier.get());
 475     CapturePreconnectsSSLSocketPool* ssl_conn_pool =
 476         new CapturePreconnectsSSLSocketPool(
 477             session_deps.host_resolver.get(),
 478             session_deps.cert_verifier.get());
 479     scoped_ptr<MockClientSocketPoolManager> mock_pool_manager(
 480         new MockClientSocketPoolManager);
 481     mock_pool_manager->SetSocketPoolForHTTPProxy(proxy_host, http_proxy_pool);
 482     mock_pool_manager->SetSocketPoolForSSLWithProxy(proxy_host, ssl_conn_pool);
 483     peer.SetClientSocketPoolManager(
 484         mock_pool_manager.PassAs<ClientSocketPoolManager>());
 485     PreconnectHelper(kTests[i], session.get());
 486     if (kTests[i].ssl)
 487       EXPECT_EQ(kTests[i].num_streams, ssl_conn_pool->last_num_streams());
 488     else
 489       EXPECT_EQ(kTests[i].num_streams, http_proxy_pool->last_num_streams());
 490   }
 491 }
 492
 493 TEST_P(HttpStreamFactoryTest, PreconnectSocksProxy) {
 494   for (size_t i = 0; i < arraysize(kTests); ++i) {
 495     SpdySessionDependencies session_deps(
 496         GetParam(), ProxyService::CreateFixed("socks4://socks_proxy:1080"));
 497     scoped_refptr<HttpNetworkSession> session(
 498         SpdySessionDependencies::SpdyCreateSession(&session_deps));
 499     HttpNetworkSessionPeer peer(session);
 500     HostPortPair proxy_host("socks_proxy", 1080);
 501     CapturePreconnectsSOCKSSocketPool* socks_proxy_pool =
 502         new CapturePreconnectsSOCKSSocketPool(
 503             session_deps.host_resolver.get(),
 504             session_deps.cert_verifier.get());
 505     CapturePreconnectsSSLSocketPool* ssl_conn_pool =
 506         new CapturePreconnectsSSLSocketPool(
 507             session_deps.host_resolver.get(),
 508             session_deps.cert_verifier.get());
 509     scoped_ptr<MockClientSocketPoolManager> mock_pool_manager(
 510         new MockClientSocketPoolManager);
 511     mock_pool_manager->SetSocketPoolForSOCKSProxy(proxy_host, socks_proxy_pool);
 512     mock_pool_manager->SetSocketPoolForSSLWithProxy(proxy_host, ssl_conn_pool);
 513     peer.SetClientSocketPoolManager(
 514         mock_pool_manager.PassAs<ClientSocketPoolManager>());
 515     PreconnectHelper(kTests[i], session.get());
 516     if (kTests[i].ssl)
 517       EXPECT_EQ(kTests[i].num_streams, ssl_conn_pool->last_num_streams());
 518     else
 519       EXPECT_EQ(kTests[i].num_streams, socks_proxy_pool->last_num_streams());
 520   }
 521 }
 522
 523 TEST_P(HttpStreamFactoryTest, PreconnectDirectWithExistingSpdySession) {
 524   for (size_t i = 0; i < arraysize(kTests); ++i) {
 525     SpdySessionDependencies session_deps(
 526         GetParam(), ProxyService::CreateDirect());
 527     scoped_refptr<HttpNetworkSession> session(
 528         SpdySessionDependencies::SpdyCreateSession(&session_deps));
 529     HttpNetworkSessionPeer peer(session);
 530
 531     // Put a SpdySession in the pool.
 532     HostPortPair host_port_pair("www.google.com", 443);
 533     SpdySessionKey key(host_port_pair, ProxyServer::Direct(),
 534                        PRIVACY_MODE_DISABLED);
 535     ignore_result(CreateFakeSpdySession(session->spdy_session_pool(), key));
 536
 537     CapturePreconnectsTransportSocketPool* transport_conn_pool =
 538         new CapturePreconnectsTransportSocketPool(
 539             session_deps.host_resolver.get(),
 540             session_deps.cert_verifier.get());
 541     CapturePreconnectsSSLSocketPool* ssl_conn_pool =
 542         new CapturePreconnectsSSLSocketPool(
 543             session_deps.host_resolver.get(),
 544             session_deps.cert_verifier.get());
 545     scoped_ptr<MockClientSocketPoolManager> mock_pool_manager(
 546         new MockClientSocketPoolManager);
 547     mock_pool_manager->SetTransportSocketPool(transport_conn_pool);
 548     mock_pool_manager->SetSSLSocketPool(ssl_conn_pool);
 549     peer.SetClientSocketPoolManager(
 550         mock_pool_manager.PassAs<ClientSocketPoolManager>());
 551     PreconnectHelper(kTests[i], session.get());
 552     // We shouldn't be preconnecting if we have an existing session, which is
 553     // the case for https://www.google.com.
 554     if (kTests[i].ssl)
 555       EXPECT_EQ(-1, ssl_conn_pool->last_num_streams());
 556     else
 557       EXPECT_EQ(kTests[i].num_streams,
 558                 transport_conn_pool->last_num_streams());
 559   }
 560 }
 561
 562 // Verify that preconnects to unsafe ports are cancelled before they reach
 563 // the SocketPool.
 564 TEST_P(HttpStreamFactoryTest, PreconnectUnsafePort) {
 565   ASSERT_FALSE(IsPortAllowedByDefault(7));
 566   ASSERT_FALSE(IsPortAllowedByOverride(7));
 567
 568   SpdySessionDependencies session_deps(
 569       GetParam(), ProxyService::CreateDirect());
 570   scoped_refptr<HttpNetworkSession> session(
 571       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 572   HttpNetworkSessionPeer peer(session);
 573   CapturePreconnectsTransportSocketPool* transport_conn_pool =
 574       new CapturePreconnectsTransportSocketPool(
 575           session_deps.host_resolver.get(),
 576           session_deps.cert_verifier.get());
 577   scoped_ptr<MockClientSocketPoolManager> mock_pool_manager(
 578       new MockClientSocketPoolManager);
 579   mock_pool_manager->SetTransportSocketPool(transport_conn_pool);
 580   peer.SetClientSocketPoolManager(
 581       mock_pool_manager.PassAs<ClientSocketPoolManager>());
 582
 583   PreconnectHelperForURL(1, GURL("http://www.google.com:7"), session.get());
 584
 585   EXPECT_EQ(-1, transport_conn_pool->last_num_streams());
 586 }
 587
 588 TEST_P(HttpStreamFactoryTest, JobNotifiesProxy) {
 589   const char* kProxyString = "PROXY bad:99; PROXY maybe:80; DIRECT";
 590   SpdySessionDependencies session_deps(
 591       GetParam(), ProxyService::CreateFixedFromPacResult(kProxyString));
 592
 593   // First connection attempt fails
 594   StaticSocketDataProvider socket_data1;
 595   socket_data1.set_connect_data(MockConnect(ASYNC, ERR_ADDRESS_UNREACHABLE));
 596   session_deps.socket_factory->AddSocketDataProvider(&socket_data1);
 597
 598   // Second connection attempt succeeds
 599   StaticSocketDataProvider socket_data2;
 600   socket_data2.set_connect_data(MockConnect(ASYNC, OK));
 601   session_deps.socket_factory->AddSocketDataProvider(&socket_data2);
 602
 603   scoped_refptr<HttpNetworkSession> session(
 604       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 605
 606   // Now request a stream. It should succeed using the second proxy in the
 607   // list.
 608   HttpRequestInfo request_info;
 609   request_info.method = "GET";
 610   request_info.url = GURL("http://www.google.com");
 611
 612   SSLConfig ssl_config;
 613   StreamRequestWaiter waiter;
 614   scoped_ptr<HttpStreamRequest> request(
 615       session->http_stream_factory()->RequestStream(
 616           request_info, DEFAULT_PRIORITY, ssl_config, ssl_config,
 617           &waiter, BoundNetLog()));
 618   waiter.WaitForStream();
 619
 620   // The proxy that failed should now be known to the proxy_service as bad.
 621   const ProxyRetryInfoMap& retry_info =
 622       session->proxy_service()->proxy_retry_info();
 623   EXPECT_EQ(1u, retry_info.size());
 624   ProxyRetryInfoMap::const_iterator iter = retry_info.find("bad:99");
 625   EXPECT_TRUE(iter != retry_info.end());
 626 }
 627
 628 TEST_P(HttpStreamFactoryTest, PrivacyModeDisablesChannelId) {
 629   SpdySessionDependencies session_deps(
 630       GetParam(), ProxyService::CreateDirect());
 631
 632   StaticSocketDataProvider socket_data;
 633   socket_data.set_connect_data(MockConnect(ASYNC, OK));
 634   session_deps.socket_factory->AddSocketDataProvider(&socket_data);
 635
 636   SSLSocketDataProvider ssl(ASYNC, OK);
 637   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl);
 638
 639   scoped_refptr<HttpNetworkSession> session(
 640       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 641
 642   // Set an existing SpdySession in the pool.
 643   HostPortPair host_port_pair("www.google.com", 443);
 644   SpdySessionKey key(host_port_pair, ProxyServer::Direct(),
 645                      PRIVACY_MODE_ENABLED);
 646
 647   HttpRequestInfo request_info;
 648   request_info.method = "GET";
 649   request_info.url = GURL("https://www.google.com");
 650   request_info.load_flags = 0;
 651   request_info.privacy_mode = PRIVACY_MODE_DISABLED;
 652
 653   SSLConfig ssl_config;
 654   StreamRequestWaiter waiter;
 655   scoped_ptr<HttpStreamRequest> request(
 656       session->http_stream_factory()->RequestStream(
 657           request_info, DEFAULT_PRIORITY, ssl_config, ssl_config,
 658           &waiter, BoundNetLog()));
 659   waiter.WaitForStream();
 660
 661   // The stream shouldn't come from spdy as we are using different privacy mode
 662   EXPECT_FALSE(request->using_spdy());
 663
 664   SSLConfig used_ssl_config = waiter.used_ssl_config();
 665   EXPECT_EQ(used_ssl_config.channel_id_enabled, ssl_config.channel_id_enabled);
 666 }
 667
 668 namespace {
 669 // Return count of distinct groups in given socket pool.
 670 int GetSocketPoolGroupCount(ClientSocketPool* pool) {
 671   int count = 0;
 672   scoped_ptr<base::DictionaryValue> dict(pool->GetInfoAsValue("", "", false));
 673   EXPECT_TRUE(dict != NULL);
 674   base::DictionaryValue* groups = NULL;
 675   if (dict->GetDictionary("groups", &groups) && (groups != NULL)) {
 676     count = static_cast<int>(groups->size());
 677   }
 678   return count;
 679 }
 680 }  // namespace
 681
 682 TEST_P(HttpStreamFactoryTest, PrivacyModeUsesDifferentSocketPoolGroup) {
 683   SpdySessionDependencies session_deps(
 684       GetParam(), ProxyService::CreateDirect());
 685
 686   StaticSocketDataProvider socket_data;
 687   socket_data.set_connect_data(MockConnect(ASYNC, OK));
 688   session_deps.socket_factory->AddSocketDataProvider(&socket_data);
 689
 690   SSLSocketDataProvider ssl(ASYNC, OK);
 691   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl);
 692
 693   scoped_refptr<HttpNetworkSession> session(
 694       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 695   SSLClientSocketPool* ssl_pool = session->GetSSLSocketPool(
 696       HttpNetworkSession::NORMAL_SOCKET_POOL);
 697
 698   EXPECT_EQ(GetSocketPoolGroupCount(ssl_pool), 0);
 699
 700   HttpRequestInfo request_info;
 701   request_info.method = "GET";
 702   request_info.url = GURL("https://www.google.com");
 703   request_info.load_flags = 0;
 704   request_info.privacy_mode = PRIVACY_MODE_DISABLED;
 705
 706   SSLConfig ssl_config;
 707   StreamRequestWaiter waiter;
 708
 709   scoped_ptr<HttpStreamRequest> request1(
 710       session->http_stream_factory()->RequestStream(
 711           request_info, DEFAULT_PRIORITY, ssl_config, ssl_config,
 712           &waiter, BoundNetLog()));
 713   waiter.WaitForStream();
 714
 715   EXPECT_EQ(GetSocketPoolGroupCount(ssl_pool), 1);
 716
 717   scoped_ptr<HttpStreamRequest> request2(
 718       session->http_stream_factory()->RequestStream(
 719           request_info, DEFAULT_PRIORITY, ssl_config, ssl_config,
 720           &waiter, BoundNetLog()));
 721   waiter.WaitForStream();
 722
 723   EXPECT_EQ(GetSocketPoolGroupCount(ssl_pool), 1);
 724
 725   request_info.privacy_mode = PRIVACY_MODE_ENABLED;
 726   scoped_ptr<HttpStreamRequest> request3(
 727       session->http_stream_factory()->RequestStream(
 728           request_info, DEFAULT_PRIORITY, ssl_config, ssl_config,
 729           &waiter, BoundNetLog()));
 730   waiter.WaitForStream();
 731
 732   EXPECT_EQ(GetSocketPoolGroupCount(ssl_pool), 2);
 733 }
 734
 735 TEST_P(HttpStreamFactoryTest, GetLoadState) {
 736   SpdySessionDependencies session_deps(
 737       GetParam(), ProxyService::CreateDirect());
 738
 739   StaticSocketDataProvider socket_data;
 740   socket_data.set_connect_data(MockConnect(ASYNC, OK));
 741   session_deps.socket_factory->AddSocketDataProvider(&socket_data);
 742
 743   scoped_refptr<HttpNetworkSession> session(
 744       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 745
 746   HttpRequestInfo request_info;
 747   request_info.method = "GET";
 748   request_info.url = GURL("http://www.google.com");
 749
 750   SSLConfig ssl_config;
 751   StreamRequestWaiter waiter;
 752   scoped_ptr<HttpStreamRequest> request(
 753       session->http_stream_factory()->RequestStream(
 754           request_info, DEFAULT_PRIORITY, ssl_config, ssl_config,
 755           &waiter, BoundNetLog()));
 756
 757   EXPECT_EQ(LOAD_STATE_RESOLVING_HOST, request->GetLoadState());
 758
 759   waiter.WaitForStream();
 760 }
 761
 762 TEST_P(HttpStreamFactoryTest, RequestHttpStream) {
 763   SpdySessionDependencies session_deps(
 764       GetParam(), ProxyService::CreateDirect());
 765
 766   StaticSocketDataProvider socket_data;
 767   socket_data.set_connect_data(MockConnect(ASYNC, OK));
 768   session_deps.socket_factory->AddSocketDataProvider(&socket_data);
 769
 770   scoped_refptr<HttpNetworkSession> session(
 771       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 772
 773   // Now request a stream.  It should succeed using the second proxy in the
 774   // list.
 775   HttpRequestInfo request_info;
 776   request_info.method = "GET";
 777   request_info.url = GURL("http://www.google.com");
 778   request_info.load_flags = 0;
 779
 780   SSLConfig ssl_config;
 781   StreamRequestWaiter waiter;
 782   scoped_ptr<HttpStreamRequest> request(
 783       session->http_stream_factory()->RequestStream(
 784           request_info,
 785           DEFAULT_PRIORITY,
 786           ssl_config,
 787           ssl_config,
 788           &waiter,
 789           BoundNetLog()));
 790   waiter.WaitForStream();
 791   EXPECT_TRUE(waiter.stream_done());
 792   ASSERT_TRUE(NULL != waiter.stream());
 793   EXPECT_TRUE(NULL == waiter.websocket_stream());
 794   EXPECT_FALSE(waiter.stream()->IsSpdyHttpStream());
 795
 796   EXPECT_EQ(1, GetSocketPoolGroupCount(
 797       session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
 798   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSSLSocketPool(
 799       HttpNetworkSession::NORMAL_SOCKET_POOL)));
 800   EXPECT_EQ(0, GetSocketPoolGroupCount(
 801       session->GetTransportSocketPool(
 802           HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
 803   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSSLSocketPool(
 804       HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
 805   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
 806 }
 807
 808 TEST_P(HttpStreamFactoryTest, RequestHttpStreamOverSSL) {
 809   SpdySessionDependencies session_deps(
 810       GetParam(), ProxyService::CreateDirect());
 811
 812   MockRead mock_read(ASYNC, OK);
 813   StaticSocketDataProvider socket_data(&mock_read, 1, NULL, 0);
 814   socket_data.set_connect_data(MockConnect(ASYNC, OK));
 815   session_deps.socket_factory->AddSocketDataProvider(&socket_data);
 816
 817   SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
 818   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
 819
 820   scoped_refptr<HttpNetworkSession> session(
 821       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 822
 823   // Now request a stream.
 824   HttpRequestInfo request_info;
 825   request_info.method = "GET";
 826   request_info.url = GURL("https://www.google.com");
 827   request_info.load_flags = 0;
 828
 829   SSLConfig ssl_config;
 830   StreamRequestWaiter waiter;
 831   scoped_ptr<HttpStreamRequest> request(
 832       session->http_stream_factory()->RequestStream(
 833           request_info,
 834           DEFAULT_PRIORITY,
 835           ssl_config,
 836           ssl_config,
 837           &waiter,
 838           BoundNetLog()));
 839   waiter.WaitForStream();
 840   EXPECT_TRUE(waiter.stream_done());
 841   ASSERT_TRUE(NULL != waiter.stream());
 842   EXPECT_TRUE(NULL == waiter.websocket_stream());
 843   EXPECT_FALSE(waiter.stream()->IsSpdyHttpStream());
 844   EXPECT_EQ(1, GetSocketPoolGroupCount(
 845       session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
 846   EXPECT_EQ(1, GetSocketPoolGroupCount(
 847       session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
 848   EXPECT_EQ(0, GetSocketPoolGroupCount(
 849       session->GetTransportSocketPool(
 850           HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
 851   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSSLSocketPool(
 852       HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
 853   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
 854 }
 855
 856 TEST_P(HttpStreamFactoryTest, RequestHttpStreamOverProxy) {
 857   SpdySessionDependencies session_deps(
 858       GetParam(), ProxyService::CreateFixed("myproxy:8888"));
 859
 860   StaticSocketDataProvider socket_data;
 861   socket_data.set_connect_data(MockConnect(ASYNC, OK));
 862   session_deps.socket_factory->AddSocketDataProvider(&socket_data);
 863
 864   scoped_refptr<HttpNetworkSession> session(
 865       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 866
 867   // Now request a stream.  It should succeed using the second proxy in the
 868   // list.
 869   HttpRequestInfo request_info;
 870   request_info.method = "GET";
 871   request_info.url = GURL("http://www.google.com");
 872   request_info.load_flags = 0;
 873
 874   SSLConfig ssl_config;
 875   StreamRequestWaiter waiter;
 876   scoped_ptr<HttpStreamRequest> request(
 877       session->http_stream_factory()->RequestStream(
 878           request_info,
 879           DEFAULT_PRIORITY,
 880           ssl_config,
 881           ssl_config,
 882           &waiter,
 883           BoundNetLog()));
 884   waiter.WaitForStream();
 885   EXPECT_TRUE(waiter.stream_done());
 886   ASSERT_TRUE(NULL != waiter.stream());
 887   EXPECT_TRUE(NULL == waiter.websocket_stream());
 888   EXPECT_FALSE(waiter.stream()->IsSpdyHttpStream());
 889   EXPECT_EQ(0, GetSocketPoolGroupCount(
 890       session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
 891   EXPECT_EQ(0, GetSocketPoolGroupCount(
 892       session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
 893   EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetSocketPoolForHTTPProxy(
 894       HttpNetworkSession::NORMAL_SOCKET_POOL,
 895       HostPortPair("myproxy", 8888))));
 896   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSocketPoolForSSLWithProxy(
 897       HttpNetworkSession::NORMAL_SOCKET_POOL,
 898       HostPortPair("myproxy", 8888))));
 899   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSocketPoolForHTTPProxy(
 900       HttpNetworkSession::WEBSOCKET_SOCKET_POOL,
 901       HostPortPair("myproxy", 8888))));
 902   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSocketPoolForSSLWithProxy(
 903       HttpNetworkSession::WEBSOCKET_SOCKET_POOL,
 904       HostPortPair("myproxy", 8888))));
 905   EXPECT_FALSE(waiter.used_proxy_info().is_direct());
 906 }
 907
 908 TEST_P(HttpStreamFactoryTest, RequestWebSocketBasicHandshakeStream) {
 909   SpdySessionDependencies session_deps(
 910       GetParam(), ProxyService::CreateDirect());
 911
 912   StaticSocketDataProvider socket_data;
 913   socket_data.set_connect_data(MockConnect(ASYNC, OK));
 914   session_deps.socket_factory->AddSocketDataProvider(&socket_data);
 915
 916   scoped_refptr<HttpNetworkSession> session(
 917       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 918
 919   // Now request a stream.
 920   HttpRequestInfo request_info;
 921   request_info.method = "GET";
 922   request_info.url = GURL("ws://www.google.com");
 923   request_info.load_flags = 0;
 924
 925   SSLConfig ssl_config;
 926   StreamRequestWaiter waiter;
 927   WebSocketStreamCreateHelper create_helper;
 928   scoped_ptr<HttpStreamRequest> request(
 929       session->http_stream_factory_for_websocket()
 930           ->RequestWebSocketHandshakeStream(request_info,
 931                                             DEFAULT_PRIORITY,
 932                                             ssl_config,
 933                                             ssl_config,
 934                                             &waiter,
 935                                             &create_helper,
 936                                             BoundNetLog()));
 937   waiter.WaitForStream();
 938   EXPECT_TRUE(waiter.stream_done());
 939   EXPECT_TRUE(NULL == waiter.stream());
 940   ASSERT_TRUE(NULL != waiter.websocket_stream());
 941   EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeBasic,
 942             waiter.websocket_stream()->type());
 943   EXPECT_EQ(0, GetSocketPoolGroupCount(
 944       session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
 945   EXPECT_EQ(0, GetSocketPoolGroupCount(
 946       session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
 947   EXPECT_EQ(0, GetSocketPoolGroupCount(
 948       session->GetSSLSocketPool(HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
 949   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
 950 }
 951
 952 TEST_P(HttpStreamFactoryTest, RequestWebSocketBasicHandshakeStreamOverSSL) {
 953   SpdySessionDependencies session_deps(
 954       GetParam(), ProxyService::CreateDirect());
 955
 956   MockRead mock_read(ASYNC, OK);
 957   StaticSocketDataProvider socket_data(&mock_read, 1, NULL, 0);
 958   socket_data.set_connect_data(MockConnect(ASYNC, OK));
 959   session_deps.socket_factory->AddSocketDataProvider(&socket_data);
 960
 961   SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
 962   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
 963
 964   scoped_refptr<HttpNetworkSession> session(
 965       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 966
 967   // Now request a stream.
 968   HttpRequestInfo request_info;
 969   request_info.method = "GET";
 970   request_info.url = GURL("wss://www.google.com");
 971   request_info.load_flags = 0;
 972
 973   SSLConfig ssl_config;
 974   StreamRequestWaiter waiter;
 975   WebSocketStreamCreateHelper create_helper;
 976   scoped_ptr<HttpStreamRequest> request(
 977       session->http_stream_factory_for_websocket()
 978           ->RequestWebSocketHandshakeStream(request_info,
 979                                             DEFAULT_PRIORITY,
 980                                             ssl_config,
 981                                             ssl_config,
 982                                             &waiter,
 983                                             &create_helper,
 984                                             BoundNetLog()));
 985   waiter.WaitForStream();
 986   EXPECT_TRUE(waiter.stream_done());
 987   EXPECT_TRUE(NULL == waiter.stream());
 988   ASSERT_TRUE(NULL != waiter.websocket_stream());
 989   EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeBasic,
 990             waiter.websocket_stream()->type());
 991   EXPECT_EQ(0, GetSocketPoolGroupCount(
 992       session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
 993   EXPECT_EQ(0, GetSocketPoolGroupCount(
 994       session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
 995   EXPECT_EQ(1, GetSocketPoolGroupCount(
 996       session->GetSSLSocketPool(HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
 997   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
 998 }
 999
1000 TEST_P(HttpStreamFactoryTest, RequestWebSocketBasicHandshakeStreamOverProxy) {
1001   SpdySessionDependencies session_deps(
1002       GetParam(), ProxyService::CreateFixed("myproxy:8888"));
1003
1004   MockRead read(SYNCHRONOUS, "HTTP/1.0 200 Connection established\r\n\r\n");
1005   StaticSocketDataProvider socket_data(&read, 1, 0, 0);
1006   socket_data.set_connect_data(MockConnect(ASYNC, OK));
1007   session_deps.socket_factory->AddSocketDataProvider(&socket_data);
1008
1009   scoped_refptr<HttpNetworkSession> session(
1010       SpdySessionDependencies::SpdyCreateSession(&session_deps));
1011
1012   // Now request a stream.
1013   HttpRequestInfo request_info;
1014   request_info.method = "GET";
1015   request_info.url = GURL("ws://www.google.com");
1016   request_info.load_flags = 0;
1017
1018   SSLConfig ssl_config;
1019   StreamRequestWaiter waiter;
1020   WebSocketStreamCreateHelper create_helper;
1021   scoped_ptr<HttpStreamRequest> request(
1022       session->http_stream_factory_for_websocket()
1023           ->RequestWebSocketHandshakeStream(request_info,
1024                                             DEFAULT_PRIORITY,
1025                                             ssl_config,
1026                                             ssl_config,
1027                                             &waiter,
1028                                             &create_helper,
1029                                             BoundNetLog()));
1030   waiter.WaitForStream();
1031   EXPECT_TRUE(waiter.stream_done());
1032   EXPECT_TRUE(NULL == waiter.stream());
1033   ASSERT_TRUE(NULL != waiter.websocket_stream());
1034   EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeBasic,
1035             waiter.websocket_stream()->type());
1036   EXPECT_EQ(0, GetSocketPoolGroupCount(
1037       session->GetTransportSocketPool(
1038           HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
1039   EXPECT_EQ(0, GetSocketPoolGroupCount(
1040       session->GetSSLSocketPool(HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
1041   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSocketPoolForHTTPProxy(
1042       HttpNetworkSession::NORMAL_SOCKET_POOL,
1043       HostPortPair("myproxy", 8888))));
1044   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSocketPoolForSSLWithProxy(
1045       HttpNetworkSession::NORMAL_SOCKET_POOL,
1046       HostPortPair("myproxy", 8888))));
1047   EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetSocketPoolForHTTPProxy(
1048       HttpNetworkSession::WEBSOCKET_SOCKET_POOL,
1049       HostPortPair("myproxy", 8888))));
1050   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSocketPoolForSSLWithProxy(
1051       HttpNetworkSession::WEBSOCKET_SOCKET_POOL,
1052       HostPortPair("myproxy", 8888))));
1053   EXPECT_FALSE(waiter.used_proxy_info().is_direct());
1054 }
1055
1056 TEST_P(HttpStreamFactoryTest, RequestSpdyHttpStream) {
1057   SpdySessionDependencies session_deps(GetParam(),
1058                                        ProxyService::CreateDirect());
1059
1060   MockRead mock_read(ASYNC, OK);
1061   DeterministicSocketData socket_data(&mock_read, 1, NULL, 0);
1062   socket_data.set_connect_data(MockConnect(ASYNC, OK));
1063   session_deps.deterministic_socket_factory->AddSocketDataProvider(
1064       &socket_data);
1065
1066   SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
1067   ssl_socket_data.SetNextProto(GetParam());
1068   session_deps.deterministic_socket_factory->AddSSLSocketDataProvider(
1069       &ssl_socket_data);
1070
1071   HostPortPair host_port_pair("www.google.com", 443);
1072   scoped_refptr<HttpNetworkSession>
1073       session(SpdySessionDependencies::SpdyCreateSessionDeterministic(
1074           &session_deps));
1075
1076   // Now request a stream.
1077   HttpRequestInfo request_info;
1078   request_info.method = "GET";
1079   request_info.url = GURL("https://www.google.com");
1080   request_info.load_flags = 0;
1081
1082   SSLConfig ssl_config;
1083   StreamRequestWaiter waiter;
1084   scoped_ptr<HttpStreamRequest> request(
1085       session->http_stream_factory()->RequestStream(
1086           request_info,
1087           DEFAULT_PRIORITY,
1088           ssl_config,
1089           ssl_config,
1090           &waiter,
1091           BoundNetLog()));
1092   waiter.WaitForStream();
1093   EXPECT_TRUE(waiter.stream_done());
1094   EXPECT_TRUE(NULL == waiter.websocket_stream());
1095   ASSERT_TRUE(NULL != waiter.stream());
1096   EXPECT_TRUE(waiter.stream()->IsSpdyHttpStream());
1097   EXPECT_EQ(1, GetSocketPoolGroupCount(
1098       session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
1099   EXPECT_EQ(1, GetSocketPoolGroupCount(
1100       session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
1101   EXPECT_EQ(0, GetSocketPoolGroupCount(
1102       session->GetTransportSocketPool(
1103           HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
1104   EXPECT_EQ(0, GetSocketPoolGroupCount(
1105       session->GetSSLSocketPool(HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
1106   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
1107 }
1108
1109 // TODO(ricea): This test can be removed once the new WebSocket stack supports
1110 // SPDY. Currently, even if we connect to a SPDY-supporting server, we need to
1111 // use plain SSL.
1112 TEST_P(HttpStreamFactoryTest, RequestWebSocketSpdyHandshakeStreamButGetSSL) {
1113   SpdySessionDependencies session_deps(GetParam(),
1114                                        ProxyService::CreateDirect());
1115
1116   MockRead mock_read(SYNCHRONOUS, ERR_IO_PENDING);
1117   StaticSocketDataProvider socket_data(&mock_read, 1, NULL, 0);
1118   socket_data.set_connect_data(MockConnect(ASYNC, OK));
1119   session_deps.socket_factory->AddSocketDataProvider(&socket_data);
1120
1121   SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
1122   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
1123
1124   HostPortPair host_port_pair("www.google.com", 80);
1125   scoped_refptr<HttpNetworkSession>
1126       session(SpdySessionDependencies::SpdyCreateSession(&session_deps));
1127
1128   // Now request a stream.
1129   HttpRequestInfo request_info;
1130   request_info.method = "GET";
1131   request_info.url = GURL("wss://www.google.com");
1132   request_info.load_flags = 0;
1133
1134   SSLConfig ssl_config;
1135   StreamRequestWaiter waiter1;
1136   WebSocketStreamCreateHelper create_helper;
1137   scoped_ptr<HttpStreamRequest> request1(
1138       session->http_stream_factory_for_websocket()
1139           ->RequestWebSocketHandshakeStream(request_info,
1140                                             DEFAULT_PRIORITY,
1141                                             ssl_config,
1142                                             ssl_config,
1143                                             &waiter1,
1144                                             &create_helper,
1145                                             BoundNetLog()));
1146   waiter1.WaitForStream();
1147   EXPECT_TRUE(waiter1.stream_done());
1148   ASSERT_TRUE(NULL != waiter1.websocket_stream());
1149   EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeBasic,
1150             waiter1.websocket_stream()->type());
1151   EXPECT_TRUE(NULL == waiter1.stream());
1152
1153   EXPECT_EQ(0, GetSocketPoolGroupCount(
1154       session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
1155   EXPECT_EQ(0, GetSocketPoolGroupCount(
1156       session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
1157   EXPECT_EQ(1, GetSocketPoolGroupCount(
1158       session->GetSSLSocketPool(HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
1159   EXPECT_TRUE(waiter1.used_proxy_info().is_direct());
1160 }
1161
1162 // TODO(ricea): Re-enable once WebSocket-over-SPDY is implemented.
1163 TEST_P(HttpStreamFactoryTest, DISABLED_RequestWebSocketSpdyHandshakeStream) {
1164   SpdySessionDependencies session_deps(GetParam(),
1165                                        ProxyService::CreateDirect());
1166
1167   MockRead mock_read(SYNCHRONOUS, ERR_IO_PENDING);
1168   StaticSocketDataProvider socket_data(&mock_read, 1, NULL, 0);
1169   socket_data.set_connect_data(MockConnect(ASYNC, OK));
1170   session_deps.socket_factory->AddSocketDataProvider(&socket_data);
1171
1172   SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
1173   ssl_socket_data.SetNextProto(GetParam());
1174   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
1175
1176   HostPortPair host_port_pair("www.google.com", 80);
1177   scoped_refptr<HttpNetworkSession>
1178       session(SpdySessionDependencies::SpdyCreateSession(&session_deps));
1179
1180   // Now request a stream.
1181   HttpRequestInfo request_info;
1182   request_info.method = "GET";
1183   request_info.url = GURL("wss://www.google.com");
1184   request_info.load_flags = 0;
1185
1186   SSLConfig ssl_config;
1187   StreamRequestWaiter waiter1;
1188   WebSocketStreamCreateHelper create_helper;
1189   scoped_ptr<HttpStreamRequest> request1(
1190       session->http_stream_factory_for_websocket()
1191           ->RequestWebSocketHandshakeStream(request_info,
1192                                             DEFAULT_PRIORITY,
1193                                             ssl_config,
1194                                             ssl_config,
1195                                             &waiter1,
1196                                             &create_helper,
1197                                             BoundNetLog()));
1198   waiter1.WaitForStream();
1199   EXPECT_TRUE(waiter1.stream_done());
1200   ASSERT_TRUE(NULL != waiter1.websocket_stream());
1201   EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeSpdy,
1202             waiter1.websocket_stream()->type());
1203   EXPECT_TRUE(NULL == waiter1.stream());
1204
1205   StreamRequestWaiter waiter2;
1206   scoped_ptr<HttpStreamRequest> request2(
1207       session->http_stream_factory_for_websocket()
1208           ->RequestWebSocketHandshakeStream(request_info,
1209                                             DEFAULT_PRIORITY,
1210                                             ssl_config,
1211                                             ssl_config,
1212                                             &waiter2,
1213                                             &create_helper,
1214                                             BoundNetLog()));
1215   waiter2.WaitForStream();
1216   EXPECT_TRUE(waiter2.stream_done());
1217   ASSERT_TRUE(NULL != waiter2.websocket_stream());
1218   EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeSpdy,
1219             waiter2.websocket_stream()->type());
1220   EXPECT_TRUE(NULL == waiter2.stream());
1221   EXPECT_NE(waiter2.websocket_stream(), waiter1.websocket_stream());
1222   EXPECT_EQ(static_cast<WebSocketSpdyHandshakeStream*>(
1223                 waiter2.websocket_stream())->spdy_session(),
1224             static_cast<WebSocketSpdyHandshakeStream*>(
1225                 waiter1.websocket_stream())->spdy_session());
1226
1227   EXPECT_EQ(0, GetSocketPoolGroupCount(
1228       session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
1229   EXPECT_EQ(0, GetSocketPoolGroupCount(
1230       session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
1231   EXPECT_EQ(1, GetSocketPoolGroupCount(
1232       session->GetTransportSocketPool(
1233           HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
1234   EXPECT_EQ(1, GetSocketPoolGroupCount(
1235       session->GetSSLSocketPool(HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
1236   EXPECT_TRUE(waiter1.used_proxy_info().is_direct());
1237 }
1238
1239 // TODO(ricea): Re-enable once WebSocket over SPDY is implemented.
1240 TEST_P(HttpStreamFactoryTest, DISABLED_OrphanedWebSocketStream) {
1241   SpdySessionDependencies session_deps(GetParam(),
1242                                        ProxyService::CreateDirect());
1243   session_deps.use_alternate_protocols = true;
1244
1245   MockRead mock_read(ASYNC, OK);
1246   DeterministicSocketData socket_data(&mock_read, 1, NULL, 0);
1247   socket_data.set_connect_data(MockConnect(ASYNC, OK));
1248   session_deps.deterministic_socket_factory->AddSocketDataProvider(
1249       &socket_data);
1250
1251   MockRead mock_read2(ASYNC, OK);
1252   DeterministicSocketData socket_data2(&mock_read2, 1, NULL, 0);
1253   socket_data2.set_connect_data(MockConnect(ASYNC, ERR_IO_PENDING));
1254   session_deps.deterministic_socket_factory->AddSocketDataProvider(
1255       &socket_data2);
1256
1257   SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
1258   ssl_socket_data.SetNextProto(GetParam());
1259   session_deps.deterministic_socket_factory->AddSSLSocketDataProvider(
1260       &ssl_socket_data);
1261
1262   scoped_refptr<HttpNetworkSession>
1263       session(SpdySessionDependencies::SpdyCreateSessionDeterministic(
1264           &session_deps));
1265
1266   // Now request a stream.
1267   HttpRequestInfo request_info;
1268   request_info.method = "GET";
1269   request_info.url = GURL("ws://www.google.com:8888");
1270   request_info.load_flags = 0;
1271
1272   session->http_server_properties()->SetAlternateProtocol(
1273       HostPortPair("www.google.com", 8888),
1274       9999,
1275       NPN_SPDY_3,
1276       1);
1277
1278   SSLConfig ssl_config;
1279   StreamRequestWaiter waiter;
1280   WebSocketStreamCreateHelper create_helper;
1281   scoped_ptr<HttpStreamRequest> request(
1282       session->http_stream_factory_for_websocket()
1283           ->RequestWebSocketHandshakeStream(request_info,
1284                                             DEFAULT_PRIORITY,
1285                                             ssl_config,
1286                                             ssl_config,
1287                                             &waiter,
1288                                             &create_helper,
1289                                             BoundNetLog()));
1290   waiter.WaitForStream();
1291   EXPECT_TRUE(waiter.stream_done());
1292   EXPECT_TRUE(NULL == waiter.stream());
1293   ASSERT_TRUE(NULL != waiter.websocket_stream());
1294   EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeSpdy,
1295             waiter.websocket_stream()->type());
1296
1297   // Make sure that there was an alternative connection
1298   // which consumes extra connections.
1299   EXPECT_EQ(0, GetSocketPoolGroupCount(
1300       session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
1301   EXPECT_EQ(0, GetSocketPoolGroupCount(
1302       session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
1303   EXPECT_EQ(2, GetSocketPoolGroupCount(
1304       session->GetTransportSocketPool(
1305           HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
1306   EXPECT_EQ(1, GetSocketPoolGroupCount(
1307       session->GetSSLSocketPool(HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
1308   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
1309
1310   // Make sure there is no orphaned job. it is already canceled.
1311   ASSERT_EQ(0u, static_cast<HttpStreamFactoryImpl*>(
1312       session->http_stream_factory_for_websocket())->num_orphaned_jobs());
1313 }
1314
1315 }  // namespace
1316
1317 }  // namespace net