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