net/spdy/spdy_network_transaction_unittest.cc - Issue 6684019: Reland rest of r77399.

Unified Diff: net/spdy/spdy_network_transaction_unittest.cc

Issue 6684019: Reland rest of r77399. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src

Patch Set: Created 9 years, 9 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/spdy/spdy_network_transaction_unittest.cc

diff --git a/net/spdy/spdy_network_transaction_unittest.cc b/net/spdy/spdy_network_transaction_unittest.cc

index acfb7eaa246a60beea6dfc62209d93a87a358bcd..9f4e1fef7501b18bcad1071ae90105f16eda0a59 100644

--- a/net/spdy/spdy_network_transaction_unittest.cc

+++ b/net/spdy/spdy_network_transaction_unittest.cc

@@ -11,6 +11,7 @@

#include "net/base/net_log_unittest.h"

#include "net/http/http_network_session_peer.h"

#include "net/http/http_transaction_unittest.h"

+#include "net/socket/client_socket_pool_base.h"

#include "net/spdy/spdy_http_stream.h"

#include "net/spdy/spdy_http_utils.h"

#include "net/spdy/spdy_session.h"

@@ -35,17 +36,25 @@ enum SpdyNetworkTransactionTestTypes {

class SpdyNetworkTransactionTest

: public ::testing::TestWithParam<SpdyNetworkTransactionTestTypes> {

protected:

virtual void SetUp() {

// By default, all tests turn off compression.

EnableCompression(false);

google_get_request_initialized_ = false;

google_post_request_initialized_ = false;

google_chunked_post_request_initialized_ = false;

+ backup_jobs_prev_value_ =

+ internal::ClientSocketPoolBaseHelper::connect_backup_jobs_enabled();

+ internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(

+ false);

}

virtual void TearDown() {

// Empty the current queue.

MessageLoop::current()->RunAllPending();

+ internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(

+ backup_jobs_prev_value_);

}

struct TransactionHelperResult {

@@ -167,10 +176,8 @@ class SpdyNetworkTransactionTest

EXPECT_EQ(spdy_enabled_, response->was_fetched_via_spdy);

if (test_type_ == SPDYNPN && spdy_enabled_) {

EXPECT_TRUE(response->was_npn_negotiated);

- EXPECT_TRUE(response->was_alternate_protocol_available);

} else {

EXPECT_TRUE(!response->was_npn_negotiated);

- EXPECT_TRUE(!response->was_alternate_protocol_available);

}

// If SPDY is not enabled, a HTTP request should not be diverted

// over a SSL session.

@@ -237,9 +244,20 @@ class SpdyNetworkTransactionTest

ssl_->was_npn_negotiated = true;

}

ssl_vector_.push_back(ssl_);

- if(test_type_ == SPDYNPN || test_type_ == SPDYSSL)

+ if (test_type_ == SPDYNPN || test_type_ == SPDYSSL)

session_deps_->socket_factory->AddSSLSocketDataProvider(ssl_.get());

session_deps_->socket_factory->AddSocketDataProvider(data);

+ if (test_type_ == SPDYNPN) {

+ MockConnect never_finishing_connect(false, ERR_IO_PENDING);

+ linked_ptr<StaticSocketDataProvider>

+ hanging_non_alternate_protocol_socket(

+ new StaticSocketDataProvider(NULL, 0, NULL, 0));

+ hanging_non_alternate_protocol_socket->set_connect_data(

+ never_finishing_connect);

+ session_deps_->socket_factory->AddSocketDataProvider(

+ hanging_non_alternate_protocol_socket.get());

+ alternate_vector_.push_back(hanging_non_alternate_protocol_socket);

+ }

}

void AddDeterministicData(DeterministicSocketData* data) {

@@ -253,10 +271,23 @@ class SpdyNetworkTransactionTest

ssl_->was_npn_negotiated = true;

}

ssl_vector_.push_back(ssl_);

- if(test_type_ == SPDYNPN || test_type_ == SPDYSSL)

+ if (test_type_ == SPDYNPN || test_type_ == SPDYSSL) {

session_deps_->deterministic_socket_factory->

AddSSLSocketDataProvider(ssl_.get());

+ }

session_deps_->deterministic_socket_factory->AddSocketDataProvider(data);

+ if (test_type_ == SPDYNPN) {

+ MockConnect never_finishing_connect(false, ERR_IO_PENDING);

+ scoped_refptr<DeterministicSocketData>

+ hanging_non_alternate_protocol_socket(

+ new DeterministicSocketData(NULL, 0, NULL, 0));

+ hanging_non_alternate_protocol_socket->set_connect_data(

+ never_finishing_connect);

+ session_deps_->deterministic_socket_factory->AddSocketDataProvider(

+ hanging_non_alternate_protocol_socket);

+ alternate_deterministic_vector_.push_back(

+ hanging_non_alternate_protocol_socket);

+ }

}

