Save pipelining capabilities for the most used hosts between sessions.

net/http/http_pipelined_host_pool_unittest.cc

 // Copyright (c) 2011 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_pipelined_host_pool.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "net/base/ssl_config_service.h"
 #include "net/http/http_pipelined_host.h"
+#include "net/http/http_pipelined_host_capability.h"
+#include "net/http/http_server_properties_impl.h"
 #include "net/proxy/proxy_info.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::Ref;
 using testing::Return;
 using testing::ReturnNull;
 
 namespace net {
 
 namespace {
 
 ClientSocketHandle* kDummyConnection =
     reinterpret_cast<ClientSocketHandle*>(188);
 HttpPipelinedStream* kDummyStream =
     reinterpret_cast<HttpPipelinedStream*>(99);
 
 class MockPoolDelegate : public HttpPipelinedHostPool::Delegate {
  public:
   MOCK_METHOD1(OnHttpPipelinedHostHasAdditionalCapacity,
                void(const HostPortPair& origin));
 };
 
 class MockHostFactory : public HttpPipelinedHost::Factory {
  public:
   MOCK_METHOD4(CreateNewHost, HttpPipelinedHost*(
       HttpPipelinedHost::Delegate* delegate, const HostPortPair& origin,
       HttpPipelinedConnection::Factory* factory,
-      HttpPipelinedHost::Capability capability));
+      HttpPipelinedHostCapability capability));
 };
 
 class MockHost : public HttpPipelinedHost {
  public:
   MockHost(const HostPortPair& origin)
       : origin_(origin) {
   }
 
   MOCK_METHOD5(CreateStreamOnNewPipeline, HttpPipelinedStream*(
       ClientSocketHandle* connection,
       const SSLConfig& used_ssl_config,
       const ProxyInfo& used_proxy_info,
       const BoundNetLog& net_log,
       bool was_npn_negotiated));
   MOCK_METHOD0(CreateStreamOnExistingPipeline, HttpPipelinedStream*());
   MOCK_CONST_METHOD0(IsExistingPipelineAvailable, bool());
 
   virtual const HostPortPair& origin() const OVERRIDE { return origin_; }
 
  private:
   HostPortPair origin_;
 };
 
 class HttpPipelinedHostPoolTest : public testing::Test {
  public:
   HttpPipelinedHostPoolTest()
       : origin_("host", 123),
         factory_(new MockHostFactory),  // Owned by pool_.
         host_(new MockHost(origin_)),  // Owned by pool_.
-        pool_(new HttpPipelinedHostPool(&delegate_, factory_)),
+        http_server_properties_(new HttpServerPropertiesImpl),
+        pool_(new HttpPipelinedHostPool(&delegate_, factory_,
+                                        http_server_properties_.get())),
         was_npn_negotiated_(false) {
   }
 
   void CreateDummyStream() {
     EXPECT_CALL(*host_, CreateStreamOnNewPipeline(kDummyConnection,
                                                   Ref(ssl_config_),
                                                   Ref(proxy_info_),
                                                   Ref(net_log_),
                                                   was_npn_negotiated_))
         .Times(1)
         .WillOnce(Return(kDummyStream));
     EXPECT_EQ(kDummyStream,
               pool_->CreateStreamOnNewPipeline(origin_, kDummyConnection,
                                                ssl_config_, proxy_info_,
                                                net_log_, was_npn_negotiated_));
   }
 
   HostPortPair origin_;
   MockPoolDelegate delegate_;
   MockHostFactory* factory_;
   MockHost* host_;
+  scoped_ptr<HttpServerPropertiesImpl> http_server_properties_;
   scoped_ptr<HttpPipelinedHostPool> pool_;
 
   const SSLConfig ssl_config_;
   const ProxyInfo proxy_info_;
   const BoundNetLog net_log_;
   bool was_npn_negotiated_;
 };
 
 TEST_F(HttpPipelinedHostPoolTest, DefaultUnknown) {
   EXPECT_TRUE(pool_->IsHostEligibleForPipelining(origin_));
   EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(origin_), _,
-                                       HttpPipelinedHost::UNKNOWN))
+                                       PIPELINE_UNKNOWN))
       .Times(1)
       .WillOnce(Return(host_));
 
   CreateDummyStream();
   pool_->OnHostIdle(host_);
 }
 
 TEST_F(HttpPipelinedHostPoolTest, RemembersIncapable) {
   EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(origin_), _,
-                                       HttpPipelinedHost::UNKNOWN))
+                                       PIPELINE_UNKNOWN))
       .Times(1)
       .WillOnce(Return(host_));
 
   CreateDummyStream();
