Add a force pipelining option to load flags.

net/http/http_pipelined_host_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_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/http/http_pipelined_host_test_util.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::NiceMock;
 using testing::Ref;
 using testing::Return;
 using testing::ReturnNull;
 
 namespace net {
 
 namespace {
 
 ClientSocketHandle* kDummyConnection =
     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,
-                    HttpPipelinedHostCapability capability));
-};
-
-class MockPipelineFactory : public HttpPipelinedConnection::Factory {
- public:
-  MOCK_METHOD8(CreateNewPipeline, HttpPipelinedConnection*(
-      ClientSocketHandle* connection,
-      HttpPipelinedConnection::Delegate* delegate,
-      const HostPortPair& origin,
-      const SSLConfig& used_ssl_config,
-      const ProxyInfo& used_proxy_info,
-      const BoundNetLog& net_log,
-      bool was_npn_negotiated,
-      SSLClientSocket::NextProto protocol_negotiated));
-};
-
-class MockPipeline : public HttpPipelinedConnection {
- public:
-  MockPipeline(int depth, bool usable, bool active)
-      : depth_(depth),
-        usable_(usable),
-        active_(active) {
-  }
-
-  void SetState(int depth, bool usable, bool active) {
-    depth_ = depth;
-    usable_ = usable;
-    active_ = active;
-  }
-
-  virtual int depth() const OVERRIDE { return depth_; }
-  virtual bool usable() const OVERRIDE { return usable_; }
-  virtual bool active() const OVERRIDE { return active_; }
-
-  MOCK_METHOD0(CreateNewStream, HttpPipelinedStream*());
-  MOCK_METHOD1(OnStreamDeleted, void(int pipeline_id));
-  MOCK_CONST_METHOD0(used_ssl_config, const SSLConfig&());
-  MOCK_CONST_METHOD0(used_proxy_info, const ProxyInfo&());
-  MOCK_CONST_METHOD0(net_log, const BoundNetLog&());
-  MOCK_CONST_METHOD0(was_npn_negotiated, bool());
-  MOCK_CONST_METHOD0(protocol_negotiated, SSLClientSocket::NextProto());
-
- private:
-  int depth_;
-  bool usable_;
-  bool active_;
-};
-
-MATCHER_P(MatchesOrigin, expected, "") { return expected.Equals(arg); }
-
 class HttpPipelinedHostImplTest : public testing::Test {
  public:
   HttpPipelinedHostImplTest()
-      : origin_("host", 123),
+      : key_(HostPortPair("host", 123), false),
         factory_(new MockPipelineFactory),  // Owned by host_.
-        host_(new HttpPipelinedHostImpl(&delegate_, origin_, factory_,
+        host_(new HttpPipelinedHostImpl(&delegate_, key_, factory_,
                                         PIPELINE_CAPABLE)) {
   }
 
   void SetCapability(HttpPipelinedHostCapability capability) {
     factory_ = new MockPipelineFactory;
     host_.reset(new HttpPipelinedHostImpl(
-        &delegate_, origin_, factory_, capability));
+        &delegate_, key_, factory_, capability));
   }
 
   MockPipeline* AddTestPipeline(int depth, bool usable, bool active) {
     MockPipeline* pipeline = new MockPipeline(depth, usable, active);
     EXPECT_CALL(*factory_, CreateNewPipeline(kDummyConnection, host_.get(),
-                                             MatchesOrigin(origin_),
+                                             MatchesOrigin(key_.origin()),
                                              Ref(ssl_config_), Ref(proxy_info_),
                                              Ref(net_log_), true,
                                              SSLClientSocket::kProtoSPDY21))
         .Times(1)
         .WillOnce(Return(pipeline));
     EXPECT_CALL(*pipeline, CreateNewStream())
         .Times(1)
         .WillOnce(Return(kDummyStream));
     EXPECT_EQ(kDummyStream, host_->CreateStreamOnNewPipeline(
         kDummyConnection, ssl_config_, proxy_info_, net_log_, true,
         SSLClientSocket::kProtoSPDY21));
     return pipeline;
   }
 
   void ClearTestPipeline(MockPipeline* pipeline) {
     pipeline->SetState(0, true, true);
     host_->OnPipelineHasCapacity(pipeline);
   }
 
   NiceMock<MockHostDelegate> delegate_;
-  HostPortPair origin_;
+  HttpPipelinedHost::Key key_;
   MockPipelineFactory* factory_;
   scoped_ptr<HttpPipelinedHostImpl> host_;
 
   SSLConfig ssl_config_;
   ProxyInfo proxy_info_;
   BoundNetLog net_log_;
 };
 
 TEST_F(HttpPipelinedHostImplTest, Delegate) {
-  EXPECT_TRUE(origin_.Equals(host_->origin()));
+  EXPECT_TRUE(key_.origin().Equals(host_->key().origin()));
+  EXPECT_EQ(key_.force_pipelining(), host_->key().force_pipelining());
 }
 
 TEST_F(HttpPipelinedHostImplTest, OnUnusablePipelineHasCapacity) {
   MockPipeline* pipeline = AddTestPipeline(0, false, true);
 
   EXPECT_CALL(delegate_, OnHostHasAdditionalCapacity(host_.get()))
       .Times(0);
   EXPECT_CALL(delegate_, OnHostIdle(host_.get()))
       .Times(1);
   host_->OnPipelineHasCapacity(pipeline);
@@ skipping 209 matching lines @@
       .Times(1);
   host_->OnPipelineFeedback(pipeline,
                             HttpPipelinedConnection::PIPELINE_SOCKET_ERROR);
 
   ClearTestPipeline(pipeline);
 }
 
 }  // anonymous namespace
 
 }  // namespace net