// This can only be called after RunPreTestSetup. It adds a Data Provider,

@@ -289,6 +320,9 @@ class SpdyNetworkTransactionTest

private:

typedef std::vector<StaticSocketDataProvider*> DataVector;

typedef std::vector<linked_ptr<SSLSocketDataProvider> > SSLVector;

+ typedef std::vector<linked_ptr<StaticSocketDataProvider> > AlternateVector;

+ typedef std::vector<scoped_refptr<DeterministicSocketData> >

+ AlternateDeterministicVector;

HttpRequestInfo request_;

scoped_ptr<SpdySessionDependencies> session_deps_;

scoped_refptr<HttpNetworkSession> session_;

@@ -299,6 +333,8 @@ class SpdyNetworkTransactionTest

scoped_ptr<HttpNetworkTransaction> trans_;

scoped_ptr<HttpNetworkTransaction> trans_http_;

DataVector data_vector_;

+ AlternateVector alternate_vector_;

+ AlternateDeterministicVector alternate_deterministic_vector_;

const BoundNetLog& log_;

SpdyNetworkTransactionTestTypes test_type_;

int port_;

@@ -475,6 +511,8 @@ class SpdyNetworkTransactionTest

HttpRequestInfo google_post_request_;

HttpRequestInfo google_chunked_post_request_;

HttpRequestInfo google_get_push_request_;

+ bool backup_jobs_prev_value_;

};

//-----------------------------------------------------------------------------

@@ -704,7 +742,7 @@ TEST_P(SpdyNetworkTransactionTest, TwoGetsLateBinding) {

new OrderedSocketData(reads, arraysize(reads),

writes, arraysize(writes)));

- MockConnect never_finishing_connect(true, ERR_IO_PENDING);

+ MockConnect never_finishing_connect(false, ERR_IO_PENDING);

scoped_refptr<OrderedSocketData> data_placeholder(

new OrderedSocketData(NULL, 0, NULL, 0));