-  pool_->OnHostDeterminedCapability(host_, HttpPipelinedHost::INCAPABLE);
+  pool_->OnHostDeterminedCapability(host_, PIPELINE_INCAPABLE);
   pool_->OnHostIdle(host_);
   EXPECT_FALSE(pool_->IsHostEligibleForPipelining(origin_));
   EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(origin_), _,
-                                       HttpPipelinedHost::INCAPABLE))
+                                       PIPELINE_INCAPABLE))
       .Times(0);
   EXPECT_EQ(NULL,
             pool_->CreateStreamOnNewPipeline(origin_, kDummyConnection,
                                              ssl_config_, proxy_info_, net_log_,
                                              was_npn_negotiated_));
 }
 
 TEST_F(HttpPipelinedHostPoolTest, RemembersCapable) {
   EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(origin_), _,
-                                       HttpPipelinedHost::UNKNOWN))
+                                       PIPELINE_UNKNOWN))
       .Times(1)
       .WillOnce(Return(host_));
 
   CreateDummyStream();
-  pool_->OnHostDeterminedCapability(host_, HttpPipelinedHost::CAPABLE);
+  pool_->OnHostDeterminedCapability(host_, PIPELINE_CAPABLE);
   pool_->OnHostIdle(host_);
   EXPECT_TRUE(pool_->IsHostEligibleForPipelining(origin_));
 
   host_ = new MockHost(origin_);
   EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(origin_), _,
-                                       HttpPipelinedHost::CAPABLE))
+                                       PIPELINE_CAPABLE))
       .Times(1)
       .WillOnce(Return(host_));
   CreateDummyStream();
   pool_->OnHostIdle(host_);
 }
 
 TEST_F(HttpPipelinedHostPoolTest, IncapableIsSticky) {
   EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(origin_), _,
-                                       HttpPipelinedHost::UNKNOWN))
+                                       PIPELINE_UNKNOWN))
       .Times(1)
       .WillOnce(Return(host_));
 
   CreateDummyStream();
-  pool_->OnHostDeterminedCapability(host_, HttpPipelinedHost::CAPABLE);
-  pool_->OnHostDeterminedCapability(host_, HttpPipelinedHost::INCAPABLE);
-  pool_->OnHostDeterminedCapability(host_, HttpPipelinedHost::CAPABLE);
+  pool_->OnHostDeterminedCapability(host_, PIPELINE_CAPABLE);
+  pool_->OnHostDeterminedCapability(host_, PIPELINE_INCAPABLE);
+  pool_->OnHostDeterminedCapability(host_, PIPELINE_CAPABLE);
   pool_->OnHostIdle(host_);
   EXPECT_FALSE(pool_->IsHostEligibleForPipelining(origin_));
 }
 
 TEST_F(HttpPipelinedHostPoolTest, RemainsUnknownWithoutFeedback) {
   EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(origin_), _,
-                                       HttpPipelinedHost::UNKNOWN))
+                                       PIPELINE_UNKNOWN))
       .Times(1)
       .WillOnce(Return(host_));
 
   CreateDummyStream();
   pool_->OnHostIdle(host_);
   EXPECT_TRUE(pool_->IsHostEligibleForPipelining(origin_));
 
   host_ = new MockHost(origin_);
   EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(origin_), _,
-                                       HttpPipelinedHost::UNKNOWN))
+                                       PIPELINE_UNKNOWN))
       .Times(1)
       .WillOnce(Return(host_));
 
   CreateDummyStream();
   pool_->OnHostIdle(host_);
 }
 
+TEST_F(HttpPipelinedHostPoolTest, PopulatesServerProperties) {
+  EXPECT_EQ(PIPELINE_UNKNOWN,
+            http_server_properties_->GetPipelineCapability(host_->origin()));
+  pool_->OnHostDeterminedCapability(host_, PIPELINE_CAPABLE);
+  EXPECT_EQ(PIPELINE_CAPABLE,
+            http_server_properties_->GetPipelineCapability(host_->origin()));
+}
+
 }  // anonymous namespace
 
 }  // namespace net