Move logic to figure out if a socket can be reused into HttpStream.

net/http/http_stream_factory_impl_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/http/http_stream_factory_impl.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 63 matching lines @@
   int ReadResponseHeaders(const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
   int ReadResponseBody(IOBuffer* buf,
                        int buf_len,
                        const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
   void Close(bool not_reusable) override {}
   bool IsResponseBodyComplete() const override { return false; }
-  bool CanFindEndOfResponse() const override { return false; }
   bool IsConnectionReused() const override { return false; }
   void SetConnectionReused() override {}
-  bool IsConnectionReusable() const override { return false; }
+  bool CanReuseConnection() const override { return false; }
   int64 GetTotalReceivedBytes() const override { return 0; }
   bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const override {
     return false;
   }
   void GetSSLInfo(SSLInfo* ssl_info) override {}
   void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info) override {}
-  bool IsSpdyHttpStream() const override { return false; }
   void Drain(HttpNetworkSession* session) override {}
   void SetPriority(RequestPriority priority) override {}
   UploadProgress GetUploadProgress() const override { return UploadProgress(); }
   HttpStream* RenewStreamForAuth() override { return nullptr; }
 
   scoped_ptr<WebSocketStream> Upgrade() override {
     return scoped_ptr<WebSocketStream>();
   }
 
  private:
@@ skipping 666 matching lines @@
   waiter.WaitForStream();
 
   // The stream shouldn't come from spdy as we are using different privacy mode
   EXPECT_FALSE(request->using_spdy());
 
   SSLConfig used_ssl_config = waiter.used_ssl_config();
   EXPECT_EQ(used_ssl_config.channel_id_enabled, ssl_config.channel_id_enabled);
 }
 
 namespace {
+
 // Return count of distinct groups in given socket pool.
 int GetSocketPoolGroupCount(ClientSocketPool* pool) {
   int count = 0;
   scoped_ptr<base::DictionaryValue> dict(pool->GetInfoAsValue("", "", false));
   EXPECT_TRUE(dict != nullptr);
   base::DictionaryValue* groups = nullptr;
   if (dict->GetDictionary("groups", &groups) && (groups != nullptr)) {
     count = static_cast<int>(groups->size());
   }
   return count;
 }
+
+// Return count of distinct spdy sessions.
+int GetSpdySessionCount(HttpNetworkSession* session) {
+  scoped_ptr<base::Value> value(
+      session->spdy_session_pool()->SpdySessionPoolInfoToValue());
+  base::ListValue* session_list;
+  if (!value || !value->GetAsList(&session_list))
+    return -1;
+  return session_list->GetSize();
+}
+
 }  // namespace
 
 TEST_P(HttpStreamFactoryTest, PrivacyModeUsesDifferentSocketPoolGroup) {
   SpdySessionDependencies session_deps(
       GetParam(), ProxyService::CreateDirect());
 
   StaticSocketDataProvider socket_data;
   socket_data.set_connect_data(MockConnect(ASYNC, OK));
   session_deps.socket_factory->AddSocketDataProvider(&socket_data);
 
@@ skipping 94 matching lines @@
           request_info,
           DEFAULT_PRIORITY,
           ssl_config,
           ssl_config,
           &waiter,
           BoundNetLog()));
   waiter.WaitForStream();
   EXPECT_TRUE(waiter.stream_done());
   ASSERT_TRUE(nullptr != waiter.stream());
   EXPECT_TRUE(nullptr == waiter.websocket_stream());
-  EXPECT_FALSE(waiter.stream()->IsSpdyHttpStream());
 
+  EXPECT_EQ(0, GetSpdySessionCount(session.get()));
   EXPECT_EQ(1, GetSocketPoolGroupCount(
       session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSSLSocketPool(
       HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetTransportSocketPool(
           HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSSLSocketPool(
       HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
@@ skipping 27 matching lines @@
           request_info,
           DEFAULT_PRIORITY,
           ssl_config,
           ssl_config,
           &waiter,
           BoundNetLog()));
   waiter.WaitForStream();
   EXPECT_TRUE(waiter.stream_done());
   ASSERT_TRUE(nullptr != waiter.stream());
   EXPECT_TRUE(nullptr == waiter.websocket_stream());
-  EXPECT_FALSE(waiter.stream()->IsSpdyHttpStream());
+
+  EXPECT_EQ(0, GetSpdySessionCount(session.get()));
   EXPECT_EQ(1, GetSocketPoolGroupCount(
       session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(1, GetSocketPoolGroupCount(
       session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetTransportSocketPool(
           HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSSLSocketPool(
       HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
@@ skipping 24 matching lines @@
           request_info,
           DEFAULT_PRIORITY,
           ssl_config,
           ssl_config,
           &waiter,
           BoundNetLog()));
   waiter.WaitForStream();
   EXPECT_TRUE(waiter.stream_done());
   ASSERT_TRUE(nullptr != waiter.stream());
   EXPECT_TRUE(nullptr == waiter.websocket_stream());
-  EXPECT_FALSE(waiter.stream()->IsSpdyHttpStream());
+
+  EXPECT_EQ(0, GetSpdySessionCount(session.get()));
   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))));
@@ skipping 151 matching lines @@
   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSocketPoolForSSLWithProxy(
       HttpNetworkSession::WEBSOCKET_SOCKET_POOL,
       HostPortPair("myproxy", 8888))));
   EXPECT_FALSE(waiter.used_proxy_info().is_direct());
 }
 
 TEST_P(HttpStreamFactoryTest, RequestSpdyHttpStream) {
   SpdySessionDependencies session_deps(GetParam(),
                                        ProxyService::CreateDirect());
 
-  MockRead mock_read(ASYNC, OK);
+  MockRead mock_read(SYNCHRONOUS, ERR_IO_PENDING);
   SequencedSocketData socket_data(&mock_read, 1, nullptr, 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.SetNextProto(GetParam());
   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
 
   HostPortPair host_port_pair("www.google.com", 443);
   scoped_refptr<HttpNetworkSession> session(
@@ skipping 12 matching lines @@
           request_info,
           DEFAULT_PRIORITY,
           ssl_config,
           ssl_config,
           &waiter,
           BoundNetLog()));
   waiter.WaitForStream();
   EXPECT_TRUE(waiter.stream_done());
   EXPECT_TRUE(nullptr == waiter.websocket_stream());
   ASSERT_TRUE(nullptr != waiter.stream());
-  EXPECT_TRUE(waiter.stream()->IsSpdyHttpStream());
+
+  EXPECT_EQ(1, GetSpdySessionCount(session.get()));
   EXPECT_EQ(1, GetSocketPoolGroupCount(
       session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(1, GetSocketPoolGroupCount(
       session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetTransportSocketPool(
           HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetSSLSocketPool(HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
@@ skipping 196 matching lines @@
   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
 
   // Make sure there is no orphaned job. it is already canceled.
   ASSERT_EQ(0u, static_cast<HttpStreamFactoryImpl*>(
       session->http_stream_factory_for_websocket())->num_orphaned_jobs());
 }
 
 }  // namespace
 
 }  // namespace net