| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "net/spdy/spdy_proxy_client_socket.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/bind_helpers.h" | |
| 9 #include "base/strings/utf_string_conversions.h" | |
| 10 #include "net/base/address_list.h" | |
| 11 #include "net/base/capturing_net_log.h" | |
| 12 #include "net/base/net_log.h" | |
| 13 #include "net/base/net_log_unittest.h" | |
| 14 #include "net/base/test_completion_callback.h" | |
| 15 #include "net/base/winsock_init.h" | |
| 16 #include "net/dns/mock_host_resolver.h" | |
| 17 #include "net/http/http_response_headers.h" | |
| 18 #include "net/http/http_response_info.h" | |
| 19 #include "net/socket/client_socket_factory.h" | |
| 20 #include "net/socket/next_proto.h" | |
| 21 #include "net/socket/socket_test_util.h" | |
| 22 #include "net/socket/tcp_client_socket.h" | |
| 23 #include "net/spdy/buffered_spdy_framer.h" | |
| 24 #include "net/spdy/spdy_http_utils.h" | |
| 25 #include "net/spdy/spdy_protocol.h" | |
| 26 #include "net/spdy/spdy_session_pool.h" | |
| 27 #include "net/spdy/spdy_test_util_common.h" | |
| 28 #include "testing/gtest/include/gtest/gtest.h" | |
| 29 #include "testing/platform_test.h" | |
| 30 | |
| 31 //----------------------------------------------------------------------------- | |
| 32 | |
| 33 namespace { | |
| 34 | |
| 35 static const char kRequestUrl[] = "https://www.google.com/"; | |
| 36 static const char kOriginHost[] = "www.google.com"; | |
| 37 static const int kOriginPort = 443; | |
| 38 static const char kOriginHostPort[] = "www.google.com:443"; | |
| 39 static const char kProxyUrl[] = "https://myproxy:6121/"; | |
| 40 static const char kProxyHost[] = "myproxy"; | |
| 41 static const int kProxyPort = 6121; | |
| 42 static const char kUserAgent[] = "Mozilla/1.0"; | |
| 43 | |
| 44 static const int kStreamId = 1; | |
| 45 | |
| 46 static const char kMsg1[] = "\0hello!\xff"; | |
| 47 static const int kLen1 = 8; | |
| 48 static const char kMsg2[] = "\0a2345678\0"; | |
| 49 static const int kLen2 = 10; | |
| 50 static const char kMsg3[] = "bye!"; | |
| 51 static const int kLen3 = 4; | |
| 52 static const char kMsg33[] = "bye!bye!"; | |
| 53 static const int kLen33 = kLen3 + kLen3; | |
| 54 static const char kMsg333[] = "bye!bye!bye!"; | |
| 55 static const int kLen333 = kLen3 + kLen3 + kLen3; | |
| 56 | |
| 57 static const char kRedirectUrl[] = "https://example.com/"; | |
| 58 | |
| 59 } // anonymous namespace | |
| 60 | |
| 61 namespace net { | |
| 62 | |
| 63 class SpdyProxyClientSocketTest | |
| 64 : public PlatformTest, | |
| 65 public testing::WithParamInterface<NextProto> { | |
| 66 public: | |
| 67 SpdyProxyClientSocketTest(); | |
| 68 | |
| 69 void TearDown() override; | |
| 70 | |
| 71 protected: | |
| 72 void Initialize(MockRead* reads, size_t reads_count, MockWrite* writes, | |
| 73 size_t writes_count); | |
| 74 void PopulateConnectRequestIR(SpdyHeaderBlock* syn_ir); | |
| 75 void PopulateConnectReplyIR(SpdyHeaderBlock* block, const char* status); | |
| 76 SpdyFrame* ConstructConnectRequestFrame(); | |
| 77 SpdyFrame* ConstructConnectAuthRequestFrame(); | |
| 78 SpdyFrame* ConstructConnectReplyFrame(); | |
| 79 SpdyFrame* ConstructConnectAuthReplyFrame(); | |
| 80 SpdyFrame* ConstructConnectRedirectReplyFrame(); | |
| 81 SpdyFrame* ConstructConnectErrorReplyFrame(); | |
| 82 SpdyFrame* ConstructBodyFrame(const char* data, int length); | |
| 83 scoped_refptr<IOBufferWithSize> CreateBuffer(const char* data, int size); | |
| 84 void AssertConnectSucceeds(); | |
| 85 void AssertConnectFails(int result); | |
| 86 void AssertConnectionEstablished(); | |
| 87 void AssertSyncReadEquals(const char* data, int len); | |
| 88 void AssertAsyncReadEquals(const char* data, int len); | |
| 89 void AssertReadStarts(const char* data, int len); | |
| 90 void AssertReadReturns(const char* data, int len); | |
| 91 void AssertAsyncWriteSucceeds(const char* data, int len); | |
| 92 void AssertWriteReturns(const char* data, int len, int rv); | |
| 93 void AssertWriteLength(int len); | |
| 94 void AssertAsyncWriteWithReadsSucceeds(const char* data, int len, | |
| 95 int num_reads); | |
| 96 | |
| 97 void AddAuthToCache() { | |
| 98 const base::string16 kFoo(base::ASCIIToUTF16("foo")); | |
| 99 const base::string16 kBar(base::ASCIIToUTF16("bar")); | |
| 100 session_->http_auth_cache()->Add(GURL(kProxyUrl), | |
| 101 "MyRealm1", | |
| 102 HttpAuth::AUTH_SCHEME_BASIC, | |
| 103 "Basic realm=MyRealm1", | |
| 104 AuthCredentials(kFoo, kBar), | |
| 105 "/"); | |
| 106 } | |
| 107 | |
| 108 void Run(int steps) { | |
| 109 data_->StopAfter(steps); | |
| 110 data_->Run(); | |
| 111 } | |
| 112 | |
| 113 void CloseSpdySession(net::Error error, const std::string& description) { | |
| 114 spdy_session_->CloseSessionOnError(error, description); | |
| 115 } | |
| 116 | |
| 117 SpdyTestUtil spdy_util_; | |
| 118 scoped_ptr<SpdyProxyClientSocket> sock_; | |
| 119 TestCompletionCallback read_callback_; | |
| 120 TestCompletionCallback write_callback_; | |
| 121 scoped_ptr<DeterministicSocketData> data_; | |
| 122 CapturingBoundNetLog net_log_; | |
| 123 | |
| 124 private: | |
| 125 scoped_refptr<HttpNetworkSession> session_; | |
| 126 scoped_refptr<IOBuffer> read_buf_; | |
| 127 SpdySessionDependencies session_deps_; | |
| 128 MockConnect connect_data_; | |
| 129 base::WeakPtr<SpdySession> spdy_session_; | |
| 130 BufferedSpdyFramer framer_; | |
| 131 | |
| 132 std::string user_agent_; | |
| 133 GURL url_; | |
| 134 HostPortPair proxy_host_port_; | |
| 135 HostPortPair endpoint_host_port_pair_; | |
| 136 ProxyServer proxy_; | |
| 137 SpdySessionKey endpoint_spdy_session_key_; | |
| 138 | |
| 139 DISALLOW_COPY_AND_ASSIGN(SpdyProxyClientSocketTest); | |
| 140 }; | |
| 141 | |
| 142 INSTANTIATE_TEST_CASE_P( | |
| 143 NextProto, | |
| 144 SpdyProxyClientSocketTest, | |
| 145 testing::Values(kProtoSPDY31, kProtoSPDY4_14, kProtoSPDY4_15)); | |
| 146 | |
| 147 SpdyProxyClientSocketTest::SpdyProxyClientSocketTest() | |
| 148 : spdy_util_(GetParam()), | |
| 149 session_(NULL), | |
| 150 read_buf_(NULL), | |
| 151 session_deps_(GetParam()), | |
| 152 connect_data_(SYNCHRONOUS, OK), | |
| 153 framer_(spdy_util_.spdy_version(), false), | |
| 154 user_agent_(kUserAgent), | |
| 155 url_(kRequestUrl), | |
| 156 proxy_host_port_(kProxyHost, kProxyPort), | |
| 157 endpoint_host_port_pair_(kOriginHost, kOriginPort), | |
| 158 proxy_(ProxyServer::SCHEME_HTTPS, proxy_host_port_), | |
| 159 endpoint_spdy_session_key_(endpoint_host_port_pair_, | |
| 160 proxy_, | |
| 161 PRIVACY_MODE_DISABLED) { | |
| 162 session_deps_.net_log = net_log_.bound().net_log(); | |
| 163 } | |
| 164 | |
| 165 void SpdyProxyClientSocketTest::TearDown() { | |
| 166 if (session_.get() != NULL) | |
| 167 session_->spdy_session_pool()->CloseAllSessions(); | |
| 168 | |
| 169 // Empty the current queue. | |
| 170 base::MessageLoop::current()->RunUntilIdle(); | |
| 171 PlatformTest::TearDown(); | |
| 172 } | |
| 173 | |
| 174 void SpdyProxyClientSocketTest::Initialize(MockRead* reads, | |
| 175 size_t reads_count, | |
| 176 MockWrite* writes, | |
| 177 size_t writes_count) { | |
| 178 data_.reset(new DeterministicSocketData(reads, reads_count, | |
| 179 writes, writes_count)); | |
| 180 data_->set_connect_data(connect_data_); | |
| 181 data_->SetStop(2); | |
| 182 | |
| 183 session_deps_.deterministic_socket_factory->AddSocketDataProvider( | |
| 184 data_.get()); | |
| 185 session_deps_.host_resolver->set_synchronous_mode(true); | |
| 186 | |
| 187 session_ = SpdySessionDependencies::SpdyCreateSessionDeterministic( | |
| 188 &session_deps_); | |
| 189 | |
| 190 // Creates the SPDY session and stream. | |
| 191 spdy_session_ = | |
| 192 CreateInsecureSpdySession( | |
| 193 session_, endpoint_spdy_session_key_, BoundNetLog()); | |
| 194 base::WeakPtr<SpdyStream> spdy_stream( | |
| 195 CreateStreamSynchronously( | |
| 196 SPDY_BIDIRECTIONAL_STREAM, spdy_session_, url_, LOWEST, | |
| 197 net_log_.bound())); | |
| 198 ASSERT_TRUE(spdy_stream.get() != NULL); | |
| 199 | |
| 200 // Create the SpdyProxyClientSocket. | |
| 201 sock_.reset( | |
| 202 new SpdyProxyClientSocket(spdy_stream, user_agent_, | |
| 203 endpoint_host_port_pair_, url_, | |
| 204 proxy_host_port_, net_log_.bound(), | |
| 205 session_->http_auth_cache(), | |
| 206 session_->http_auth_handler_factory())); | |
| 207 } | |
| 208 | |
| 209 scoped_refptr<IOBufferWithSize> SpdyProxyClientSocketTest::CreateBuffer( | |
| 210 const char* data, int size) { | |
| 211 scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(size)); | |
| 212 memcpy(buf->data(), data, size); | |
| 213 return buf; | |
| 214 } | |
| 215 | |
| 216 void SpdyProxyClientSocketTest::AssertConnectSucceeds() { | |
| 217 ASSERT_EQ(ERR_IO_PENDING, sock_->Connect(read_callback_.callback())); | |
| 218 data_->Run(); | |
| 219 ASSERT_EQ(OK, read_callback_.WaitForResult()); | |
| 220 } | |
| 221 | |
| 222 void SpdyProxyClientSocketTest::AssertConnectFails(int result) { | |
| 223 ASSERT_EQ(ERR_IO_PENDING, sock_->Connect(read_callback_.callback())); | |
| 224 data_->Run(); | |
| 225 ASSERT_EQ(result, read_callback_.WaitForResult()); | |
| 226 } | |
| 227 | |
| 228 void SpdyProxyClientSocketTest::AssertConnectionEstablished() { | |
| 229 const HttpResponseInfo* response = sock_->GetConnectResponseInfo(); | |
| 230 ASSERT_TRUE(response != NULL); | |
| 231 ASSERT_EQ(200, response->headers->response_code()); | |
| 232 } | |
| 233 | |
| 234 void SpdyProxyClientSocketTest::AssertSyncReadEquals(const char* data, | |
| 235 int len) { | |
| 236 scoped_refptr<IOBuffer> buf(new IOBuffer(len)); | |
| 237 ASSERT_EQ(len, sock_->Read(buf.get(), len, CompletionCallback())); | |
| 238 ASSERT_EQ(std::string(data, len), std::string(buf->data(), len)); | |
| 239 ASSERT_TRUE(sock_->IsConnected()); | |
| 240 } | |
| 241 | |
| 242 void SpdyProxyClientSocketTest::AssertAsyncReadEquals(const char* data, | |
| 243 int len) { | |
| 244 data_->StopAfter(1); | |
| 245 // Issue the read, which will be completed asynchronously | |
| 246 scoped_refptr<IOBuffer> buf(new IOBuffer(len)); | |
| 247 ASSERT_EQ(ERR_IO_PENDING, | |
| 248 sock_->Read(buf.get(), len, read_callback_.callback())); | |
| 249 EXPECT_TRUE(sock_->IsConnected()); | |
| 250 data_->Run(); | |
| 251 | |
| 252 EXPECT_TRUE(sock_->IsConnected()); | |
| 253 | |
| 254 // Now the read will return | |
| 255 EXPECT_EQ(len, read_callback_.WaitForResult()); | |
| 256 ASSERT_EQ(std::string(data, len), std::string(buf->data(), len)); | |
| 257 } | |
| 258 | |
| 259 void SpdyProxyClientSocketTest::AssertReadStarts(const char* data, | |
| 260 int len) { | |
| 261 data_->StopAfter(1); | |
| 262 // Issue the read, which will be completed asynchronously | |
| 263 read_buf_ = new IOBuffer(len); | |
| 264 ASSERT_EQ(ERR_IO_PENDING, | |
| 265 sock_->Read(read_buf_.get(), len, read_callback_.callback())); | |
| 266 EXPECT_TRUE(sock_->IsConnected()); | |
| 267 } | |
| 268 | |
| 269 void SpdyProxyClientSocketTest::AssertReadReturns(const char* data, | |
| 270 int len) { | |
| 271 EXPECT_TRUE(sock_->IsConnected()); | |
| 272 | |
| 273 // Now the read will return | |
| 274 EXPECT_EQ(len, read_callback_.WaitForResult()); | |
| 275 ASSERT_EQ(std::string(data, len), std::string(read_buf_->data(), len)); | |
| 276 } | |
| 277 | |
| 278 void SpdyProxyClientSocketTest::AssertAsyncWriteSucceeds(const char* data, | |
| 279 int len) { | |
| 280 AssertWriteReturns(data, len, ERR_IO_PENDING); | |
| 281 data_->RunFor(1); | |
| 282 AssertWriteLength(len); | |
| 283 } | |
| 284 | |
| 285 void SpdyProxyClientSocketTest::AssertWriteReturns(const char* data, | |
| 286 int len, | |
| 287 int rv) { | |
| 288 scoped_refptr<IOBufferWithSize> buf(CreateBuffer(data, len)); | |
| 289 EXPECT_EQ(rv, | |
| 290 sock_->Write(buf.get(), buf->size(), write_callback_.callback())); | |
| 291 } | |
| 292 | |
| 293 void SpdyProxyClientSocketTest::AssertWriteLength(int len) { | |
| 294 EXPECT_EQ(len, write_callback_.WaitForResult()); | |
| 295 } | |
| 296 | |
| 297 void SpdyProxyClientSocketTest::AssertAsyncWriteWithReadsSucceeds( | |
| 298 const char* data, int len, int num_reads) { | |
| 299 scoped_refptr<IOBufferWithSize> buf(CreateBuffer(data, len)); | |
| 300 | |
| 301 EXPECT_EQ(ERR_IO_PENDING, | |
| 302 sock_->Write(buf.get(), buf->size(), write_callback_.callback())); | |
| 303 | |
| 304 for (int i = 0; i < num_reads; i++) { | |
| 305 Run(1); | |
| 306 AssertSyncReadEquals(kMsg2, kLen2); | |
| 307 } | |
| 308 | |
| 309 write_callback_.WaitForResult(); | |
| 310 } | |
| 311 | |
| 312 void SpdyProxyClientSocketTest::PopulateConnectRequestIR( | |
| 313 SpdyHeaderBlock* block) { | |
| 314 (*block)[spdy_util_.GetMethodKey()] = "CONNECT"; | |
| 315 (*block)[spdy_util_.GetPathKey()] = kOriginHostPort; | |
| 316 (*block)[spdy_util_.GetHostKey()] = kOriginHost; | |
| 317 (*block)["user-agent"] = kUserAgent; | |
| 318 spdy_util_.MaybeAddVersionHeader(block); | |
| 319 } | |
| 320 | |
| 321 void SpdyProxyClientSocketTest::PopulateConnectReplyIR(SpdyHeaderBlock* block, | |
| 322 const char* status) { | |
| 323 (*block)[spdy_util_.GetStatusKey()] = status; | |
| 324 spdy_util_.MaybeAddVersionHeader(block); | |
| 325 } | |
| 326 | |
| 327 // Constructs a standard SPDY SYN_STREAM frame for a CONNECT request. | |
| 328 SpdyFrame* | |
| 329 SpdyProxyClientSocketTest::ConstructConnectRequestFrame() { | |
| 330 SpdyHeaderBlock block; | |
| 331 PopulateConnectRequestIR(&block); | |
| 332 return spdy_util_.ConstructSpdySyn(kStreamId, block, LOWEST, false, false); | |
| 333 } | |
| 334 | |
| 335 // Constructs a SPDY SYN_STREAM frame for a CONNECT request which includes | |
| 336 // Proxy-Authorization headers. | |
| 337 SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectAuthRequestFrame() { | |
| 338 SpdyHeaderBlock block; | |
| 339 PopulateConnectRequestIR(&block); | |
| 340 block["proxy-authorization"] = "Basic Zm9vOmJhcg=="; | |
| 341 return spdy_util_.ConstructSpdySyn(kStreamId, block, LOWEST, false, false); | |
| 342 } | |
| 343 | |
| 344 // Constructs a standard SPDY SYN_REPLY frame to match the SPDY CONNECT. | |
| 345 SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectReplyFrame() { | |
| 346 SpdyHeaderBlock block; | |
| 347 PopulateConnectReplyIR(&block, "200"); | |
| 348 SpdySynReplyIR reply_ir(kStreamId); | |
| 349 return spdy_util_.ConstructSpdyReply(kStreamId, block); | |
| 350 } | |
| 351 | |
| 352 // Constructs a standard SPDY SYN_REPLY frame to match the SPDY CONNECT, | |
| 353 // including Proxy-Authenticate headers. | |
| 354 SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectAuthReplyFrame() { | |
| 355 SpdyHeaderBlock block; | |
| 356 PopulateConnectReplyIR(&block, "407"); | |
| 357 block["proxy-authenticate"] = "Basic realm=\"MyRealm1\""; | |
| 358 return spdy_util_.ConstructSpdyReply(kStreamId, block); | |
| 359 } | |
| 360 | |
| 361 // Constructs a SPDY SYN_REPLY frame with an HTTP 302 redirect. | |
| 362 SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectRedirectReplyFrame() { | |
| 363 SpdyHeaderBlock block; | |
| 364 PopulateConnectReplyIR(&block, "302"); | |
| 365 block["location"] = kRedirectUrl; | |
| 366 block["set-cookie"] = "foo=bar"; | |
| 367 return spdy_util_.ConstructSpdyReply(kStreamId, block); | |
| 368 } | |
| 369 | |
| 370 // Constructs a SPDY SYN_REPLY frame with an HTTP 500 error. | |
| 371 SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectErrorReplyFrame() { | |
| 372 SpdyHeaderBlock block; | |
| 373 PopulateConnectReplyIR(&block, "500"); | |
| 374 return spdy_util_.ConstructSpdyReply(kStreamId, block); | |
| 375 } | |
| 376 | |
| 377 SpdyFrame* SpdyProxyClientSocketTest::ConstructBodyFrame( | |
| 378 const char* data, | |
| 379 int length) { | |
| 380 return framer_.CreateDataFrame(kStreamId, data, length, DATA_FLAG_NONE); | |
| 381 } | |
| 382 | |
| 383 // ----------- Connect | |
| 384 | |
| 385 TEST_P(SpdyProxyClientSocketTest, ConnectSendsCorrectRequest) { | |
| 386 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 387 MockWrite writes[] = { | |
| 388 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 389 }; | |
| 390 | |
| 391 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 392 MockRead reads[] = { | |
| 393 CreateMockRead(*resp, 1, ASYNC), | |
| 394 MockRead(ASYNC, 0, 2), // EOF | |
| 395 }; | |
| 396 | |
| 397 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 398 | |
| 399 ASSERT_FALSE(sock_->IsConnected()); | |
| 400 | |
| 401 AssertConnectSucceeds(); | |
| 402 | |
| 403 AssertConnectionEstablished(); | |
| 404 } | |
| 405 | |
| 406 TEST_P(SpdyProxyClientSocketTest, ConnectWithAuthRequested) { | |
| 407 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 408 MockWrite writes[] = { | |
| 409 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 410 }; | |
| 411 | |
| 412 scoped_ptr<SpdyFrame> resp(ConstructConnectAuthReplyFrame()); | |
| 413 MockRead reads[] = { | |
| 414 CreateMockRead(*resp, 1, ASYNC), | |
| 415 MockRead(ASYNC, 0, 2), // EOF | |
| 416 }; | |
| 417 | |
| 418 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 419 | |
| 420 AssertConnectFails(ERR_PROXY_AUTH_REQUESTED); | |
| 421 | |
| 422 const HttpResponseInfo* response = sock_->GetConnectResponseInfo(); | |
| 423 ASSERT_TRUE(response != NULL); | |
| 424 ASSERT_EQ(407, response->headers->response_code()); | |
| 425 } | |
| 426 | |
| 427 TEST_P(SpdyProxyClientSocketTest, ConnectWithAuthCredentials) { | |
| 428 scoped_ptr<SpdyFrame> conn(ConstructConnectAuthRequestFrame()); | |
| 429 MockWrite writes[] = { | |
| 430 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 431 }; | |
| 432 | |
| 433 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 434 MockRead reads[] = { | |
| 435 CreateMockRead(*resp, 1, ASYNC), | |
| 436 MockRead(ASYNC, 0, 2), // EOF | |
| 437 }; | |
| 438 | |
| 439 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 440 AddAuthToCache(); | |
| 441 | |
| 442 AssertConnectSucceeds(); | |
| 443 | |
| 444 AssertConnectionEstablished(); | |
| 445 } | |
| 446 | |
| 447 TEST_P(SpdyProxyClientSocketTest, ConnectRedirects) { | |
| 448 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 449 scoped_ptr<SpdyFrame> rst( | |
| 450 spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL)); | |
| 451 MockWrite writes[] = { | |
| 452 CreateMockWrite(*conn, 0, SYNCHRONOUS), CreateMockWrite(*rst, 2), | |
| 453 }; | |
| 454 | |
| 455 scoped_ptr<SpdyFrame> resp(ConstructConnectRedirectReplyFrame()); | |
| 456 MockRead reads[] = { | |
| 457 CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 3), // EOF | |
| 458 }; | |
| 459 | |
| 460 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 461 | |
| 462 AssertConnectFails(ERR_HTTPS_PROXY_TUNNEL_RESPONSE); | |
| 463 | |
| 464 const HttpResponseInfo* response = sock_->GetConnectResponseInfo(); | |
| 465 ASSERT_TRUE(response != NULL); | |
| 466 | |
| 467 const HttpResponseHeaders* headers = response->headers.get(); | |
| 468 ASSERT_EQ(302, headers->response_code()); | |
| 469 ASSERT_FALSE(headers->HasHeader("set-cookie")); | |
| 470 ASSERT_TRUE(headers->HasHeaderValue("content-length", "0")); | |
| 471 | |
| 472 std::string location; | |
| 473 ASSERT_TRUE(headers->IsRedirect(&location)); | |
| 474 ASSERT_EQ(location, kRedirectUrl); | |
| 475 | |
| 476 // Let the RST_STREAM write while |rst| is in-scope. | |
| 477 base::MessageLoop::current()->RunUntilIdle(); | |
| 478 } | |
| 479 | |
| 480 TEST_P(SpdyProxyClientSocketTest, ConnectFails) { | |
| 481 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 482 MockWrite writes[] = { | |
| 483 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 484 }; | |
| 485 | |
| 486 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 487 MockRead reads[] = { | |
| 488 MockRead(ASYNC, 0, 1), // EOF | |
| 489 }; | |
| 490 | |
| 491 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 492 | |
| 493 ASSERT_FALSE(sock_->IsConnected()); | |
| 494 | |
| 495 AssertConnectFails(ERR_CONNECTION_CLOSED); | |
| 496 | |
| 497 ASSERT_FALSE(sock_->IsConnected()); | |
| 498 } | |
| 499 | |
| 500 // ----------- WasEverUsed | |
| 501 | |
| 502 TEST_P(SpdyProxyClientSocketTest, WasEverUsedReturnsCorrectValues) { | |
| 503 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 504 scoped_ptr<SpdyFrame> rst( | |
| 505 spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL)); | |
| 506 MockWrite writes[] = { | |
| 507 CreateMockWrite(*conn, 0, SYNCHRONOUS), CreateMockWrite(*rst, 2), | |
| 508 }; | |
| 509 | |
| 510 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 511 MockRead reads[] = { | |
| 512 CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 3), // EOF | |
| 513 }; | |
| 514 | |
| 515 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 516 | |
| 517 EXPECT_FALSE(sock_->WasEverUsed()); | |
| 518 AssertConnectSucceeds(); | |
| 519 EXPECT_TRUE(sock_->WasEverUsed()); | |
| 520 sock_->Disconnect(); | |
| 521 EXPECT_TRUE(sock_->WasEverUsed()); | |
| 522 | |
| 523 // Let the RST_STREAM write while |rst| is in-scope. | |
| 524 base::MessageLoop::current()->RunUntilIdle(); | |
| 525 } | |
| 526 | |
| 527 // ----------- GetPeerAddress | |
| 528 | |
| 529 TEST_P(SpdyProxyClientSocketTest, GetPeerAddressReturnsCorrectValues) { | |
| 530 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 531 MockWrite writes[] = { | |
| 532 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 533 }; | |
| 534 | |
| 535 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 536 MockRead reads[] = { | |
| 537 CreateMockRead(*resp, 1, ASYNC), | |
| 538 MockRead(ASYNC, 0, 2), // EOF | |
| 539 }; | |
| 540 | |
| 541 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 542 | |
| 543 net::IPEndPoint addr; | |
| 544 EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->GetPeerAddress(&addr)); | |
| 545 | |
| 546 AssertConnectSucceeds(); | |
| 547 EXPECT_TRUE(sock_->IsConnected()); | |
| 548 EXPECT_EQ(OK, sock_->GetPeerAddress(&addr)); | |
| 549 | |
| 550 Run(1); | |
| 551 | |
| 552 EXPECT_FALSE(sock_->IsConnected()); | |
| 553 EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->GetPeerAddress(&addr)); | |
| 554 | |
| 555 sock_->Disconnect(); | |
| 556 | |
| 557 EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->GetPeerAddress(&addr)); | |
| 558 } | |
| 559 | |
| 560 // ----------- Write | |
| 561 | |
| 562 TEST_P(SpdyProxyClientSocketTest, WriteSendsDataInDataFrame) { | |
| 563 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 564 scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); | |
| 565 scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2)); | |
| 566 MockWrite writes[] = { | |
| 567 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 568 CreateMockWrite(*msg1, 2, SYNCHRONOUS), | |
| 569 CreateMockWrite(*msg2, 3, SYNCHRONOUS), | |
| 570 }; | |
| 571 | |
| 572 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 573 MockRead reads[] = { | |
| 574 CreateMockRead(*resp, 1, ASYNC), | |
| 575 MockRead(ASYNC, 0, 4), // EOF | |
| 576 }; | |
| 577 | |
| 578 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 579 | |
| 580 AssertConnectSucceeds(); | |
| 581 | |
| 582 AssertAsyncWriteSucceeds(kMsg1, kLen1); | |
| 583 AssertAsyncWriteSucceeds(kMsg2, kLen2); | |
| 584 } | |
| 585 | |
| 586 TEST_P(SpdyProxyClientSocketTest, WriteSplitsLargeDataIntoMultipleFrames) { | |
| 587 std::string chunk_data(kMaxSpdyFrameChunkSize, 'x'); | |
| 588 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 589 scoped_ptr<SpdyFrame> chunk(ConstructBodyFrame(chunk_data.data(), | |
| 590 chunk_data.length())); | |
| 591 MockWrite writes[] = { | |
| 592 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 593 CreateMockWrite(*chunk, 2, SYNCHRONOUS), | |
| 594 CreateMockWrite(*chunk, 3, SYNCHRONOUS), | |
| 595 CreateMockWrite(*chunk, 4, SYNCHRONOUS) | |
| 596 }; | |
| 597 | |
| 598 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 599 MockRead reads[] = { | |
| 600 CreateMockRead(*resp, 1, ASYNC), | |
| 601 MockRead(ASYNC, 0, 5), // EOF | |
| 602 }; | |
| 603 | |
| 604 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 605 | |
| 606 AssertConnectSucceeds(); | |
| 607 | |
| 608 std::string big_data(kMaxSpdyFrameChunkSize * 3, 'x'); | |
| 609 scoped_refptr<IOBufferWithSize> buf(CreateBuffer(big_data.data(), | |
| 610 big_data.length())); | |
| 611 | |
| 612 EXPECT_EQ(ERR_IO_PENDING, | |
| 613 sock_->Write(buf.get(), buf->size(), write_callback_.callback())); | |
| 614 data_->RunFor(3); | |
| 615 | |
| 616 EXPECT_EQ(buf->size(), write_callback_.WaitForResult()); | |
| 617 } | |
| 618 | |
| 619 // ----------- Read | |
| 620 | |
| 621 TEST_P(SpdyProxyClientSocketTest, ReadReadsDataInDataFrame) { | |
| 622 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 623 MockWrite writes[] = { | |
| 624 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 625 }; | |
| 626 | |
| 627 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 628 scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); | |
| 629 MockRead reads[] = { | |
| 630 CreateMockRead(*resp, 1, ASYNC), | |
| 631 CreateMockRead(*msg1, 2, ASYNC), | |
| 632 MockRead(ASYNC, 0, 3), // EOF | |
| 633 }; | |
| 634 | |
| 635 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 636 | |
| 637 AssertConnectSucceeds(); | |
| 638 | |
| 639 Run(1); // SpdySession consumes the next read and sends it to | |
| 640 // sock_ to be buffered. | |
| 641 AssertSyncReadEquals(kMsg1, kLen1); | |
| 642 } | |
| 643 | |
| 644 TEST_P(SpdyProxyClientSocketTest, ReadDataFromBufferedFrames) { | |
| 645 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 646 MockWrite writes[] = { | |
| 647 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 648 }; | |
| 649 | |
| 650 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 651 scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); | |
| 652 scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2)); | |
| 653 MockRead reads[] = { | |
| 654 CreateMockRead(*resp, 1, ASYNC), | |
| 655 CreateMockRead(*msg1, 2, ASYNC), | |
| 656 CreateMockRead(*msg2, 3, ASYNC), | |
| 657 MockRead(ASYNC, 0, 4), // EOF | |
| 658 }; | |
| 659 | |
| 660 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 661 | |
| 662 AssertConnectSucceeds(); | |
| 663 | |
| 664 Run(1); // SpdySession consumes the next read and sends it to | |
| 665 // sock_ to be buffered. | |
| 666 AssertSyncReadEquals(kMsg1, kLen1); | |
| 667 Run(1); // SpdySession consumes the next read and sends it to | |
| 668 // sock_ to be buffered. | |
| 669 AssertSyncReadEquals(kMsg2, kLen2); | |
| 670 } | |
| 671 | |
| 672 TEST_P(SpdyProxyClientSocketTest, ReadDataMultipleBufferedFrames) { | |
| 673 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 674 MockWrite writes[] = { | |
| 675 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 676 }; | |
| 677 | |
| 678 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 679 scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); | |
| 680 scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2)); | |
| 681 MockRead reads[] = { | |
| 682 CreateMockRead(*resp, 1, ASYNC), | |
| 683 CreateMockRead(*msg1, 2, ASYNC), | |
| 684 CreateMockRead(*msg2, 3, ASYNC), | |
| 685 MockRead(ASYNC, 0, 4), // EOF | |
| 686 }; | |
| 687 | |
| 688 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 689 | |
| 690 AssertConnectSucceeds(); | |
| 691 | |
| 692 Run(2); // SpdySession consumes the next two reads and sends then to | |
| 693 // sock_ to be buffered. | |
| 694 AssertSyncReadEquals(kMsg1, kLen1); | |
| 695 AssertSyncReadEquals(kMsg2, kLen2); | |
| 696 } | |
| 697 | |
| 698 TEST_P(SpdyProxyClientSocketTest, | |
| 699 LargeReadWillMergeDataFromDifferentFrames) { | |
| 700 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 701 MockWrite writes[] = { | |
| 702 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 703 }; | |
| 704 | |
| 705 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 706 scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); | |
| 707 scoped_ptr<SpdyFrame> msg3(ConstructBodyFrame(kMsg3, kLen3)); | |
| 708 MockRead reads[] = { | |
| 709 CreateMockRead(*resp, 1, ASYNC), | |
| 710 CreateMockRead(*msg3, 2, ASYNC), | |
| 711 CreateMockRead(*msg3, 3, ASYNC), | |
| 712 MockRead(ASYNC, 0, 4), // EOF | |
| 713 }; | |
| 714 | |
| 715 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 716 | |
| 717 AssertConnectSucceeds(); | |
| 718 | |
| 719 Run(2); // SpdySession consumes the next two reads and sends then to | |
| 720 // sock_ to be buffered. | |
| 721 // The payload from two data frames, each with kMsg3 will be combined | |
| 722 // together into a single read(). | |
| 723 AssertSyncReadEquals(kMsg33, kLen33); | |
| 724 } | |
| 725 | |
| 726 TEST_P(SpdyProxyClientSocketTest, MultipleShortReadsThenMoreRead) { | |
| 727 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 728 MockWrite writes[] = { | |
| 729 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 730 }; | |
| 731 | |
| 732 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 733 scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); | |
| 734 scoped_ptr<SpdyFrame> msg3(ConstructBodyFrame(kMsg3, kLen3)); | |
| 735 scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2)); | |
| 736 MockRead reads[] = { | |
| 737 CreateMockRead(*resp, 1, ASYNC), | |
| 738 CreateMockRead(*msg1, 2, ASYNC), | |
| 739 CreateMockRead(*msg3, 3, ASYNC), | |
| 740 CreateMockRead(*msg3, 4, ASYNC), | |
| 741 CreateMockRead(*msg2, 5, ASYNC), | |
| 742 MockRead(ASYNC, 0, 6), // EOF | |
| 743 }; | |
| 744 | |
| 745 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 746 | |
| 747 AssertConnectSucceeds(); | |
| 748 | |
| 749 Run(4); // SpdySession consumes the next four reads and sends then to | |
| 750 // sock_ to be buffered. | |
| 751 AssertSyncReadEquals(kMsg1, kLen1); | |
| 752 // The payload from two data frames, each with kMsg3 will be combined | |
| 753 // together into a single read(). | |
| 754 AssertSyncReadEquals(kMsg33, kLen33); | |
| 755 AssertSyncReadEquals(kMsg2, kLen2); | |
| 756 } | |
| 757 | |
| 758 TEST_P(SpdyProxyClientSocketTest, ReadWillSplitDataFromLargeFrame) { | |
| 759 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 760 MockWrite writes[] = { | |
| 761 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 762 }; | |
| 763 | |
| 764 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 765 scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); | |
| 766 scoped_ptr<SpdyFrame> msg33(ConstructBodyFrame(kMsg33, kLen33)); | |
| 767 scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2)); | |
| 768 MockRead reads[] = { | |
| 769 CreateMockRead(*resp, 1, ASYNC), | |
| 770 CreateMockRead(*msg1, 2, ASYNC), | |
| 771 CreateMockRead(*msg33, 3, ASYNC), | |
| 772 MockRead(ASYNC, 0, 4), // EOF | |
| 773 }; | |
| 774 | |
| 775 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 776 | |
| 777 AssertConnectSucceeds(); | |
| 778 | |
| 779 Run(2); // SpdySession consumes the next two reads and sends then to | |
| 780 // sock_ to be buffered. | |
| 781 AssertSyncReadEquals(kMsg1, kLen1); | |
| 782 // The payload from the single large data frame will be read across | |
| 783 // two different reads. | |
| 784 AssertSyncReadEquals(kMsg3, kLen3); | |
| 785 AssertSyncReadEquals(kMsg3, kLen3); | |
| 786 } | |
| 787 | |
| 788 TEST_P(SpdyProxyClientSocketTest, MultipleReadsFromSameLargeFrame) { | |
| 789 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 790 MockWrite writes[] = { | |
| 791 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 792 }; | |
| 793 | |
| 794 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 795 scoped_ptr<SpdyFrame> msg333(ConstructBodyFrame(kMsg333, kLen333)); | |
| 796 MockRead reads[] = { | |
| 797 CreateMockRead(*resp, 1, ASYNC), | |
| 798 CreateMockRead(*msg333, 2, ASYNC), | |
| 799 MockRead(ASYNC, 0, 3), // EOF | |
| 800 }; | |
| 801 | |
| 802 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 803 | |
| 804 AssertConnectSucceeds(); | |
| 805 | |
| 806 Run(1); // SpdySession consumes the next read and sends it to | |
| 807 // sock_ to be buffered. | |
| 808 // The payload from the single large data frame will be read across | |
| 809 // two different reads. | |
| 810 AssertSyncReadEquals(kMsg33, kLen33); | |
| 811 | |
| 812 // Now attempt to do a read of more data than remains buffered | |
| 813 scoped_refptr<IOBuffer> buf(new IOBuffer(kLen33)); | |
| 814 ASSERT_EQ(kLen3, sock_->Read(buf.get(), kLen33, read_callback_.callback())); | |
| 815 ASSERT_EQ(std::string(kMsg3, kLen3), std::string(buf->data(), kLen3)); | |
| 816 ASSERT_TRUE(sock_->IsConnected()); | |
| 817 } | |
| 818 | |
| 819 TEST_P(SpdyProxyClientSocketTest, ReadAuthResponseBody) { | |
| 820 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 821 MockWrite writes[] = { | |
| 822 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 823 }; | |
| 824 | |
| 825 scoped_ptr<SpdyFrame> resp(ConstructConnectAuthReplyFrame()); | |
| 826 scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); | |
| 827 scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2)); | |
| 828 MockRead reads[] = { | |
| 829 CreateMockRead(*resp, 1, ASYNC), | |
| 830 CreateMockRead(*msg1, 2, ASYNC), | |
| 831 CreateMockRead(*msg2, 3, ASYNC), | |
| 832 MockRead(ASYNC, 0, 4), // EOF | |
| 833 }; | |
| 834 | |
| 835 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 836 | |
| 837 AssertConnectFails(ERR_PROXY_AUTH_REQUESTED); | |
| 838 | |
| 839 Run(2); // SpdySession consumes the next two reads and sends then to | |
| 840 // sock_ to be buffered. | |
| 841 AssertSyncReadEquals(kMsg1, kLen1); | |
| 842 AssertSyncReadEquals(kMsg2, kLen2); | |
| 843 } | |
| 844 | |
| 845 TEST_P(SpdyProxyClientSocketTest, ReadErrorResponseBody) { | |
| 846 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 847 MockWrite writes[] = { | |
| 848 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 849 }; | |
| 850 | |
| 851 scoped_ptr<SpdyFrame> resp(ConstructConnectErrorReplyFrame()); | |
| 852 scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); | |
| 853 scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2)); | |
| 854 MockRead reads[] = { | |
| 855 CreateMockRead(*resp, 1, ASYNC), | |
| 856 CreateMockRead(*msg1, 2, ASYNC), | |
| 857 CreateMockRead(*msg2, 3, ASYNC), | |
| 858 MockRead(ASYNC, 0, 4), // EOF | |
| 859 }; | |
| 860 | |
| 861 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 862 | |
| 863 AssertConnectFails(ERR_TUNNEL_CONNECTION_FAILED); | |
| 864 } | |
| 865 | |
| 866 // ----------- Reads and Writes | |
| 867 | |
| 868 TEST_P(SpdyProxyClientSocketTest, AsyncReadAroundWrite) { | |
| 869 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 870 scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2)); | |
| 871 MockWrite writes[] = { | |
| 872 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 873 CreateMockWrite(*msg2, 3, SYNCHRONOUS), | |
| 874 }; | |
| 875 | |
| 876 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 877 scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); | |
| 878 scoped_ptr<SpdyFrame> msg3(ConstructBodyFrame(kMsg3, kLen3)); | |
| 879 MockRead reads[] = { | |
| 880 CreateMockRead(*resp, 1, ASYNC), | |
| 881 CreateMockRead(*msg1, 2, ASYNC), // sync read | |
| 882 CreateMockRead(*msg3, 4, ASYNC), // async read | |
| 883 MockRead(ASYNC, 0, 5), // EOF | |
| 884 }; | |
| 885 | |
| 886 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 887 | |
| 888 AssertConnectSucceeds(); | |
| 889 | |
| 890 Run(1); | |
| 891 AssertSyncReadEquals(kMsg1, kLen1); | |
| 892 | |
| 893 AssertReadStarts(kMsg3, kLen3); | |
| 894 // Read should block until after the write succeeds | |
| 895 | |
| 896 AssertAsyncWriteSucceeds(kMsg2, kLen2); // Runs 1 step | |
| 897 | |
| 898 ASSERT_FALSE(read_callback_.have_result()); | |
| 899 Run(1); | |
| 900 // Now the read will return | |
| 901 AssertReadReturns(kMsg3, kLen3); | |
| 902 } | |
| 903 | |
| 904 TEST_P(SpdyProxyClientSocketTest, AsyncWriteAroundReads) { | |
| 905 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 906 scoped_ptr<SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2)); | |
| 907 MockWrite writes[] = { | |
| 908 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 909 CreateMockWrite(*msg2, 4, ASYNC), | |
| 910 }; | |
| 911 | |
| 912 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 913 scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); | |
| 914 scoped_ptr<SpdyFrame> msg3(ConstructBodyFrame(kMsg3, kLen3)); | |
| 915 MockRead reads[] = { | |
| 916 CreateMockRead(*resp, 1, ASYNC), | |
| 917 CreateMockRead(*msg1, 2, ASYNC), | |
| 918 CreateMockRead(*msg3, 3, ASYNC), | |
| 919 MockRead(ASYNC, 0, 5), // EOF | |
| 920 }; | |
| 921 | |
| 922 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 923 | |
| 924 AssertConnectSucceeds(); | |
| 925 | |
| 926 Run(1); | |
| 927 AssertSyncReadEquals(kMsg1, kLen1); | |
| 928 // Write should block until the read completes | |
| 929 AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING); | |
| 930 | |
| 931 AssertAsyncReadEquals(kMsg3, kLen3); | |
| 932 | |
| 933 ASSERT_FALSE(write_callback_.have_result()); | |
| 934 | |
| 935 // Now the write will complete | |
| 936 Run(1); | |
| 937 AssertWriteLength(kLen2); | |
| 938 } | |
| 939 | |
| 940 // ----------- Reading/Writing on Closed socket | |
| 941 | |
| 942 // Reading from an already closed socket should return 0 | |
| 943 TEST_P(SpdyProxyClientSocketTest, ReadOnClosedSocketReturnsZero) { | |
| 944 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 945 MockWrite writes[] = { | |
| 946 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 947 }; | |
| 948 | |
| 949 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 950 MockRead reads[] = { | |
| 951 CreateMockRead(*resp, 1, ASYNC), | |
| 952 MockRead(ASYNC, 0, 2), // EOF | |
| 953 }; | |
| 954 | |
| 955 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 956 | |
| 957 AssertConnectSucceeds(); | |
| 958 | |
| 959 Run(1); | |
| 960 | |
| 961 ASSERT_FALSE(sock_->IsConnected()); | |
| 962 ASSERT_EQ(0, sock_->Read(NULL, 1, CompletionCallback())); | |
| 963 ASSERT_EQ(0, sock_->Read(NULL, 1, CompletionCallback())); | |
| 964 ASSERT_EQ(0, sock_->Read(NULL, 1, CompletionCallback())); | |
| 965 ASSERT_FALSE(sock_->IsConnectedAndIdle()); | |
| 966 } | |
| 967 | |
| 968 // Read pending when socket is closed should return 0 | |
| 969 TEST_P(SpdyProxyClientSocketTest, PendingReadOnCloseReturnsZero) { | |
| 970 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 971 MockWrite writes[] = { | |
| 972 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 973 }; | |
| 974 | |
| 975 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 976 MockRead reads[] = { | |
| 977 CreateMockRead(*resp, 1, ASYNC), | |
| 978 MockRead(ASYNC, 0, 2), // EOF | |
| 979 }; | |
| 980 | |
| 981 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 982 | |
| 983 AssertConnectSucceeds(); | |
| 984 | |
| 985 AssertReadStarts(kMsg1, kLen1); | |
| 986 | |
| 987 Run(1); | |
| 988 | |
| 989 ASSERT_EQ(0, read_callback_.WaitForResult()); | |
| 990 } | |
| 991 | |
| 992 // Reading from a disconnected socket is an error | |
| 993 TEST_P(SpdyProxyClientSocketTest, | |
| 994 ReadOnDisconnectSocketReturnsNotConnected) { | |
| 995 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 996 scoped_ptr<SpdyFrame> rst( | |
| 997 spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL)); | |
| 998 MockWrite writes[] = { | |
| 999 CreateMockWrite(*conn, 0, SYNCHRONOUS), CreateMockWrite(*rst, 2), | |
| 1000 }; | |
| 1001 | |
| 1002 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 1003 MockRead reads[] = { | |
| 1004 CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 3), // EOF | |
| 1005 }; | |
| 1006 | |
| 1007 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 1008 | |
| 1009 AssertConnectSucceeds(); | |
| 1010 | |
| 1011 sock_->Disconnect(); | |
| 1012 | |
| 1013 ASSERT_EQ(ERR_SOCKET_NOT_CONNECTED, | |
| 1014 sock_->Read(NULL, 1, CompletionCallback())); | |
| 1015 | |
| 1016 // Let the RST_STREAM write while |rst| is in-scope. | |
| 1017 base::MessageLoop::current()->RunUntilIdle(); | |
| 1018 } | |
| 1019 | |
| 1020 // Reading buffered data from an already closed socket should return | |
| 1021 // buffered data, then 0. | |
| 1022 TEST_P(SpdyProxyClientSocketTest, ReadOnClosedSocketReturnsBufferedData) { | |
| 1023 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 1024 MockWrite writes[] = { | |
| 1025 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 1026 }; | |
| 1027 | |
| 1028 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 1029 scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); | |
| 1030 MockRead reads[] = { | |
| 1031 CreateMockRead(*resp, 1, ASYNC), | |
| 1032 CreateMockRead(*msg1, 2, ASYNC), | |
| 1033 MockRead(ASYNC, 0, 3), // EOF | |
| 1034 }; | |
| 1035 | |
| 1036 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 1037 | |
| 1038 AssertConnectSucceeds(); | |
| 1039 | |
| 1040 Run(2); | |
| 1041 | |
| 1042 ASSERT_FALSE(sock_->IsConnected()); | |
| 1043 scoped_refptr<IOBuffer> buf(new IOBuffer(kLen1)); | |
| 1044 ASSERT_EQ(kLen1, sock_->Read(buf.get(), kLen1, CompletionCallback())); | |
| 1045 ASSERT_EQ(std::string(kMsg1, kLen1), std::string(buf->data(), kLen1)); | |
| 1046 | |
| 1047 ASSERT_EQ(0, sock_->Read(NULL, 1, CompletionCallback())); | |
| 1048 ASSERT_EQ(0, sock_->Read(NULL, 1, CompletionCallback())); | |
| 1049 sock_->Disconnect(); | |
| 1050 ASSERT_EQ(ERR_SOCKET_NOT_CONNECTED, | |
| 1051 sock_->Read(NULL, 1, CompletionCallback())); | |
| 1052 } | |
| 1053 | |
| 1054 // Calling Write() on a closed socket is an error | |
| 1055 TEST_P(SpdyProxyClientSocketTest, WriteOnClosedStream) { | |
| 1056 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 1057 MockWrite writes[] = { | |
| 1058 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 1059 }; | |
| 1060 | |
| 1061 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 1062 scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); | |
| 1063 MockRead reads[] = { | |
| 1064 CreateMockRead(*resp, 1, ASYNC), | |
| 1065 MockRead(ASYNC, 0, 2), // EOF | |
| 1066 }; | |
| 1067 | |
| 1068 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 1069 | |
| 1070 AssertConnectSucceeds(); | |
| 1071 | |
| 1072 Run(1); // Read EOF which will close the stream | |
| 1073 scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1)); | |
| 1074 EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, | |
| 1075 sock_->Write(buf.get(), buf->size(), CompletionCallback())); | |
| 1076 } | |
| 1077 | |
| 1078 // Calling Write() on a disconnected socket is an error | |
| 1079 TEST_P(SpdyProxyClientSocketTest, WriteOnDisconnectedSocket) { | |
| 1080 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 1081 scoped_ptr<SpdyFrame> rst( | |
| 1082 spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL)); | |
| 1083 MockWrite writes[] = { | |
| 1084 CreateMockWrite(*conn, 0, SYNCHRONOUS), CreateMockWrite(*rst, 2), | |
| 1085 }; | |
| 1086 | |
| 1087 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 1088 scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); | |
| 1089 MockRead reads[] = { | |
| 1090 CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 3), // EOF | |
| 1091 }; | |
| 1092 | |
| 1093 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 1094 | |
| 1095 AssertConnectSucceeds(); | |
| 1096 | |
| 1097 sock_->Disconnect(); | |
| 1098 | |
| 1099 scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1)); | |
| 1100 EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, | |
| 1101 sock_->Write(buf.get(), buf->size(), CompletionCallback())); | |
| 1102 | |
| 1103 // Let the RST_STREAM write while |rst| is in-scope. | |
| 1104 base::MessageLoop::current()->RunUntilIdle(); | |
| 1105 } | |
| 1106 | |
| 1107 // If the socket is closed with a pending Write(), the callback | |
| 1108 // should be called with ERR_CONNECTION_CLOSED. | |
| 1109 TEST_P(SpdyProxyClientSocketTest, WritePendingOnClose) { | |
| 1110 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 1111 MockWrite writes[] = { | |
| 1112 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 1113 MockWrite(ASYNC, ERR_ABORTED, 2), | |
| 1114 }; | |
| 1115 | |
| 1116 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 1117 MockRead reads[] = { | |
| 1118 CreateMockRead(*resp, 1, ASYNC), | |
| 1119 MockRead(ASYNC, 0, 3), // EOF | |
| 1120 }; | |
| 1121 | |
| 1122 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 1123 | |
| 1124 AssertConnectSucceeds(); | |
| 1125 | |
| 1126 EXPECT_TRUE(sock_->IsConnected()); | |
| 1127 | |
| 1128 scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1)); | |
| 1129 EXPECT_EQ(ERR_IO_PENDING, | |
| 1130 sock_->Write(buf.get(), buf->size(), write_callback_.callback())); | |
| 1131 | |
| 1132 CloseSpdySession(ERR_ABORTED, std::string()); | |
| 1133 | |
| 1134 EXPECT_EQ(ERR_CONNECTION_CLOSED, write_callback_.WaitForResult()); | |
| 1135 } | |
| 1136 | |
| 1137 // If the socket is Disconnected with a pending Write(), the callback | |
| 1138 // should not be called. | |
| 1139 TEST_P(SpdyProxyClientSocketTest, DisconnectWithWritePending) { | |
| 1140 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 1141 scoped_ptr<SpdyFrame> rst( | |
| 1142 spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL)); | |
| 1143 MockWrite writes[] = { | |
| 1144 CreateMockWrite(*conn, 0, SYNCHRONOUS), CreateMockWrite(*rst, 2), | |
| 1145 MockWrite(SYNCHRONOUS, 0, 3), // EOF | |
| 1146 }; | |
| 1147 | |
| 1148 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 1149 MockRead reads[] = { | |
| 1150 CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 4), // EOF | |
| 1151 }; | |
| 1152 | |
| 1153 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 1154 | |
| 1155 AssertConnectSucceeds(); | |
| 1156 | |
| 1157 EXPECT_TRUE(sock_->IsConnected()); | |
| 1158 | |
| 1159 scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1)); | |
| 1160 EXPECT_EQ(ERR_IO_PENDING, | |
| 1161 sock_->Write(buf.get(), buf->size(), write_callback_.callback())); | |
| 1162 | |
| 1163 sock_->Disconnect(); | |
| 1164 | |
| 1165 EXPECT_FALSE(sock_->IsConnected()); | |
| 1166 EXPECT_FALSE(write_callback_.have_result()); | |
| 1167 | |
| 1168 // Let the RST_STREAM write while |rst| is in-scope. | |
| 1169 base::MessageLoop::current()->RunUntilIdle(); | |
| 1170 } | |
| 1171 | |
| 1172 // If the socket is Disconnected with a pending Read(), the callback | |
| 1173 // should not be called. | |
| 1174 TEST_P(SpdyProxyClientSocketTest, DisconnectWithReadPending) { | |
| 1175 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 1176 scoped_ptr<SpdyFrame> rst( | |
| 1177 spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL)); | |
| 1178 MockWrite writes[] = { | |
| 1179 CreateMockWrite(*conn, 0, SYNCHRONOUS), CreateMockWrite(*rst, 2), | |
| 1180 }; | |
| 1181 | |
| 1182 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 1183 MockRead reads[] = { | |
| 1184 CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 3), // EOF | |
| 1185 }; | |
| 1186 | |
| 1187 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 1188 | |
| 1189 AssertConnectSucceeds(); | |
| 1190 | |
| 1191 EXPECT_TRUE(sock_->IsConnected()); | |
| 1192 | |
| 1193 scoped_refptr<IOBuffer> buf(new IOBuffer(kLen1)); | |
| 1194 ASSERT_EQ(ERR_IO_PENDING, | |
| 1195 sock_->Read(buf.get(), kLen1, read_callback_.callback())); | |
| 1196 | |
| 1197 sock_->Disconnect(); | |
| 1198 | |
| 1199 EXPECT_FALSE(sock_->IsConnected()); | |
| 1200 EXPECT_FALSE(read_callback_.have_result()); | |
| 1201 | |
| 1202 // Let the RST_STREAM write while |rst| is in-scope. | |
| 1203 base::MessageLoop::current()->RunUntilIdle(); | |
| 1204 } | |
| 1205 | |
| 1206 // If the socket is Reset when both a read and write are pending, | |
| 1207 // both should be called back. | |
| 1208 TEST_P(SpdyProxyClientSocketTest, RstWithReadAndWritePending) { | |
| 1209 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 1210 MockWrite writes[] = { | |
| 1211 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 1212 MockWrite(ASYNC, ERR_ABORTED, 3), | |
| 1213 }; | |
| 1214 | |
| 1215 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 1216 scoped_ptr<SpdyFrame> rst( | |
| 1217 spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL)); | |
| 1218 MockRead reads[] = { | |
| 1219 CreateMockRead(*resp, 1, ASYNC), | |
| 1220 CreateMockRead(*rst, 2, ASYNC), | |
| 1221 MockRead(ASYNC, 0, 4) // EOF | |
| 1222 }; | |
| 1223 | |
| 1224 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 1225 | |
| 1226 AssertConnectSucceeds(); | |
| 1227 | |
| 1228 EXPECT_TRUE(sock_->IsConnected()); | |
| 1229 | |
| 1230 scoped_refptr<IOBuffer> read_buf(new IOBuffer(kLen1)); | |
| 1231 ASSERT_EQ(ERR_IO_PENDING, | |
| 1232 sock_->Read(read_buf.get(), kLen1, read_callback_.callback())); | |
| 1233 | |
| 1234 scoped_refptr<IOBufferWithSize> write_buf(CreateBuffer(kMsg1, kLen1)); | |
| 1235 EXPECT_EQ( | |
| 1236 ERR_IO_PENDING, | |
| 1237 sock_->Write( | |
| 1238 write_buf.get(), write_buf->size(), write_callback_.callback())); | |
| 1239 | |
| 1240 Run(2); | |
| 1241 | |
| 1242 EXPECT_TRUE(sock_.get()); | |
| 1243 EXPECT_TRUE(read_callback_.have_result()); | |
| 1244 EXPECT_TRUE(write_callback_.have_result()); | |
| 1245 | |
| 1246 // Let the RST_STREAM write while |rst| is in-scope. | |
| 1247 base::MessageLoop::current()->RunUntilIdle(); | |
| 1248 } | |
| 1249 | |
| 1250 // Makes sure the proxy client socket's source gets the expected NetLog events | |
| 1251 // and only the expected NetLog events (No SpdySession events). | |
| 1252 TEST_P(SpdyProxyClientSocketTest, NetLog) { | |
| 1253 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 1254 scoped_ptr<SpdyFrame> rst( | |
| 1255 spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL)); | |
| 1256 MockWrite writes[] = { | |
| 1257 CreateMockWrite(*conn, 0, SYNCHRONOUS), CreateMockWrite(*rst, 3), | |
| 1258 }; | |
| 1259 | |
| 1260 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 1261 scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); | |
| 1262 MockRead reads[] = { | |
| 1263 CreateMockRead(*resp, 1, ASYNC), CreateMockRead(*msg1, 2, ASYNC), | |
| 1264 MockRead(ASYNC, 0, 4), // EOF | |
| 1265 }; | |
| 1266 | |
| 1267 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 1268 | |
| 1269 AssertConnectSucceeds(); | |
| 1270 | |
| 1271 Run(1); // SpdySession consumes the next read and sends it to | |
| 1272 // sock_ to be buffered. | |
| 1273 AssertSyncReadEquals(kMsg1, kLen1); | |
| 1274 | |
| 1275 NetLog::Source sock_source = sock_->NetLog().source(); | |
| 1276 sock_.reset(); | |
| 1277 | |
| 1278 CapturingNetLog::CapturedEntryList entry_list; | |
| 1279 net_log_.GetEntriesForSource(sock_source, &entry_list); | |
| 1280 | |
| 1281 ASSERT_EQ(entry_list.size(), 10u); | |
| 1282 EXPECT_TRUE(LogContainsBeginEvent(entry_list, 0, NetLog::TYPE_SOCKET_ALIVE)); | |
| 1283 EXPECT_TRUE(LogContainsEvent(entry_list, 1, | |
| 1284 NetLog::TYPE_SPDY_PROXY_CLIENT_SESSION, | |
| 1285 NetLog::PHASE_NONE)); | |
| 1286 EXPECT_TRUE(LogContainsBeginEvent(entry_list, 2, | |
| 1287 NetLog::TYPE_HTTP_TRANSACTION_TUNNEL_SEND_REQUEST)); | |
| 1288 EXPECT_TRUE(LogContainsEvent(entry_list, 3, | |
| 1289 NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS, | |
| 1290 NetLog::PHASE_NONE)); | |
| 1291 EXPECT_TRUE(LogContainsEndEvent(entry_list, 4, | |
| 1292 NetLog::TYPE_HTTP_TRANSACTION_TUNNEL_SEND_REQUEST)); | |
| 1293 EXPECT_TRUE(LogContainsBeginEvent(entry_list, 5, | |
| 1294 NetLog::TYPE_HTTP_TRANSACTION_TUNNEL_READ_HEADERS)); | |
| 1295 EXPECT_TRUE(LogContainsEvent(entry_list, 6, | |
| 1296 NetLog::TYPE_HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS, | |
| 1297 NetLog::PHASE_NONE)); | |
| 1298 EXPECT_TRUE(LogContainsEndEvent(entry_list, 7, | |
| 1299 NetLog::TYPE_HTTP_TRANSACTION_TUNNEL_READ_HEADERS)); | |
| 1300 EXPECT_TRUE(LogContainsEvent(entry_list, 8, | |
| 1301 NetLog::TYPE_SOCKET_BYTES_RECEIVED, | |
| 1302 NetLog::PHASE_NONE)); | |
| 1303 EXPECT_TRUE(LogContainsEndEvent(entry_list, 9, NetLog::TYPE_SOCKET_ALIVE)); | |
| 1304 | |
| 1305 // Let the RST_STREAM write while |rst| is in-scope. | |
| 1306 base::MessageLoop::current()->RunUntilIdle(); | |
| 1307 } | |
| 1308 | |
| 1309 // CompletionCallback that causes the SpdyProxyClientSocket to be | |
| 1310 // deleted when Run is invoked. | |
| 1311 class DeleteSockCallback : public TestCompletionCallbackBase { | |
| 1312 public: | |
| 1313 explicit DeleteSockCallback(scoped_ptr<SpdyProxyClientSocket>* sock) | |
| 1314 : sock_(sock), | |
| 1315 callback_(base::Bind(&DeleteSockCallback::OnComplete, | |
| 1316 base::Unretained(this))) { | |
| 1317 } | |
| 1318 | |
| 1319 ~DeleteSockCallback() override {} | |
| 1320 | |
| 1321 const CompletionCallback& callback() const { return callback_; } | |
| 1322 | |
| 1323 private: | |
| 1324 void OnComplete(int result) { | |
| 1325 sock_->reset(NULL); | |
| 1326 SetResult(result); | |
| 1327 } | |
| 1328 | |
| 1329 scoped_ptr<SpdyProxyClientSocket>* sock_; | |
| 1330 CompletionCallback callback_; | |
| 1331 | |
| 1332 DISALLOW_COPY_AND_ASSIGN(DeleteSockCallback); | |
| 1333 }; | |
| 1334 | |
| 1335 // If the socket is Reset when both a read and write are pending, and the | |
| 1336 // read callback causes the socket to be deleted, the write callback should | |
| 1337 // not be called. | |
| 1338 TEST_P(SpdyProxyClientSocketTest, RstWithReadAndWritePendingDelete) { | |
| 1339 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | |
| 1340 MockWrite writes[] = { | |
| 1341 CreateMockWrite(*conn, 0, SYNCHRONOUS), | |
| 1342 MockWrite(ASYNC, ERR_ABORTED, 3), | |
| 1343 }; | |
| 1344 | |
| 1345 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | |
| 1346 scoped_ptr<SpdyFrame> rst( | |
| 1347 spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL)); | |
| 1348 MockRead reads[] = { | |
| 1349 CreateMockRead(*resp, 1, ASYNC), | |
| 1350 CreateMockRead(*rst, 2, ASYNC), | |
| 1351 MockRead(ASYNC, 0, 4), // EOF | |
| 1352 }; | |
| 1353 | |
| 1354 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | |
| 1355 | |
| 1356 AssertConnectSucceeds(); | |
| 1357 | |
| 1358 EXPECT_TRUE(sock_->IsConnected()); | |
| 1359 | |
| 1360 DeleteSockCallback read_callback(&sock_); | |
| 1361 | |
| 1362 scoped_refptr<IOBuffer> read_buf(new IOBuffer(kLen1)); | |
| 1363 ASSERT_EQ(ERR_IO_PENDING, | |
| 1364 sock_->Read(read_buf.get(), kLen1, read_callback.callback())); | |
| 1365 | |
| 1366 scoped_refptr<IOBufferWithSize> write_buf(CreateBuffer(kMsg1, kLen1)); | |
| 1367 EXPECT_EQ( | |
| 1368 ERR_IO_PENDING, | |
| 1369 sock_->Write( | |
| 1370 write_buf.get(), write_buf->size(), write_callback_.callback())); | |
| 1371 | |
| 1372 Run(1); | |
| 1373 | |
| 1374 EXPECT_FALSE(sock_.get()); | |
| 1375 EXPECT_TRUE(read_callback.have_result()); | |
| 1376 EXPECT_FALSE(write_callback_.have_result()); | |
| 1377 | |
| 1378 // Let the RST_STREAM write while |rst| is in-scope. | |
| 1379 base::MessageLoop::current()->RunUntilIdle(); | |
| 1380 } | |
| 1381 | |
| 1382 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master