| Index: net/http/http_pipelined_connection_impl_unittest.cc
|
| diff --git a/net/http/http_pipelined_connection_impl_unittest.cc b/net/http/http_pipelined_connection_impl_unittest.cc
|
| index 296194ecd63ff8e7ecb17f204670b078f50f5302..0abcfb1a5ec92bda36fd0c062c02879985d403d3 100644
|
| --- a/net/http/http_pipelined_connection_impl_unittest.cc
|
| +++ b/net/http/http_pipelined_connection_impl_unittest.cc
|
| @@ -60,9 +60,9 @@ void TestLoadTimingNotReused(const HttpStream& stream) {
|
| class MockPipelineDelegate : public HttpPipelinedConnection::Delegate {
|
| public:
|
| MOCK_METHOD1(OnPipelineHasCapacity, void(HttpPipelinedConnection* pipeline));
|
| - MOCK_METHOD2(OnPipelineFeedback, void(
|
| - HttpPipelinedConnection* pipeline,
|
| - HttpPipelinedConnection::Feedback feedback));
|
| + MOCK_METHOD2(OnPipelineFeedback,
|
| + void(HttpPipelinedConnection* pipeline,
|
| + HttpPipelinedConnection::Feedback feedback));
|
| };
|
|
|
| class SuddenCloseObserver : public base::MessageLoop::TaskObserver {
|
| @@ -70,7 +70,7 @@ class SuddenCloseObserver : public base::MessageLoop::TaskObserver {
|
| SuddenCloseObserver(HttpStream* stream, int close_before_task)
|
| : stream_(stream),
|
| close_before_task_(close_before_task),
|
| - current_task_(0) { }
|
| + current_task_(0) {}
|
|
|
| virtual void WillProcessTask(const base::PendingTask& pending_task) OVERRIDE {
|
| ++current_task_;
|
| @@ -93,17 +93,16 @@ class HttpPipelinedConnectionImplTest : public testing::Test {
|
| HttpPipelinedConnectionImplTest()
|
| : histograms_("a"),
|
| pool_(1, 1, &histograms_, &factory_),
|
| - origin_("host", 123) {
|
| - }
|
| + origin_("host", 123) {}
|
|
|
| - void TearDown() {
|
| - base::MessageLoop::current()->RunUntilIdle();
|
| - }
|
| + void TearDown() { base::MessageLoop::current()->RunUntilIdle(); }
|
|
|
| - void Initialize(MockRead* reads, size_t reads_count,
|
| - MockWrite* writes, size_t writes_count) {
|
| - data_.reset(new DeterministicSocketData(reads, reads_count,
|
| - writes, writes_count));
|
| + void Initialize(MockRead* reads,
|
| + size_t reads_count,
|
| + MockWrite* writes,
|
| + size_t writes_count) {
|
| + data_.reset(
|
| + new DeterministicSocketData(reads, reads_count, writes, writes_count));
|
| data_->set_connect_data(MockConnect(SYNCHRONOUS, OK));
|
| if (reads_count || writes_count) {
|
| data_->StopAfter(reads_count + writes_count);
|
| @@ -115,11 +114,16 @@ class HttpPipelinedConnectionImplTest : public testing::Test {
|
| // the connection's ID, rather than the pipeline's. Since pipelines are
|
| // destroyed when they've responded to all requests, but the connection
|
| // lives on, this is an important behavior.
|
| - connection->Init("a", params, MEDIUM, CompletionCallback(), &pool_,
|
| - net_log_.bound());
|
| - pipeline_.reset(new HttpPipelinedConnectionImpl(
|
| - connection, &delegate_, origin_, ssl_config_, proxy_info_,
|
| - BoundNetLog(), false, kProtoUnknown));
|
| + connection->Init(
|
| + "a", params, MEDIUM, CompletionCallback(), &pool_, net_log_.bound());
|
| + pipeline_.reset(new HttpPipelinedConnectionImpl(connection,
|
| + &delegate_,
|
| + origin_,
|
| + ssl_config_,
|
| + proxy_info_,
|
| + BoundNetLog(),
|
| + false,
|
| + kProtoUnknown));
|
| }
|
|
|
| HttpRequestInfo* GetRequestInfo(const std::string& filename) {
|
| @@ -140,19 +144,20 @@ class HttpPipelinedConnectionImplTest : public testing::Test {
|
| }
|
|
|
| void ExpectResponse(const std::string& expected,
|
| - scoped_ptr<HttpStream>& stream, bool async) {
|
| + scoped_ptr<HttpStream>& stream,
|
| + bool async) {
|
| scoped_refptr<IOBuffer> buffer(new IOBuffer(expected.size()));
|
|
|
| if (async) {
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| - stream->ReadResponseBody(buffer.get(), expected.size(),
|
| - callback_.callback()));
|
| + stream->ReadResponseBody(
|
| + buffer.get(), expected.size(), callback_.callback()));
|
| data_->RunFor(1);
|
| EXPECT_EQ(static_cast<int>(expected.size()), callback_.WaitForResult());
|
| } else {
|
| EXPECT_EQ(static_cast<int>(expected.size()),
|
| - stream->ReadResponseBody(buffer.get(), expected.size(),
|
| - callback_.callback()));
|
| + stream->ReadResponseBody(
|
| + buffer.get(), expected.size(), callback_.callback()));
|
| }
|
| std::string actual(buffer->data(), expected.size());
|
| EXPECT_THAT(actual, StrEq(expected));
|
| @@ -162,8 +167,8 @@ class HttpPipelinedConnectionImplTest : public testing::Test {
|
| const std::string& filename) {
|
| HttpRequestHeaders headers;
|
| HttpResponseInfo response;
|
| - EXPECT_EQ(OK, stream->SendRequest(headers, &response,
|
| - callback_.callback()));
|
| + EXPECT_EQ(OK,
|
| + stream->SendRequest(headers, &response, callback_.callback()));
|
| EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
|
| ExpectResponse(filename, stream, false);
|
|
|
| @@ -209,12 +214,12 @@ TEST_F(HttpPipelinedConnectionImplTest, StreamBoundButNotUsed) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, SyncSingleRequest) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n\r\n"),
|
| - MockRead(SYNCHRONOUS, 3, "ok.html"),
|
| + MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 3, "ok.html"),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -226,12 +231,12 @@ TEST_F(HttpPipelinedConnectionImplTest, SyncSingleRequest) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, AsyncSingleRequest) {
|
| MockWrite writes[] = {
|
| - MockWrite(ASYNC, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(ASYNC, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(ASYNC, 1, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(ASYNC, 2, "Content-Length: 7\r\n\r\n"),
|
| - MockRead(ASYNC, 3, "ok.html"),
|
| + MockRead(ASYNC, 1, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(ASYNC, 2, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(ASYNC, 3, "ok.html"),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -239,8 +244,8 @@ TEST_F(HttpPipelinedConnectionImplTest, AsyncSingleRequest) {
|
|
|
| HttpRequestHeaders headers;
|
| HttpResponseInfo response;
|
| - EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers, &response,
|
| - callback_.callback()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + stream->SendRequest(headers, &response, callback_.callback()));
|
| data_->RunFor(1);
|
| EXPECT_LE(OK, callback_.WaitForResult());
|
| TestLoadTimingNotReused(*stream);
|
| @@ -258,16 +263,16 @@ TEST_F(HttpPipelinedConnectionImplTest, AsyncSingleRequest) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, LockStepAsyncRequests) {
|
| MockWrite writes[] = {
|
| - MockWrite(ASYNC, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(ASYNC, 1, "GET /ko.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(ASYNC, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(ASYNC, 1, "GET /ko.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(ASYNC, 2, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(ASYNC, 3, "Content-Length: 7\r\n\r\n"),
|
| - MockRead(ASYNC, 4, "ok.html"),
|
| - MockRead(ASYNC, 5, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(ASYNC, 6, "Content-Length: 7\r\n\r\n"),
|
| - MockRead(ASYNC, 7, "ko.html"),
|
| + MockRead(ASYNC, 2, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(ASYNC, 3, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(ASYNC, 4, "ok.html"),
|
| + MockRead(ASYNC, 5, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(ASYNC, 6, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(ASYNC, 7, "ko.html"),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -276,14 +281,14 @@ TEST_F(HttpPipelinedConnectionImplTest, LockStepAsyncRequests) {
|
|
|
| HttpRequestHeaders headers1;
|
| HttpResponseInfo response1;
|
| - EXPECT_EQ(ERR_IO_PENDING, stream1->SendRequest(headers1, &response1,
|
| - callback_.callback()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + stream1->SendRequest(headers1, &response1, callback_.callback()));
|
| TestLoadTimingNotReused(*stream1);
|
|
|
| HttpRequestHeaders headers2;
|
| HttpResponseInfo response2;
|
| - EXPECT_EQ(ERR_IO_PENDING, stream2->SendRequest(headers2, &response2,
|
| - callback_.callback()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + stream2->SendRequest(headers2, &response2, callback_.callback()));
|
| TestLoadTimingReused(*stream2);
|
|
|
| data_->RunFor(1);
|
| @@ -312,24 +317,24 @@ TEST_F(HttpPipelinedConnectionImplTest, LockStepAsyncRequests) {
|
| TestLoadTimingReused(*stream2);
|
| LoadTimingInfo load_timing_info2;
|
| EXPECT_TRUE(stream2->GetLoadTimingInfo(&load_timing_info2));
|
| - EXPECT_EQ(load_timing_info1.socket_log_id,
|
| - load_timing_info2.socket_log_id);
|
| + EXPECT_EQ(load_timing_info1.socket_log_id, load_timing_info2.socket_log_id);
|
| stream2->Close(false);
|
| }
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, TwoResponsesInOnePacket) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 1, "GET /ko.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 1, "GET /ko.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 2,
|
| - "HTTP/1.1 200 OK\r\n"
|
| - "Content-Length: 7\r\n\r\n"
|
| - "ok.html"
|
| - "HTTP/1.1 200 OK\r\n"
|
| - "Content-Length: 7\r\n\r\n"
|
| - "ko.html"),
|
| + MockRead(SYNCHRONOUS,
|
| + 2,
|
| + "HTTP/1.1 200 OK\r\n"
|
| + "Content-Length: 7\r\n\r\n"
|
| + "ok.html"
|
| + "HTTP/1.1 200 OK\r\n"
|
| + "Content-Length: 7\r\n\r\n"
|
| + "ko.html"),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -338,12 +343,12 @@ TEST_F(HttpPipelinedConnectionImplTest, TwoResponsesInOnePacket) {
|
|
|
| HttpRequestHeaders headers1;
|
| HttpResponseInfo response1;
|
| - EXPECT_EQ(OK, stream1->SendRequest(headers1,
|
| - &response1, callback_.callback()));
|
| + EXPECT_EQ(OK,
|
| + stream1->SendRequest(headers1, &response1, callback_.callback()));
|
| HttpRequestHeaders headers2;
|
| HttpResponseInfo response2;
|
| - EXPECT_EQ(OK, stream2->SendRequest(headers2,
|
| - &response2, callback_.callback()));
|
| + EXPECT_EQ(OK,
|
| + stream2->SendRequest(headers2, &response2, callback_.callback()));
|
|
|
| EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
|
| ExpectResponse("ok.html", stream1, false);
|
| @@ -356,16 +361,16 @@ TEST_F(HttpPipelinedConnectionImplTest, TwoResponsesInOnePacket) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, SendOrderSwapped) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /ko.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 4, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /ko.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 4, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n\r\n"),
|
| - MockRead(SYNCHRONOUS, 3, "ko.html"),
|
| - MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(SYNCHRONOUS, 6, "Content-Length: 7\r\n\r\n"),
|
| - MockRead(SYNCHRONOUS, 7, "ok.html"),
|
| + MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 3, "ko.html"),
|
| + MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(SYNCHRONOUS, 6, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 7, "ok.html"),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -380,16 +385,16 @@ TEST_F(HttpPipelinedConnectionImplTest, SendOrderSwapped) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, ReadOrderSwapped) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 1, "GET /ko.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 1, "GET /ko.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"),
|
| - MockRead(SYNCHRONOUS, 4, "ok.html"),
|
| - MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(SYNCHRONOUS, 6, "Content-Length: 7\r\n\r\n"),
|
| - MockRead(SYNCHRONOUS, 7, "ko.html"),
|
| + MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 4, "ok.html"),
|
| + MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(SYNCHRONOUS, 6, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 7, "ko.html"),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -398,13 +403,13 @@ TEST_F(HttpPipelinedConnectionImplTest, ReadOrderSwapped) {
|
|
|
| HttpRequestHeaders headers1;
|
| HttpResponseInfo response1;
|
| - EXPECT_EQ(OK, stream1->SendRequest(headers1,
|
| - &response1, callback_.callback()));
|
| + EXPECT_EQ(OK,
|
| + stream1->SendRequest(headers1, &response1, callback_.callback()));
|
|
|
| HttpRequestHeaders headers2;
|
| HttpResponseInfo response2;
|
| - EXPECT_EQ(OK, stream2->SendRequest(headers2,
|
| - &response2, callback_.callback()));
|
| + EXPECT_EQ(OK,
|
| + stream2->SendRequest(headers2, &response2, callback_.callback()));
|
|
|
| EXPECT_EQ(ERR_IO_PENDING, stream2->ReadResponseHeaders(callback_.callback()));
|
|
|
| @@ -421,16 +426,16 @@ TEST_F(HttpPipelinedConnectionImplTest, ReadOrderSwapped) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, SendWhileReading) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 3, "GET /ko.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 3, "GET /ko.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n\r\n"),
|
| - MockRead(SYNCHRONOUS, 4, "ok.html"),
|
| - MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(SYNCHRONOUS, 6, "Content-Length: 7\r\n\r\n"),
|
| - MockRead(SYNCHRONOUS, 7, "ko.html"),
|
| + MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 4, "ok.html"),
|
| + MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(SYNCHRONOUS, 6, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 7, "ko.html"),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -439,14 +444,14 @@ TEST_F(HttpPipelinedConnectionImplTest, SendWhileReading) {
|
|
|
| HttpRequestHeaders headers1;
|
| HttpResponseInfo response1;
|
| - EXPECT_EQ(OK, stream1->SendRequest(headers1,
|
| - &response1, callback_.callback()));
|
| + EXPECT_EQ(OK,
|
| + stream1->SendRequest(headers1, &response1, callback_.callback()));
|
| EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
|
|
|
| HttpRequestHeaders headers2;
|
| HttpResponseInfo response2;
|
| - EXPECT_EQ(OK, stream2->SendRequest(headers2,
|
| - &response2, callback_.callback()));
|
| + EXPECT_EQ(OK,
|
| + stream2->SendRequest(headers2, &response2, callback_.callback()));
|
|
|
| ExpectResponse("ok.html", stream1, false);
|
| stream1->Close(false);
|
| @@ -458,16 +463,16 @@ TEST_F(HttpPipelinedConnectionImplTest, SendWhileReading) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, AsyncSendWhileAsyncReadBlocked) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(ASYNC, 3, "GET /ko.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(ASYNC, 3, "GET /ko.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n\r\n"),
|
| - MockRead(ASYNC, 4, "ok.html"),
|
| - MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(SYNCHRONOUS, 6, "Content-Length: 7\r\n\r\n"),
|
| - MockRead(SYNCHRONOUS, 7, "ko.html"),
|
| + MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(ASYNC, 4, "ok.html"),
|
| + MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(SYNCHRONOUS, 6, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 7, "ko.html"),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -476,21 +481,21 @@ TEST_F(HttpPipelinedConnectionImplTest, AsyncSendWhileAsyncReadBlocked) {
|
|
|
| HttpRequestHeaders headers1;
|
| HttpResponseInfo response1;
|
| - EXPECT_EQ(OK, stream1->SendRequest(headers1,
|
| - &response1, callback_.callback()));
|
| + EXPECT_EQ(OK,
|
| + stream1->SendRequest(headers1, &response1, callback_.callback()));
|
| EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
|
| TestCompletionCallback callback1;
|
| std::string expected = "ok.html";
|
| scoped_refptr<IOBuffer> buffer(new IOBuffer(expected.size()));
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| - stream1->ReadResponseBody(buffer.get(), expected.size(),
|
| - callback1.callback()));
|
| + stream1->ReadResponseBody(
|
| + buffer.get(), expected.size(), callback1.callback()));
|
|
|
| HttpRequestHeaders headers2;
|
| HttpResponseInfo response2;
|
| TestCompletionCallback callback2;
|
| - EXPECT_EQ(ERR_IO_PENDING, stream2->SendRequest(headers2, &response2,
|
| - callback2.callback()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + stream2->SendRequest(headers2, &response2, callback2.callback()));
|
|
|
| data_->RunFor(1);
|
| EXPECT_LE(OK, callback2.WaitForResult());
|
| @@ -510,12 +515,12 @@ TEST_F(HttpPipelinedConnectionImplTest, AsyncSendWhileAsyncReadBlocked) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, UnusedStreamAllowsLaterUse) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n\r\n"),
|
| - MockRead(SYNCHRONOUS, 3, "ok.html"),
|
| + MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 3, "ok.html"),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -528,16 +533,16 @@ TEST_F(HttpPipelinedConnectionImplTest, UnusedStreamAllowsLaterUse) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, UnsentStreamAllowsLaterUse) {
|
| MockWrite writes[] = {
|
| - MockWrite(ASYNC, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 4, "GET /ko.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(ASYNC, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 4, "GET /ko.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(ASYNC, 1, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(ASYNC, 2, "Content-Length: 7\r\n\r\n"),
|
| - MockRead(ASYNC, 3, "ok.html"),
|
| - MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(SYNCHRONOUS, 6, "Content-Length: 7\r\n\r\n"),
|
| - MockRead(SYNCHRONOUS, 7, "ko.html"),
|
| + MockRead(ASYNC, 1, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(ASYNC, 2, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(ASYNC, 3, "ok.html"),
|
| + MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(SYNCHRONOUS, 6, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 7, "ko.html"),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -545,15 +550,15 @@ TEST_F(HttpPipelinedConnectionImplTest, UnsentStreamAllowsLaterUse) {
|
|
|
| HttpRequestHeaders headers;
|
| HttpResponseInfo response;
|
| - EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers, &response,
|
| - callback_.callback()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + stream->SendRequest(headers, &response, callback_.callback()));
|
|
|
| scoped_ptr<HttpStream> unsent_stream(NewTestStream("unsent.html"));
|
| HttpRequestHeaders unsent_headers;
|
| HttpResponseInfo unsent_response;
|
| - EXPECT_EQ(ERR_IO_PENDING, unsent_stream->SendRequest(unsent_headers,
|
| - &unsent_response,
|
| - callback_.callback()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + unsent_stream->SendRequest(
|
| + unsent_headers, &unsent_response, callback_.callback()));
|
| unsent_stream->Close(false);
|
|
|
| data_->RunFor(1);
|
| @@ -574,7 +579,7 @@ TEST_F(HttpPipelinedConnectionImplTest, UnsentStreamAllowsLaterUse) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, FailedSend) {
|
| MockWrite writes[] = {
|
| - MockWrite(ASYNC, ERR_FAILED),
|
| + MockWrite(ASYNC, ERR_FAILED),
|
| };
|
| Initialize(NULL, 0, writes, arraysize(writes));
|
|
|
| @@ -587,22 +592,23 @@ TEST_F(HttpPipelinedConnectionImplTest, FailedSend) {
|
| HttpResponseInfo response;
|
| TestCompletionCallback failed_callback;
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| - failed_stream->SendRequest(headers, &response,
|
| - failed_callback.callback()));
|
| + failed_stream->SendRequest(
|
| + headers, &response, failed_callback.callback()));
|
| TestCompletionCallback evicted_callback;
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| - evicted_stream->SendRequest(headers, &response,
|
| - evicted_callback.callback()));
|
| - EXPECT_EQ(ERR_IO_PENDING, closed_stream->SendRequest(headers, &response,
|
| - callback_.callback()));
|
| + evicted_stream->SendRequest(
|
| + headers, &response, evicted_callback.callback()));
|
| + EXPECT_EQ(
|
| + ERR_IO_PENDING,
|
| + closed_stream->SendRequest(headers, &response, callback_.callback()));
|
| closed_stream->Close(false);
|
|
|
| data_->RunFor(1);
|
| EXPECT_EQ(ERR_FAILED, failed_callback.WaitForResult());
|
| EXPECT_EQ(ERR_PIPELINE_EVICTION, evicted_callback.WaitForResult());
|
| - EXPECT_EQ(ERR_PIPELINE_EVICTION,
|
| - rejected_stream->SendRequest(headers, &response,
|
| - callback_.callback()));
|
| + EXPECT_EQ(
|
| + ERR_PIPELINE_EVICTION,
|
| + rejected_stream->SendRequest(headers, &response, callback_.callback()));
|
|
|
| failed_stream->Close(true);
|
| evicted_stream->Close(true);
|
| @@ -611,16 +617,17 @@ TEST_F(HttpPipelinedConnectionImplTest, FailedSend) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, ConnectionSuddenlyClosedAfterResponse) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 1, "GET /read_evicted.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 2, "GET /read_rejected.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(ASYNC, ERR_SOCKET_NOT_CONNECTED, 5),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 1, "GET /read_evicted.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 2, "GET /read_rejected.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(ASYNC, ERR_SOCKET_NOT_CONNECTED, 5),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n\r\n"),
|
| - MockRead(SYNCHRONOUS, 4, "ok.html"),
|
| - MockRead(ASYNC, OK, 6), // Connection closed message. Not read before the
|
| - // ERR_SOCKET_NOT_CONNECTED.
|
| + MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 4, "ok.html"),
|
| + MockRead(
|
| + ASYNC, OK, 6), // Connection closed message. Not read before the
|
| + // ERR_SOCKET_NOT_CONNECTED.
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -629,8 +636,7 @@ TEST_F(HttpPipelinedConnectionImplTest, ConnectionSuddenlyClosedAfterResponse) {
|
| NewTestStream("read_evicted.html"));
|
| scoped_ptr<HttpStream> read_rejected_stream(
|
| NewTestStream("read_rejected.html"));
|
| - scoped_ptr<HttpStream> send_closed_stream(
|
| - NewTestStream("send_closed.html"));
|
| + scoped_ptr<HttpStream> send_closed_stream(NewTestStream("send_closed.html"));
|
| scoped_ptr<HttpStream> send_evicted_stream(
|
| NewTestStream("send_evicted.html"));
|
| scoped_ptr<HttpStream> send_rejected_stream(
|
| @@ -638,20 +644,22 @@ TEST_F(HttpPipelinedConnectionImplTest, ConnectionSuddenlyClosedAfterResponse) {
|
|
|
| HttpRequestHeaders headers;
|
| HttpResponseInfo response;
|
| - EXPECT_EQ(OK, closed_stream->SendRequest(headers,
|
| - &response, callback_.callback()));
|
| - EXPECT_EQ(OK, read_evicted_stream->SendRequest(headers, &response,
|
| - callback_.callback()));
|
| - EXPECT_EQ(OK, read_rejected_stream->SendRequest(headers, &response,
|
| - callback_.callback()));
|
| + EXPECT_EQ(
|
| + OK, closed_stream->SendRequest(headers, &response, callback_.callback()));
|
| + EXPECT_EQ(OK,
|
| + read_evicted_stream->SendRequest(
|
| + headers, &response, callback_.callback()));
|
| + EXPECT_EQ(OK,
|
| + read_rejected_stream->SendRequest(
|
| + headers, &response, callback_.callback()));
|
| TestCompletionCallback send_closed_callback;
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| - send_closed_stream->SendRequest(headers, &response,
|
| - send_closed_callback.callback()));
|
| + send_closed_stream->SendRequest(
|
| + headers, &response, send_closed_callback.callback()));
|
| TestCompletionCallback send_evicted_callback;
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| - send_evicted_stream->SendRequest(headers, &response,
|
| - send_evicted_callback.callback()));
|
| + send_evicted_stream->SendRequest(
|
| + headers, &response, send_evicted_callback.callback()));
|
|
|
| TestCompletionCallback read_evicted_callback;
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| @@ -677,14 +685,14 @@ TEST_F(HttpPipelinedConnectionImplTest, ConnectionSuddenlyClosedAfterResponse) {
|
| send_evicted_stream->Close(true);
|
|
|
| EXPECT_EQ(ERR_PIPELINE_EVICTION,
|
| - send_rejected_stream->SendRequest(headers, &response,
|
| - callback_.callback()));
|
| + send_rejected_stream->SendRequest(
|
| + headers, &response, callback_.callback()));
|
| send_rejected_stream->Close(true);
|
| }
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, AbortWhileSending) {
|
| MockWrite writes[] = {
|
| - MockWrite(ASYNC, 0, "GET /aborts.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(ASYNC, 0, "GET /aborts.html HTTP/1.1\r\n\r\n"),
|
| };
|
| Initialize(NULL, 0, writes, arraysize(writes));
|
|
|
| @@ -695,12 +703,12 @@ TEST_F(HttpPipelinedConnectionImplTest, AbortWhileSending) {
|
| HttpResponseInfo response;
|
| TestCompletionCallback aborted_callback;
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| - aborted_stream->SendRequest(headers, &response,
|
| - aborted_callback.callback()));
|
| + aborted_stream->SendRequest(
|
| + headers, &response, aborted_callback.callback()));
|
| TestCompletionCallback evicted_callback;
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| - evicted_stream->SendRequest(headers, &response,
|
| - evicted_callback.callback()));
|
| + evicted_stream->SendRequest(
|
| + headers, &response, evicted_callback.callback()));
|
|
|
| aborted_stream->Close(true);
|
| EXPECT_EQ(ERR_PIPELINE_EVICTION, evicted_callback.WaitForResult());
|
| @@ -710,8 +718,8 @@ TEST_F(HttpPipelinedConnectionImplTest, AbortWhileSending) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, AbortWhileSendingSecondRequest) {
|
| MockWrite writes[] = {
|
| - MockWrite(ASYNC, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(ASYNC, 1, "GET /aborts.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(ASYNC, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(ASYNC, 1, "GET /aborts.html HTTP/1.1\r\n\r\n"),
|
| };
|
| Initialize(NULL, 0, writes, arraysize(writes));
|
|
|
| @@ -722,16 +730,16 @@ TEST_F(HttpPipelinedConnectionImplTest, AbortWhileSendingSecondRequest) {
|
| HttpRequestHeaders headers;
|
| HttpResponseInfo response;
|
| TestCompletionCallback ok_callback;
|
| - EXPECT_EQ(ERR_IO_PENDING, ok_stream->SendRequest(headers, &response,
|
| - ok_callback.callback()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + ok_stream->SendRequest(headers, &response, ok_callback.callback()));
|
| TestCompletionCallback aborted_callback;
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| - aborted_stream->SendRequest(headers, &response,
|
| - aborted_callback.callback()));
|
| + aborted_stream->SendRequest(
|
| + headers, &response, aborted_callback.callback()));
|
| TestCompletionCallback evicted_callback;
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| - evicted_stream->SendRequest(headers, &response,
|
| - evicted_callback.callback()));
|
| + evicted_stream->SendRequest(
|
| + headers, &response, evicted_callback.callback()));
|
|
|
| data_->RunFor(1);
|
| EXPECT_LE(OK, ok_callback.WaitForResult());
|
| @@ -745,11 +753,11 @@ TEST_F(HttpPipelinedConnectionImplTest, AbortWhileSendingSecondRequest) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, AbortWhileReadingHeaders) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /aborts.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /aborts.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(ASYNC, ERR_FAILED, 2),
|
| + MockRead(ASYNC, ERR_FAILED, 2),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -759,12 +767,12 @@ TEST_F(HttpPipelinedConnectionImplTest, AbortWhileReadingHeaders) {
|
|
|
| HttpRequestHeaders headers;
|
| HttpResponseInfo response;
|
| - EXPECT_EQ(OK,
|
| - aborted_stream->SendRequest(headers, &response,
|
| - callback_.callback()));
|
| - EXPECT_EQ(OK,
|
| - evicted_stream->SendRequest(headers, &response,
|
| - callback_.callback()));
|
| + EXPECT_EQ(
|
| + OK,
|
| + aborted_stream->SendRequest(headers, &response, callback_.callback()));
|
| + EXPECT_EQ(
|
| + OK,
|
| + evicted_stream->SendRequest(headers, &response, callback_.callback()));
|
|
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| aborted_stream->ReadResponseHeaders(callback_.callback()));
|
| @@ -776,22 +784,22 @@ TEST_F(HttpPipelinedConnectionImplTest, AbortWhileReadingHeaders) {
|
| EXPECT_EQ(ERR_PIPELINE_EVICTION, evicted_callback.WaitForResult());
|
| evicted_stream->Close(true);
|
|
|
| - EXPECT_EQ(ERR_PIPELINE_EVICTION,
|
| - rejected_stream->SendRequest(headers, &response,
|
| - callback_.callback()));
|
| + EXPECT_EQ(
|
| + ERR_PIPELINE_EVICTION,
|
| + rejected_stream->SendRequest(headers, &response, callback_.callback()));
|
| rejected_stream->Close(true);
|
| }
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, PendingResponseAbandoned) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 1, "GET /abandoned.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 2, "GET /evicted.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 1, "GET /abandoned.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 2, "GET /evicted.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(SYNCHRONOUS, 4, "Content-Length: 7\r\n\r\n"),
|
| - MockRead(SYNCHRONOUS, 5, "ok.html"),
|
| + MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(SYNCHRONOUS, 4, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 5, "ok.html"),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -801,17 +809,20 @@ TEST_F(HttpPipelinedConnectionImplTest, PendingResponseAbandoned) {
|
|
|
| HttpRequestHeaders headers;
|
| HttpResponseInfo response;
|
| - EXPECT_EQ(OK, ok_stream->SendRequest(headers, &response,
|
| - callback_.callback()));
|
| - EXPECT_EQ(OK, abandoned_stream->SendRequest(headers, &response,
|
| - callback_.callback()));
|
| - EXPECT_EQ(OK, evicted_stream->SendRequest(headers, &response,
|
| - callback_.callback()));
|
| + EXPECT_EQ(OK,
|
| + ok_stream->SendRequest(headers, &response, callback_.callback()));
|
| + EXPECT_EQ(
|
| + OK,
|
| + abandoned_stream->SendRequest(headers, &response, callback_.callback()));
|
| + EXPECT_EQ(
|
| + OK,
|
| + evicted_stream->SendRequest(headers, &response, callback_.callback()));
|
|
|
| EXPECT_EQ(OK, ok_stream->ReadResponseHeaders(callback_.callback()));
|
| TestCompletionCallback abandoned_callback;
|
| - EXPECT_EQ(ERR_IO_PENDING, abandoned_stream->ReadResponseHeaders(
|
| - abandoned_callback.callback()));
|
| + EXPECT_EQ(
|
| + ERR_IO_PENDING,
|
| + abandoned_stream->ReadResponseHeaders(abandoned_callback.callback()));
|
| TestCompletionCallback evicted_callback;
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| evicted_stream->ReadResponseHeaders(evicted_callback.callback()));
|
| @@ -828,16 +839,16 @@ TEST_F(HttpPipelinedConnectionImplTest, PendingResponseAbandoned) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, DisconnectedAfterOneRequestRecovery) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 1, "GET /rejected.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(ASYNC, ERR_SOCKET_NOT_CONNECTED, 5),
|
| - MockWrite(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 7),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 1, "GET /rejected.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(ASYNC, ERR_SOCKET_NOT_CONNECTED, 5),
|
| + MockWrite(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 7),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"),
|
| - MockRead(SYNCHRONOUS, 4, "ok.html"),
|
| - MockRead(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 6),
|
| + MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 4, "ok.html"),
|
| + MockRead(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 6),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -848,10 +859,11 @@ TEST_F(HttpPipelinedConnectionImplTest, DisconnectedAfterOneRequestRecovery) {
|
|
|
| HttpRequestHeaders headers;
|
| HttpResponseInfo response;
|
| - EXPECT_EQ(OK, ok_stream->SendRequest(headers,
|
| - &response, callback_.callback()));
|
| - EXPECT_EQ(OK, rejected_read_stream->SendRequest(headers, &response,
|
| - callback_.callback()));
|
| + EXPECT_EQ(OK,
|
| + ok_stream->SendRequest(headers, &response, callback_.callback()));
|
| + EXPECT_EQ(OK,
|
| + rejected_read_stream->SendRequest(
|
| + headers, &response, callback_.callback()));
|
|
|
| EXPECT_EQ(OK, ok_stream->ReadResponseHeaders(callback_.callback()));
|
| ExpectResponse("ok.html", ok_stream, false);
|
| @@ -859,16 +871,16 @@ TEST_F(HttpPipelinedConnectionImplTest, DisconnectedAfterOneRequestRecovery) {
|
|
|
| TestCompletionCallback read_callback;
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| - evicted_send_stream->SendRequest(headers, &response,
|
| - read_callback.callback()));
|
| + evicted_send_stream->SendRequest(
|
| + headers, &response, read_callback.callback()));
|
| data_->RunFor(1);
|
| EXPECT_EQ(ERR_PIPELINE_EVICTION, read_callback.WaitForResult());
|
|
|
| EXPECT_EQ(ERR_PIPELINE_EVICTION,
|
| rejected_read_stream->ReadResponseHeaders(callback_.callback()));
|
| EXPECT_EQ(ERR_PIPELINE_EVICTION,
|
| - rejected_send_stream->SendRequest(headers, &response,
|
| - callback_.callback()));
|
| + rejected_send_stream->SendRequest(
|
| + headers, &response, callback_.callback()));
|
|
|
| rejected_read_stream->Close(true);
|
| rejected_send_stream->Close(true);
|
| @@ -876,14 +888,14 @@ TEST_F(HttpPipelinedConnectionImplTest, DisconnectedAfterOneRequestRecovery) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, DisconnectedPendingReadRecovery) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"),
|
| - MockRead(SYNCHRONOUS, 4, "ok.html"),
|
| - MockRead(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 5),
|
| + MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 4, "ok.html"),
|
| + MockRead(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 5),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -892,10 +904,11 @@ TEST_F(HttpPipelinedConnectionImplTest, DisconnectedPendingReadRecovery) {
|
|
|
| HttpRequestHeaders headers;
|
| HttpResponseInfo response;
|
| - EXPECT_EQ(OK, ok_stream->SendRequest(headers,
|
| - &response, callback_.callback()));
|
| - EXPECT_EQ(OK, evicted_stream->SendRequest(headers, &response,
|
| - callback_.callback()));
|
| + EXPECT_EQ(OK,
|
| + ok_stream->SendRequest(headers, &response, callback_.callback()));
|
| + EXPECT_EQ(
|
| + OK,
|
| + evicted_stream->SendRequest(headers, &response, callback_.callback()));
|
|
|
| EXPECT_EQ(OK, ok_stream->ReadResponseHeaders(callback_.callback()));
|
| ExpectResponse("ok.html", ok_stream, false);
|
| @@ -912,14 +925,14 @@ TEST_F(HttpPipelinedConnectionImplTest, DisconnectedPendingReadRecovery) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, CloseCalledBeforeNextReadLoop) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"),
|
| - MockRead(SYNCHRONOUS, 4, "ok.html"),
|
| - MockRead(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 5),
|
| + MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 4, "ok.html"),
|
| + MockRead(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 5),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -928,10 +941,11 @@ TEST_F(HttpPipelinedConnectionImplTest, CloseCalledBeforeNextReadLoop) {
|
|
|
| HttpRequestHeaders headers;
|
| HttpResponseInfo response;
|
| - EXPECT_EQ(OK, ok_stream->SendRequest(headers,
|
| - &response, callback_.callback()));
|
| - EXPECT_EQ(OK, evicted_stream->SendRequest(headers, &response,
|
| - callback_.callback()));
|
| + EXPECT_EQ(OK,
|
| + ok_stream->SendRequest(headers, &response, callback_.callback()));
|
| + EXPECT_EQ(
|
| + OK,
|
| + evicted_stream->SendRequest(headers, &response, callback_.callback()));
|
|
|
| EXPECT_EQ(OK, ok_stream->ReadResponseHeaders(callback_.callback()));
|
| ExpectResponse("ok.html", ok_stream, false);
|
| @@ -946,14 +960,14 @@ TEST_F(HttpPipelinedConnectionImplTest, CloseCalledBeforeNextReadLoop) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, CloseCalledBeforeReadCallback) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"),
|
| - MockRead(SYNCHRONOUS, 4, "ok.html"),
|
| - MockRead(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 5),
|
| + MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 4, "ok.html"),
|
| + MockRead(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 5),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -962,10 +976,11 @@ TEST_F(HttpPipelinedConnectionImplTest, CloseCalledBeforeReadCallback) {
|
|
|
| HttpRequestHeaders headers;
|
| HttpResponseInfo response;
|
| - EXPECT_EQ(OK, ok_stream->SendRequest(headers,
|
| - &response, callback_.callback()));
|
| - EXPECT_EQ(OK, evicted_stream->SendRequest(headers, &response,
|
| - callback_.callback()));
|
| + EXPECT_EQ(OK,
|
| + ok_stream->SendRequest(headers, &response, callback_.callback()));
|
| + EXPECT_EQ(
|
| + OK,
|
| + evicted_stream->SendRequest(headers, &response, callback_.callback()));
|
|
|
| EXPECT_EQ(OK, ok_stream->ReadResponseHeaders(callback_.callback()));
|
| ExpectResponse("ok.html", ok_stream, false);
|
| @@ -989,13 +1004,10 @@ class StreamDeleter {
|
| public:
|
| StreamDeleter(HttpStream* stream)
|
| : stream_(stream),
|
| - callback_(base::Bind(&StreamDeleter::OnIOComplete,
|
| - base::Unretained(this))) {
|
| - }
|
| + callback_(
|
| + base::Bind(&StreamDeleter::OnIOComplete, base::Unretained(this))) {}
|
|
|
| - ~StreamDeleter() {
|
| - EXPECT_FALSE(stream_);
|
| - }
|
| + ~StreamDeleter() { EXPECT_FALSE(stream_); }
|
|
|
| const CompletionCallback& callback() { return callback_; }
|
|
|
| @@ -1011,7 +1023,7 @@ class StreamDeleter {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, CloseCalledDuringSendCallback) {
|
| MockWrite writes[] = {
|
| - MockWrite(ASYNC, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(ASYNC, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| };
|
| Initialize(NULL, 0, writes, arraysize(writes));
|
|
|
| @@ -1020,18 +1032,18 @@ TEST_F(HttpPipelinedConnectionImplTest, CloseCalledDuringSendCallback) {
|
| StreamDeleter deleter(stream);
|
| HttpRequestHeaders headers;
|
| HttpResponseInfo response;
|
| - EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers, &response,
|
| - deleter.callback()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + stream->SendRequest(headers, &response, deleter.callback()));
|
| data_->RunFor(1);
|
| }
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, CloseCalledDuringReadCallback) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(ASYNC, 2, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(ASYNC, 2, "Content-Length: 7\r\n\r\n"),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -1039,8 +1051,7 @@ TEST_F(HttpPipelinedConnectionImplTest, CloseCalledDuringReadCallback) {
|
|
|
| HttpRequestHeaders headers;
|
| HttpResponseInfo response;
|
| - EXPECT_EQ(OK, stream->SendRequest(headers,
|
| - &response, callback_.callback()));
|
| + EXPECT_EQ(OK, stream->SendRequest(headers, &response, callback_.callback()));
|
|
|
| StreamDeleter deleter(stream);
|
| EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(deleter.callback()));
|
| @@ -1050,12 +1061,12 @@ TEST_F(HttpPipelinedConnectionImplTest, CloseCalledDuringReadCallback) {
|
| TEST_F(HttpPipelinedConnectionImplTest,
|
| CloseCalledDuringReadCallbackWithPendingRead) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /failed.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /failed.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(ASYNC, 3, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(ASYNC, 3, "Content-Length: 7\r\n\r\n"),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -1064,10 +1075,11 @@ TEST_F(HttpPipelinedConnectionImplTest,
|
|
|
| HttpRequestHeaders headers;
|
| HttpResponseInfo response;
|
| - EXPECT_EQ(OK, failed_stream->SendRequest(headers, &response,
|
| - callback_.callback()));
|
| - EXPECT_EQ(OK, evicted_stream->SendRequest(headers, &response,
|
| - callback_.callback()));
|
| + EXPECT_EQ(
|
| + OK, failed_stream->SendRequest(headers, &response, callback_.callback()));
|
| + EXPECT_EQ(
|
| + OK,
|
| + evicted_stream->SendRequest(headers, &response, callback_.callback()));
|
|
|
| StreamDeleter failed_deleter(failed_stream);
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| @@ -1080,12 +1092,12 @@ TEST_F(HttpPipelinedConnectionImplTest,
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, CloseOtherDuringReadCallback) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /deleter.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 1, "GET /deleted.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /deleter.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 1, "GET /deleted.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(ASYNC, 3, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 2, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(ASYNC, 3, "Content-Length: 7\r\n\r\n"),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -1094,10 +1106,12 @@ TEST_F(HttpPipelinedConnectionImplTest, CloseOtherDuringReadCallback) {
|
|
|
| HttpRequestHeaders headers;
|
| HttpResponseInfo response;
|
| - EXPECT_EQ(OK, deleter_stream->SendRequest(headers,
|
| - &response, callback_.callback()));
|
| - EXPECT_EQ(OK, deleted_stream->SendRequest(headers,
|
| - &response, callback_.callback()));
|
| + EXPECT_EQ(
|
| + OK,
|
| + deleter_stream->SendRequest(headers, &response, callback_.callback()));
|
| + EXPECT_EQ(
|
| + OK,
|
| + deleted_stream->SendRequest(headers, &response, callback_.callback()));
|
|
|
| StreamDeleter deleter(deleted_stream);
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| @@ -1109,21 +1123,20 @@ TEST_F(HttpPipelinedConnectionImplTest, CloseOtherDuringReadCallback) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, CloseBeforeSendCallbackRuns) {
|
| MockWrite writes[] = {
|
| - MockWrite(ASYNC, 0, "GET /close.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(ASYNC, 1, "GET /dummy.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(ASYNC, 0, "GET /close.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(ASYNC, 1, "GET /dummy.html HTTP/1.1\r\n\r\n"),
|
| };
|
| Initialize(NULL, 0, writes, arraysize(writes));
|
|
|
| scoped_ptr<HttpStream> close_stream(NewTestStream("close.html"));
|
| scoped_ptr<HttpStream> dummy_stream(NewTestStream("dummy.html"));
|
|
|
| - scoped_ptr<TestCompletionCallback> close_callback(
|
| - new TestCompletionCallback);
|
| + scoped_ptr<TestCompletionCallback> close_callback(new TestCompletionCallback);
|
| HttpRequestHeaders headers;
|
| HttpResponseInfo response;
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| - close_stream->SendRequest(headers,
|
| - &response, close_callback->callback()));
|
| + close_stream->SendRequest(
|
| + headers, &response, close_callback->callback()));
|
|
|
| data_->RunFor(1);
|
| EXPECT_FALSE(close_callback->have_result());
|
| @@ -1137,12 +1150,12 @@ TEST_F(HttpPipelinedConnectionImplTest, CloseBeforeSendCallbackRuns) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, CloseBeforeReadCallbackRuns) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /close.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 3, "GET /dummy.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /close.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 3, "GET /dummy.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(ASYNC, 2, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(ASYNC, 2, "Content-Length: 7\r\n\r\n"),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -1151,11 +1164,10 @@ TEST_F(HttpPipelinedConnectionImplTest, CloseBeforeReadCallbackRuns) {
|
|
|
| HttpRequestHeaders headers;
|
| HttpResponseInfo response;
|
| - EXPECT_EQ(OK, close_stream->SendRequest(headers,
|
| - &response, callback_.callback()));
|
| + EXPECT_EQ(
|
| + OK, close_stream->SendRequest(headers, &response, callback_.callback()));
|
|
|
| - scoped_ptr<TestCompletionCallback> close_callback(
|
| - new TestCompletionCallback);
|
| + scoped_ptr<TestCompletionCallback> close_callback(new TestCompletionCallback);
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| close_stream->ReadResponseHeaders(close_callback->callback()));
|
|
|
| @@ -1171,8 +1183,8 @@ TEST_F(HttpPipelinedConnectionImplTest, CloseBeforeReadCallbackRuns) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, AbortWhileSendQueued) {
|
| MockWrite writes[] = {
|
| - MockWrite(ASYNC, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(ASYNC, 1, "GET /ko.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(ASYNC, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(ASYNC, 1, "GET /ko.html HTTP/1.1\r\n\r\n"),
|
| };
|
| Initialize(NULL, 0, writes, arraysize(writes));
|
|
|
| @@ -1182,14 +1194,14 @@ TEST_F(HttpPipelinedConnectionImplTest, AbortWhileSendQueued) {
|
| HttpRequestHeaders headers1;
|
| HttpResponseInfo response1;
|
| TestCompletionCallback callback1;
|
| - EXPECT_EQ(ERR_IO_PENDING, stream1->SendRequest(headers1, &response1,
|
| - callback1.callback()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + stream1->SendRequest(headers1, &response1, callback1.callback()));
|
|
|
| HttpRequestHeaders headers2;
|
| HttpResponseInfo response2;
|
| TestCompletionCallback callback2;
|
| - EXPECT_EQ(ERR_IO_PENDING, stream2->SendRequest(headers2, &response2,
|
| - callback2.callback()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + stream2->SendRequest(headers2, &response2, callback2.callback()));
|
|
|
| stream2.reset();
|
| stream1->Close(true);
|
| @@ -1199,12 +1211,12 @@ TEST_F(HttpPipelinedConnectionImplTest, AbortWhileSendQueued) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, NoGapBetweenCloseAndEviction) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /close.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 2, "GET /dummy.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /close.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 2, "GET /dummy.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(ASYNC, 3, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(ASYNC, 3, "Content-Length: 7\r\n\r\n"),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -1213,15 +1225,15 @@ TEST_F(HttpPipelinedConnectionImplTest, NoGapBetweenCloseAndEviction) {
|
|
|
| HttpRequestHeaders headers;
|
| HttpResponseInfo response;
|
| - EXPECT_EQ(OK, close_stream->SendRequest(headers, &response,
|
| - callback_.callback()));
|
| + EXPECT_EQ(
|
| + OK, close_stream->SendRequest(headers, &response, callback_.callback()));
|
|
|
| TestCompletionCallback close_callback;
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| close_stream->ReadResponseHeaders(close_callback.callback()));
|
|
|
| - EXPECT_EQ(OK, dummy_stream->SendRequest(headers, &response,
|
| - callback_.callback()));
|
| + EXPECT_EQ(
|
| + OK, dummy_stream->SendRequest(headers, &response, callback_.callback()));
|
|
|
| TestCompletionCallback dummy_callback;
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| @@ -1239,18 +1251,20 @@ TEST_F(HttpPipelinedConnectionImplTest, NoGapBetweenCloseAndEviction) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, RecoverFromDrainOnRedirect) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /redirect.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 1, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /redirect.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 1, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 2,
|
| - "HTTP/1.1 302 OK\r\n"
|
| - "Content-Length: 8\r\n\r\n"
|
| - "redirect"),
|
| - MockRead(SYNCHRONOUS, 3,
|
| - "HTTP/1.1 200 OK\r\n"
|
| - "Content-Length: 7\r\n\r\n"
|
| - "ok.html"),
|
| + MockRead(SYNCHRONOUS,
|
| + 2,
|
| + "HTTP/1.1 302 OK\r\n"
|
| + "Content-Length: 8\r\n\r\n"
|
| + "redirect"),
|
| + MockRead(SYNCHRONOUS,
|
| + 3,
|
| + "HTTP/1.1 200 OK\r\n"
|
| + "Content-Length: 7\r\n\r\n"
|
| + "ok.html"),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -1259,12 +1273,12 @@ TEST_F(HttpPipelinedConnectionImplTest, RecoverFromDrainOnRedirect) {
|
|
|
| HttpRequestHeaders headers1;
|
| HttpResponseInfo response1;
|
| - EXPECT_EQ(OK, stream1->SendRequest(headers1,
|
| - &response1, callback_.callback()));
|
| + EXPECT_EQ(OK,
|
| + stream1->SendRequest(headers1, &response1, callback_.callback()));
|
| HttpRequestHeaders headers2;
|
| HttpResponseInfo response2;
|
| - EXPECT_EQ(OK, stream2->SendRequest(headers2,
|
| - &response2, callback_.callback()));
|
| + EXPECT_EQ(OK,
|
| + stream2->SendRequest(headers2, &response2, callback_.callback()));
|
|
|
| EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
|
| stream1.release()->Drain(NULL);
|
| @@ -1276,13 +1290,14 @@ TEST_F(HttpPipelinedConnectionImplTest, RecoverFromDrainOnRedirect) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, EvictAfterDrainOfUnknownSize) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /redirect.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 1, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /redirect.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 1, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 2,
|
| - "HTTP/1.1 302 OK\r\n\r\n"
|
| - "redirect"),
|
| + MockRead(SYNCHRONOUS,
|
| + 2,
|
| + "HTTP/1.1 302 OK\r\n\r\n"
|
| + "redirect"),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -1291,12 +1306,12 @@ TEST_F(HttpPipelinedConnectionImplTest, EvictAfterDrainOfUnknownSize) {
|
|
|
| HttpRequestHeaders headers1;
|
| HttpResponseInfo response1;
|
| - EXPECT_EQ(OK, stream1->SendRequest(headers1,
|
| - &response1, callback_.callback()));
|
| + EXPECT_EQ(OK,
|
| + stream1->SendRequest(headers1, &response1, callback_.callback()));
|
| HttpRequestHeaders headers2;
|
| HttpResponseInfo response2;
|
| - EXPECT_EQ(OK, stream2->SendRequest(headers2,
|
| - &response2, callback_.callback()));
|
| + EXPECT_EQ(OK,
|
| + stream2->SendRequest(headers2, &response2, callback_.callback()));
|
|
|
| EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
|
| stream1.release()->Drain(NULL);
|
| @@ -1308,14 +1323,15 @@ TEST_F(HttpPipelinedConnectionImplTest, EvictAfterDrainOfUnknownSize) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, EvictAfterFailedDrain) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /redirect.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 1, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /redirect.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 1, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 2,
|
| - "HTTP/1.1 302 OK\r\n"
|
| - "Content-Length: 8\r\n\r\n"),
|
| - MockRead(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 3),
|
| + MockRead(SYNCHRONOUS,
|
| + 2,
|
| + "HTTP/1.1 302 OK\r\n"
|
| + "Content-Length: 8\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 3),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -1324,13 +1340,12 @@ TEST_F(HttpPipelinedConnectionImplTest, EvictAfterFailedDrain) {
|
|
|
| HttpRequestHeaders headers1;
|
| HttpResponseInfo response1;
|
| - EXPECT_EQ(OK, stream1->SendRequest(headers1,
|
| - &response1, callback_.callback()));
|
| + EXPECT_EQ(OK,
|
| + stream1->SendRequest(headers1, &response1, callback_.callback()));
|
| HttpRequestHeaders headers2;
|
| HttpResponseInfo response2;
|
| - EXPECT_EQ(OK, stream2->SendRequest(headers2,
|
| - &response2, callback_.callback()));
|
| -
|
| + EXPECT_EQ(OK,
|
| + stream2->SendRequest(headers2, &response2, callback_.callback()));
|
|
|
| EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
|
| stream1.release()->Drain(NULL);
|
| @@ -1342,15 +1357,15 @@ TEST_F(HttpPipelinedConnectionImplTest, EvictAfterFailedDrain) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, EvictIfDrainingChunkedEncoding) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /redirect.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 1, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /redirect.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 1, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 2,
|
| - "HTTP/1.1 302 OK\r\n"
|
| - "Transfer-Encoding: chunked\r\n\r\n"),
|
| - MockRead(SYNCHRONOUS, 3,
|
| - "jibberish"),
|
| + MockRead(SYNCHRONOUS,
|
| + 2,
|
| + "HTTP/1.1 302 OK\r\n"
|
| + "Transfer-Encoding: chunked\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 3, "jibberish"),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -1359,13 +1374,12 @@ TEST_F(HttpPipelinedConnectionImplTest, EvictIfDrainingChunkedEncoding) {
|
|
|
| HttpRequestHeaders headers1;
|
| HttpResponseInfo response1;
|
| - EXPECT_EQ(OK, stream1->SendRequest(headers1,
|
| - &response1, callback_.callback()));
|
| + EXPECT_EQ(OK,
|
| + stream1->SendRequest(headers1, &response1, callback_.callback()));
|
| HttpRequestHeaders headers2;
|
| HttpResponseInfo response2;
|
| - EXPECT_EQ(OK, stream2->SendRequest(headers2,
|
| - &response2, callback_.callback()));
|
| -
|
| + EXPECT_EQ(OK,
|
| + stream2->SendRequest(headers2, &response2, callback_.callback()));
|
|
|
| EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
|
| stream1.release()->Drain(NULL);
|
| @@ -1377,14 +1391,13 @@ TEST_F(HttpPipelinedConnectionImplTest, EvictIfDrainingChunkedEncoding) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, EvictionDueToMissingContentLength) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
|
| - MockWrite(SYNCHRONOUS, 2, "GET /rejected.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 1, "GET /evicted.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 2, "GET /rejected.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(ASYNC, 3, "HTTP/1.1 200 OK\r\n\r\n"),
|
| - MockRead(SYNCHRONOUS, 4, "ok.html"),
|
| - MockRead(SYNCHRONOUS, OK, 5),
|
| + MockRead(ASYNC, 3, "HTTP/1.1 200 OK\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 4, "ok.html"), MockRead(SYNCHRONOUS, OK, 5),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -1394,12 +1407,14 @@ TEST_F(HttpPipelinedConnectionImplTest, EvictionDueToMissingContentLength) {
|
|
|
| HttpRequestHeaders headers;
|
| HttpResponseInfo response;
|
| - EXPECT_EQ(OK, ok_stream->SendRequest(headers,
|
| - &response, callback_.callback()));
|
| - EXPECT_EQ(OK, evicted_stream->SendRequest(headers,
|
| - &response, callback_.callback()));
|
| - EXPECT_EQ(OK, rejected_stream->SendRequest(headers,
|
| - &response, callback_.callback()));
|
| + EXPECT_EQ(OK,
|
| + ok_stream->SendRequest(headers, &response, callback_.callback()));
|
| + EXPECT_EQ(
|
| + OK,
|
| + evicted_stream->SendRequest(headers, &response, callback_.callback()));
|
| + EXPECT_EQ(
|
| + OK,
|
| + rejected_stream->SendRequest(headers, &response, callback_.callback()));
|
|
|
| TestCompletionCallback ok_callback;
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| @@ -1425,57 +1440,53 @@ TEST_F(HttpPipelinedConnectionImplTest, EvictionDueToMissingContentLength) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnSocketError) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, ERR_FAILED, 1),
|
| + MockRead(SYNCHRONOUS, ERR_FAILED, 1),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| EXPECT_CALL(delegate_,
|
| OnPipelineFeedback(
|
| pipeline_.get(),
|
| - HttpPipelinedConnection::PIPELINE_SOCKET_ERROR))
|
| - .Times(1);
|
| + HttpPipelinedConnection::PIPELINE_SOCKET_ERROR)).Times(1);
|
|
|
| scoped_ptr<HttpStream> stream(NewTestStream("ok.html"));
|
| HttpRequestHeaders headers;
|
| HttpResponseInfo response;
|
| - EXPECT_EQ(OK, stream->SendRequest(headers,
|
| - &response, callback_.callback()));
|
| + EXPECT_EQ(OK, stream->SendRequest(headers, &response, callback_.callback()));
|
| EXPECT_EQ(ERR_FAILED, stream->ReadResponseHeaders(callback_.callback()));
|
| }
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnNoInternetConnection) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, ERR_INTERNET_DISCONNECTED, 1),
|
| + MockRead(SYNCHRONOUS, ERR_INTERNET_DISCONNECTED, 1),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| - EXPECT_CALL(delegate_, OnPipelineFeedback(_, _))
|
| - .Times(0);
|
| + EXPECT_CALL(delegate_, OnPipelineFeedback(_, _)).Times(0);
|
|
|
| scoped_ptr<HttpStream> stream(NewTestStream("ok.html"));
|
| HttpRequestHeaders headers;
|
| HttpResponseInfo response;
|
| - EXPECT_EQ(OK, stream->SendRequest(headers,
|
| - &response, callback_.callback()));
|
| + EXPECT_EQ(OK, stream->SendRequest(headers, &response, callback_.callback()));
|
| EXPECT_EQ(ERR_INTERNET_DISCONNECTED,
|
| stream->ReadResponseHeaders(callback_.callback()));
|
| }
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnHttp10) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 1, "HTTP/1.0 200 OK\r\n"),
|
| - MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n"),
|
| - MockRead(SYNCHRONOUS, 3, "Connection: keep-alive\r\n\r\n"),
|
| - MockRead(SYNCHRONOUS, 4, "ok.html"),
|
| + MockRead(SYNCHRONOUS, 1, "HTTP/1.0 200 OK\r\n"),
|
| + MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n"),
|
| + MockRead(SYNCHRONOUS, 3, "Connection: keep-alive\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 4, "ok.html"),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| @@ -1490,21 +1501,20 @@ TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnHttp10) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnMustClose) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
|
| - MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n"),
|
| - MockRead(SYNCHRONOUS, 3, "Connection: close\r\n\r\n"),
|
| - MockRead(SYNCHRONOUS, 4, "ok.html"),
|
| + MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
|
| + MockRead(SYNCHRONOUS, 2, "Content-Length: 7\r\n"),
|
| + MockRead(SYNCHRONOUS, 3, "Connection: close\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 4, "ok.html"),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| EXPECT_CALL(delegate_,
|
| OnPipelineFeedback(
|
| pipeline_.get(),
|
| - HttpPipelinedConnection::MUST_CLOSE_CONNECTION))
|
| - .Times(1);
|
| + HttpPipelinedConnection::MUST_CLOSE_CONNECTION)).Times(1);
|
|
|
| scoped_ptr<HttpStream> stream(NewTestStream("ok.html"));
|
| TestSyncRequest(stream, "ok.html");
|
| @@ -1512,19 +1522,18 @@ TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnMustClose) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnNoContentLength) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n\r\n"),
|
| - MockRead(SYNCHRONOUS, 2, "ok.html"),
|
| + MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 2, "ok.html"),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| EXPECT_CALL(delegate_,
|
| OnPipelineFeedback(
|
| pipeline_.get(),
|
| - HttpPipelinedConnection::MUST_CLOSE_CONNECTION))
|
| - .Times(1);
|
| + HttpPipelinedConnection::MUST_CLOSE_CONNECTION)).Times(1);
|
|
|
| scoped_ptr<HttpStream> stream(NewTestStream("ok.html"));
|
| TestSyncRequest(stream, "ok.html");
|
| @@ -1532,21 +1541,20 @@ TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnNoContentLength) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnAuthenticationRequired) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| };
|
| MockRead reads[] = {
|
| - MockRead(SYNCHRONOUS, 1, "HTTP/1.1 401 Unauthorized\r\n"),
|
| - MockRead(SYNCHRONOUS, 2, "WWW-Authenticate: NTLM\r\n"),
|
| - MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"),
|
| - MockRead(SYNCHRONOUS, 4, "ok.html"),
|
| + MockRead(SYNCHRONOUS, 1, "HTTP/1.1 401 Unauthorized\r\n"),
|
| + MockRead(SYNCHRONOUS, 2, "WWW-Authenticate: NTLM\r\n"),
|
| + MockRead(SYNCHRONOUS, 3, "Content-Length: 7\r\n\r\n"),
|
| + MockRead(SYNCHRONOUS, 4, "ok.html"),
|
| };
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
| EXPECT_CALL(delegate_,
|
| OnPipelineFeedback(
|
| pipeline_.get(),
|
| - HttpPipelinedConnection::AUTHENTICATION_REQUIRED))
|
| - .Times(1);
|
| + HttpPipelinedConnection::AUTHENTICATION_REQUIRED)).Times(1);
|
|
|
| scoped_ptr<HttpStream> stream(NewTestStream("ok.html"));
|
| TestSyncRequest(stream, "ok.html");
|
| @@ -1554,7 +1562,7 @@ TEST_F(HttpPipelinedConnectionImplTest, FeedbackOnAuthenticationRequired) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, OnPipelineHasCapacity) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| };
|
| Initialize(NULL, 0, writes, arraysize(writes));
|
|
|
| @@ -1564,8 +1572,7 @@ TEST_F(HttpPipelinedConnectionImplTest, OnPipelineHasCapacity) {
|
| EXPECT_CALL(delegate_, OnPipelineHasCapacity(pipeline_.get())).Times(1);
|
| HttpRequestHeaders headers;
|
| HttpResponseInfo response;
|
| - EXPECT_EQ(OK, stream->SendRequest(headers,
|
| - &response, callback_.callback()));
|
| + EXPECT_EQ(OK, stream->SendRequest(headers, &response, callback_.callback()));
|
|
|
| EXPECT_CALL(delegate_, OnPipelineHasCapacity(pipeline_.get())).Times(0);
|
| base::MessageLoop::current()->RunUntilIdle();
|
| @@ -1577,7 +1584,7 @@ TEST_F(HttpPipelinedConnectionImplTest, OnPipelineHasCapacity) {
|
|
|
| TEST_F(HttpPipelinedConnectionImplTest, OnPipelineHasCapacityWithoutSend) {
|
| MockWrite writes[] = {
|
| - MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| + MockWrite(SYNCHRONOUS, 0, "GET /ok.html HTTP/1.1\r\n\r\n"),
|
| };
|
| Initialize(NULL, 0, writes, arraysize(writes));
|
|
|
|
|
Chromium Code Reviews