@@ -893,10 +931,12 @@ TEST_P(SpdyNetworkTransactionTest, ThreeGetsWithMaxConcurrent) {

settings.push_back(spdy::SpdySetting(id, max_concurrent_streams));

scoped_ptr<spdy::SpdyFrame> settings_frame(ConstructSpdySettings(settings));

- MockWrite writes[] = { CreateMockWrite(*req),

- CreateMockWrite(*req2),

- CreateMockWrite(*req3),

+ MockWrite writes[] = {

+ CreateMockWrite(*req),

+ CreateMockWrite(*req2),

+ CreateMockWrite(*req3),

};

MockRead reads[] = {

CreateMockRead(*settings_frame, 1),

CreateMockRead(*resp),

@@ -921,14 +961,14 @@ TEST_P(SpdyNetworkTransactionTest, ThreeGetsWithMaxConcurrent) {

BoundNetLog log;

TransactionHelperResult out;

{

- NormalSpdyTransactionHelper helper(CreateGetRequest(),

- BoundNetLog(), GetParam());

- helper.RunPreTestSetup();

- helper.AddData(data.get());

- // We require placeholder data because three get requests are sent out, so

- // there needs to be three sets of SSL connection data.

- helper.AddData(data_placeholder.get());

+ NormalSpdyTransactionHelper helper(CreateGetRequest(),

+ BoundNetLog(), GetParam());

+ helper.RunPreTestSetup();

+ helper.AddData(data.get());

+ // We require placeholder data because three get requests are sent out, so

+ // there needs to be three sets of SSL connection data.

+ helper.AddData(data_placeholder.get());

scoped_ptr<HttpNetworkTransaction> trans1(

new HttpNetworkTransaction(helper.session()));

scoped_ptr<HttpNetworkTransaction> trans2(

@@ -1716,7 +1756,7 @@ TEST_P(SpdyNetworkTransactionTest, SocketWriteReturnsZero) {

scoped_refptr<DeterministicSocketData> data(

new DeterministicSocketData(reads, arraysize(reads),

- writes, arraysize(writes)));

+ writes, arraysize(writes)));

NormalSpdyTransactionHelper helper(CreateGetRequest(),

BoundNetLog(), GetParam());

helper.SetDeterministic();

@@ -3807,80 +3847,6 @@ TEST_P(SpdyNetworkTransactionTest, BufferFull) {

EXPECT_EQ("goodbye world", out.response_data);

}

-TEST_P(SpdyNetworkTransactionTest, ConnectFailureFallbackToHttp) {

- MockConnect connects[] = {

- MockConnect(true, ERR_NAME_NOT_RESOLVED),

- MockConnect(false, ERR_NAME_NOT_RESOLVED),

- MockConnect(true, ERR_INTERNET_DISCONNECTED),

- MockConnect(false, ERR_INTERNET_DISCONNECTED)

- };

- for (size_t index = 0; index < arraysize(connects); ++index) {

- scoped_ptr<spdy::SpdyFrame> req(

- ConstructSpdyGet(NULL, 0, false, 1, LOWEST));

- MockWrite writes[] = {

- CreateMockWrite(*req),

- MockWrite(true, 0, 0) // EOF

- };

- scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));

- scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));

- MockRead reads[] = {

- CreateMockRead(*resp),

- CreateMockRead(*body),

- MockRead(true, 0, 0) // EOF

- };

- scoped_refptr<DelayedSocketData> data(

- new DelayedSocketData(connects[index], 1, reads, arraysize(reads),

- writes, arraysize(writes)));

- NormalSpdyTransactionHelper helper(CreateGetRequest(),

- BoundNetLog(), GetParam());

- helper.RunPreTestSetup();

- helper.AddData(data.get());

- // Set up http fallback data.

- MockRead http_fallback_data[] = {

- MockRead("HTTP/1.1 200 OK\r\n\r\n"),

- MockRead("hello world!!!"),

- MockRead(true, OK),

- };

- scoped_ptr<StaticSocketDataProvider> http_fallback(

- new StaticSocketDataProvider(http_fallback_data,

- arraysize(http_fallback_data),

- NULL, 0));

- helper.AddDataNoSSL(http_fallback.get());

- HttpNetworkTransaction* trans = helper.trans();

- TestCompletionCallback callback;

- int rv = trans->Start(&helper.request(), &callback, BoundNetLog());

- EXPECT_EQ(rv, ERR_IO_PENDING);

- rv = callback.WaitForResult();

- const HttpResponseInfo* response = trans->GetResponseInfo();

- if (GetParam() == SPDYNOSSL || GetParam() == SPDYSSL) {

- ASSERT_TRUE(response == NULL);

- return;

- }

- if (GetParam() != SPDYNPN)

- NOTREACHED();

- ASSERT_TRUE(response != NULL);

- ASSERT_TRUE(response->headers != NULL);

- EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());

- std::string response_data;

- rv = ReadTransaction(trans, &response_data);

- EXPECT_EQ(OK, rv);

- EXPECT_TRUE(!response->was_fetched_via_spdy);

- EXPECT_TRUE(!response->was_npn_negotiated);

- EXPECT_TRUE(response->was_alternate_protocol_available);

- EXPECT_TRUE(http_fallback->at_read_eof());

- EXPECT_EQ(0u, data->read_index());

- EXPECT_EQ(0u, data->write_index());

- EXPECT_EQ("hello world!!!", response_data);

- }

// Verify that basic buffering works; when multiple data frames arrive

// at the same time, ensure that we don't notify a read completion for

// each data frame individually.

« no previous file with comments | « net/socket/client_socket_pool_base.cc ('k') | net/url_request/url_request.h » ('j') | no next file with comments »