net/http/http_pipelined_host_pool_unittest.cc - Issue 275953002: Remove HTTP pipelining support.

Unified Diff: net/http/http_pipelined_host_pool_unittest.cc

Issue 275953002: Remove HTTP pipelining support. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src

Patch Set: Merge Created 6 years, 7 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: net/http/http_pipelined_host_pool_unittest.cc

diff --git a/net/http/http_pipelined_host_pool_unittest.cc b/net/http/http_pipelined_host_pool_unittest.cc

deleted file mode 100644

index fa8d93facb17848cff0603d3c85d3efde28c127f..0000000000000000000000000000000000000000

--- a/net/http/http_pipelined_host_pool_unittest.cc

+++ /dev/null

@@ -1,262 +0,0 @@

-// 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 "base/rand_util.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 "net/ssl/ssl_config_service.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(HttpPipelinedHost* host));

-};

-class MockHostFactory : public HttpPipelinedHost::Factory {

- public:

- MOCK_METHOD5(CreateNewHost, HttpPipelinedHost*(

- HttpPipelinedHost::Delegate* delegate,

- const HttpPipelinedHost::Key& key,

- HttpPipelinedConnection::Factory* factory,

- HttpPipelinedHostCapability capability,

- bool force_pipelining));

-};

-class MockHost : public HttpPipelinedHost {

- public:

- MockHost(const Key& key)

- : key_(key) {

- }

- MOCK_METHOD6(CreateStreamOnNewPipeline, HttpPipelinedStream*(

- ClientSocketHandle* connection,

- const SSLConfig& used_ssl_config,

- const ProxyInfo& used_proxy_info,

- const BoundNetLog& net_log,

- bool was_npn_negotiated,

- NextProto protocol_negotiated));

- MOCK_METHOD0(CreateStreamOnExistingPipeline, HttpPipelinedStream*());

- MOCK_CONST_METHOD0(IsExistingPipelineAvailable, bool());

- MOCK_CONST_METHOD0(PipelineInfoToValue, base::Value*());

- virtual const Key& GetKey() const OVERRIDE { return key_; }

- private:

- Key key_;

-};

-class HttpPipelinedHostPoolTest : public testing::Test {

- public:

- HttpPipelinedHostPoolTest()

- : key_(HostPortPair("host", 123)),

- factory_(new MockHostFactory), // Owned by pool_.

- host_(new MockHost(key_)), // Owned by pool_.

- http_server_properties_(new HttpServerPropertiesImpl()),

- pool_(new HttpPipelinedHostPool(

- &delegate_, factory_,

- http_server_properties_->GetWeakPtr(), false)),

- was_npn_negotiated_(false),

- protocol_negotiated_(kProtoUnknown) {

- }

- void CreateDummyStream(const HttpPipelinedHost::Key& key,

- ClientSocketHandle* connection,

- HttpPipelinedStream* stream,

- MockHost* host) {

- EXPECT_CALL(*host, CreateStreamOnNewPipeline(connection,

- Ref(ssl_config_),

- Ref(proxy_info_),

- Ref(net_log_),

- was_npn_negotiated_,

- protocol_negotiated_))

- .Times(1)

- .WillOnce(Return(stream));

- EXPECT_EQ(stream,

- pool_->CreateStreamOnNewPipeline(key, connection,

- ssl_config_, proxy_info_,

- net_log_, was_npn_negotiated_,

- protocol_negotiated_));

- }

- MockHost* CreateDummyHost(const HttpPipelinedHost::Key& key) {

- MockHost* mock_host = new MockHost(key);

- EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(key), _,

- PIPELINE_UNKNOWN, false))

- .Times(1)

- .WillOnce(Return(mock_host));

- ClientSocketHandle* dummy_connection =

- reinterpret_cast<ClientSocketHandle*>(base::RandUint64());

- HttpPipelinedStream* dummy_stream =

- reinterpret_cast<HttpPipelinedStream*>(base::RandUint64());

- CreateDummyStream(key, dummy_connection, dummy_stream, mock_host);

- return mock_host;

- }

- HttpPipelinedHost::Key key_;

- 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_;

- NextProto protocol_negotiated_;

-};

-TEST_F(HttpPipelinedHostPoolTest, DefaultUnknown) {

- EXPECT_TRUE(pool_->IsKeyEligibleForPipelining(key_));

- EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(key_), _,

- PIPELINE_UNKNOWN, false))

- .Times(1)

- .WillOnce(Return(host_));

- CreateDummyStream(key_, kDummyConnection, kDummyStream, host_);

- pool_->OnHostIdle(host_);

-TEST_F(HttpPipelinedHostPoolTest, RemembersIncapable) {

- EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(key_), _,

- PIPELINE_UNKNOWN, false))

- .Times(1)

- .WillOnce(Return(host_));

- CreateDummyStream(key_, kDummyConnection, kDummyStream, host_);

- pool_->OnHostDeterminedCapability(host_, PIPELINE_INCAPABLE);

- pool_->OnHostIdle(host_);

