Save pipelining capabilities for the most used hosts between sessions.

net/http/http_pipelined_host_impl_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_impl.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "net/base/ssl_config_service.h"
 #include "net/http/http_pipelined_connection.h"
 #include "net/proxy/proxy_info.h"
@@ skipping 14 matching lines @@
     reinterpret_cast<ClientSocketHandle*>(84);
 HttpPipelinedStream* kDummyStream =
     reinterpret_cast<HttpPipelinedStream*>(42);
 
 class MockHostDelegate : public HttpPipelinedHost::Delegate {
  public:
   MOCK_METHOD1(OnHostIdle, void(HttpPipelinedHost* host));
   MOCK_METHOD1(OnHostHasAdditionalCapacity, void(HttpPipelinedHost* host));
   MOCK_METHOD2(OnHostDeterminedCapability,
                void(HttpPipelinedHost* host,
-                    HttpPipelinedHost::Capability capability));
+                    HttpPipelinedHostCapability capability));
 };
 
 class MockPipelineFactory : public HttpPipelinedConnection::Factory {
  public:
   MOCK_METHOD6(CreateNewPipeline, HttpPipelinedConnection*(
       ClientSocketHandle* connection,
       HttpPipelinedConnection::Delegate* delegate,
       const SSLConfig& used_ssl_config,
       const ProxyInfo& used_proxy_info,
       const BoundNetLog& net_log,
@@ skipping 30 matching lines @@
   bool usable_;
   bool active_;
 };
 
 class HttpPipelinedHostImplTest : public testing::Test {
  public:
   HttpPipelinedHostImplTest()
       : origin_("host", 123),
         factory_(new MockPipelineFactory),  // Owned by host_.
         host_(new HttpPipelinedHostImpl(&delegate_, origin_, factory_,
-                                        HttpPipelinedHost::CAPABLE)) {
+                                        PIPELINE_CAPABLE)) {
   }
 
-  void SetCapability(HttpPipelinedHost::Capability capability) {
+  void SetCapability(HttpPipelinedHostCapability capability) {
     factory_ = new MockPipelineFactory;
     host_.reset(new HttpPipelinedHostImpl(
         &delegate_, origin_, factory_, capability));
   }
 
   MockPipeline* AddTestPipeline(int depth, bool usable, bool active) {
     MockPipeline* pipeline = new MockPipeline(depth, usable, active);
     EXPECT_CALL(*factory_, CreateNewPipeline(kDummyConnection, host_.get(),
                                              Ref(ssl_config_), Ref(proxy_info_),
                                              Ref(net_log_), true))
@@ skipping 93 matching lines @@
       .Times(1)
       .WillOnce(ReturnNull());
   EXPECT_EQ(NULL, host_->CreateStreamOnExistingPipeline());
 
   ClearTestPipeline(full_pipeline);
   ClearTestPipeline(usable_pipeline);
   ClearTestPipeline(empty_pipeline);
 }
 
 TEST_F(HttpPipelinedHostImplTest, OpensUpOnPipelineSuccess) {
-  SetCapability(HttpPipelinedHost::UNKNOWN);
+  SetCapability(PIPELINE_UNKNOWN);
   MockPipeline* pipeline = AddTestPipeline(1, true, true);
 
   EXPECT_EQ(NULL, host_->CreateStreamOnExistingPipeline());
   EXPECT_CALL(delegate_, OnHostHasAdditionalCapacity(host_.get()))
       .Times(1);
   host_->OnPipelineFeedback(pipeline, HttpPipelinedConnection::OK);
 
   EXPECT_CALL(*pipeline, CreateNewStream())
       .Times(1)
       .WillOnce(Return(kDummyStream));
   EXPECT_EQ(kDummyStream, host_->CreateStreamOnExistingPipeline());
 
   EXPECT_CALL(delegate_, OnHostHasAdditionalCapacity(host_.get()))
       .Times(1);
   ClearTestPipeline(pipeline);
 }
 
 TEST_F(HttpPipelinedHostImplTest, OpensAllPipelinesOnPipelineSuccess) {
-  SetCapability(HttpPipelinedHost::UNKNOWN);
+  SetCapability(PIPELINE_UNKNOWN);
   MockPipeline* pipeline1 = AddTestPipeline(1, false, true);
   MockPipeline* pipeline2 = AddTestPipeline(1, true, true);
 
   EXPECT_EQ(NULL, host_->CreateStreamOnExistingPipeline());
   EXPECT_CALL(delegate_, OnHostHasAdditionalCapacity(host_.get()))
       .Times(1);
   host_->OnPipelineFeedback(pipeline1, HttpPipelinedConnection::OK);
 
   EXPECT_CALL(*pipeline2, CreateNewStream())
       .Times(1)
       .WillOnce(Return(kDummyStream));
   EXPECT_EQ(kDummyStream, host_->CreateStreamOnExistingPipeline());
 
   EXPECT_CALL(delegate_, OnHostHasAdditionalCapacity(host_.get()))
       .Times(2);
   ClearTestPipeline(pipeline1);
   ClearTestPipeline(pipeline2);
 }
 
 TEST_F(HttpPipelinedHostImplTest, ShutsDownOnOldVersion) {
-  SetCapability(HttpPipelinedHost::UNKNOWN);
+  SetCapability(PIPELINE_UNKNOWN);
   MockPipeline* pipeline = AddTestPipeline(1, true, true);
 
   EXPECT_EQ(NULL, host_->CreateStreamOnExistingPipeline());
   EXPECT_CALL(delegate_, OnHostHasAdditionalCapacity(host_.get()))
       .Times(0);
   EXPECT_CALL(delegate_,
-              OnHostDeterminedCapability(host_.get(),
-                                         HttpPipelinedHost::INCAPABLE))
+              OnHostDeterminedCapability(host_.get(), PIPELINE_INCAPABLE))
       .Times(1);
   host_->OnPipelineFeedback(pipeline,
                             HttpPipelinedConnection::OLD_HTTP_VERSION);
 
   ClearTestPipeline(pipeline);
   EXPECT_EQ(NULL, host_->CreateStreamOnNewPipeline(
       kDummyConnection, ssl_config_, proxy_info_, net_log_, true));
 }
 
 TEST_F(HttpPipelinedHostImplTest, ConnectionCloseHasNoEffect) {
-  SetCapability(HttpPipelinedHost::UNKNOWN);
+  SetCapability(PIPELINE_UNKNOWN);
   MockPipeline* pipeline = AddTestPipeline(1, true, true);
 
   EXPECT_CALL(delegate_, OnHostHasAdditionalCapacity(host_.get()))
       .Times(0);
   EXPECT_CALL(delegate_, OnHostDeterminedCapability(host_.get(), _))
       .Times(0);
   host_->OnPipelineFeedback(pipeline,
                             HttpPipelinedConnection::MUST_CLOSE_CONNECTION);
   EXPECT_EQ(NULL, host_->CreateStreamOnExistingPipeline());
 
   EXPECT_CALL(delegate_, OnHostHasAdditionalCapacity(host_.get()))
       .Times(1);
   ClearTestPipeline(pipeline);
 }
 
 TEST_F(HttpPipelinedHostImplTest, SuccessesLeadToCapable) {
-  SetCapability(HttpPipelinedHost::UNKNOWN);
+  SetCapability(PIPELINE_UNKNOWN);
   MockPipeline* pipeline = AddTestPipeline(1, true, true);
 
   EXPECT_CALL(delegate_, OnHostHasAdditionalCapacity(host_.get()))
       .Times(1);
   EXPECT_CALL(delegate_,
-              OnHostDeterminedCapability(host_.get(),
-                                         HttpPipelinedHost::CAPABLE))
+              OnHostDeterminedCapability(host_.get(), PIPELINE_CAPABLE))
       .Times(1);
   host_->OnPipelineFeedback(pipeline, HttpPipelinedConnection::OK);
 
   pipeline->SetState(3, true, true);
   host_->OnPipelineFeedback(pipeline, HttpPipelinedConnection::OK);
   host_->OnPipelineFeedback(pipeline, HttpPipelinedConnection::OK);
 
   EXPECT_CALL(delegate_, OnHostHasAdditionalCapacity(host_.get()))
       .Times(1);
   ClearTestPipeline(pipeline);
 }
 
 }  // anonymous namespace
 
 }  // namespace net