Introduce RequestWebSocketStream into HttpStreamFactory

net/http/http_stream_factory_impl_unittest.cc

Index: net/http/http_stream_factory_impl_unittest.cc
diff --git a/net/http/http_stream_factory_impl_unittest.cc b/net/http/http_stream_factory_impl_unittest.cc
index cac7f02d254583abdb332ce8ab758f8dcb5ea55a..6ebdf88365370511533c0211b373064b59328e2b 100644
--- a/net/http/http_stream_factory_impl_unittest.cc
+++ b/net/http/http_stream_factory_impl_unittest.cc
@@ -5,6 +5,7 @@
 #include "net/http/http_stream_factory_impl.h"
 
 #include <string>
+#include <vector>
 
 #include "base/basictypes.h"
 #include "net/base/net_log.h"
@@ -18,12 +19,17 @@
 #include "net/http/http_request_info.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/http/http_stream.h"
+#include "net/http/websocket_stream_base.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_service.h"
+#include "net/socket/client_socket_handle.h"
 #include "net/socket/mock_client_socket_pool_manager.h"
+#include "net/socket/next_proto.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_session_pool.h"
+#include "net/spdy/spdy_test_util_common.h"
+#include "net/ssl/ssl_config_service.h"
 #include "net/ssl/ssl_config_service_defaults.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -31,10 +37,33 @@ namespace net {
 
 namespace {
 
-class MockHttpStreamFactoryImpl : public HttpStreamFactoryImpl {
+class ScopedForceSpdySsl {

[mmenke, 2013/05/30 19:46:14]

I don't believe this class is needed.  Looks like you're creating SPDY
handshakes to me...  If we aren't mocking enough of the code for those mock
handshakes to take effect, then we shouldn't be using SSLSocketDataProviders at
all, since they aren't doing anything.

[yhirano, 2013/05/31 08:36:45]

Done.
In order to control was_spdy_negotiated in MockSSLClientSocket, I added some
code to net/socket/socket_test_util.{h, cc}.

  public:
-  MockHttpStreamFactoryImpl(HttpNetworkSession* session)
-      : HttpStreamFactoryImpl(session),
+  explicit ScopedForceSpdySsl(bool enabled):
+      orig_force_spdy_over_ssl_(HttpStreamFactory::force_spdy_over_ssl()),
+      orig_force_spdy_always_(HttpStreamFactory::force_spdy_always()),
+      orig_spdy_enabled_(HttpStreamFactory::spdy_enabled()) {
+    HttpStreamFactory::set_force_spdy_over_ssl(enabled);
+    HttpStreamFactory::set_force_spdy_always(enabled);
+    HttpStreamFactory::set_spdy_enabled(enabled);
+  }
+  ~ScopedForceSpdySsl() {
+    HttpStreamFactory::set_spdy_enabled(orig_spdy_enabled_);
+    HttpStreamFactory::set_force_spdy_over_ssl(orig_force_spdy_over_ssl_);
+    HttpStreamFactory::set_force_spdy_always(orig_force_spdy_always_);
+  }
+
+ private:
+  const bool orig_force_spdy_over_ssl_;
+  const bool orig_force_spdy_always_;
+  const bool orig_spdy_enabled_;
+};
+
+class MockHttpStreamFactoryImplForPreconnect : public HttpStreamFactoryImpl {
+ public:
+  MockHttpStreamFactoryImplForPreconnect(HttpNetworkSession* session,
+                                         bool for_websockets)
+      : HttpStreamFactoryImpl(session, for_websockets),
         preconnect_done_(false),
         waiting_for_preconnect_(false) {}
 
@@ -76,6 +105,19 @@ class StreamRequestWaiter : public HttpStreamRequest::Delegate {
       base::MessageLoop::current()->Quit();
     stream_.reset(stream);
     used_ssl_config_ = used_ssl_config;
+    used_proxy_info_ = used_proxy_info;
+  }
+
+  virtual void OnWebSocketStreamReady(
+      const SSLConfig& used_ssl_config,
+      const ProxyInfo& used_proxy_info,
+      WebSocketStreamBase* stream) OVERRIDE {
+    stream_done_ = true;
+    if (waiting_for_stream_)
+      MessageLoop::current()->Quit();
+    websocket_stream_.reset(stream);
+    used_ssl_config_ = used_ssl_config;
+    used_proxy_info_ = used_proxy_info;
   }
 
   virtual void OnStreamFailed(
@@ -112,20 +154,64 @@ class StreamRequestWaiter : public HttpStreamRequest::Delegate {
     return used_ssl_config_;
   }
 
+  const ProxyInfo& used_proxy_info() const {
+    return used_proxy_info_;
+  }
+
   HttpStreamBase* stream() {
     return stream_.get();
   }
 
+  WebSocketStreamBase* websocket_stream() {
+    return websocket_stream_.get();
+  }
+
+  bool stream_done() const { return stream_done_; }
 
  private:
   bool waiting_for_stream_;
   bool stream_done_;
   scoped_ptr<HttpStreamBase> stream_;
+  scoped_ptr<WebSocketStreamBase> websocket_stream_;
   SSLConfig used_ssl_config_;
+  ProxyInfo used_proxy_info_;
 
   DISALLOW_COPY_AND_ASSIGN(StreamRequestWaiter);
 };
 
+class WebSocketSpdyStream : public WebSocketStreamBase {
+ public:
+  explicit WebSocketSpdyStream(SpdySession* spdy_session):
+      WebSocketStreamBase(kStreamTypeSpdy), spdy_session_(spdy_session) {}
+  SpdySession* spdy_session() {return spdy_session_.get();}
+
+ private:
+  scoped_refptr<SpdySession> spdy_session_;
+};
+
+class WebSocketBasicStream : public WebSocketStreamBase {
+ public:
+  explicit WebSocketBasicStream(ClientSocketHandle* connection):
+      WebSocketStreamBase(kStreamTypeBasic), connection_(connection) {}
+  ClientSocketHandle* connection() {return connection_.get();}
+
+ private:
+  scoped_ptr<ClientSocketHandle> connection_;
+};
+
+class WebSocketStreamFactory : public WebSocketStreamBase::Factory {
+ public:
+  virtual WebSocketStreamBase* CreateBasicStream(ClientSocketHandle* connection,
+                                                 bool using_proxy) OVERRIDE {
+    return new WebSocketBasicStream(connection);
+  }
+  virtual WebSocketStreamBase* CreateSpdyStream(
+      SpdySession* spdy_session,
+      bool use_relative_url) OVERRIDE {
+    return new WebSocketSpdyStream(spdy_session);
+  }
+};
+
 struct SessionDependencies {
   // Custom proxy service dependency.
   explicit SessionDependencies(ProxyService* proxy_service)
@@ -158,6 +244,7 @@ HttpNetworkSession* CreateSession(SessionDependencies* session_deps) {
       session_deps->http_auth_handler_factory.get();
   params.net_log = session_deps->net_log;
   params.http_server_properties = &session_deps->http_server_properties;
+
   return new HttpNetworkSession(params);
 }
 
@@ -177,8 +264,8 @@ void PreconnectHelperForURL(int num_streams,
                             const GURL& url,
                             HttpNetworkSession* session) {
   HttpNetworkSessionPeer peer(session);
-  MockHttpStreamFactoryImpl* mock_factory =
-      new MockHttpStreamFactoryImpl(session);
+  MockHttpStreamFactoryImplForPreconnect* mock_factory =
+      new MockHttpStreamFactoryImplForPreconnect(session, false);
   peer.SetHttpStreamFactory(mock_factory);
   SSLConfig ssl_config;
   session->ssl_config_service()->GetSSLConfig(&ssl_config);
@@ -460,8 +547,7 @@ TEST(HttpStreamFactoryTest, JobNotifiesProxy) {
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
-  // Now request a stream.  It should succeed using the second proxy in the
-  // list.
+  // Now request a stream.
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("http://www.google.com");
@@ -610,6 +696,344 @@ TEST(HttpStreamFactoryTest, GetLoadState) {
   waiter.WaitForStream();
 }
 
+TEST(HttpStreamFactoryTest, RequestHttpStream) {
+  SessionDependencies session_deps(ProxyService::CreateDirect());
+
+  StaticSocketDataProvider socket_data;
+  socket_data.set_connect_data(MockConnect(ASYNC, OK));
+  session_deps.socket_factory.AddSocketDataProvider(&socket_data);
+
+  scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
+
+  // Now request a stream.  It should succeed using the second proxy in the
+  // list.
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("http://www.google.com");
+  request_info.load_flags = 0;
+
+  SSLConfig ssl_config;
+  StreamRequestWaiter waiter;
+  scoped_ptr<HttpStreamRequest> request(
+      session->http_stream_factory()->RequestStream(
+          request_info,
+          DEFAULT_PRIORITY,
+          ssl_config,
+          ssl_config,
+          &waiter,
+          BoundNetLog()));
+  waiter.WaitForStream();
+  EXPECT_TRUE(waiter.stream_done());
+  EXPECT_TRUE(NULL == waiter.websocket_stream());
+
+  EXPECT_EQ(1, GetSocketPoolGroupCount(
+      session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
+  EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSSLSocketPool(
+      HttpNetworkSession::NORMAL_SOCKET_POOL)));
+  EXPECT_TRUE(waiter.used_proxy_info().is_direct());
+}
+
+TEST(HttpStreamFactoryTest, RequestHttpStreamOverSSL) {
+  SessionDependencies session_deps(ProxyService::CreateDirect());
+
+  MockRead mock_read(ASYNC, ERR_IO_PENDING);
+  StaticSocketDataProvider socket_data(&mock_read, 1, NULL, 0);
+  socket_data.set_connect_data(MockConnect(ASYNC, OK));
+  session_deps.socket_factory.AddSocketDataProvider(&socket_data);
+
+  SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
+  ssl_socket_data.protocol_negotiated = kProtoSPDY3;

[mmenke, 2013/05/30 19:46:14]

As-is, looks like this test is actually using SPDY, rather than HTTPS.  I
believe we can peek at the SPDY session pool to tell the difference between the
two cases

[yhirano, 2013/05/31 08:36:45]

Done.

+  session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_socket_data);
+
+  SSLSocketDataProvider ssl_socket_data2(ASYNC, OK);
+  ssl_socket_data2.protocol_negotiated = kProtoSPDY3;
+  session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_socket_data2);

[mmenke, 2013/05/30 19:46:14]

I don't believe we need two of these.

[yhirano, 2013/05/31 08:36:45]

Done.

+
+  scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
+
+  // Now request a stream.  It should succeed using the second proxy in the
+  // list.
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("https://www.google.com");
+  request_info.load_flags = 0;
+
+  SSLConfig ssl_config;
+  StreamRequestWaiter waiter;
+  scoped_ptr<HttpStreamRequest> request(
+      session->http_stream_factory()->RequestStream(
+          request_info,
+          DEFAULT_PRIORITY,
+          ssl_config,
+          ssl_config,
+          &waiter,
+          BoundNetLog()));
+  waiter.WaitForStream();
+  EXPECT_TRUE(waiter.stream_done());
+  EXPECT_TRUE(NULL == waiter.websocket_stream());
+  EXPECT_TRUE(NULL != waiter.stream());
+  EXPECT_EQ(1, GetSocketPoolGroupCount(
+      session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
+  EXPECT_EQ(1, GetSocketPoolGroupCount(
+      session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
+  EXPECT_TRUE(waiter.used_proxy_info().is_direct());
+}
+
+TEST(HttpStreamFactoryTest, RequestHttpStreamOverProxy) {
+  SessionDependencies session_deps(ProxyService::CreateFixed("myproxy:8888"));
+
+  StaticSocketDataProvider socket_data;
+  socket_data.set_connect_data(MockConnect(ASYNC, OK));
+  session_deps.socket_factory.AddSocketDataProvider(&socket_data);
+
+  scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
+
+  // Now request a stream.  It should succeed using the second proxy in the
+  // list.
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("http://www.google.com");
+  request_info.load_flags = 0;
+
+  SSLConfig ssl_config;
+  StreamRequestWaiter waiter;
+  scoped_ptr<HttpStreamRequest> request(
+      session->http_stream_factory()->RequestStream(
+          request_info,
+          DEFAULT_PRIORITY,
+          ssl_config,
+          ssl_config,
+          &waiter,
+          BoundNetLog()));
+  waiter.WaitForStream();
+  EXPECT_TRUE(waiter.stream_done());
+  EXPECT_TRUE(NULL == waiter.websocket_stream());
+  EXPECT_TRUE(NULL != waiter.stream());
+  EXPECT_EQ(0, GetSocketPoolGroupCount(
+      session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
+  EXPECT_EQ(0, GetSocketPoolGroupCount(
+      session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
+  EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetSocketPoolForHTTPProxy(
+      HttpNetworkSession::NORMAL_SOCKET_POOL,
+      HostPortPair("myproxy", 8888))));
+  EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSocketPoolForSSLWithProxy(
+      HttpNetworkSession::NORMAL_SOCKET_POOL,
+      HostPortPair("myproxy", 8888))));
+  EXPECT_FALSE(waiter.used_proxy_info().is_direct());
+}
+
+TEST(HttpStreamFactoryTest, RequestWebSocketBasicStream) {
+  SessionDependencies session_deps(ProxyService::CreateDirect());
+
+  StaticSocketDataProvider socket_data;
+  socket_data.set_connect_data(MockConnect(ASYNC, OK));
+  session_deps.socket_factory.AddSocketDataProvider(&socket_data);
+
+  scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
+
+  // Now request a stream.
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("ws://www.google.com");
+  request_info.load_flags = 0;
+
+  SSLConfig ssl_config;
+  StreamRequestWaiter waiter;
+  WebSocketStreamFactory factory;
+  scoped_ptr<HttpStreamRequest> request(
+      session->websocket_stream_factory()->RequestWebSocketStream(
+          request_info,
+          DEFAULT_PRIORITY,
+          ssl_config,
+          ssl_config,
+          &waiter,
+          &factory,
+          BoundNetLog()));
+  waiter.WaitForStream();
+  EXPECT_TRUE(waiter.stream_done());
+  EXPECT_TRUE(NULL == waiter.stream());
+  EXPECT_TRUE(NULL != waiter.websocket_stream());
+  EXPECT_EQ(WebSocketStreamBase::kStreamTypeBasic,
+            waiter.websocket_stream()->type());
+  EXPECT_EQ(1, GetSocketPoolGroupCount(
+      session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
+  EXPECT_EQ(0, GetSocketPoolGroupCount(
+      session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
+  EXPECT_TRUE(waiter.used_proxy_info().is_direct());
+}
+
+TEST(HttpStreamFactoryTest, RequestWebSocketBasicStreamOverSSL) {
+  ScopedForceSpdySsl use_spdy(false);

[mmenke, 2013/05/30 19:46:14]

I don't believe this is needed.  We only upgrade to SPDY if the server indicates
it supports it during SSL negotiation.

[yhirano, 2013/05/31 08:36:45]

Done.

+  SessionDependencies session_deps(ProxyService::CreateDirect());
+
+  MockRead mock_read(ASYNC, ERR_IO_PENDING);
+  StaticSocketDataProvider socket_data(&mock_read, 1, NULL, 0);
+  socket_data.set_connect_data(MockConnect(ASYNC, OK));
+  session_deps.socket_factory.AddSocketDataProvider(&socket_data);
+
+  SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
+  ssl_socket_data.protocol_negotiated = kProtoSPDY3;

[mmenke, 2013/05/30 19:46:14]

This indicates SPDY 3 is being negotiated.  I don't think we want that.  See
earlier comments.

[yhirano, 2013/05/31 08:36:45]

Done.

+  session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_socket_data);
+
+  SSLSocketDataProvider ssl_socket_data2(ASYNC, OK);
+  ssl_socket_data2.protocol_negotiated = kProtoSPDY3;
+  session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_socket_data2);

[mmenke, 2013/05/30 19:46:14]

Why are these two needed?

[yhirano, 2013/05/31 08:36:45]

Done.

+
+  scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
+
+  // Now request a stream.
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("wss://www.google.com");
+  request_info.load_flags = 0;
+
+  SSLConfig ssl_config;
+  StreamRequestWaiter waiter;
+  WebSocketStreamFactory factory;
+  scoped_ptr<HttpStreamRequest> request(
+      session->websocket_stream_factory()->RequestWebSocketStream(
+          request_info,
+          DEFAULT_PRIORITY,
+          ssl_config,
+          ssl_config,
+          &waiter,
+          &factory,
+          BoundNetLog()));
+  waiter.WaitForStream();
+  EXPECT_TRUE(waiter.stream_done());
+  EXPECT_TRUE(NULL == waiter.stream());
+  EXPECT_TRUE(NULL != waiter.websocket_stream());
+  EXPECT_EQ(WebSocketStreamBase::kStreamTypeBasic,
+            waiter.websocket_stream()->type());
+  EXPECT_EQ(1, GetSocketPoolGroupCount(
+      session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
+  EXPECT_EQ(1, GetSocketPoolGroupCount(
+      session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
+  EXPECT_TRUE(waiter.used_proxy_info().is_direct());
+}
+
+TEST(HttpStreamFactoryTest, RequestSpdyHttpStream) {
+  ScopedForceSpdySsl use_spdy(true);
+  SpdySessionDependencies session_deps(kProtoSPDY3,
+                                       ProxyService::CreateDirect());
+
+  MockRead mock_read(ASYNC, OK);
+  StaticSocketDataProvider socket_data(&mock_read, 1, NULL, 0);
+  socket_data.set_connect_data(MockConnect(ASYNC, OK));
+  session_deps.socket_factory->AddSocketDataProvider(&socket_data);
+
+  SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
+  ssl_socket_data.protocol_negotiated = kProtoSPDY3;
+  session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
+
+  HostPortPair host_port_pair("www.google.com", 80);
+  scoped_refptr<HttpNetworkSession>
+      session(SpdySessionDependencies::SpdyCreateSession(&session_deps));
+
+  // Now request a stream.
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("https://www.google.com");
+  request_info.load_flags = 0;
+
+  SSLConfig ssl_config;
+  StreamRequestWaiter waiter;
+  scoped_ptr<HttpStreamRequest> request(
+      session->http_stream_factory()->RequestStream(
+          request_info,
+          DEFAULT_PRIORITY,
+          ssl_config,
+          ssl_config,
+          &waiter,
+          BoundNetLog()));
+  waiter.WaitForStream();
+  EXPECT_TRUE(waiter.stream_done());
+  EXPECT_TRUE(NULL == waiter.websocket_stream());
+  EXPECT_TRUE(NULL != waiter.stream());
+  EXPECT_TRUE(waiter.stream()->IsSpdyHttpStream());
+  EXPECT_EQ(1, GetSocketPoolGroupCount(
+      session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
+  EXPECT_EQ(1, GetSocketPoolGroupCount(
+      session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
+  EXPECT_TRUE(waiter.used_proxy_info().is_direct());
+}
+
+TEST(HttpStreamFactoryTest, RequestWebSocketSpdyStream) {
+  ScopedForceSpdySsl use_spdy(true);
+  SpdySessionDependencies session_deps(kProtoSPDY3,
+                                       ProxyService::CreateDirect());
+
+  MockRead mock_read(ASYNC, ERR_IO_PENDING);
+  StaticSocketDataProvider socket_data(&mock_read, 1, NULL, 0);
+  socket_data.set_connect_data(MockConnect(ASYNC, OK));
+  session_deps.socket_factory->AddSocketDataProvider(&socket_data);
+
+  SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
+  ssl_socket_data.protocol_negotiated = kProtoSPDY3;
+  session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
+
+  SSLSocketDataProvider ssl_socket_data2(ASYNC, OK);
+  ssl_socket_data2.protocol_negotiated = kProtoSPDY3;
+  session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data2);

[mmenke, 2013/05/30 19:46:14]

Again, I don't think we need two of these.

[yhirano, 2013/05/31 08:36:45]

Done.

+
+  HostPortPair host_port_pair("www.google.com", 80);
+  scoped_refptr<HttpNetworkSession>
+      session(SpdySessionDependencies::SpdyCreateSession(&session_deps));
+
+  // Now request a stream.
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("wss://www.google.com");
+  request_info.load_flags = 0;
+
+  SSLConfig ssl_config;
+  StreamRequestWaiter waiter1;
+  WebSocketStreamFactory factory;
+  scoped_ptr<HttpStreamRequest> request1(
+      session->websocket_stream_factory()->RequestWebSocketStream(
+          request_info,
+          DEFAULT_PRIORITY,
+          ssl_config,
+          ssl_config,
+          &waiter1,
+          &factory,
+          BoundNetLog()));
+  waiter1.WaitForStream();
+  EXPECT_TRUE(waiter1.stream_done());
+  EXPECT_TRUE(NULL != waiter1.websocket_stream());
+  EXPECT_EQ(WebSocketStreamBase::kStreamTypeSpdy,
+            waiter1.websocket_stream()->type());
+  EXPECT_TRUE(NULL == waiter1.stream());
+
+  StreamRequestWaiter waiter2;
+  scoped_ptr<HttpStreamRequest> request2(
+      session->websocket_stream_factory()->RequestWebSocketStream(
+          request_info,
+          DEFAULT_PRIORITY,
+          ssl_config,
+          ssl_config,
+          &waiter2,
+          &factory,
+          BoundNetLog()));
+  waiter2.WaitForStream();
+  EXPECT_TRUE(waiter2.stream_done());
+  EXPECT_TRUE(NULL != waiter2.websocket_stream());
+  EXPECT_EQ(WebSocketStreamBase::kStreamTypeSpdy,
+            waiter2.websocket_stream()->type());
+  EXPECT_TRUE(NULL == waiter2.stream());
+  EXPECT_NE(waiter2.websocket_stream(), waiter1.websocket_stream());
+  EXPECT_EQ(static_cast<WebSocketSpdyStream*>(waiter2.websocket_stream())->
+            spdy_session(),
+            static_cast<WebSocketSpdyStream*>(waiter1.websocket_stream())->
+            spdy_session());
+
+  EXPECT_EQ(1, GetSocketPoolGroupCount(
+      session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
+  EXPECT_EQ(1, GetSocketPoolGroupCount(
+      session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
+  EXPECT_TRUE(waiter1.used_proxy_info().is_direct());
+}
+
 }  // namespace
 
 }  // namespace net