- EXPECT_FALSE(pool_->IsKeyEligibleForPipelining(key_));

- EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(key_), _,

- PIPELINE_INCAPABLE, false))

- .Times(0);

- EXPECT_EQ(NULL,

- pool_->CreateStreamOnNewPipeline(key_, kDummyConnection,

- ssl_config_, proxy_info_, net_log_,

- was_npn_negotiated_,

- protocol_negotiated_));

-TEST_F(HttpPipelinedHostPoolTest, RemembersCapable) {

- EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(key_), _,

- PIPELINE_UNKNOWN, false))

- .Times(1)

- .WillOnce(Return(host_));

- CreateDummyStream(key_, kDummyConnection, kDummyStream, host_);

- pool_->OnHostDeterminedCapability(host_, PIPELINE_CAPABLE);

- pool_->OnHostIdle(host_);

- EXPECT_TRUE(pool_->IsKeyEligibleForPipelining(key_));

- host_ = new MockHost(key_);

- EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(key_), _,

- PIPELINE_CAPABLE, false))

- .Times(1)

- .WillOnce(Return(host_));

- CreateDummyStream(key_, kDummyConnection, kDummyStream, host_);

- pool_->OnHostIdle(host_);

-TEST_F(HttpPipelinedHostPoolTest, IncapableIsSticky) {

- EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(key_), _,

- PIPELINE_UNKNOWN, false))

- .Times(1)

- .WillOnce(Return(host_));

- CreateDummyStream(key_, kDummyConnection, kDummyStream, host_);

- pool_->OnHostDeterminedCapability(host_, PIPELINE_CAPABLE);

- pool_->OnHostDeterminedCapability(host_, PIPELINE_INCAPABLE);

- pool_->OnHostDeterminedCapability(host_, PIPELINE_CAPABLE);

- pool_->OnHostIdle(host_);

- EXPECT_FALSE(pool_->IsKeyEligibleForPipelining(key_));

-TEST_F(HttpPipelinedHostPoolTest, RemainsUnknownWithoutFeedback) {

- EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(key_), _,

- PIPELINE_UNKNOWN, false))

- .Times(1)

- .WillOnce(Return(host_));

- CreateDummyStream(key_, kDummyConnection, kDummyStream, host_);

- pool_->OnHostIdle(host_);

- EXPECT_TRUE(pool_->IsKeyEligibleForPipelining(key_));

- host_ = new MockHost(key_);

- EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(key_), _,

- PIPELINE_UNKNOWN, false))

- .Times(1)

- .WillOnce(Return(host_));

- CreateDummyStream(key_, kDummyConnection, kDummyStream, host_);

- pool_->OnHostIdle(host_);

-TEST_F(HttpPipelinedHostPoolTest, PopulatesServerProperties) {

- EXPECT_EQ(PIPELINE_UNKNOWN,

- http_server_properties_->GetPipelineCapability(

- host_->GetKey().origin()));

- pool_->OnHostDeterminedCapability(host_, PIPELINE_CAPABLE);

- EXPECT_EQ(PIPELINE_CAPABLE,

- http_server_properties_->GetPipelineCapability(

- host_->GetKey().origin()));

- delete host_; // Must manually delete, because it's never added to |pool_|.

-TEST_F(HttpPipelinedHostPoolTest, MultipleKeys) {

- HttpPipelinedHost::Key key1(HostPortPair("host", 123));

- HttpPipelinedHost::Key key2(HostPortPair("host", 456));

- HttpPipelinedHost::Key key3(HostPortPair("other", 456));

- HttpPipelinedHost::Key key4(HostPortPair("other", 789));

- MockHost* host1 = CreateDummyHost(key1);

- MockHost* host2 = CreateDummyHost(key2);

- MockHost* host3 = CreateDummyHost(key3);

- EXPECT_CALL(*host1, IsExistingPipelineAvailable())

- .Times(1)

- .WillOnce(Return(true));

- EXPECT_TRUE(pool_->IsExistingPipelineAvailableForKey(key1));

- EXPECT_CALL(*host2, IsExistingPipelineAvailable())

- .Times(1)

- .WillOnce(Return(false));

- EXPECT_FALSE(pool_->IsExistingPipelineAvailableForKey(key2));

- EXPECT_CALL(*host3, IsExistingPipelineAvailable())

- .Times(1)

- .WillOnce(Return(true));

- EXPECT_TRUE(pool_->IsExistingPipelineAvailableForKey(key3));

- EXPECT_FALSE(pool_->IsExistingPipelineAvailableForKey(key4));

- pool_->OnHostIdle(host1);

- pool_->OnHostIdle(host2);

- pool_->OnHostIdle(host3);

- delete host_; // Must manually delete, because it's never added to |pool_|.

-} // anonymous namespace

-} // namespace net

« net/http/http_chunked_decoder.h ('K') | « net/http/http_pipelined_host_pool.cc ('k') | net/http/http_pipelined_host_test_util.h » ('j') | net/http/http_stream.h » ('J')