Home | History | Annotate | Download | only in http 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "net/http/http_pipelined_host_pool.h"
      6 
      7 #include "base/memory/scoped_ptr.h"
      8 #include "base/rand_util.h"
      9 #include "net/http/http_pipelined_host.h"
     10 #include "net/http/http_pipelined_host_capability.h"
     11 #include "net/http/http_server_properties_impl.h"
     12 #include "net/proxy/proxy_info.h"
     13 #include "net/ssl/ssl_config_service.h"
     14 #include "testing/gmock/include/gmock/gmock.h"
     15 #include "testing/gtest/include/gtest/gtest.h"
     16 
     17 using testing::_;
     18 using testing::Ref;
     19 using testing::Return;
     20 using testing::ReturnNull;
     21 
     22 namespace net {
     23 
     24 namespace {
     25 
     26 ClientSocketHandle* kDummyConnection =
     27     reinterpret_cast<ClientSocketHandle*>(188);
     28 HttpPipelinedStream* kDummyStream =
     29     reinterpret_cast<HttpPipelinedStream*>(99);
     30 
     31 class MockPoolDelegate : public HttpPipelinedHostPool::Delegate {
     32  public:
     33   MOCK_METHOD1(OnHttpPipelinedHostHasAdditionalCapacity,
     34                void(HttpPipelinedHost* host));
     35 };
     36 
     37 class MockHostFactory : public HttpPipelinedHost::Factory {
     38  public:
     39   MOCK_METHOD5(CreateNewHost, HttpPipelinedHost*(
     40       HttpPipelinedHost::Delegate* delegate,
     41       const HttpPipelinedHost::Key& key,
     42       HttpPipelinedConnection::Factory* factory,
     43       HttpPipelinedHostCapability capability,
     44       bool force_pipelining));
     45 };
     46 
     47 class MockHost : public HttpPipelinedHost {
     48  public:
     49   MockHost(const Key& key)
     50       : key_(key) {
     51   }
     52 
     53   MOCK_METHOD6(CreateStreamOnNewPipeline, HttpPipelinedStream*(
     54       ClientSocketHandle* connection,
     55       const SSLConfig& used_ssl_config,
     56       const ProxyInfo& used_proxy_info,
     57       const BoundNetLog& net_log,
     58       bool was_npn_negotiated,
     59       NextProto protocol_negotiated));
     60   MOCK_METHOD0(CreateStreamOnExistingPipeline, HttpPipelinedStream*());
     61   MOCK_CONST_METHOD0(IsExistingPipelineAvailable, bool());
     62   MOCK_CONST_METHOD0(PipelineInfoToValue, base::Value*());
     63 
     64   virtual const Key& GetKey() const OVERRIDE { return key_; }
     65 
     66  private:
     67   Key key_;
     68 };
     69 
     70 class HttpPipelinedHostPoolTest : public testing::Test {
     71  public:
     72   HttpPipelinedHostPoolTest()
     73       : key_(HostPortPair("host", 123)),
     74         factory_(new MockHostFactory),  // Owned by pool_.
     75         host_(new MockHost(key_)),  // Owned by pool_.
     76         http_server_properties_(new HttpServerPropertiesImpl()),
     77         pool_(new HttpPipelinedHostPool(
     78             &delegate_, factory_,
     79             http_server_properties_->GetWeakPtr(), false)),
     80         was_npn_negotiated_(false),
     81         protocol_negotiated_(kProtoUnknown) {
     82   }
     83 
     84   void CreateDummyStream(const HttpPipelinedHost::Key& key,
     85                          ClientSocketHandle* connection,
     86                          HttpPipelinedStream* stream,
     87                          MockHost* host) {
     88     EXPECT_CALL(*host, CreateStreamOnNewPipeline(connection,
     89                                                  Ref(ssl_config_),
     90                                                  Ref(proxy_info_),
     91                                                  Ref(net_log_),
     92                                                  was_npn_negotiated_,
     93                                                  protocol_negotiated_))
     94         .Times(1)
     95         .WillOnce(Return(stream));
     96     EXPECT_EQ(stream,
     97               pool_->CreateStreamOnNewPipeline(key, connection,
     98                                                ssl_config_, proxy_info_,
     99                                                net_log_, was_npn_negotiated_,
    100                                                protocol_negotiated_));
    101   }
    102 
    103   MockHost* CreateDummyHost(const HttpPipelinedHost::Key& key) {
    104     MockHost* mock_host = new MockHost(key);
    105     EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(key), _,
    106                                          PIPELINE_UNKNOWN, false))
    107         .Times(1)
    108         .WillOnce(Return(mock_host));
    109     ClientSocketHandle* dummy_connection =
    110         reinterpret_cast<ClientSocketHandle*>(base::RandUint64());
    111     HttpPipelinedStream* dummy_stream =
    112         reinterpret_cast<HttpPipelinedStream*>(base::RandUint64());
    113     CreateDummyStream(key, dummy_connection, dummy_stream, mock_host);
    114     return mock_host;
    115   }
    116 
    117   HttpPipelinedHost::Key key_;
    118   MockPoolDelegate delegate_;
    119   MockHostFactory* factory_;
    120   MockHost* host_;
    121   scoped_ptr<HttpServerPropertiesImpl> http_server_properties_;
    122   scoped_ptr<HttpPipelinedHostPool> pool_;
    123 
    124   const SSLConfig ssl_config_;
    125   const ProxyInfo proxy_info_;
    126   const BoundNetLog net_log_;
    127   bool was_npn_negotiated_;
    128   NextProto protocol_negotiated_;
    129 };
    130 
    131 TEST_F(HttpPipelinedHostPoolTest, DefaultUnknown) {
    132   EXPECT_TRUE(pool_->IsKeyEligibleForPipelining(key_));
    133   EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(key_), _,
    134                                        PIPELINE_UNKNOWN, false))
    135       .Times(1)
    136       .WillOnce(Return(host_));
    137 
    138   CreateDummyStream(key_, kDummyConnection, kDummyStream, host_);
    139   pool_->OnHostIdle(host_);
    140 }
    141 
    142 TEST_F(HttpPipelinedHostPoolTest, RemembersIncapable) {
    143   EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(key_), _,
    144                                        PIPELINE_UNKNOWN, false))
    145       .Times(1)
    146       .WillOnce(Return(host_));
    147 
    148   CreateDummyStream(key_, kDummyConnection, kDummyStream, host_);
    149   pool_->OnHostDeterminedCapability(host_, PIPELINE_INCAPABLE);
    150   pool_->OnHostIdle(host_);
    151   EXPECT_FALSE(pool_->IsKeyEligibleForPipelining(key_));
    152   EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(key_), _,
    153                                        PIPELINE_INCAPABLE, false))
    154       .Times(0);
    155   EXPECT_EQ(NULL,
    156             pool_->CreateStreamOnNewPipeline(key_, kDummyConnection,
    157                                              ssl_config_, proxy_info_, net_log_,
    158                                              was_npn_negotiated_,
    159                                              protocol_negotiated_));
    160 }
    161 
    162 TEST_F(HttpPipelinedHostPoolTest, RemembersCapable) {
    163   EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(key_), _,
    164                                        PIPELINE_UNKNOWN, false))
    165       .Times(1)
    166       .WillOnce(Return(host_));
    167 
    168   CreateDummyStream(key_, kDummyConnection, kDummyStream, host_);
    169   pool_->OnHostDeterminedCapability(host_, PIPELINE_CAPABLE);
    170   pool_->OnHostIdle(host_);
    171   EXPECT_TRUE(pool_->IsKeyEligibleForPipelining(key_));
    172 
    173   host_ = new MockHost(key_);
    174   EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(key_), _,
    175                                        PIPELINE_CAPABLE, false))
    176       .Times(1)
    177       .WillOnce(Return(host_));
    178   CreateDummyStream(key_, kDummyConnection, kDummyStream, host_);
    179   pool_->OnHostIdle(host_);
    180 }
    181 
    182 TEST_F(HttpPipelinedHostPoolTest, IncapableIsSticky) {
    183   EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(key_), _,
    184                                        PIPELINE_UNKNOWN, false))
    185       .Times(1)
    186       .WillOnce(Return(host_));
    187 
    188   CreateDummyStream(key_, kDummyConnection, kDummyStream, host_);
    189   pool_->OnHostDeterminedCapability(host_, PIPELINE_CAPABLE);
    190   pool_->OnHostDeterminedCapability(host_, PIPELINE_INCAPABLE);
    191   pool_->OnHostDeterminedCapability(host_, PIPELINE_CAPABLE);
    192   pool_->OnHostIdle(host_);
    193   EXPECT_FALSE(pool_->IsKeyEligibleForPipelining(key_));
    194 }
    195 
    196 TEST_F(HttpPipelinedHostPoolTest, RemainsUnknownWithoutFeedback) {
    197   EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(key_), _,
    198                                        PIPELINE_UNKNOWN, false))
    199       .Times(1)
    200       .WillOnce(Return(host_));
    201 
    202   CreateDummyStream(key_, kDummyConnection, kDummyStream, host_);
    203   pool_->OnHostIdle(host_);
    204   EXPECT_TRUE(pool_->IsKeyEligibleForPipelining(key_));
    205 
    206   host_ = new MockHost(key_);
    207   EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(key_), _,
    208                                        PIPELINE_UNKNOWN, false))
    209       .Times(1)
    210       .WillOnce(Return(host_));
    211 
    212   CreateDummyStream(key_, kDummyConnection, kDummyStream, host_);
    213   pool_->OnHostIdle(host_);
    214 }
    215 
    216 TEST_F(HttpPipelinedHostPoolTest, PopulatesServerProperties) {
    217   EXPECT_EQ(PIPELINE_UNKNOWN,
    218             http_server_properties_->GetPipelineCapability(
    219                 host_->GetKey().origin()));
    220   pool_->OnHostDeterminedCapability(host_, PIPELINE_CAPABLE);
    221   EXPECT_EQ(PIPELINE_CAPABLE,
    222             http_server_properties_->GetPipelineCapability(
    223                 host_->GetKey().origin()));
    224   delete host_;  // Must manually delete, because it's never added to |pool_|.
    225 }
    226 
    227 TEST_F(HttpPipelinedHostPoolTest, MultipleKeys) {
    228   HttpPipelinedHost::Key key1(HostPortPair("host", 123));
    229   HttpPipelinedHost::Key key2(HostPortPair("host", 456));
    230   HttpPipelinedHost::Key key3(HostPortPair("other", 456));
    231   HttpPipelinedHost::Key key4(HostPortPair("other", 789));
    232   MockHost* host1 = CreateDummyHost(key1);
    233   MockHost* host2 = CreateDummyHost(key2);
    234   MockHost* host3 = CreateDummyHost(key3);
    235 
    236   EXPECT_CALL(*host1, IsExistingPipelineAvailable())
    237       .Times(1)
    238       .WillOnce(Return(true));
    239   EXPECT_TRUE(pool_->IsExistingPipelineAvailableForKey(key1));
    240 
    241   EXPECT_CALL(*host2, IsExistingPipelineAvailable())
    242       .Times(1)
    243       .WillOnce(Return(false));
    244   EXPECT_FALSE(pool_->IsExistingPipelineAvailableForKey(key2));
    245 
    246   EXPECT_CALL(*host3, IsExistingPipelineAvailable())
    247       .Times(1)
    248       .WillOnce(Return(true));
    249   EXPECT_TRUE(pool_->IsExistingPipelineAvailableForKey(key3));
    250 
    251   EXPECT_FALSE(pool_->IsExistingPipelineAvailableForKey(key4));
    252 
    253   pool_->OnHostIdle(host1);
    254   pool_->OnHostIdle(host2);
    255   pool_->OnHostIdle(host3);
    256 
    257   delete host_;  // Must manually delete, because it's never added to |pool_|.
    258 }
    259 
    260 }  // anonymous namespace
    261 
    262 }  // namespace net
    263