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_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 {
@@ skipping 39 matching lines @@
  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_;

[mmenke, 2011/12/02 21:52:10]

You might want to explicitly query this in a test or two, to make sure it's
populated.

[James Simonsen, 2011/12/03 03:16:00]

Done.

   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_));
@@ skipping 75 matching lines @@
       .Times(1)
       .WillOnce(Return(host_));
 
   CreateDummyStream();
   pool_->OnHostIdle(host_);
 }
 
 }  // anonymous namespace
 
 }  // namespace net