| Index: net/spdy/spdy_proxy_client_socket_unittest.cc
|
| diff --git a/net/spdy/spdy_proxy_client_socket_unittest.cc b/net/spdy/spdy_proxy_client_socket_unittest.cc
|
| index 7ae59f5e73ff9bc09a93e4a8fb7db7ea503beb9c..94f967308f87bf671f7df36b9f5f16d26a126377 100644
|
| --- a/net/spdy/spdy_proxy_client_socket_unittest.cc
|
| +++ b/net/spdy/spdy_proxy_client_socket_unittest.cc
|
| @@ -69,7 +69,9 @@ class SpdyProxyClientSocketTest
|
| virtual void TearDown();
|
|
|
| protected:
|
| - void Initialize(MockRead* reads, size_t reads_count, MockWrite* writes,
|
| + void Initialize(MockRead* reads,
|
| + size_t reads_count,
|
| + MockWrite* writes,
|
| size_t writes_count);
|
| void PopulateConnectRequestIR(SpdySynStreamIR* syn_ir);
|
| void PopulateConnectReplyIR(SpdySynReplyIR* reply_ir, const char* status);
|
| @@ -91,8 +93,9 @@ class SpdyProxyClientSocketTest
|
| void AssertAsyncWriteSucceeds(const char* data, int len);
|
| void AssertWriteReturns(const char* data, int len, int rv);
|
| void AssertWriteLength(int len);
|
| - void AssertAsyncWriteWithReadsSucceeds(const char* data, int len,
|
| - int num_reads);
|
| + void AssertAsyncWriteWithReadsSucceeds(const char* data,
|
| + int len,
|
| + int num_reads);
|
|
|
| void AddAuthToCache() {
|
| const base::string16 kFoo(base::ASCIIToUTF16("foo"));
|
| @@ -139,11 +142,12 @@ class SpdyProxyClientSocketTest
|
| DISALLOW_COPY_AND_ASSIGN(SpdyProxyClientSocketTest);
|
| };
|
|
|
| -INSTANTIATE_TEST_CASE_P(
|
| - NextProto,
|
| - SpdyProxyClientSocketTest,
|
| - testing::Values(kProtoDeprecatedSPDY2,
|
| - kProtoSPDY3, kProtoSPDY31, kProtoSPDY4));
|
| +INSTANTIATE_TEST_CASE_P(NextProto,
|
| + SpdyProxyClientSocketTest,
|
| + testing::Values(kProtoDeprecatedSPDY2,
|
| + kProtoSPDY3,
|
| + kProtoSPDY31,
|
| + kProtoSPDY4));
|
|
|
| SpdyProxyClientSocketTest::SpdyProxyClientSocketTest()
|
| : spdy_util_(GetParam()),
|
| @@ -174,11 +178,11 @@ void SpdyProxyClientSocketTest::TearDown() {
|
| }
|
|
|
| void SpdyProxyClientSocketTest::Initialize(MockRead* reads,
|
| - size_t reads_count,
|
| - MockWrite* writes,
|
| - size_t writes_count) {
|
| - data_.reset(new DeterministicSocketData(reads, reads_count,
|
| - writes, writes_count));
|
| + size_t reads_count,
|
| + MockWrite* writes,
|
| + size_t writes_count) {
|
| + data_.reset(
|
| + new DeterministicSocketData(reads, reads_count, writes, writes_count));
|
| data_->set_connect_data(connect_data_);
|
| data_->SetStop(2);
|
|
|
| @@ -186,30 +190,34 @@ void SpdyProxyClientSocketTest::Initialize(MockRead* reads,
|
| data_.get());
|
| session_deps_.host_resolver->set_synchronous_mode(true);
|
|
|
| - session_ = SpdySessionDependencies::SpdyCreateSessionDeterministic(
|
| - &session_deps_);
|
| + session_ =
|
| + SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
|
|
|
| // Creates the SPDY session and stream.
|
| - spdy_session_ =
|
| - CreateInsecureSpdySession(
|
| - session_, endpoint_spdy_session_key_, BoundNetLog());
|
| + spdy_session_ = CreateInsecureSpdySession(
|
| + session_, endpoint_spdy_session_key_, BoundNetLog());
|
| base::WeakPtr<SpdyStream> spdy_stream(
|
| - CreateStreamSynchronously(
|
| - SPDY_BIDIRECTIONAL_STREAM, spdy_session_, url_, LOWEST,
|
| - net_log_.bound()));
|
| + CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
|
| + spdy_session_,
|
| + url_,
|
| + LOWEST,
|
| + net_log_.bound()));
|
| ASSERT_TRUE(spdy_stream.get() != NULL);
|
|
|
| // Create the SpdyProxyClientSocket.
|
| - sock_.reset(
|
| - new SpdyProxyClientSocket(spdy_stream, user_agent_,
|
| - endpoint_host_port_pair_, url_,
|
| - proxy_host_port_, net_log_.bound(),
|
| - session_->http_auth_cache(),
|
| - session_->http_auth_handler_factory()));
|
| + sock_.reset(new SpdyProxyClientSocket(spdy_stream,
|
| + user_agent_,
|
| + endpoint_host_port_pair_,
|
| + url_,
|
| + proxy_host_port_,
|
| + net_log_.bound(),
|
| + session_->http_auth_cache(),
|
| + session_->http_auth_handler_factory()));
|
| }
|
|
|
| scoped_refptr<IOBufferWithSize> SpdyProxyClientSocketTest::CreateBuffer(
|
| - const char* data, int size) {
|
| + const char* data,
|
| + int size) {
|
| scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(size));
|
| memcpy(buf->data(), data, size);
|
| return buf;
|
| @@ -242,7 +250,7 @@ void SpdyProxyClientSocketTest::AssertSyncReadEquals(const char* data,
|
| }
|
|
|
| void SpdyProxyClientSocketTest::AssertAsyncReadEquals(const char* data,
|
| - int len) {
|
| + int len) {
|
| data_->StopAfter(1);
|
| // Issue the read, which will be completed asynchronously
|
| scoped_refptr<IOBuffer> buf(new IOBuffer(len));
|
| @@ -258,8 +266,7 @@ void SpdyProxyClientSocketTest::AssertAsyncReadEquals(const char* data,
|
| ASSERT_EQ(std::string(data, len), std::string(buf->data(), len));
|
| }
|
|
|
| -void SpdyProxyClientSocketTest::AssertReadStarts(const char* data,
|
| - int len) {
|
| +void SpdyProxyClientSocketTest::AssertReadStarts(const char* data, int len) {
|
| data_->StopAfter(1);
|
| // Issue the read, which will be completed asynchronously
|
| read_buf_ = new IOBuffer(len);
|
| @@ -268,8 +275,7 @@ void SpdyProxyClientSocketTest::AssertReadStarts(const char* data,
|
| EXPECT_TRUE(sock_->IsConnected());
|
| }
|
|
|
| -void SpdyProxyClientSocketTest::AssertReadReturns(const char* data,
|
| - int len) {
|
| +void SpdyProxyClientSocketTest::AssertReadReturns(const char* data, int len) {
|
| EXPECT_TRUE(sock_->IsConnected());
|
|
|
| // Now the read will return
|
| @@ -278,15 +284,15 @@ void SpdyProxyClientSocketTest::AssertReadReturns(const char* data,
|
| }
|
|
|
| void SpdyProxyClientSocketTest::AssertAsyncWriteSucceeds(const char* data,
|
| - int len) {
|
| + int len) {
|
| AssertWriteReturns(data, len, ERR_IO_PENDING);
|
| data_->RunFor(1);
|
| AssertWriteLength(len);
|
| }
|
|
|
| void SpdyProxyClientSocketTest::AssertWriteReturns(const char* data,
|
| - int len,
|
| - int rv) {
|
| + int len,
|
| + int rv) {
|
| scoped_refptr<IOBufferWithSize> buf(CreateBuffer(data, len));
|
| EXPECT_EQ(rv,
|
| sock_->Write(buf.get(), buf->size(), write_callback_.callback()));
|
| @@ -297,7 +303,9 @@ void SpdyProxyClientSocketTest::AssertWriteLength(int len) {
|
| }
|
|
|
| void SpdyProxyClientSocketTest::AssertAsyncWriteWithReadsSucceeds(
|
| - const char* data, int len, int num_reads) {
|
| + const char* data,
|
| + int len,
|
| + int num_reads) {
|
| scoped_refptr<IOBufferWithSize> buf(CreateBuffer(data, len));
|
|
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| @@ -328,8 +336,7 @@ void SpdyProxyClientSocketTest::PopulateConnectReplyIR(SpdySynReplyIR* reply_ir,
|
| }
|
|
|
| // Constructs a standard SPDY SYN_STREAM frame for a CONNECT request.
|
| -SpdyFrame*
|
| -SpdyProxyClientSocketTest::ConstructConnectRequestFrame() {
|
| +SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectRequestFrame() {
|
| SpdySynStreamIR syn_ir(kStreamId);
|
| PopulateConnectRequestIR(&syn_ir);
|
| return spdy_util_.CreateFramer(false)->SerializeFrame(syn_ir);
|
| @@ -376,9 +383,8 @@ SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectErrorReplyFrame() {
|
| return framer_.SerializeFrame(reply_ir);
|
| }
|
|
|
| -SpdyFrame* SpdyProxyClientSocketTest::ConstructBodyFrame(
|
| - const char* data,
|
| - int length) {
|
| +SpdyFrame* SpdyProxyClientSocketTest::ConstructBodyFrame(const char* data,
|
| + int length) {
|
| return framer_.CreateDataFrame(kStreamId, data, length, DATA_FLAG_NONE);
|
| }
|
|
|
| @@ -387,13 +393,12 @@ SpdyFrame* SpdyProxyClientSocketTest::ConstructBodyFrame(
|
| TEST_P(SpdyProxyClientSocketTest, ConnectSendsCorrectRequest) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - MockRead(ASYNC, 0, 2), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 2), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -408,13 +413,12 @@ TEST_P(SpdyProxyClientSocketTest, ConnectSendsCorrectRequest) {
|
| TEST_P(SpdyProxyClientSocketTest, ConnectWithAuthRequested) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectAuthReplyFrame());
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - MockRead(ASYNC, 0, 2), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 2), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -429,13 +433,12 @@ TEST_P(SpdyProxyClientSocketTest, ConnectWithAuthRequested) {
|
| TEST_P(SpdyProxyClientSocketTest, ConnectWithAuthCredentials) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectAuthRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - MockRead(ASYNC, 0, 2), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 2), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -449,13 +452,12 @@ TEST_P(SpdyProxyClientSocketTest, ConnectWithAuthCredentials) {
|
| TEST_P(SpdyProxyClientSocketTest, ConnectRedirects) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectRedirectReplyFrame());
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - MockRead(ASYNC, 0, 2), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 2), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -478,12 +480,12 @@ TEST_P(SpdyProxyClientSocketTest, ConnectRedirects) {
|
| TEST_P(SpdyProxyClientSocketTest, ConnectFails) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| MockRead reads[] = {
|
| - MockRead(ASYNC, 0, 1), // EOF
|
| + MockRead(ASYNC, 0, 1), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -500,13 +502,12 @@ TEST_P(SpdyProxyClientSocketTest, ConnectFails) {
|
| TEST_P(SpdyProxyClientSocketTest, WasEverUsedReturnsCorrectValues) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - MockRead(ASYNC, 0, 2), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 2), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -523,13 +524,12 @@ TEST_P(SpdyProxyClientSocketTest, WasEverUsedReturnsCorrectValues) {
|
| TEST_P(SpdyProxyClientSocketTest, GetPeerAddressReturnsCorrectValues) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - MockRead(ASYNC, 0, 2), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 2), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -558,15 +558,14 @@ TEST_P(SpdyProxyClientSocketTest, WriteSendsDataInDataFrame) {
|
| scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
|
| scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| - CreateMockWrite(*msg1, 2, SYNCHRONOUS),
|
| - CreateMockWrite(*msg2, 3, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*msg1, 2, SYNCHRONOUS),
|
| + CreateMockWrite(*msg2, 3, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - MockRead(ASYNC, 0, 4), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 4), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -580,19 +579,16 @@ TEST_P(SpdyProxyClientSocketTest, WriteSendsDataInDataFrame) {
|
| TEST_P(SpdyProxyClientSocketTest, WriteSplitsLargeDataIntoMultipleFrames) {
|
| std::string chunk_data(kMaxSpdyFrameChunkSize, 'x');
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| - scoped_ptr<SpdyFrame> chunk(ConstructBodyFrame(chunk_data.data(),
|
| - chunk_data.length()));
|
| - MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| - CreateMockWrite(*chunk, 2, SYNCHRONOUS),
|
| - CreateMockWrite(*chunk, 3, SYNCHRONOUS),
|
| - CreateMockWrite(*chunk, 4, SYNCHRONOUS)
|
| - };
|
| + scoped_ptr<SpdyFrame> chunk(
|
| + ConstructBodyFrame(chunk_data.data(), chunk_data.length()));
|
| + MockWrite writes[] = {CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*chunk, 2, SYNCHRONOUS),
|
| + CreateMockWrite(*chunk, 3, SYNCHRONOUS),
|
| + CreateMockWrite(*chunk, 4, SYNCHRONOUS)};
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - MockRead(ASYNC, 0, 5), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 5), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -600,8 +596,8 @@ TEST_P(SpdyProxyClientSocketTest, WriteSplitsLargeDataIntoMultipleFrames) {
|
| AssertConnectSucceeds();
|
|
|
| std::string big_data(kMaxSpdyFrameChunkSize * 3, 'x');
|
| - scoped_refptr<IOBufferWithSize> buf(CreateBuffer(big_data.data(),
|
| - big_data.length()));
|
| + scoped_refptr<IOBufferWithSize> buf(
|
| + CreateBuffer(big_data.data(), big_data.length()));
|
|
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| sock_->Write(buf.get(), buf->size(), write_callback_.callback()));
|
| @@ -615,15 +611,14 @@ TEST_P(SpdyProxyClientSocketTest, WriteSplitsLargeDataIntoMultipleFrames) {
|
| TEST_P(SpdyProxyClientSocketTest, ReadReadsDataInDataFrame) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - CreateMockRead(*msg1, 2, ASYNC),
|
| - MockRead(ASYNC, 0, 3), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), CreateMockRead(*msg1, 2, ASYNC),
|
| + MockRead(ASYNC, 0, 3), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -638,17 +633,15 @@ TEST_P(SpdyProxyClientSocketTest, ReadReadsDataInDataFrame) {
|
| TEST_P(SpdyProxyClientSocketTest, ReadDataFromBufferedFrames) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
|
| scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - CreateMockRead(*msg1, 2, ASYNC),
|
| - CreateMockRead(*msg2, 3, ASYNC),
|
| - MockRead(ASYNC, 0, 4), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), CreateMockRead(*msg1, 2, ASYNC),
|
| + CreateMockRead(*msg2, 3, ASYNC), MockRead(ASYNC, 0, 4), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -666,17 +659,15 @@ TEST_P(SpdyProxyClientSocketTest, ReadDataFromBufferedFrames) {
|
| TEST_P(SpdyProxyClientSocketTest, ReadDataMultipleBufferedFrames) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
|
| scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - CreateMockRead(*msg1, 2, ASYNC),
|
| - CreateMockRead(*msg2, 3, ASYNC),
|
| - MockRead(ASYNC, 0, 4), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), CreateMockRead(*msg1, 2, ASYNC),
|
| + CreateMockRead(*msg2, 3, ASYNC), MockRead(ASYNC, 0, 4), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -689,21 +680,18 @@ TEST_P(SpdyProxyClientSocketTest, ReadDataMultipleBufferedFrames) {
|
| AssertSyncReadEquals(kMsg2, kLen2);
|
| }
|
|
|
| -TEST_P(SpdyProxyClientSocketTest,
|
| - LargeReadWillMergeDataFromDifferentFrames) {
|
| +TEST_P(SpdyProxyClientSocketTest, LargeReadWillMergeDataFromDifferentFrames) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
|
| scoped_ptr<SpdyFrame> msg3(ConstructBodyFrame(kMsg3, kLen3));
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - CreateMockRead(*msg3, 2, ASYNC),
|
| - CreateMockRead(*msg3, 3, ASYNC),
|
| - MockRead(ASYNC, 0, 4), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), CreateMockRead(*msg3, 2, ASYNC),
|
| + CreateMockRead(*msg3, 3, ASYNC), MockRead(ASYNC, 0, 4), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -720,7 +708,7 @@ TEST_P(SpdyProxyClientSocketTest,
|
| TEST_P(SpdyProxyClientSocketTest, MultipleShortReadsThenMoreRead) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| @@ -728,12 +716,9 @@ TEST_P(SpdyProxyClientSocketTest, MultipleShortReadsThenMoreRead) {
|
| scoped_ptr<SpdyFrame> msg3(ConstructBodyFrame(kMsg3, kLen3));
|
| scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - CreateMockRead(*msg1, 2, ASYNC),
|
| - CreateMockRead(*msg3, 3, ASYNC),
|
| - CreateMockRead(*msg3, 4, ASYNC),
|
| - CreateMockRead(*msg2, 5, ASYNC),
|
| - MockRead(ASYNC, 0, 6), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), CreateMockRead(*msg1, 2, ASYNC),
|
| + CreateMockRead(*msg3, 3, ASYNC), CreateMockRead(*msg3, 4, ASYNC),
|
| + CreateMockRead(*msg2, 5, ASYNC), MockRead(ASYNC, 0, 6), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -752,7 +737,7 @@ TEST_P(SpdyProxyClientSocketTest, MultipleShortReadsThenMoreRead) {
|
| TEST_P(SpdyProxyClientSocketTest, ReadWillSplitDataFromLargeFrame) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| @@ -760,10 +745,8 @@ TEST_P(SpdyProxyClientSocketTest, ReadWillSplitDataFromLargeFrame) {
|
| scoped_ptr<SpdyFrame> msg33(ConstructBodyFrame(kMsg33, kLen33));
|
| scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - CreateMockRead(*msg1, 2, ASYNC),
|
| - CreateMockRead(*msg33, 3, ASYNC),
|
| - MockRead(ASYNC, 0, 4), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), CreateMockRead(*msg1, 2, ASYNC),
|
| + CreateMockRead(*msg33, 3, ASYNC), MockRead(ASYNC, 0, 4), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -782,15 +765,14 @@ TEST_P(SpdyProxyClientSocketTest, ReadWillSplitDataFromLargeFrame) {
|
| TEST_P(SpdyProxyClientSocketTest, MultipleReadsFromSameLargeFrame) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| scoped_ptr<SpdyFrame> msg333(ConstructBodyFrame(kMsg333, kLen333));
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - CreateMockRead(*msg333, 2, ASYNC),
|
| - MockRead(ASYNC, 0, 3), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), CreateMockRead(*msg333, 2, ASYNC),
|
| + MockRead(ASYNC, 0, 3), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -813,17 +795,15 @@ TEST_P(SpdyProxyClientSocketTest, MultipleReadsFromSameLargeFrame) {
|
| TEST_P(SpdyProxyClientSocketTest, ReadAuthResponseBody) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectAuthReplyFrame());
|
| scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
|
| scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - CreateMockRead(*msg1, 2, ASYNC),
|
| - CreateMockRead(*msg2, 3, ASYNC),
|
| - MockRead(ASYNC, 0, 4), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), CreateMockRead(*msg1, 2, ASYNC),
|
| + CreateMockRead(*msg2, 3, ASYNC), MockRead(ASYNC, 0, 4), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -839,17 +819,15 @@ TEST_P(SpdyProxyClientSocketTest, ReadAuthResponseBody) {
|
| TEST_P(SpdyProxyClientSocketTest, ReadErrorResponseBody) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectErrorReplyFrame());
|
| scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
|
| scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - CreateMockRead(*msg1, 2, ASYNC),
|
| - CreateMockRead(*msg2, 3, ASYNC),
|
| - MockRead(ASYNC, 0, 4), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), CreateMockRead(*msg1, 2, ASYNC),
|
| + CreateMockRead(*msg2, 3, ASYNC), MockRead(ASYNC, 0, 4), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -863,18 +841,18 @@ TEST_P(SpdyProxyClientSocketTest, AsyncReadAroundWrite) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| - CreateMockWrite(*msg2, 3, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*msg2, 3, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
|
| scoped_ptr<SpdyFrame> msg3(ConstructBodyFrame(kMsg3, kLen3));
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - CreateMockRead(*msg1, 2, ASYNC), // sync read
|
| - CreateMockRead(*msg3, 4, ASYNC), // async read
|
| - MockRead(ASYNC, 0, 5), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC),
|
| + CreateMockRead(*msg1, 2, ASYNC), // sync read
|
| + CreateMockRead(*msg3, 4, ASYNC), // async read
|
| + MockRead(ASYNC, 0, 5), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -899,18 +877,15 @@ TEST_P(SpdyProxyClientSocketTest, AsyncWriteAroundReads) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| - CreateMockWrite(*msg2, 4, ASYNC),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS), CreateMockWrite(*msg2, 4, ASYNC),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
|
| scoped_ptr<SpdyFrame> msg3(ConstructBodyFrame(kMsg3, kLen3));
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - CreateMockRead(*msg1, 2, ASYNC),
|
| - CreateMockRead(*msg3, 3, ASYNC),
|
| - MockRead(ASYNC, 0, 5), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), CreateMockRead(*msg1, 2, ASYNC),
|
| + CreateMockRead(*msg3, 3, ASYNC), MockRead(ASYNC, 0, 5), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -937,13 +912,12 @@ TEST_P(SpdyProxyClientSocketTest, AsyncWriteAroundReads) {
|
| TEST_P(SpdyProxyClientSocketTest, ReadOnClosedSocketReturnsZero) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - MockRead(ASYNC, 0, 2), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 2), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -963,13 +937,12 @@ TEST_P(SpdyProxyClientSocketTest, ReadOnClosedSocketReturnsZero) {
|
| TEST_P(SpdyProxyClientSocketTest, PendingReadOnCloseReturnsZero) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - MockRead(ASYNC, 0, 2), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 2), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -984,17 +957,15 @@ TEST_P(SpdyProxyClientSocketTest, PendingReadOnCloseReturnsZero) {
|
| }
|
|
|
| // Reading from a disconnected socket is an error
|
| -TEST_P(SpdyProxyClientSocketTest,
|
| - ReadOnDisconnectSocketReturnsNotConnected) {
|
| +TEST_P(SpdyProxyClientSocketTest, ReadOnDisconnectSocketReturnsNotConnected) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - MockRead(ASYNC, 0, 2), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 2), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -1012,15 +983,14 @@ TEST_P(SpdyProxyClientSocketTest,
|
| TEST_P(SpdyProxyClientSocketTest, ReadOnClosedSocketReturnsBufferedData) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - CreateMockRead(*msg1, 2, ASYNC),
|
| - MockRead(ASYNC, 0, 3), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), CreateMockRead(*msg1, 2, ASYNC),
|
| + MockRead(ASYNC, 0, 3), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -1045,14 +1015,13 @@ TEST_P(SpdyProxyClientSocketTest, ReadOnClosedSocketReturnsBufferedData) {
|
| TEST_P(SpdyProxyClientSocketTest, WriteOnClosedStream) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - MockRead(ASYNC, 0, 2), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 2), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -1069,14 +1038,13 @@ TEST_P(SpdyProxyClientSocketTest, WriteOnClosedStream) {
|
| TEST_P(SpdyProxyClientSocketTest, WriteOnDisconnectedSocket) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - MockRead(ASYNC, 0, 2), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 2), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -1095,14 +1063,12 @@ TEST_P(SpdyProxyClientSocketTest, WriteOnDisconnectedSocket) {
|
| TEST_P(SpdyProxyClientSocketTest, WritePendingOnClose) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| - MockWrite(ASYNC, ERR_ABORTED, 2),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS), MockWrite(ASYNC, ERR_ABORTED, 2),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - MockRead(ASYNC, 0, 3), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 3), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -1125,14 +1091,13 @@ TEST_P(SpdyProxyClientSocketTest, WritePendingOnClose) {
|
| TEST_P(SpdyProxyClientSocketTest, DisconnectWithWritePending) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| - MockWrite(SYNCHRONOUS, 0, 2), // EOF
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + MockWrite(SYNCHRONOUS, 0, 2), // EOF
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - MockRead(ASYNC, 0, 3), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 3), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -1156,13 +1121,12 @@ TEST_P(SpdyProxyClientSocketTest, DisconnectWithWritePending) {
|
| TEST_P(SpdyProxyClientSocketTest, DisconnectWithReadPending) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - MockRead(ASYNC, 0, 2), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 2), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -1186,17 +1150,15 @@ TEST_P(SpdyProxyClientSocketTest, DisconnectWithReadPending) {
|
| TEST_P(SpdyProxyClientSocketTest, RstWithReadAndWritePending) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| - MockWrite(ASYNC, ERR_ABORTED, 3),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS), MockWrite(ASYNC, ERR_ABORTED, 3),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| scoped_ptr<SpdyFrame> rst(
|
| spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - CreateMockRead(*rst, 2, ASYNC),
|
| - MockRead(ASYNC, 0, 4) // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), CreateMockRead(*rst, 2, ASYNC),
|
| + MockRead(ASYNC, 0, 4) // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -1227,15 +1189,14 @@ TEST_P(SpdyProxyClientSocketTest, RstWithReadAndWritePending) {
|
| TEST_P(SpdyProxyClientSocketTest, NetLog) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - CreateMockRead(*msg1, 2, ASYNC),
|
| - MockRead(ASYNC, 0, 3), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), CreateMockRead(*msg1, 2, ASYNC),
|
| + MockRead(ASYNC, 0, 3), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
| @@ -1254,26 +1215,30 @@ TEST_P(SpdyProxyClientSocketTest, NetLog) {
|
|
|
| ASSERT_EQ(entry_list.size(), 10u);
|
| EXPECT_TRUE(LogContainsBeginEvent(entry_list, 0, NetLog::TYPE_SOCKET_ALIVE));
|
| - EXPECT_TRUE(LogContainsEvent(entry_list, 1,
|
| - NetLog::TYPE_SPDY_PROXY_CLIENT_SESSION,
|
| - NetLog::PHASE_NONE));
|
| - EXPECT_TRUE(LogContainsBeginEvent(entry_list, 2,
|
| - NetLog::TYPE_HTTP_TRANSACTION_TUNNEL_SEND_REQUEST));
|
| - EXPECT_TRUE(LogContainsEvent(entry_list, 3,
|
| - NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
|
| - NetLog::PHASE_NONE));
|
| - EXPECT_TRUE(LogContainsEndEvent(entry_list, 4,
|
| - NetLog::TYPE_HTTP_TRANSACTION_TUNNEL_SEND_REQUEST));
|
| - EXPECT_TRUE(LogContainsBeginEvent(entry_list, 5,
|
| - NetLog::TYPE_HTTP_TRANSACTION_TUNNEL_READ_HEADERS));
|
| - EXPECT_TRUE(LogContainsEvent(entry_list, 6,
|
| - NetLog::TYPE_HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS,
|
| - NetLog::PHASE_NONE));
|
| - EXPECT_TRUE(LogContainsEndEvent(entry_list, 7,
|
| - NetLog::TYPE_HTTP_TRANSACTION_TUNNEL_READ_HEADERS));
|
| - EXPECT_TRUE(LogContainsEvent(entry_list, 8,
|
| - NetLog::TYPE_SOCKET_BYTES_RECEIVED,
|
| - NetLog::PHASE_NONE));
|
| + EXPECT_TRUE(LogContainsEvent(entry_list,
|
| + 1,
|
| + NetLog::TYPE_SPDY_PROXY_CLIENT_SESSION,
|
| + NetLog::PHASE_NONE));
|
| + EXPECT_TRUE(LogContainsBeginEvent(
|
| + entry_list, 2, NetLog::TYPE_HTTP_TRANSACTION_TUNNEL_SEND_REQUEST));
|
| + EXPECT_TRUE(
|
| + LogContainsEvent(entry_list,
|
| + 3,
|
| + NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
|
| + NetLog::PHASE_NONE));
|
| + EXPECT_TRUE(LogContainsEndEvent(
|
| + entry_list, 4, NetLog::TYPE_HTTP_TRANSACTION_TUNNEL_SEND_REQUEST));
|
| + EXPECT_TRUE(LogContainsBeginEvent(
|
| + entry_list, 5, NetLog::TYPE_HTTP_TRANSACTION_TUNNEL_READ_HEADERS));
|
| + EXPECT_TRUE(LogContainsEvent(
|
| + entry_list,
|
| + 6,
|
| + NetLog::TYPE_HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS,
|
| + NetLog::PHASE_NONE));
|
| + EXPECT_TRUE(LogContainsEndEvent(
|
| + entry_list, 7, NetLog::TYPE_HTTP_TRANSACTION_TUNNEL_READ_HEADERS));
|
| + EXPECT_TRUE(LogContainsEvent(
|
| + entry_list, 8, NetLog::TYPE_SOCKET_BYTES_RECEIVED, NetLog::PHASE_NONE));
|
| EXPECT_TRUE(LogContainsEndEvent(entry_list, 9, NetLog::TYPE_SOCKET_ALIVE));
|
| }
|
|
|
| @@ -1284,11 +1249,9 @@ class DeleteSockCallback : public TestCompletionCallbackBase {
|
| explicit DeleteSockCallback(scoped_ptr<SpdyProxyClientSocket>* sock)
|
| : sock_(sock),
|
| callback_(base::Bind(&DeleteSockCallback::OnComplete,
|
| - base::Unretained(this))) {
|
| - }
|
| + base::Unretained(this))) {}
|
|
|
| - virtual ~DeleteSockCallback() {
|
| - }
|
| + virtual ~DeleteSockCallback() {}
|
|
|
| const CompletionCallback& callback() const { return callback_; }
|
|
|
| @@ -1310,17 +1273,15 @@ class DeleteSockCallback : public TestCompletionCallbackBase {
|
| TEST_P(SpdyProxyClientSocketTest, RstWithReadAndWritePendingDelete) {
|
| scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
|
| MockWrite writes[] = {
|
| - CreateMockWrite(*conn, 0, SYNCHRONOUS),
|
| - MockWrite(ASYNC, ERR_ABORTED, 3),
|
| + CreateMockWrite(*conn, 0, SYNCHRONOUS), MockWrite(ASYNC, ERR_ABORTED, 3),
|
| };
|
|
|
| scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
|
| scoped_ptr<SpdyFrame> rst(
|
| spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
|
| MockRead reads[] = {
|
| - CreateMockRead(*resp, 1, ASYNC),
|
| - CreateMockRead(*rst, 2, ASYNC),
|
| - MockRead(ASYNC, 0, 4), // EOF
|
| + CreateMockRead(*resp, 1, ASYNC), CreateMockRead(*rst, 2, ASYNC),
|
| + MockRead(ASYNC, 0, 4), // EOF
|
| };
|
|
|
| Initialize(reads, arraysize(reads), writes, arraysize(writes));
|
|
|
Chromium Code Reviews
