OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/spdy/spdy_proxy_client_socket.h" | 5 #include "net/spdy/spdy_proxy_client_socket.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/bind_helpers.h" | 8 #include "base/bind_helpers.h" |
9 #include "base/utf_string_conversions.h" | 9 #include "base/utf_string_conversions.h" |
10 #include "net/base/address_list.h" | 10 #include "net/base/address_list.h" |
(...skipping 147 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
158 transport_params_(new TransportSocketParams(proxy_host_port_, | 158 transport_params_(new TransportSocketParams(proxy_host_port_, |
159 LOWEST, | 159 LOWEST, |
160 false, | 160 false, |
161 false, | 161 false, |
162 OnHostResolutionCallback())) { | 162 OnHostResolutionCallback())) { |
163 session_deps_.net_log = net_log_.bound().net_log(); | 163 session_deps_.net_log = net_log_.bound().net_log(); |
164 } | 164 } |
165 | 165 |
166 void SpdyProxyClientSocketTest::TearDown() { | 166 void SpdyProxyClientSocketTest::TearDown() { |
167 sock_.reset(NULL); | 167 sock_.reset(NULL); |
168 if (session_ != NULL) | 168 if (session_.get() != NULL) |
169 session_->spdy_session_pool()->CloseAllSessions(); | 169 session_->spdy_session_pool()->CloseAllSessions(); |
170 | 170 |
171 // Empty the current queue. | 171 // Empty the current queue. |
172 base::MessageLoop::current()->RunUntilIdle(); | 172 base::MessageLoop::current()->RunUntilIdle(); |
173 PlatformTest::TearDown(); | 173 PlatformTest::TearDown(); |
174 } | 174 } |
175 | 175 |
176 void SpdyProxyClientSocketTest::Initialize(MockRead* reads, | 176 void SpdyProxyClientSocketTest::Initialize(MockRead* reads, |
177 size_t reads_count, | 177 size_t reads_count, |
178 MockWrite* writes, | 178 MockWrite* writes, |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
242 void SpdyProxyClientSocketTest::AssertConnectionEstablished() { | 242 void SpdyProxyClientSocketTest::AssertConnectionEstablished() { |
243 const HttpResponseInfo* response = sock_->GetConnectResponseInfo(); | 243 const HttpResponseInfo* response = sock_->GetConnectResponseInfo(); |
244 ASSERT_TRUE(response != NULL); | 244 ASSERT_TRUE(response != NULL); |
245 ASSERT_EQ(200, response->headers->response_code()); | 245 ASSERT_EQ(200, response->headers->response_code()); |
246 ASSERT_EQ("Connection Established", response->headers->GetStatusText()); | 246 ASSERT_EQ("Connection Established", response->headers->GetStatusText()); |
247 } | 247 } |
248 | 248 |
249 void SpdyProxyClientSocketTest::AssertSyncReadEquals(const char* data, | 249 void SpdyProxyClientSocketTest::AssertSyncReadEquals(const char* data, |
250 int len) { | 250 int len) { |
251 scoped_refptr<IOBuffer> buf(new IOBuffer(len)); | 251 scoped_refptr<IOBuffer> buf(new IOBuffer(len)); |
252 ASSERT_EQ(len, sock_->Read(buf, len, CompletionCallback())); | 252 ASSERT_EQ(len, sock_->Read(buf.get(), len, CompletionCallback())); |
253 ASSERT_EQ(std::string(data, len), std::string(buf->data(), len)); | 253 ASSERT_EQ(std::string(data, len), std::string(buf->data(), len)); |
254 ASSERT_TRUE(sock_->IsConnected()); | 254 ASSERT_TRUE(sock_->IsConnected()); |
255 } | 255 } |
256 | 256 |
257 void SpdyProxyClientSocketTest::AssertAsyncReadEquals(const char* data, | 257 void SpdyProxyClientSocketTest::AssertAsyncReadEquals(const char* data, |
258 int len) { | 258 int len) { |
259 data_->StopAfter(1); | 259 data_->StopAfter(1); |
260 // Issue the read, which will be completed asynchronously | 260 // Issue the read, which will be completed asynchronously |
261 scoped_refptr<IOBuffer> buf(new IOBuffer(len)); | 261 scoped_refptr<IOBuffer> buf(new IOBuffer(len)); |
262 ASSERT_EQ(ERR_IO_PENDING, sock_->Read(buf, len, read_callback_.callback())); | 262 ASSERT_EQ(ERR_IO_PENDING, |
| 263 sock_->Read(buf.get(), len, read_callback_.callback())); |
263 EXPECT_TRUE(sock_->IsConnected()); | 264 EXPECT_TRUE(sock_->IsConnected()); |
264 data_->Run(); | 265 data_->Run(); |
265 | 266 |
266 EXPECT_TRUE(sock_->IsConnected()); | 267 EXPECT_TRUE(sock_->IsConnected()); |
267 | 268 |
268 // Now the read will return | 269 // Now the read will return |
269 EXPECT_EQ(len, read_callback_.WaitForResult()); | 270 EXPECT_EQ(len, read_callback_.WaitForResult()); |
270 ASSERT_EQ(std::string(data, len), std::string(buf->data(), len)); | 271 ASSERT_EQ(std::string(data, len), std::string(buf->data(), len)); |
271 } | 272 } |
272 | 273 |
273 void SpdyProxyClientSocketTest::AssertReadStarts(const char* data, | 274 void SpdyProxyClientSocketTest::AssertReadStarts(const char* data, |
274 int len) { | 275 int len) { |
275 data_->StopAfter(1); | 276 data_->StopAfter(1); |
276 // Issue the read, which will be completed asynchronously | 277 // Issue the read, which will be completed asynchronously |
277 read_buf_ = new IOBuffer(len); | 278 read_buf_ = new IOBuffer(len); |
278 ASSERT_EQ(ERR_IO_PENDING, | 279 ASSERT_EQ(ERR_IO_PENDING, |
279 sock_->Read(read_buf_, len, read_callback_.callback())); | 280 sock_->Read(read_buf_.get(), len, read_callback_.callback())); |
280 EXPECT_TRUE(sock_->IsConnected()); | 281 EXPECT_TRUE(sock_->IsConnected()); |
281 } | 282 } |
282 | 283 |
283 void SpdyProxyClientSocketTest::AssertReadReturns(const char* data, | 284 void SpdyProxyClientSocketTest::AssertReadReturns(const char* data, |
284 int len) { | 285 int len) { |
285 EXPECT_TRUE(sock_->IsConnected()); | 286 EXPECT_TRUE(sock_->IsConnected()); |
286 | 287 |
287 // Now the read will return | 288 // Now the read will return |
288 EXPECT_EQ(len, read_callback_.WaitForResult()); | 289 EXPECT_EQ(len, read_callback_.WaitForResult()); |
289 ASSERT_EQ(std::string(data, len), std::string(read_buf_->data(), len)); | 290 ASSERT_EQ(std::string(data, len), std::string(read_buf_->data(), len)); |
290 } | 291 } |
291 | 292 |
292 void SpdyProxyClientSocketTest::AssertAsyncWriteSucceeds(const char* data, | 293 void SpdyProxyClientSocketTest::AssertAsyncWriteSucceeds(const char* data, |
293 int len) { | 294 int len) { |
294 AssertWriteReturns(data, len, ERR_IO_PENDING); | 295 AssertWriteReturns(data, len, ERR_IO_PENDING); |
295 data_->RunFor(1); | 296 data_->RunFor(1); |
296 AssertWriteLength(len); | 297 AssertWriteLength(len); |
297 } | 298 } |
298 | 299 |
299 void SpdyProxyClientSocketTest::AssertWriteReturns(const char* data, | 300 void SpdyProxyClientSocketTest::AssertWriteReturns(const char* data, |
300 int len, | 301 int len, |
301 int rv) { | 302 int rv) { |
302 scoped_refptr<IOBufferWithSize> buf(CreateBuffer(data, len)); | 303 scoped_refptr<IOBufferWithSize> buf(CreateBuffer(data, len)); |
303 EXPECT_EQ(rv, sock_->Write(buf, buf->size(), write_callback_.callback())); | 304 EXPECT_EQ(rv, |
| 305 sock_->Write(buf.get(), buf->size(), write_callback_.callback())); |
304 } | 306 } |
305 | 307 |
306 void SpdyProxyClientSocketTest::AssertWriteLength(int len) { | 308 void SpdyProxyClientSocketTest::AssertWriteLength(int len) { |
307 EXPECT_EQ(len, write_callback_.WaitForResult()); | 309 EXPECT_EQ(len, write_callback_.WaitForResult()); |
308 } | 310 } |
309 | 311 |
310 void SpdyProxyClientSocketTest::AssertAsyncWriteWithReadsSucceeds( | 312 void SpdyProxyClientSocketTest::AssertAsyncWriteWithReadsSucceeds( |
311 const char* data, int len, int num_reads) { | 313 const char* data, int len, int num_reads) { |
312 scoped_refptr<IOBufferWithSize> buf(CreateBuffer(data, len)); | 314 scoped_refptr<IOBufferWithSize> buf(CreateBuffer(data, len)); |
313 | 315 |
314 EXPECT_EQ(ERR_IO_PENDING, sock_->Write(buf, buf->size(), | 316 EXPECT_EQ(ERR_IO_PENDING, |
315 write_callback_.callback())); | 317 sock_->Write(buf.get(), buf->size(), write_callback_.callback())); |
316 | 318 |
317 for (int i = 0; i < num_reads; i++) { | 319 for (int i = 0; i < num_reads; i++) { |
318 Run(1); | 320 Run(1); |
319 AssertSyncReadEquals(kMsg2, kLen2); | 321 AssertSyncReadEquals(kMsg2, kLen2); |
320 } | 322 } |
321 | 323 |
322 write_callback_.WaitForResult(); | 324 write_callback_.WaitForResult(); |
323 } | 325 } |
324 | 326 |
325 // Constructs a standard SPDY SYN_STREAM frame for a CONNECT request. | 327 // Constructs a standard SPDY SYN_STREAM frame for a CONNECT request. |
(...skipping 228 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
554 MockRead(ASYNC, 0, 2), // EOF | 556 MockRead(ASYNC, 0, 2), // EOF |
555 }; | 557 }; |
556 | 558 |
557 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | 559 Initialize(reads, arraysize(reads), writes, arraysize(writes)); |
558 | 560 |
559 AssertConnectFails(ERR_HTTPS_PROXY_TUNNEL_RESPONSE); | 561 AssertConnectFails(ERR_HTTPS_PROXY_TUNNEL_RESPONSE); |
560 | 562 |
561 const HttpResponseInfo* response = sock_->GetConnectResponseInfo(); | 563 const HttpResponseInfo* response = sock_->GetConnectResponseInfo(); |
562 ASSERT_TRUE(response != NULL); | 564 ASSERT_TRUE(response != NULL); |
563 | 565 |
564 const HttpResponseHeaders* headers = response->headers; | 566 const HttpResponseHeaders* headers = response->headers.get(); |
565 ASSERT_EQ(302, headers->response_code()); | 567 ASSERT_EQ(302, headers->response_code()); |
566 ASSERT_FALSE(headers->HasHeader("set-cookie")); | 568 ASSERT_FALSE(headers->HasHeader("set-cookie")); |
567 ASSERT_TRUE(headers->HasHeaderValue("content-length", "0")); | 569 ASSERT_TRUE(headers->HasHeaderValue("content-length", "0")); |
568 | 570 |
569 std::string location; | 571 std::string location; |
570 ASSERT_TRUE(headers->IsRedirect(&location)); | 572 ASSERT_TRUE(headers->IsRedirect(&location)); |
571 ASSERT_EQ(location, kRedirectUrl); | 573 ASSERT_EQ(location, kRedirectUrl); |
572 } | 574 } |
573 | 575 |
574 TEST_P(SpdyProxyClientSocketTest, ConnectFails) { | 576 TEST_P(SpdyProxyClientSocketTest, ConnectFails) { |
(...skipping 117 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
692 }; | 694 }; |
693 | 695 |
694 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | 696 Initialize(reads, arraysize(reads), writes, arraysize(writes)); |
695 | 697 |
696 AssertConnectSucceeds(); | 698 AssertConnectSucceeds(); |
697 | 699 |
698 std::string big_data(kMaxSpdyFrameChunkSize * 3, 'x'); | 700 std::string big_data(kMaxSpdyFrameChunkSize * 3, 'x'); |
699 scoped_refptr<IOBufferWithSize> buf(CreateBuffer(big_data.data(), | 701 scoped_refptr<IOBufferWithSize> buf(CreateBuffer(big_data.data(), |
700 big_data.length())); | 702 big_data.length())); |
701 | 703 |
702 EXPECT_EQ(ERR_IO_PENDING, sock_->Write(buf, buf->size(), | 704 EXPECT_EQ(ERR_IO_PENDING, |
703 write_callback_.callback())); | 705 sock_->Write(buf.get(), buf->size(), write_callback_.callback())); |
704 data_->RunFor(3); | 706 data_->RunFor(3); |
705 | 707 |
706 EXPECT_EQ(buf->size(), write_callback_.WaitForResult()); | 708 EXPECT_EQ(buf->size(), write_callback_.WaitForResult()); |
707 } | 709 } |
708 | 710 |
709 // ----------- Read | 711 // ----------- Read |
710 | 712 |
711 TEST_P(SpdyProxyClientSocketTest, ReadReadsDataInDataFrame) { | 713 TEST_P(SpdyProxyClientSocketTest, ReadReadsDataInDataFrame) { |
712 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | 714 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); |
713 MockWrite writes[] = { | 715 MockWrite writes[] = { |
(...skipping 180 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
894 AssertConnectSucceeds(); | 896 AssertConnectSucceeds(); |
895 | 897 |
896 Run(1); // SpdySession consumes the next read and sends it to | 898 Run(1); // SpdySession consumes the next read and sends it to |
897 // sock_ to be buffered. | 899 // sock_ to be buffered. |
898 // The payload from the single large data frame will be read across | 900 // The payload from the single large data frame will be read across |
899 // two different reads. | 901 // two different reads. |
900 AssertSyncReadEquals(kMsg33, kLen33); | 902 AssertSyncReadEquals(kMsg33, kLen33); |
901 | 903 |
902 // Now attempt to do a read of more data than remains buffered | 904 // Now attempt to do a read of more data than remains buffered |
903 scoped_refptr<IOBuffer> buf(new IOBuffer(kLen33)); | 905 scoped_refptr<IOBuffer> buf(new IOBuffer(kLen33)); |
904 ASSERT_EQ(kLen3, sock_->Read(buf, kLen33, read_callback_.callback())); | 906 ASSERT_EQ(kLen3, sock_->Read(buf.get(), kLen33, read_callback_.callback())); |
905 ASSERT_EQ(std::string(kMsg3, kLen3), std::string(buf->data(), kLen3)); | 907 ASSERT_EQ(std::string(kMsg3, kLen3), std::string(buf->data(), kLen3)); |
906 ASSERT_TRUE(sock_->IsConnected()); | 908 ASSERT_TRUE(sock_->IsConnected()); |
907 } | 909 } |
908 | 910 |
909 TEST_P(SpdyProxyClientSocketTest, ReadAuthResponseBody) { | 911 TEST_P(SpdyProxyClientSocketTest, ReadAuthResponseBody) { |
910 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | 912 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); |
911 MockWrite writes[] = { | 913 MockWrite writes[] = { |
912 CreateMockWrite(*conn, 0, SYNCHRONOUS), | 914 CreateMockWrite(*conn, 0, SYNCHRONOUS), |
913 }; | 915 }; |
914 | 916 |
(...skipping 205 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1120 }; | 1122 }; |
1121 | 1123 |
1122 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | 1124 Initialize(reads, arraysize(reads), writes, arraysize(writes)); |
1123 | 1125 |
1124 AssertConnectSucceeds(); | 1126 AssertConnectSucceeds(); |
1125 | 1127 |
1126 Run(2); | 1128 Run(2); |
1127 | 1129 |
1128 ASSERT_FALSE(sock_->IsConnected()); | 1130 ASSERT_FALSE(sock_->IsConnected()); |
1129 scoped_refptr<IOBuffer> buf(new IOBuffer(kLen1)); | 1131 scoped_refptr<IOBuffer> buf(new IOBuffer(kLen1)); |
1130 ASSERT_EQ(kLen1, sock_->Read(buf, kLen1, CompletionCallback())); | 1132 ASSERT_EQ(kLen1, sock_->Read(buf.get(), kLen1, CompletionCallback())); |
1131 ASSERT_EQ(std::string(kMsg1, kLen1), std::string(buf->data(), kLen1)); | 1133 ASSERT_EQ(std::string(kMsg1, kLen1), std::string(buf->data(), kLen1)); |
1132 | 1134 |
1133 ASSERT_EQ(0, sock_->Read(NULL, 1, CompletionCallback())); | 1135 ASSERT_EQ(0, sock_->Read(NULL, 1, CompletionCallback())); |
1134 ASSERT_EQ(0, sock_->Read(NULL, 1, CompletionCallback())); | 1136 ASSERT_EQ(0, sock_->Read(NULL, 1, CompletionCallback())); |
1135 sock_->Disconnect(); | 1137 sock_->Disconnect(); |
1136 ASSERT_EQ(ERR_SOCKET_NOT_CONNECTED, | 1138 ASSERT_EQ(ERR_SOCKET_NOT_CONNECTED, |
1137 sock_->Read(NULL, 1, CompletionCallback())); | 1139 sock_->Read(NULL, 1, CompletionCallback())); |
1138 } | 1140 } |
1139 | 1141 |
1140 // Calling Write() on a closed socket is an error | 1142 // Calling Write() on a closed socket is an error |
(...skipping 10 matching lines...) Expand all Loading... |
1151 MockRead(ASYNC, 0, 2), // EOF | 1153 MockRead(ASYNC, 0, 2), // EOF |
1152 }; | 1154 }; |
1153 | 1155 |
1154 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | 1156 Initialize(reads, arraysize(reads), writes, arraysize(writes)); |
1155 | 1157 |
1156 AssertConnectSucceeds(); | 1158 AssertConnectSucceeds(); |
1157 | 1159 |
1158 Run(1); // Read EOF which will close the stream | 1160 Run(1); // Read EOF which will close the stream |
1159 scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1)); | 1161 scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1)); |
1160 EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, | 1162 EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, |
1161 sock_->Write(buf, buf->size(), CompletionCallback())); | 1163 sock_->Write(buf.get(), buf->size(), CompletionCallback())); |
1162 } | 1164 } |
1163 | 1165 |
1164 // Calling Write() on a disconnected socket is an error | 1166 // Calling Write() on a disconnected socket is an error |
1165 TEST_P(SpdyProxyClientSocketTest, WriteOnDisconnectedSocket) { | 1167 TEST_P(SpdyProxyClientSocketTest, WriteOnDisconnectedSocket) { |
1166 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | 1168 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); |
1167 MockWrite writes[] = { | 1169 MockWrite writes[] = { |
1168 CreateMockWrite(*conn, 0, SYNCHRONOUS), | 1170 CreateMockWrite(*conn, 0, SYNCHRONOUS), |
1169 }; | 1171 }; |
1170 | 1172 |
1171 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | 1173 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); |
1172 scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); | 1174 scoped_ptr<SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1)); |
1173 MockRead reads[] = { | 1175 MockRead reads[] = { |
1174 CreateMockRead(*resp, 1, ASYNC), | 1176 CreateMockRead(*resp, 1, ASYNC), |
1175 MockRead(ASYNC, 0, 2), // EOF | 1177 MockRead(ASYNC, 0, 2), // EOF |
1176 }; | 1178 }; |
1177 | 1179 |
1178 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | 1180 Initialize(reads, arraysize(reads), writes, arraysize(writes)); |
1179 | 1181 |
1180 AssertConnectSucceeds(); | 1182 AssertConnectSucceeds(); |
1181 | 1183 |
1182 sock_->Disconnect(); | 1184 sock_->Disconnect(); |
1183 | 1185 |
1184 scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1)); | 1186 scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1)); |
1185 EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, | 1187 EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, |
1186 sock_->Write(buf, buf->size(), CompletionCallback())); | 1188 sock_->Write(buf.get(), buf->size(), CompletionCallback())); |
1187 } | 1189 } |
1188 | 1190 |
1189 // If the socket is closed with a pending Write(), the callback | 1191 // If the socket is closed with a pending Write(), the callback |
1190 // should be called with ERR_CONNECTION_CLOSED. | 1192 // should be called with ERR_CONNECTION_CLOSED. |
1191 TEST_P(SpdyProxyClientSocketTest, WritePendingOnClose) { | 1193 TEST_P(SpdyProxyClientSocketTest, WritePendingOnClose) { |
1192 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | 1194 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); |
1193 MockWrite writes[] = { | 1195 MockWrite writes[] = { |
1194 CreateMockWrite(*conn, 0, SYNCHRONOUS), | 1196 CreateMockWrite(*conn, 0, SYNCHRONOUS), |
1195 MockWrite(ASYNC, ERR_IO_PENDING, 2), | 1197 MockWrite(ASYNC, ERR_IO_PENDING, 2), |
1196 }; | 1198 }; |
1197 | 1199 |
1198 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | 1200 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); |
1199 MockRead reads[] = { | 1201 MockRead reads[] = { |
1200 CreateMockRead(*resp, 1, ASYNC), | 1202 CreateMockRead(*resp, 1, ASYNC), |
1201 MockRead(ASYNC, 0, 3), // EOF | 1203 MockRead(ASYNC, 0, 3), // EOF |
1202 }; | 1204 }; |
1203 | 1205 |
1204 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | 1206 Initialize(reads, arraysize(reads), writes, arraysize(writes)); |
1205 | 1207 |
1206 AssertConnectSucceeds(); | 1208 AssertConnectSucceeds(); |
1207 | 1209 |
1208 EXPECT_TRUE(sock_->IsConnected()); | 1210 EXPECT_TRUE(sock_->IsConnected()); |
1209 | 1211 |
1210 scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1)); | 1212 scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1)); |
1211 EXPECT_EQ(ERR_IO_PENDING, | 1213 EXPECT_EQ(ERR_IO_PENDING, |
1212 sock_->Write(buf, buf->size(), write_callback_.callback())); | 1214 sock_->Write(buf.get(), buf->size(), write_callback_.callback())); |
1213 | 1215 |
1214 Run(1); | 1216 Run(1); |
1215 | 1217 |
1216 EXPECT_EQ(ERR_CONNECTION_CLOSED, write_callback_.WaitForResult()); | 1218 EXPECT_EQ(ERR_CONNECTION_CLOSED, write_callback_.WaitForResult()); |
1217 } | 1219 } |
1218 | 1220 |
1219 // If the socket is Disconnected with a pending Write(), the callback | 1221 // If the socket is Disconnected with a pending Write(), the callback |
1220 // should not be called. | 1222 // should not be called. |
1221 TEST_P(SpdyProxyClientSocketTest, DisconnectWithWritePending) { | 1223 TEST_P(SpdyProxyClientSocketTest, DisconnectWithWritePending) { |
1222 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | 1224 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); |
1223 MockWrite writes[] = { | 1225 MockWrite writes[] = { |
1224 CreateMockWrite(*conn, 0, SYNCHRONOUS), | 1226 CreateMockWrite(*conn, 0, SYNCHRONOUS), |
1225 MockWrite(SYNCHRONOUS, 0, 2), // EOF | 1227 MockWrite(SYNCHRONOUS, 0, 2), // EOF |
1226 }; | 1228 }; |
1227 | 1229 |
1228 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | 1230 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); |
1229 MockRead reads[] = { | 1231 MockRead reads[] = { |
1230 CreateMockRead(*resp, 1, ASYNC), | 1232 CreateMockRead(*resp, 1, ASYNC), |
1231 MockRead(ASYNC, 0, 3), // EOF | 1233 MockRead(ASYNC, 0, 3), // EOF |
1232 }; | 1234 }; |
1233 | 1235 |
1234 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | 1236 Initialize(reads, arraysize(reads), writes, arraysize(writes)); |
1235 | 1237 |
1236 AssertConnectSucceeds(); | 1238 AssertConnectSucceeds(); |
1237 | 1239 |
1238 EXPECT_TRUE(sock_->IsConnected()); | 1240 EXPECT_TRUE(sock_->IsConnected()); |
1239 | 1241 |
1240 scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1)); | 1242 scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1)); |
1241 EXPECT_EQ(ERR_IO_PENDING, | 1243 EXPECT_EQ(ERR_IO_PENDING, |
1242 sock_->Write(buf, buf->size(), write_callback_.callback())); | 1244 sock_->Write(buf.get(), buf->size(), write_callback_.callback())); |
1243 | 1245 |
1244 sock_->Disconnect(); | 1246 sock_->Disconnect(); |
1245 | 1247 |
1246 EXPECT_FALSE(sock_->IsConnected()); | 1248 EXPECT_FALSE(sock_->IsConnected()); |
1247 EXPECT_FALSE(write_callback_.have_result()); | 1249 EXPECT_FALSE(write_callback_.have_result()); |
1248 } | 1250 } |
1249 | 1251 |
1250 // If the socket is Disconnected with a pending Read(), the callback | 1252 // If the socket is Disconnected with a pending Read(), the callback |
1251 // should not be called. | 1253 // should not be called. |
1252 TEST_P(SpdyProxyClientSocketTest, DisconnectWithReadPending) { | 1254 TEST_P(SpdyProxyClientSocketTest, DisconnectWithReadPending) { |
1253 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); | 1255 scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame()); |
1254 MockWrite writes[] = { | 1256 MockWrite writes[] = { |
1255 CreateMockWrite(*conn, 0, SYNCHRONOUS), | 1257 CreateMockWrite(*conn, 0, SYNCHRONOUS), |
1256 }; | 1258 }; |
1257 | 1259 |
1258 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); | 1260 scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame()); |
1259 MockRead reads[] = { | 1261 MockRead reads[] = { |
1260 CreateMockRead(*resp, 1, ASYNC), | 1262 CreateMockRead(*resp, 1, ASYNC), |
1261 MockRead(ASYNC, 0, 2), // EOF | 1263 MockRead(ASYNC, 0, 2), // EOF |
1262 }; | 1264 }; |
1263 | 1265 |
1264 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | 1266 Initialize(reads, arraysize(reads), writes, arraysize(writes)); |
1265 | 1267 |
1266 AssertConnectSucceeds(); | 1268 AssertConnectSucceeds(); |
1267 | 1269 |
1268 EXPECT_TRUE(sock_->IsConnected()); | 1270 EXPECT_TRUE(sock_->IsConnected()); |
1269 | 1271 |
1270 scoped_refptr<IOBuffer> buf(new IOBuffer(kLen1)); | 1272 scoped_refptr<IOBuffer> buf(new IOBuffer(kLen1)); |
1271 ASSERT_EQ(ERR_IO_PENDING, | 1273 ASSERT_EQ(ERR_IO_PENDING, |
1272 sock_->Read(buf, kLen1, read_callback_.callback())); | 1274 sock_->Read(buf.get(), kLen1, read_callback_.callback())); |
1273 | 1275 |
1274 sock_->Disconnect(); | 1276 sock_->Disconnect(); |
1275 | 1277 |
1276 EXPECT_FALSE(sock_->IsConnected()); | 1278 EXPECT_FALSE(sock_->IsConnected()); |
1277 EXPECT_FALSE(read_callback_.have_result()); | 1279 EXPECT_FALSE(read_callback_.have_result()); |
1278 } | 1280 } |
1279 | 1281 |
1280 // If the socket is Reset when both a read and write are pending, | 1282 // If the socket is Reset when both a read and write are pending, |
1281 // both should be called back. | 1283 // both should be called back. |
1282 TEST_P(SpdyProxyClientSocketTest, RstWithReadAndWritePending) { | 1284 TEST_P(SpdyProxyClientSocketTest, RstWithReadAndWritePending) { |
(...skipping 12 matching lines...) Expand all Loading... |
1295 }; | 1297 }; |
1296 | 1298 |
1297 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | 1299 Initialize(reads, arraysize(reads), writes, arraysize(writes)); |
1298 | 1300 |
1299 AssertConnectSucceeds(); | 1301 AssertConnectSucceeds(); |
1300 | 1302 |
1301 EXPECT_TRUE(sock_->IsConnected()); | 1303 EXPECT_TRUE(sock_->IsConnected()); |
1302 | 1304 |
1303 scoped_refptr<IOBuffer> read_buf(new IOBuffer(kLen1)); | 1305 scoped_refptr<IOBuffer> read_buf(new IOBuffer(kLen1)); |
1304 ASSERT_EQ(ERR_IO_PENDING, | 1306 ASSERT_EQ(ERR_IO_PENDING, |
1305 sock_->Read(read_buf, kLen1, read_callback_.callback())); | 1307 sock_->Read(read_buf.get(), kLen1, read_callback_.callback())); |
1306 | 1308 |
1307 scoped_refptr<IOBufferWithSize> write_buf(CreateBuffer(kMsg1, kLen1)); | 1309 scoped_refptr<IOBufferWithSize> write_buf(CreateBuffer(kMsg1, kLen1)); |
1308 EXPECT_EQ(ERR_IO_PENDING, | 1310 EXPECT_EQ( |
1309 sock_->Write(write_buf, write_buf->size(), | 1311 ERR_IO_PENDING, |
1310 write_callback_.callback())); | 1312 sock_->Write( |
| 1313 write_buf.get(), write_buf->size(), write_callback_.callback())); |
1311 | 1314 |
1312 Run(2); | 1315 Run(2); |
1313 | 1316 |
1314 EXPECT_TRUE(sock_.get()); | 1317 EXPECT_TRUE(sock_.get()); |
1315 EXPECT_TRUE(read_callback_.have_result()); | 1318 EXPECT_TRUE(read_callback_.have_result()); |
1316 EXPECT_TRUE(write_callback_.have_result()); | 1319 EXPECT_TRUE(write_callback_.have_result()); |
1317 } | 1320 } |
1318 | 1321 |
1319 // Makes sure the proxy client socket's source gets the expected NetLog events | 1322 // Makes sure the proxy client socket's source gets the expected NetLog events |
1320 // and only the expected NetLog events (No SpdySession events). | 1323 // and only the expected NetLog events (No SpdySession events). |
(...skipping 98 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1419 Initialize(reads, arraysize(reads), writes, arraysize(writes)); | 1422 Initialize(reads, arraysize(reads), writes, arraysize(writes)); |
1420 | 1423 |
1421 AssertConnectSucceeds(); | 1424 AssertConnectSucceeds(); |
1422 | 1425 |
1423 EXPECT_TRUE(sock_->IsConnected()); | 1426 EXPECT_TRUE(sock_->IsConnected()); |
1424 | 1427 |
1425 DeleteSockCallback read_callback(&sock_); | 1428 DeleteSockCallback read_callback(&sock_); |
1426 | 1429 |
1427 scoped_refptr<IOBuffer> read_buf(new IOBuffer(kLen1)); | 1430 scoped_refptr<IOBuffer> read_buf(new IOBuffer(kLen1)); |
1428 ASSERT_EQ(ERR_IO_PENDING, | 1431 ASSERT_EQ(ERR_IO_PENDING, |
1429 sock_->Read(read_buf, kLen1, read_callback.callback())); | 1432 sock_->Read(read_buf.get(), kLen1, read_callback.callback())); |
1430 | 1433 |
1431 scoped_refptr<IOBufferWithSize> write_buf(CreateBuffer(kMsg1, kLen1)); | 1434 scoped_refptr<IOBufferWithSize> write_buf(CreateBuffer(kMsg1, kLen1)); |
1432 EXPECT_EQ(ERR_IO_PENDING, sock_->Write(write_buf, write_buf->size(), | 1435 EXPECT_EQ( |
1433 write_callback_.callback())); | 1436 ERR_IO_PENDING, |
| 1437 sock_->Write( |
| 1438 write_buf.get(), write_buf->size(), write_callback_.callback())); |
1434 | 1439 |
1435 Run(2); | 1440 Run(2); |
1436 | 1441 |
1437 EXPECT_FALSE(sock_.get()); | 1442 EXPECT_FALSE(sock_.get()); |
1438 EXPECT_TRUE(read_callback.have_result()); | 1443 EXPECT_TRUE(read_callback.have_result()); |
1439 EXPECT_FALSE(write_callback_.have_result()); | 1444 EXPECT_FALSE(write_callback_.have_result()); |
1440 } | 1445 } |
1441 | 1446 |
1442 } // namespace net | 1447 } // namespace net |
OLD | NEW |