| 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/socket/socket_test_util.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 #include <vector> | |
| 9 | |
| 10 #include "base/basictypes.h" | |
| 11 #include "base/bind.h" | |
| 12 #include "base/bind_helpers.h" | |
| 13 #include "base/callback_helpers.h" | |
| 14 #include "base/compiler_specific.h" | |
| 15 #include "base/message_loop/message_loop.h" | |
| 16 #include "base/run_loop.h" | |
| 17 #include "base/time/time.h" | |
| 18 #include "net/base/address_family.h" | |
| 19 #include "net/base/address_list.h" | |
| 20 #include "net/base/auth.h" | |
| 21 #include "net/base/load_timing_info.h" | |
| 22 #include "net/http/http_network_session.h" | |
| 23 #include "net/http/http_request_headers.h" | |
| 24 #include "net/http/http_response_headers.h" | |
| 25 #include "net/socket/client_socket_pool_histograms.h" | |
| 26 #include "net/socket/socket.h" | |
| 27 #include "net/socket/websocket_endpoint_lock_manager.h" | |
| 28 #include "net/ssl/ssl_cert_request_info.h" | |
| 29 #include "net/ssl/ssl_connection_status_flags.h" | |
| 30 #include "net/ssl/ssl_info.h" | |
| 31 #include "testing/gtest/include/gtest/gtest.h" | |
| 32 | |
| 33 // Socket events are easier to debug if you log individual reads and writes. | |
| 34 // Enable these if locally debugging, but they are too noisy for the waterfall. | |
| 35 #if 0 | |
| 36 #define NET_TRACE(level, s) DLOG(level) << s << __FUNCTION__ << "() " | |
| 37 #else | |
| 38 #define NET_TRACE(level, s) EAT_STREAM_PARAMETERS | |
| 39 #endif | |
| 40 | |
| 41 namespace net { | |
| 42 | |
| 43 namespace { | |
| 44 | |
| 45 inline char AsciifyHigh(char x) { | |
| 46 char nybble = static_cast<char>((x >> 4) & 0x0F); | |
| 47 return nybble + ((nybble < 0x0A) ? '0' : 'A' - 10); | |
| 48 } | |
| 49 | |
| 50 inline char AsciifyLow(char x) { | |
| 51 char nybble = static_cast<char>((x >> 0) & 0x0F); | |
| 52 return nybble + ((nybble < 0x0A) ? '0' : 'A' - 10); | |
| 53 } | |
| 54 | |
| 55 inline char Asciify(char x) { | |
| 56 if ((x < 0) || !isprint(x)) | |
| 57 return '.'; | |
| 58 return x; | |
| 59 } | |
| 60 | |
| 61 void DumpData(const char* data, int data_len) { | |
| 62 if (logging::LOG_INFO < logging::GetMinLogLevel()) | |
| 63 return; | |
| 64 DVLOG(1) << "Length: " << data_len; | |
| 65 const char* pfx = "Data: "; | |
| 66 if (!data || (data_len <= 0)) { | |
| 67 DVLOG(1) << pfx << "<None>"; | |
| 68 } else { | |
| 69 int i; | |
| 70 for (i = 0; i <= (data_len - 4); i += 4) { | |
| 71 DVLOG(1) << pfx | |
| 72 << AsciifyHigh(data[i + 0]) << AsciifyLow(data[i + 0]) | |
| 73 << AsciifyHigh(data[i + 1]) << AsciifyLow(data[i + 1]) | |
| 74 << AsciifyHigh(data[i + 2]) << AsciifyLow(data[i + 2]) | |
| 75 << AsciifyHigh(data[i + 3]) << AsciifyLow(data[i + 3]) | |
| 76 << " '" | |
| 77 << Asciify(data[i + 0]) | |
| 78 << Asciify(data[i + 1]) | |
| 79 << Asciify(data[i + 2]) | |
| 80 << Asciify(data[i + 3]) | |
| 81 << "'"; | |
| 82 pfx = " "; | |
| 83 } | |
| 84 // Take care of any 'trailing' bytes, if data_len was not a multiple of 4. | |
| 85 switch (data_len - i) { | |
| 86 case 3: | |
| 87 DVLOG(1) << pfx | |
| 88 << AsciifyHigh(data[i + 0]) << AsciifyLow(data[i + 0]) | |
| 89 << AsciifyHigh(data[i + 1]) << AsciifyLow(data[i + 1]) | |
| 90 << AsciifyHigh(data[i + 2]) << AsciifyLow(data[i + 2]) | |
| 91 << " '" | |
| 92 << Asciify(data[i + 0]) | |
| 93 << Asciify(data[i + 1]) | |
| 94 << Asciify(data[i + 2]) | |
| 95 << " '"; | |
| 96 break; | |
| 97 case 2: | |
| 98 DVLOG(1) << pfx | |
| 99 << AsciifyHigh(data[i + 0]) << AsciifyLow(data[i + 0]) | |
| 100 << AsciifyHigh(data[i + 1]) << AsciifyLow(data[i + 1]) | |
| 101 << " '" | |
| 102 << Asciify(data[i + 0]) | |
| 103 << Asciify(data[i + 1]) | |
| 104 << " '"; | |
| 105 break; | |
| 106 case 1: | |
| 107 DVLOG(1) << pfx | |
| 108 << AsciifyHigh(data[i + 0]) << AsciifyLow(data[i + 0]) | |
| 109 << " '" | |
| 110 << Asciify(data[i + 0]) | |
| 111 << " '"; | |
| 112 break; | |
| 113 } | |
| 114 } | |
| 115 } | |
| 116 | |
| 117 template <MockReadWriteType type> | |
| 118 void DumpMockReadWrite(const MockReadWrite<type>& r) { | |
| 119 if (logging::LOG_INFO < logging::GetMinLogLevel()) | |
| 120 return; | |
| 121 DVLOG(1) << "Async: " << (r.mode == ASYNC) | |
| 122 << "\nResult: " << r.result; | |
| 123 DumpData(r.data, r.data_len); | |
| 124 const char* stop = (r.sequence_number & MockRead::STOPLOOP) ? " (STOP)" : ""; | |
| 125 DVLOG(1) << "Stage: " << (r.sequence_number & ~MockRead::STOPLOOP) << stop | |
| 126 << "\nTime: " << r.time_stamp.ToInternalValue(); | |
| 127 } | |
| 128 | |
| 129 } // namespace | |
| 130 | |
| 131 MockConnect::MockConnect() : mode(ASYNC), result(OK) { | |
| 132 IPAddressNumber ip; | |
| 133 CHECK(ParseIPLiteralToNumber("192.0.2.33", &ip)); | |
| 134 peer_addr = IPEndPoint(ip, 0); | |
| 135 } | |
| 136 | |
| 137 MockConnect::MockConnect(IoMode io_mode, int r) : mode(io_mode), result(r) { | |
| 138 IPAddressNumber ip; | |
| 139 CHECK(ParseIPLiteralToNumber("192.0.2.33", &ip)); | |
| 140 peer_addr = IPEndPoint(ip, 0); | |
| 141 } | |
| 142 | |
| 143 MockConnect::MockConnect(IoMode io_mode, int r, IPEndPoint addr) : | |
| 144 mode(io_mode), | |
| 145 result(r), | |
| 146 peer_addr(addr) { | |
| 147 } | |
| 148 | |
| 149 MockConnect::~MockConnect() {} | |
| 150 | |
| 151 StaticSocketDataProvider::StaticSocketDataProvider() | |
| 152 : reads_(NULL), | |
| 153 read_index_(0), | |
| 154 read_count_(0), | |
| 155 writes_(NULL), | |
| 156 write_index_(0), | |
| 157 write_count_(0) { | |
| 158 } | |
| 159 | |
| 160 StaticSocketDataProvider::StaticSocketDataProvider(MockRead* reads, | |
| 161 size_t reads_count, | |
| 162 MockWrite* writes, | |
| 163 size_t writes_count) | |
| 164 : reads_(reads), | |
| 165 read_index_(0), | |
| 166 read_count_(reads_count), | |
| 167 writes_(writes), | |
| 168 write_index_(0), | |
| 169 write_count_(writes_count) { | |
| 170 } | |
| 171 | |
| 172 StaticSocketDataProvider::~StaticSocketDataProvider() {} | |
| 173 | |
| 174 const MockRead& StaticSocketDataProvider::PeekRead() const { | |
| 175 CHECK(!at_read_eof()); | |
| 176 return reads_[read_index_]; | |
| 177 } | |
| 178 | |
| 179 const MockWrite& StaticSocketDataProvider::PeekWrite() const { | |
| 180 CHECK(!at_write_eof()); | |
| 181 return writes_[write_index_]; | |
| 182 } | |
| 183 | |
| 184 const MockRead& StaticSocketDataProvider::PeekRead(size_t index) const { | |
| 185 CHECK_LT(index, read_count_); | |
| 186 return reads_[index]; | |
| 187 } | |
| 188 | |
| 189 const MockWrite& StaticSocketDataProvider::PeekWrite(size_t index) const { | |
| 190 CHECK_LT(index, write_count_); | |
| 191 return writes_[index]; | |
| 192 } | |
| 193 | |
| 194 MockRead StaticSocketDataProvider::GetNextRead() { | |
| 195 CHECK(!at_read_eof()); | |
| 196 reads_[read_index_].time_stamp = base::Time::Now(); | |
| 197 return reads_[read_index_++]; | |
| 198 } | |
| 199 | |
| 200 MockWriteResult StaticSocketDataProvider::OnWrite(const std::string& data) { | |
| 201 if (!writes_) { | |
| 202 // Not using mock writes; succeed synchronously. | |
| 203 return MockWriteResult(SYNCHRONOUS, data.length()); | |
| 204 } | |
| 205 EXPECT_FALSE(at_write_eof()); | |
| 206 if (at_write_eof()) { | |
| 207 // Show what the extra write actually consists of. | |
| 208 EXPECT_EQ("<unexpected write>", data); | |
| 209 return MockWriteResult(SYNCHRONOUS, ERR_UNEXPECTED); | |
| 210 } | |
| 211 | |
| 212 // Check that what we are writing matches the expectation. | |
| 213 // Then give the mocked return value. | |
| 214 MockWrite* w = &writes_[write_index_++]; | |
| 215 w->time_stamp = base::Time::Now(); | |
| 216 int result = w->result; | |
| 217 if (w->data) { | |
| 218 // Note - we can simulate a partial write here. If the expected data | |
| 219 // is a match, but shorter than the write actually written, that is legal. | |
| 220 // Example: | |
| 221 // Application writes "foobarbaz" (9 bytes) | |
| 222 // Expected write was "foo" (3 bytes) | |
| 223 // This is a success, and we return 3 to the application. | |
| 224 std::string expected_data(w->data, w->data_len); | |
| 225 EXPECT_GE(data.length(), expected_data.length()); | |
| 226 std::string actual_data(data.substr(0, w->data_len)); | |
| 227 EXPECT_EQ(expected_data, actual_data); | |
| 228 if (expected_data != actual_data) | |
| 229 return MockWriteResult(SYNCHRONOUS, ERR_UNEXPECTED); | |
| 230 if (result == OK) | |
| 231 result = w->data_len; | |
| 232 } | |
| 233 return MockWriteResult(w->mode, result); | |
| 234 } | |
| 235 | |
| 236 void StaticSocketDataProvider::Reset() { | |
| 237 read_index_ = 0; | |
| 238 write_index_ = 0; | |
| 239 } | |
| 240 | |
| 241 DynamicSocketDataProvider::DynamicSocketDataProvider() | |
| 242 : short_read_limit_(0), | |
| 243 allow_unconsumed_reads_(false) { | |
| 244 } | |
| 245 | |
| 246 DynamicSocketDataProvider::~DynamicSocketDataProvider() {} | |
| 247 | |
| 248 MockRead DynamicSocketDataProvider::GetNextRead() { | |
| 249 if (reads_.empty()) | |
| 250 return MockRead(SYNCHRONOUS, ERR_UNEXPECTED); | |
| 251 MockRead result = reads_.front(); | |
| 252 if (short_read_limit_ == 0 || result.data_len <= short_read_limit_) { | |
| 253 reads_.pop_front(); | |
| 254 } else { | |
| 255 result.data_len = short_read_limit_; | |
| 256 reads_.front().data += result.data_len; | |
| 257 reads_.front().data_len -= result.data_len; | |
| 258 } | |
| 259 return result; | |
| 260 } | |
| 261 | |
| 262 void DynamicSocketDataProvider::Reset() { | |
| 263 reads_.clear(); | |
| 264 } | |
| 265 | |
| 266 void DynamicSocketDataProvider::SimulateRead(const char* data, | |
| 267 const size_t length) { | |
| 268 if (!allow_unconsumed_reads_) { | |
| 269 EXPECT_TRUE(reads_.empty()) << "Unconsumed read: " << reads_.front().data; | |
| 270 } | |
| 271 reads_.push_back(MockRead(ASYNC, data, length)); | |
| 272 } | |
| 273 | |
| 274 SSLSocketDataProvider::SSLSocketDataProvider(IoMode mode, int result) | |
| 275 : connect(mode, result), | |
| 276 next_proto_status(SSLClientSocket::kNextProtoUnsupported), | |
| 277 was_npn_negotiated(false), | |
| 278 protocol_negotiated(kProtoUnknown), | |
| 279 client_cert_sent(false), | |
| 280 cert_request_info(NULL), | |
| 281 channel_id_sent(false), | |
| 282 connection_status(0), | |
| 283 should_pause_on_connect(false), | |
| 284 is_in_session_cache(false) { | |
| 285 SSLConnectionStatusSetVersion(SSL_CONNECTION_VERSION_TLS1_2, | |
| 286 &connection_status); | |
| 287 // Set to TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305 | |
| 288 SSLConnectionStatusSetCipherSuite(0xcc14, &connection_status); | |
| 289 } | |
| 290 | |
| 291 SSLSocketDataProvider::~SSLSocketDataProvider() { | |
| 292 } | |
| 293 | |
| 294 void SSLSocketDataProvider::SetNextProto(NextProto proto) { | |
| 295 was_npn_negotiated = true; | |
| 296 next_proto_status = SSLClientSocket::kNextProtoNegotiated; | |
| 297 protocol_negotiated = proto; | |
| 298 next_proto = SSLClientSocket::NextProtoToString(proto); | |
| 299 } | |
| 300 | |
| 301 DelayedSocketData::DelayedSocketData( | |
| 302 int write_delay, MockRead* reads, size_t reads_count, | |
| 303 MockWrite* writes, size_t writes_count) | |
| 304 : StaticSocketDataProvider(reads, reads_count, writes, writes_count), | |
| 305 write_delay_(write_delay), | |
| 306 read_in_progress_(false), | |
| 307 weak_factory_(this) { | |
| 308 DCHECK_GE(write_delay_, 0); | |
| 309 } | |
| 310 | |
| 311 DelayedSocketData::DelayedSocketData( | |
| 312 const MockConnect& connect, int write_delay, MockRead* reads, | |
| 313 size_t reads_count, MockWrite* writes, size_t writes_count) | |
| 314 : StaticSocketDataProvider(reads, reads_count, writes, writes_count), | |
| 315 write_delay_(write_delay), | |
| 316 read_in_progress_(false), | |
| 317 weak_factory_(this) { | |
| 318 DCHECK_GE(write_delay_, 0); | |
| 319 set_connect_data(connect); | |
| 320 } | |
| 321 | |
| 322 DelayedSocketData::~DelayedSocketData() { | |
| 323 } | |
| 324 | |
| 325 void DelayedSocketData::ForceNextRead() { | |
| 326 DCHECK(read_in_progress_); | |
| 327 write_delay_ = 0; | |
| 328 CompleteRead(); | |
| 329 } | |
| 330 | |
| 331 MockRead DelayedSocketData::GetNextRead() { | |
| 332 MockRead out = MockRead(ASYNC, ERR_IO_PENDING); | |
| 333 if (write_delay_ <= 0) | |
| 334 out = StaticSocketDataProvider::GetNextRead(); | |
| 335 read_in_progress_ = (out.result == ERR_IO_PENDING); | |
| 336 return out; | |
| 337 } | |
| 338 | |
| 339 MockWriteResult DelayedSocketData::OnWrite(const std::string& data) { | |
| 340 MockWriteResult rv = StaticSocketDataProvider::OnWrite(data); | |
| 341 // Now that our write has completed, we can allow reads to continue. | |
| 342 if (!--write_delay_ && read_in_progress_) | |
| 343 base::MessageLoop::current()->PostDelayedTask( | |
| 344 FROM_HERE, | |
| 345 base::Bind(&DelayedSocketData::CompleteRead, | |
| 346 weak_factory_.GetWeakPtr()), | |
| 347 base::TimeDelta::FromMilliseconds(100)); | |
| 348 return rv; | |
| 349 } | |
| 350 | |
| 351 void DelayedSocketData::Reset() { | |
| 352 set_socket(NULL); | |
| 353 read_in_progress_ = false; | |
| 354 weak_factory_.InvalidateWeakPtrs(); | |
| 355 StaticSocketDataProvider::Reset(); | |
| 356 } | |
| 357 | |
| 358 void DelayedSocketData::CompleteRead() { | |
| 359 if (socket() && read_in_progress_) | |
| 360 socket()->OnReadComplete(GetNextRead()); | |
| 361 } | |
| 362 | |
| 363 OrderedSocketData::OrderedSocketData( | |
| 364 MockRead* reads, size_t reads_count, MockWrite* writes, size_t writes_count) | |
| 365 : StaticSocketDataProvider(reads, reads_count, writes, writes_count), | |
| 366 sequence_number_(0), loop_stop_stage_(0), | |
| 367 blocked_(false), weak_factory_(this) { | |
| 368 } | |
| 369 | |
| 370 OrderedSocketData::OrderedSocketData( | |
| 371 const MockConnect& connect, | |
| 372 MockRead* reads, size_t reads_count, | |
| 373 MockWrite* writes, size_t writes_count) | |
| 374 : StaticSocketDataProvider(reads, reads_count, writes, writes_count), | |
| 375 sequence_number_(0), loop_stop_stage_(0), | |
| 376 blocked_(false), weak_factory_(this) { | |
| 377 set_connect_data(connect); | |
| 378 } | |
| 379 | |
| 380 void OrderedSocketData::EndLoop() { | |
| 381 // If we've already stopped the loop, don't do it again until we've advanced | |
| 382 // to the next sequence_number. | |
| 383 NET_TRACE(INFO, " *** ") << "Stage " << sequence_number_ << ": EndLoop()"; | |
| 384 if (loop_stop_stage_ > 0) { | |
| 385 const MockRead& next_read = StaticSocketDataProvider::PeekRead(); | |
| 386 if ((next_read.sequence_number & ~MockRead::STOPLOOP) > | |
| 387 loop_stop_stage_) { | |
| 388 NET_TRACE(INFO, " *** ") << "Stage " << sequence_number_ | |
| 389 << ": Clearing stop index"; | |
| 390 loop_stop_stage_ = 0; | |
| 391 } else { | |
| 392 return; | |
| 393 } | |
| 394 } | |
| 395 // Record the sequence_number at which we stopped the loop. | |
| 396 NET_TRACE(INFO, " *** ") << "Stage " << sequence_number_ | |
| 397 << ": Posting Quit at read " << read_index(); | |
| 398 loop_stop_stage_ = sequence_number_; | |
| 399 } | |
| 400 | |
| 401 MockRead OrderedSocketData::GetNextRead() { | |
| 402 weak_factory_.InvalidateWeakPtrs(); | |
| 403 blocked_ = false; | |
| 404 const MockRead& next_read = StaticSocketDataProvider::PeekRead(); | |
| 405 if (next_read.sequence_number & MockRead::STOPLOOP) | |
| 406 EndLoop(); | |
| 407 if ((next_read.sequence_number & ~MockRead::STOPLOOP) <= | |
| 408 sequence_number_++) { | |
| 409 NET_TRACE(INFO, " *** ") << "Stage " << sequence_number_ - 1 | |
| 410 << ": Read " << read_index(); | |
| 411 DumpMockReadWrite(next_read); | |
| 412 blocked_ = (next_read.result == ERR_IO_PENDING); | |
| 413 return StaticSocketDataProvider::GetNextRead(); | |
| 414 } | |
| 415 NET_TRACE(INFO, " *** ") << "Stage " << sequence_number_ - 1 | |
| 416 << ": I/O Pending"; | |
| 417 MockRead result = MockRead(ASYNC, ERR_IO_PENDING); | |
| 418 DumpMockReadWrite(result); | |
| 419 blocked_ = true; | |
| 420 return result; | |
| 421 } | |
| 422 | |
| 423 MockWriteResult OrderedSocketData::OnWrite(const std::string& data) { | |
| 424 NET_TRACE(INFO, " *** ") << "Stage " << sequence_number_ | |
| 425 << ": Write " << write_index(); | |
| 426 DumpMockReadWrite(PeekWrite()); | |
| 427 ++sequence_number_; | |
| 428 if (blocked_) { | |
| 429 // TODO(willchan): This 100ms delay seems to work around some weirdness. We | |
| 430 // should probably fix the weirdness. One example is in SpdyStream, | |
| 431 // DoSendRequest() will return ERR_IO_PENDING, and there's a race. If the | |
| 432 // SYN_REPLY causes OnResponseReceived() to get called before | |
| 433 // SpdyStream::ReadResponseHeaders() is called, we hit a NOTREACHED(). | |
| 434 base::MessageLoop::current()->PostDelayedTask( | |
| 435 FROM_HERE, | |
| 436 base::Bind(&OrderedSocketData::CompleteRead, | |
| 437 weak_factory_.GetWeakPtr()), | |
| 438 base::TimeDelta::FromMilliseconds(100)); | |
| 439 } | |
| 440 return StaticSocketDataProvider::OnWrite(data); | |
| 441 } | |
| 442 | |
| 443 void OrderedSocketData::Reset() { | |
| 444 NET_TRACE(INFO, " *** ") << "Stage " | |
| 445 << sequence_number_ << ": Reset()"; | |
| 446 sequence_number_ = 0; | |
| 447 loop_stop_stage_ = 0; | |
| 448 set_socket(NULL); | |
| 449 weak_factory_.InvalidateWeakPtrs(); | |
| 450 StaticSocketDataProvider::Reset(); | |
| 451 } | |
| 452 | |
| 453 void OrderedSocketData::CompleteRead() { | |
| 454 if (socket() && blocked_) { | |
| 455 NET_TRACE(INFO, " *** ") << "Stage " << sequence_number_; | |
| 456 socket()->OnReadComplete(GetNextRead()); | |
| 457 } | |
| 458 } | |
| 459 | |
| 460 OrderedSocketData::~OrderedSocketData() {} | |
| 461 | |
| 462 DeterministicSocketData::DeterministicSocketData(MockRead* reads, | |
| 463 size_t reads_count, MockWrite* writes, size_t writes_count) | |
| 464 : StaticSocketDataProvider(reads, reads_count, writes, writes_count), | |
| 465 sequence_number_(0), | |
| 466 current_read_(), | |
| 467 current_write_(), | |
| 468 stopping_sequence_number_(0), | |
| 469 stopped_(false), | |
| 470 print_debug_(false), | |
| 471 is_running_(false) { | |
| 472 VerifyCorrectSequenceNumbers(reads, reads_count, writes, writes_count); | |
| 473 } | |
| 474 | |
| 475 DeterministicSocketData::~DeterministicSocketData() {} | |
| 476 | |
| 477 void DeterministicSocketData::Run() { | |
| 478 DCHECK(!is_running_); | |
| 479 is_running_ = true; | |
| 480 | |
| 481 SetStopped(false); | |
| 482 int counter = 0; | |
| 483 // Continue to consume data until all data has run out, or the stopped_ flag | |
| 484 // has been set. Consuming data requires two separate operations -- running | |
| 485 // the tasks in the message loop, and explicitly invoking the read/write | |
| 486 // callbacks (simulating network I/O). We check our conditions between each, | |
| 487 // since they can change in either. | |
| 488 while ((!at_write_eof() || !at_read_eof()) && !stopped()) { | |
| 489 if (counter % 2 == 0) | |
| 490 base::RunLoop().RunUntilIdle(); | |
| 491 if (counter % 2 == 1) { | |
| 492 InvokeCallbacks(); | |
| 493 } | |
| 494 counter++; | |
| 495 } | |
| 496 // We're done consuming new data, but it is possible there are still some | |
| 497 // pending callbacks which we expect to complete before returning. | |
| 498 while (delegate_.get() && | |
| 499 (delegate_->WritePending() || delegate_->ReadPending()) && | |
| 500 !stopped()) { | |
| 501 InvokeCallbacks(); | |
| 502 base::RunLoop().RunUntilIdle(); | |
| 503 } | |
| 504 SetStopped(false); | |
| 505 is_running_ = false; | |
| 506 } | |
| 507 | |
| 508 void DeterministicSocketData::RunFor(int steps) { | |
| 509 StopAfter(steps); | |
| 510 Run(); | |
| 511 } | |
| 512 | |
| 513 void DeterministicSocketData::SetStop(int seq) { | |
| 514 DCHECK_LT(sequence_number_, seq); | |
| 515 stopping_sequence_number_ = seq; | |
| 516 stopped_ = false; | |
| 517 } | |
| 518 | |
| 519 void DeterministicSocketData::StopAfter(int seq) { | |
| 520 SetStop(sequence_number_ + seq); | |
| 521 } | |
| 522 | |
| 523 MockRead DeterministicSocketData::GetNextRead() { | |
| 524 current_read_ = StaticSocketDataProvider::PeekRead(); | |
| 525 | |
| 526 // Synchronous read while stopped is an error | |
| 527 if (stopped() && current_read_.mode == SYNCHRONOUS) { | |
| 528 LOG(ERROR) << "Unable to perform synchronous IO while stopped"; | |
| 529 return MockRead(SYNCHRONOUS, ERR_UNEXPECTED); | |
| 530 } | |
| 531 | |
| 532 // Async read which will be called back in a future step. | |
| 533 if (sequence_number_ < current_read_.sequence_number) { | |
| 534 NET_TRACE(INFO, " *** ") << "Stage " << sequence_number_ | |
| 535 << ": I/O Pending"; | |
| 536 MockRead result = MockRead(SYNCHRONOUS, ERR_IO_PENDING); | |
| 537 if (current_read_.mode == SYNCHRONOUS) { | |
| 538 LOG(ERROR) << "Unable to perform synchronous read: " | |
| 539 << current_read_.sequence_number | |
| 540 << " at stage: " << sequence_number_; | |
| 541 result = MockRead(SYNCHRONOUS, ERR_UNEXPECTED); | |
| 542 } | |
| 543 if (print_debug_) | |
| 544 DumpMockReadWrite(result); | |
| 545 return result; | |
| 546 } | |
| 547 | |
| 548 NET_TRACE(INFO, " *** ") << "Stage " << sequence_number_ | |
| 549 << ": Read " << read_index(); | |
| 550 if (print_debug_) | |
| 551 DumpMockReadWrite(current_read_); | |
| 552 | |
| 553 // Increment the sequence number if IO is complete | |
| 554 if (current_read_.mode == SYNCHRONOUS) | |
| 555 NextStep(); | |
| 556 | |
| 557 DCHECK_NE(ERR_IO_PENDING, current_read_.result); | |
| 558 StaticSocketDataProvider::GetNextRead(); | |
| 559 | |
| 560 return current_read_; | |
| 561 } | |
| 562 | |
| 563 MockWriteResult DeterministicSocketData::OnWrite(const std::string& data) { | |
| 564 const MockWrite& next_write = StaticSocketDataProvider::PeekWrite(); | |
| 565 current_write_ = next_write; | |
| 566 | |
| 567 // Synchronous write while stopped is an error | |
| 568 if (stopped() && next_write.mode == SYNCHRONOUS) { | |
| 569 LOG(ERROR) << "Unable to perform synchronous IO while stopped"; | |
| 570 return MockWriteResult(SYNCHRONOUS, ERR_UNEXPECTED); | |
| 571 } | |
| 572 | |
| 573 // Async write which will be called back in a future step. | |
| 574 if (sequence_number_ < next_write.sequence_number) { | |
| 575 NET_TRACE(INFO, " *** ") << "Stage " << sequence_number_ | |
| 576 << ": I/O Pending"; | |
| 577 if (next_write.mode == SYNCHRONOUS) { | |
| 578 LOG(ERROR) << "Unable to perform synchronous write: " | |
| 579 << next_write.sequence_number << " at stage: " << sequence_number_; | |
| 580 return MockWriteResult(SYNCHRONOUS, ERR_UNEXPECTED); | |
| 581 } | |
| 582 } else { | |
| 583 NET_TRACE(INFO, " *** ") << "Stage " << sequence_number_ | |
| 584 << ": Write " << write_index(); | |
| 585 } | |
| 586 | |
| 587 if (print_debug_) | |
| 588 DumpMockReadWrite(next_write); | |
| 589 | |
| 590 // Move to the next step if I/O is synchronous, since the operation will | |
| 591 // complete when this method returns. | |
| 592 if (next_write.mode == SYNCHRONOUS) | |
| 593 NextStep(); | |
| 594 | |
| 595 // This is either a sync write for this step, or an async write. | |
| 596 return StaticSocketDataProvider::OnWrite(data); | |
| 597 } | |
| 598 | |
| 599 void DeterministicSocketData::Reset() { | |
| 600 NET_TRACE(INFO, " *** ") << "Stage " | |
| 601 << sequence_number_ << ": Reset()"; | |
| 602 sequence_number_ = 0; | |
| 603 StaticSocketDataProvider::Reset(); | |
| 604 NOTREACHED(); | |
| 605 } | |
| 606 | |
| 607 void DeterministicSocketData::InvokeCallbacks() { | |
| 608 if (delegate_.get() && delegate_->WritePending() && | |
| 609 (current_write().sequence_number == sequence_number())) { | |
| 610 NextStep(); | |
| 611 delegate_->CompleteWrite(); | |
| 612 return; | |
| 613 } | |
| 614 if (delegate_.get() && delegate_->ReadPending() && | |
| 615 (current_read().sequence_number == sequence_number())) { | |
| 616 NextStep(); | |
| 617 delegate_->CompleteRead(); | |
| 618 return; | |
| 619 } | |
| 620 } | |
| 621 | |
| 622 void DeterministicSocketData::NextStep() { | |
| 623 // Invariant: Can never move *past* the stopping step. | |
| 624 DCHECK_LT(sequence_number_, stopping_sequence_number_); | |
| 625 sequence_number_++; | |
| 626 if (sequence_number_ == stopping_sequence_number_) | |
| 627 SetStopped(true); | |
| 628 } | |
| 629 | |
| 630 void DeterministicSocketData::VerifyCorrectSequenceNumbers( | |
| 631 MockRead* reads, size_t reads_count, | |
| 632 MockWrite* writes, size_t writes_count) { | |
| 633 size_t read = 0; | |
| 634 size_t write = 0; | |
| 635 int expected = 0; | |
| 636 while (read < reads_count || write < writes_count) { | |
| 637 // Check to see that we have a read or write at the expected | |
| 638 // state. | |
| 639 if (read < reads_count && reads[read].sequence_number == expected) { | |
| 640 ++read; | |
| 641 ++expected; | |
| 642 continue; | |
| 643 } | |
| 644 if (write < writes_count && writes[write].sequence_number == expected) { | |
| 645 ++write; | |
| 646 ++expected; | |
| 647 continue; | |
| 648 } | |
| 649 NOTREACHED() << "Missing sequence number: " << expected; | |
| 650 return; | |
| 651 } | |
| 652 DCHECK_EQ(read, reads_count); | |
| 653 DCHECK_EQ(write, writes_count); | |
| 654 } | |
| 655 | |
| 656 MockClientSocketFactory::MockClientSocketFactory() {} | |
| 657 | |
| 658 MockClientSocketFactory::~MockClientSocketFactory() {} | |
| 659 | |
| 660 void MockClientSocketFactory::AddSocketDataProvider( | |
| 661 SocketDataProvider* data) { | |
| 662 mock_data_.Add(data); | |
| 663 } | |
| 664 | |
| 665 void MockClientSocketFactory::AddSSLSocketDataProvider( | |
| 666 SSLSocketDataProvider* data) { | |
| 667 mock_ssl_data_.Add(data); | |
| 668 } | |
| 669 | |
| 670 void MockClientSocketFactory::ResetNextMockIndexes() { | |
| 671 mock_data_.ResetNextIndex(); | |
| 672 mock_ssl_data_.ResetNextIndex(); | |
| 673 } | |
| 674 | |
| 675 scoped_ptr<DatagramClientSocket> | |
| 676 MockClientSocketFactory::CreateDatagramClientSocket( | |
| 677 DatagramSocket::BindType bind_type, | |
| 678 const RandIntCallback& rand_int_cb, | |
| 679 net::NetLog* net_log, | |
| 680 const net::NetLog::Source& source) { | |
| 681 SocketDataProvider* data_provider = mock_data_.GetNext(); | |
| 682 scoped_ptr<MockUDPClientSocket> socket( | |
| 683 new MockUDPClientSocket(data_provider, net_log)); | |
| 684 data_provider->set_socket(socket.get()); | |
| 685 if (bind_type == DatagramSocket::RANDOM_BIND) | |
| 686 socket->set_source_port(static_cast<uint16>(rand_int_cb.Run(1025, 65535))); | |
| 687 return socket.Pass(); | |
| 688 } | |
| 689 | |
| 690 scoped_ptr<StreamSocket> MockClientSocketFactory::CreateTransportClientSocket( | |
| 691 const AddressList& addresses, | |
| 692 net::NetLog* net_log, | |
| 693 const net::NetLog::Source& source) { | |
| 694 SocketDataProvider* data_provider = mock_data_.GetNext(); | |
| 695 scoped_ptr<MockTCPClientSocket> socket( | |
| 696 new MockTCPClientSocket(addresses, net_log, data_provider)); | |
| 697 data_provider->set_socket(socket.get()); | |
| 698 return socket.Pass(); | |
| 699 } | |
| 700 | |
| 701 scoped_ptr<SSLClientSocket> MockClientSocketFactory::CreateSSLClientSocket( | |
| 702 scoped_ptr<ClientSocketHandle> transport_socket, | |
| 703 const HostPortPair& host_and_port, | |
| 704 const SSLConfig& ssl_config, | |
| 705 const SSLClientSocketContext& context) { | |
| 706 SSLSocketDataProvider* next_ssl_data = mock_ssl_data_.GetNext(); | |
| 707 if (!next_ssl_data->next_protos_expected_in_ssl_config.empty()) { | |
| 708 EXPECT_EQ(next_ssl_data->next_protos_expected_in_ssl_config.size(), | |
| 709 ssl_config.next_protos.size()); | |
| 710 EXPECT_TRUE( | |
| 711 std::equal(next_ssl_data->next_protos_expected_in_ssl_config.begin(), | |
| 712 next_ssl_data->next_protos_expected_in_ssl_config.end(), | |
| 713 ssl_config.next_protos.begin())); | |
| 714 } | |
| 715 scoped_ptr<MockSSLClientSocket> socket(new MockSSLClientSocket( | |
| 716 transport_socket.Pass(), host_and_port, ssl_config, next_ssl_data)); | |
| 717 ssl_client_sockets_.push_back(socket.get()); | |
| 718 return socket.Pass(); | |
| 719 } | |
| 720 | |
| 721 void MockClientSocketFactory::ClearSSLSessionCache() { | |
| 722 } | |
| 723 | |
| 724 const char MockClientSocket::kTlsUnique[] = "MOCK_TLSUNIQ"; | |
| 725 | |
| 726 MockClientSocket::MockClientSocket(const BoundNetLog& net_log) | |
| 727 : connected_(false), | |
| 728 net_log_(net_log), | |
| 729 weak_factory_(this) { | |
| 730 IPAddressNumber ip; | |
| 731 CHECK(ParseIPLiteralToNumber("192.0.2.33", &ip)); | |
| 732 peer_addr_ = IPEndPoint(ip, 0); | |
| 733 } | |
| 734 | |
| 735 int MockClientSocket::SetReceiveBufferSize(int32 size) { | |
| 736 return OK; | |
| 737 } | |
| 738 | |
| 739 int MockClientSocket::SetSendBufferSize(int32 size) { | |
| 740 return OK; | |
| 741 } | |
| 742 | |
| 743 void MockClientSocket::Disconnect() { | |
| 744 connected_ = false; | |
| 745 } | |
| 746 | |
| 747 bool MockClientSocket::IsConnected() const { | |
| 748 return connected_; | |
| 749 } | |
| 750 | |
| 751 bool MockClientSocket::IsConnectedAndIdle() const { | |
| 752 return connected_; | |
| 753 } | |
| 754 | |
| 755 int MockClientSocket::GetPeerAddress(IPEndPoint* address) const { | |
| 756 if (!IsConnected()) | |
| 757 return ERR_SOCKET_NOT_CONNECTED; | |
| 758 *address = peer_addr_; | |
| 759 return OK; | |
| 760 } | |
| 761 | |
| 762 int MockClientSocket::GetLocalAddress(IPEndPoint* address) const { | |
| 763 IPAddressNumber ip; | |
| 764 bool rv = ParseIPLiteralToNumber("192.0.2.33", &ip); | |
| 765 CHECK(rv); | |
| 766 *address = IPEndPoint(ip, 123); | |
| 767 return OK; | |
| 768 } | |
| 769 | |
| 770 const BoundNetLog& MockClientSocket::NetLog() const { | |
| 771 return net_log_; | |
| 772 } | |
| 773 | |
| 774 std::string MockClientSocket::GetSessionCacheKey() const { | |
| 775 NOTIMPLEMENTED(); | |
| 776 return std::string(); | |
| 777 } | |
| 778 | |
| 779 bool MockClientSocket::InSessionCache() const { | |
| 780 NOTIMPLEMENTED(); | |
| 781 return false; | |
| 782 } | |
| 783 | |
| 784 void MockClientSocket::SetHandshakeCompletionCallback(const base::Closure& cb) { | |
| 785 NOTIMPLEMENTED(); | |
| 786 } | |
| 787 | |
| 788 void MockClientSocket::GetSSLCertRequestInfo( | |
| 789 SSLCertRequestInfo* cert_request_info) { | |
| 790 } | |
| 791 | |
| 792 int MockClientSocket::ExportKeyingMaterial(const base::StringPiece& label, | |
| 793 bool has_context, | |
| 794 const base::StringPiece& context, | |
| 795 unsigned char* out, | |
| 796 unsigned int outlen) { | |
| 797 memset(out, 'A', outlen); | |
| 798 return OK; | |
| 799 } | |
| 800 | |
| 801 int MockClientSocket::GetTLSUniqueChannelBinding(std::string* out) { | |
| 802 out->assign(MockClientSocket::kTlsUnique); | |
| 803 return OK; | |
| 804 } | |
| 805 | |
| 806 ChannelIDService* MockClientSocket::GetChannelIDService() const { | |
| 807 NOTREACHED(); | |
| 808 return NULL; | |
| 809 } | |
| 810 | |
| 811 SSLClientSocket::NextProtoStatus | |
| 812 MockClientSocket::GetNextProto(std::string* proto) { | |
| 813 proto->clear(); | |
| 814 return SSLClientSocket::kNextProtoUnsupported; | |
| 815 } | |
| 816 | |
| 817 scoped_refptr<X509Certificate> | |
| 818 MockClientSocket::GetUnverifiedServerCertificateChain() const { | |
| 819 NOTREACHED(); | |
| 820 return NULL; | |
| 821 } | |
| 822 | |
| 823 MockClientSocket::~MockClientSocket() {} | |
| 824 | |
| 825 void MockClientSocket::RunCallbackAsync(const CompletionCallback& callback, | |
| 826 int result) { | |
| 827 base::MessageLoop::current()->PostTask( | |
| 828 FROM_HERE, | |
| 829 base::Bind(&MockClientSocket::RunCallback, | |
| 830 weak_factory_.GetWeakPtr(), | |
| 831 callback, | |
| 832 result)); | |
| 833 } | |
| 834 | |
| 835 void MockClientSocket::RunCallback(const net::CompletionCallback& callback, | |
| 836 int result) { | |
| 837 if (!callback.is_null()) | |
| 838 callback.Run(result); | |
| 839 } | |
| 840 | |
| 841 MockTCPClientSocket::MockTCPClientSocket(const AddressList& addresses, | |
| 842 net::NetLog* net_log, | |
| 843 SocketDataProvider* data) | |
| 844 : MockClientSocket(BoundNetLog::Make(net_log, net::NetLog::SOURCE_NONE)), | |
| 845 addresses_(addresses), | |
| 846 data_(data), | |
| 847 read_offset_(0), | |
| 848 read_data_(SYNCHRONOUS, ERR_UNEXPECTED), | |
| 849 need_read_data_(true), | |
| 850 peer_closed_connection_(false), | |
| 851 pending_buf_(NULL), | |
| 852 pending_buf_len_(0), | |
| 853 was_used_to_convey_data_(false) { | |
| 854 DCHECK(data_); | |
| 855 peer_addr_ = data->connect_data().peer_addr; | |
| 856 data_->Reset(); | |
| 857 } | |
| 858 | |
| 859 MockTCPClientSocket::~MockTCPClientSocket() {} | |
| 860 | |
| 861 int MockTCPClientSocket::Read(IOBuffer* buf, int buf_len, | |
| 862 const CompletionCallback& callback) { | |
| 863 if (!connected_) | |
| 864 return ERR_UNEXPECTED; | |
| 865 | |
| 866 // If the buffer is already in use, a read is already in progress! | |
| 867 DCHECK(pending_buf_.get() == NULL); | |
| 868 | |
| 869 // Store our async IO data. | |
| 870 pending_buf_ = buf; | |
| 871 pending_buf_len_ = buf_len; | |
| 872 pending_callback_ = callback; | |
| 873 | |
| 874 if (need_read_data_) { | |
| 875 read_data_ = data_->GetNextRead(); | |
| 876 if (read_data_.result == ERR_CONNECTION_CLOSED) { | |
| 877 // This MockRead is just a marker to instruct us to set | |
| 878 // peer_closed_connection_. | |
| 879 peer_closed_connection_ = true; | |
| 880 } | |
| 881 if (read_data_.result == ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ) { | |
| 882 // This MockRead is just a marker to instruct us to set | |
| 883 // peer_closed_connection_. Skip it and get the next one. | |
| 884 read_data_ = data_->GetNextRead(); | |
| 885 peer_closed_connection_ = true; | |
| 886 } | |
| 887 // ERR_IO_PENDING means that the SocketDataProvider is taking responsibility | |
| 888 // to complete the async IO manually later (via OnReadComplete). | |
| 889 if (read_data_.result == ERR_IO_PENDING) { | |
| 890 // We need to be using async IO in this case. | |
| 891 DCHECK(!callback.is_null()); | |
| 892 return ERR_IO_PENDING; | |
| 893 } | |
| 894 need_read_data_ = false; | |
| 895 } | |
| 896 | |
| 897 return CompleteRead(); | |
| 898 } | |
| 899 | |
| 900 int MockTCPClientSocket::Write(IOBuffer* buf, int buf_len, | |
| 901 const CompletionCallback& callback) { | |
| 902 DCHECK(buf); | |
| 903 DCHECK_GT(buf_len, 0); | |
| 904 | |
| 905 if (!connected_) | |
| 906 return ERR_UNEXPECTED; | |
| 907 | |
| 908 std::string data(buf->data(), buf_len); | |
| 909 MockWriteResult write_result = data_->OnWrite(data); | |
| 910 | |
| 911 was_used_to_convey_data_ = true; | |
| 912 | |
| 913 if (write_result.mode == ASYNC) { | |
| 914 RunCallbackAsync(callback, write_result.result); | |
| 915 return ERR_IO_PENDING; | |
| 916 } | |
| 917 | |
| 918 return write_result.result; | |
| 919 } | |
| 920 | |
| 921 int MockTCPClientSocket::Connect(const CompletionCallback& callback) { | |
| 922 if (connected_) | |
| 923 return OK; | |
| 924 connected_ = true; | |
| 925 peer_closed_connection_ = false; | |
| 926 if (data_->connect_data().mode == ASYNC) { | |
| 927 if (data_->connect_data().result == ERR_IO_PENDING) | |
| 928 pending_callback_ = callback; | |
| 929 else | |
| 930 RunCallbackAsync(callback, data_->connect_data().result); | |
| 931 return ERR_IO_PENDING; | |
| 932 } | |
| 933 return data_->connect_data().result; | |
| 934 } | |
| 935 | |
| 936 void MockTCPClientSocket::Disconnect() { | |
| 937 MockClientSocket::Disconnect(); | |
| 938 pending_callback_.Reset(); | |
| 939 } | |
| 940 | |
| 941 bool MockTCPClientSocket::IsConnected() const { | |
| 942 return connected_ && !peer_closed_connection_; | |
| 943 } | |
| 944 | |
| 945 bool MockTCPClientSocket::IsConnectedAndIdle() const { | |
| 946 return IsConnected(); | |
| 947 } | |
| 948 | |
| 949 int MockTCPClientSocket::GetPeerAddress(IPEndPoint* address) const { | |
| 950 if (addresses_.empty()) | |
| 951 return MockClientSocket::GetPeerAddress(address); | |
| 952 | |
| 953 *address = addresses_[0]; | |
| 954 return OK; | |
| 955 } | |
| 956 | |
| 957 bool MockTCPClientSocket::WasEverUsed() const { | |
| 958 return was_used_to_convey_data_; | |
| 959 } | |
| 960 | |
| 961 bool MockTCPClientSocket::UsingTCPFastOpen() const { | |
| 962 return false; | |
| 963 } | |
| 964 | |
| 965 bool MockTCPClientSocket::WasNpnNegotiated() const { | |
| 966 return false; | |
| 967 } | |
| 968 | |
| 969 bool MockTCPClientSocket::GetSSLInfo(SSLInfo* ssl_info) { | |
| 970 return false; | |
| 971 } | |
| 972 | |
| 973 void MockTCPClientSocket::OnReadComplete(const MockRead& data) { | |
| 974 // There must be a read pending. | |
| 975 DCHECK(pending_buf_.get()); | |
| 976 // You can't complete a read with another ERR_IO_PENDING status code. | |
| 977 DCHECK_NE(ERR_IO_PENDING, data.result); | |
| 978 // Since we've been waiting for data, need_read_data_ should be true. | |
| 979 DCHECK(need_read_data_); | |
| 980 | |
| 981 read_data_ = data; | |
| 982 need_read_data_ = false; | |
| 983 | |
| 984 // The caller is simulating that this IO completes right now. Don't | |
| 985 // let CompleteRead() schedule a callback. | |
| 986 read_data_.mode = SYNCHRONOUS; | |
| 987 | |
| 988 CompletionCallback callback = pending_callback_; | |
| 989 int rv = CompleteRead(); | |
| 990 RunCallback(callback, rv); | |
| 991 } | |
| 992 | |
| 993 void MockTCPClientSocket::OnConnectComplete(const MockConnect& data) { | |
| 994 CompletionCallback callback = pending_callback_; | |
| 995 RunCallback(callback, data.result); | |
| 996 } | |
| 997 | |
| 998 int MockTCPClientSocket::CompleteRead() { | |
| 999 DCHECK(pending_buf_.get()); | |
| 1000 DCHECK(pending_buf_len_ > 0); | |
| 1001 | |
| 1002 was_used_to_convey_data_ = true; | |
| 1003 | |
| 1004 // Save the pending async IO data and reset our |pending_| state. | |
| 1005 scoped_refptr<IOBuffer> buf = pending_buf_; | |
| 1006 int buf_len = pending_buf_len_; | |
| 1007 CompletionCallback callback = pending_callback_; | |
| 1008 pending_buf_ = NULL; | |
| 1009 pending_buf_len_ = 0; | |
| 1010 pending_callback_.Reset(); | |
| 1011 | |
| 1012 int result = read_data_.result; | |
| 1013 DCHECK(result != ERR_IO_PENDING); | |
| 1014 | |
| 1015 if (read_data_.data) { | |
| 1016 if (read_data_.data_len - read_offset_ > 0) { | |
| 1017 result = std::min(buf_len, read_data_.data_len - read_offset_); | |
| 1018 memcpy(buf->data(), read_data_.data + read_offset_, result); | |
| 1019 read_offset_ += result; | |
| 1020 if (read_offset_ == read_data_.data_len) { | |
| 1021 need_read_data_ = true; | |
| 1022 read_offset_ = 0; | |
| 1023 } | |
| 1024 } else { | |
| 1025 result = 0; // EOF | |
| 1026 } | |
| 1027 } | |
| 1028 | |
| 1029 if (read_data_.mode == ASYNC) { | |
| 1030 DCHECK(!callback.is_null()); | |
| 1031 RunCallbackAsync(callback, result); | |
| 1032 return ERR_IO_PENDING; | |
| 1033 } | |
| 1034 return result; | |
| 1035 } | |
| 1036 | |
| 1037 DeterministicSocketHelper::DeterministicSocketHelper( | |
| 1038 net::NetLog* net_log, | |
| 1039 DeterministicSocketData* data) | |
| 1040 : write_pending_(false), | |
| 1041 write_result_(0), | |
| 1042 read_data_(), | |
| 1043 read_buf_(NULL), | |
| 1044 read_buf_len_(0), | |
| 1045 read_pending_(false), | |
| 1046 data_(data), | |
| 1047 was_used_to_convey_data_(false), | |
| 1048 peer_closed_connection_(false), | |
| 1049 net_log_(BoundNetLog::Make(net_log, net::NetLog::SOURCE_NONE)) { | |
| 1050 } | |
| 1051 | |
| 1052 DeterministicSocketHelper::~DeterministicSocketHelper() {} | |
| 1053 | |
| 1054 void DeterministicSocketHelper::CompleteWrite() { | |
| 1055 was_used_to_convey_data_ = true; | |
| 1056 write_pending_ = false; | |
| 1057 write_callback_.Run(write_result_); | |
| 1058 } | |
| 1059 | |
| 1060 int DeterministicSocketHelper::CompleteRead() { | |
| 1061 DCHECK_GT(read_buf_len_, 0); | |
| 1062 DCHECK_LE(read_data_.data_len, read_buf_len_); | |
| 1063 DCHECK(read_buf_); | |
| 1064 | |
| 1065 was_used_to_convey_data_ = true; | |
| 1066 | |
| 1067 if (read_data_.result == ERR_IO_PENDING) | |
| 1068 read_data_ = data_->GetNextRead(); | |
| 1069 DCHECK_NE(ERR_IO_PENDING, read_data_.result); | |
| 1070 // If read_data_.mode is ASYNC, we do not need to wait, since this is already | |
| 1071 // the callback. Therefore we don't even bother to check it. | |
| 1072 int result = read_data_.result; | |
| 1073 | |
| 1074 if (read_data_.data_len > 0) { | |
| 1075 DCHECK(read_data_.data); | |
| 1076 result = std::min(read_buf_len_, read_data_.data_len); | |
| 1077 memcpy(read_buf_->data(), read_data_.data, result); | |
| 1078 } | |
| 1079 | |
| 1080 if (read_pending_) { | |
| 1081 read_pending_ = false; | |
| 1082 read_callback_.Run(result); | |
| 1083 } | |
| 1084 | |
| 1085 return result; | |
| 1086 } | |
| 1087 | |
| 1088 int DeterministicSocketHelper::Write( | |
| 1089 IOBuffer* buf, int buf_len, const CompletionCallback& callback) { | |
| 1090 DCHECK(buf); | |
| 1091 DCHECK_GT(buf_len, 0); | |
| 1092 | |
| 1093 std::string data(buf->data(), buf_len); | |
| 1094 MockWriteResult write_result = data_->OnWrite(data); | |
| 1095 | |
| 1096 if (write_result.mode == ASYNC) { | |
| 1097 write_callback_ = callback; | |
| 1098 write_result_ = write_result.result; | |
| 1099 DCHECK(!write_callback_.is_null()); | |
| 1100 write_pending_ = true; | |
| 1101 return ERR_IO_PENDING; | |
| 1102 } | |
| 1103 | |
| 1104 was_used_to_convey_data_ = true; | |
| 1105 write_pending_ = false; | |
| 1106 return write_result.result; | |
| 1107 } | |
| 1108 | |
| 1109 int DeterministicSocketHelper::Read( | |
| 1110 IOBuffer* buf, int buf_len, const CompletionCallback& callback) { | |
| 1111 | |
| 1112 read_data_ = data_->GetNextRead(); | |
| 1113 // The buffer should always be big enough to contain all the MockRead data. To | |
| 1114 // use small buffers, split the data into multiple MockReads. | |
| 1115 DCHECK_LE(read_data_.data_len, buf_len); | |
| 1116 | |
| 1117 if (read_data_.result == ERR_CONNECTION_CLOSED) { | |
| 1118 // This MockRead is just a marker to instruct us to set | |
| 1119 // peer_closed_connection_. | |
| 1120 peer_closed_connection_ = true; | |
| 1121 } | |
| 1122 if (read_data_.result == ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ) { | |
| 1123 // This MockRead is just a marker to instruct us to set | |
| 1124 // peer_closed_connection_. Skip it and get the next one. | |
| 1125 read_data_ = data_->GetNextRead(); | |
| 1126 peer_closed_connection_ = true; | |
| 1127 } | |
| 1128 | |
| 1129 read_buf_ = buf; | |
| 1130 read_buf_len_ = buf_len; | |
| 1131 read_callback_ = callback; | |
| 1132 | |
| 1133 if (read_data_.mode == ASYNC || (read_data_.result == ERR_IO_PENDING)) { | |
| 1134 read_pending_ = true; | |
| 1135 DCHECK(!read_callback_.is_null()); | |
| 1136 return ERR_IO_PENDING; | |
| 1137 } | |
| 1138 | |
| 1139 was_used_to_convey_data_ = true; | |
| 1140 return CompleteRead(); | |
| 1141 } | |
| 1142 | |
| 1143 DeterministicMockUDPClientSocket::DeterministicMockUDPClientSocket( | |
| 1144 net::NetLog* net_log, | |
| 1145 DeterministicSocketData* data) | |
| 1146 : connected_(false), | |
| 1147 helper_(net_log, data), | |
| 1148 source_port_(123) { | |
| 1149 } | |
| 1150 | |
| 1151 DeterministicMockUDPClientSocket::~DeterministicMockUDPClientSocket() {} | |
| 1152 | |
| 1153 bool DeterministicMockUDPClientSocket::WritePending() const { | |
| 1154 return helper_.write_pending(); | |
| 1155 } | |
| 1156 | |
| 1157 bool DeterministicMockUDPClientSocket::ReadPending() const { | |
| 1158 return helper_.read_pending(); | |
| 1159 } | |
| 1160 | |
| 1161 void DeterministicMockUDPClientSocket::CompleteWrite() { | |
| 1162 helper_.CompleteWrite(); | |
| 1163 } | |
| 1164 | |
| 1165 int DeterministicMockUDPClientSocket::CompleteRead() { | |
| 1166 return helper_.CompleteRead(); | |
| 1167 } | |
| 1168 | |
| 1169 int DeterministicMockUDPClientSocket::Connect(const IPEndPoint& address) { | |
| 1170 if (connected_) | |
| 1171 return OK; | |
| 1172 connected_ = true; | |
| 1173 peer_address_ = address; | |
| 1174 return helper_.data()->connect_data().result; | |
| 1175 }; | |
| 1176 | |
| 1177 int DeterministicMockUDPClientSocket::Write( | |
| 1178 IOBuffer* buf, | |
| 1179 int buf_len, | |
| 1180 const CompletionCallback& callback) { | |
| 1181 if (!connected_) | |
| 1182 return ERR_UNEXPECTED; | |
| 1183 | |
| 1184 return helper_.Write(buf, buf_len, callback); | |
| 1185 } | |
| 1186 | |
| 1187 int DeterministicMockUDPClientSocket::Read( | |
| 1188 IOBuffer* buf, | |
| 1189 int buf_len, | |
| 1190 const CompletionCallback& callback) { | |
| 1191 if (!connected_) | |
| 1192 return ERR_UNEXPECTED; | |
| 1193 | |
| 1194 return helper_.Read(buf, buf_len, callback); | |
| 1195 } | |
| 1196 | |
| 1197 int DeterministicMockUDPClientSocket::SetReceiveBufferSize(int32 size) { | |
| 1198 return OK; | |
| 1199 } | |
| 1200 | |
| 1201 int DeterministicMockUDPClientSocket::SetSendBufferSize(int32 size) { | |
| 1202 return OK; | |
| 1203 } | |
| 1204 | |
| 1205 void DeterministicMockUDPClientSocket::Close() { | |
| 1206 connected_ = false; | |
| 1207 } | |
| 1208 | |
| 1209 int DeterministicMockUDPClientSocket::GetPeerAddress( | |
| 1210 IPEndPoint* address) const { | |
| 1211 *address = peer_address_; | |
| 1212 return OK; | |
| 1213 } | |
| 1214 | |
| 1215 int DeterministicMockUDPClientSocket::GetLocalAddress( | |
| 1216 IPEndPoint* address) const { | |
| 1217 IPAddressNumber ip; | |
| 1218 bool rv = ParseIPLiteralToNumber("192.0.2.33", &ip); | |
| 1219 CHECK(rv); | |
| 1220 *address = IPEndPoint(ip, source_port_); | |
| 1221 return OK; | |
| 1222 } | |
| 1223 | |
| 1224 const BoundNetLog& DeterministicMockUDPClientSocket::NetLog() const { | |
| 1225 return helper_.net_log(); | |
| 1226 } | |
| 1227 | |
| 1228 void DeterministicMockUDPClientSocket::OnReadComplete(const MockRead& data) {} | |
| 1229 | |
| 1230 void DeterministicMockUDPClientSocket::OnConnectComplete( | |
| 1231 const MockConnect& data) { | |
| 1232 NOTIMPLEMENTED(); | |
| 1233 } | |
| 1234 | |
| 1235 DeterministicMockTCPClientSocket::DeterministicMockTCPClientSocket( | |
| 1236 net::NetLog* net_log, | |
| 1237 DeterministicSocketData* data) | |
| 1238 : MockClientSocket(BoundNetLog::Make(net_log, net::NetLog::SOURCE_NONE)), | |
| 1239 helper_(net_log, data) { | |
| 1240 peer_addr_ = data->connect_data().peer_addr; | |
| 1241 } | |
| 1242 | |
| 1243 DeterministicMockTCPClientSocket::~DeterministicMockTCPClientSocket() {} | |
| 1244 | |
| 1245 bool DeterministicMockTCPClientSocket::WritePending() const { | |
| 1246 return helper_.write_pending(); | |
| 1247 } | |
| 1248 | |
| 1249 bool DeterministicMockTCPClientSocket::ReadPending() const { | |
| 1250 return helper_.read_pending(); | |
| 1251 } | |
| 1252 | |
| 1253 void DeterministicMockTCPClientSocket::CompleteWrite() { | |
| 1254 helper_.CompleteWrite(); | |
| 1255 } | |
| 1256 | |
| 1257 int DeterministicMockTCPClientSocket::CompleteRead() { | |
| 1258 return helper_.CompleteRead(); | |
| 1259 } | |
| 1260 | |
| 1261 int DeterministicMockTCPClientSocket::Write( | |
| 1262 IOBuffer* buf, | |
| 1263 int buf_len, | |
| 1264 const CompletionCallback& callback) { | |
| 1265 if (!connected_) | |
| 1266 return ERR_UNEXPECTED; | |
| 1267 | |
| 1268 return helper_.Write(buf, buf_len, callback); | |
| 1269 } | |
| 1270 | |
| 1271 int DeterministicMockTCPClientSocket::Read( | |
| 1272 IOBuffer* buf, | |
| 1273 int buf_len, | |
| 1274 const CompletionCallback& callback) { | |
| 1275 if (!connected_) | |
| 1276 return ERR_UNEXPECTED; | |
| 1277 | |
| 1278 return helper_.Read(buf, buf_len, callback); | |
| 1279 } | |
| 1280 | |
| 1281 // TODO(erikchen): Support connect sequencing. | |
| 1282 int DeterministicMockTCPClientSocket::Connect( | |
| 1283 const CompletionCallback& callback) { | |
| 1284 if (connected_) | |
| 1285 return OK; | |
| 1286 connected_ = true; | |
| 1287 if (helper_.data()->connect_data().mode == ASYNC) { | |
| 1288 RunCallbackAsync(callback, helper_.data()->connect_data().result); | |
| 1289 return ERR_IO_PENDING; | |
| 1290 } | |
| 1291 return helper_.data()->connect_data().result; | |
| 1292 } | |
| 1293 | |
| 1294 void DeterministicMockTCPClientSocket::Disconnect() { | |
| 1295 MockClientSocket::Disconnect(); | |
| 1296 } | |
| 1297 | |
| 1298 bool DeterministicMockTCPClientSocket::IsConnected() const { | |
| 1299 return connected_ && !helper_.peer_closed_connection(); | |
| 1300 } | |
| 1301 | |
| 1302 bool DeterministicMockTCPClientSocket::IsConnectedAndIdle() const { | |
| 1303 return IsConnected(); | |
| 1304 } | |
| 1305 | |
| 1306 bool DeterministicMockTCPClientSocket::WasEverUsed() const { | |
| 1307 return helper_.was_used_to_convey_data(); | |
| 1308 } | |
| 1309 | |
| 1310 bool DeterministicMockTCPClientSocket::UsingTCPFastOpen() const { | |
| 1311 return false; | |
| 1312 } | |
| 1313 | |
| 1314 bool DeterministicMockTCPClientSocket::WasNpnNegotiated() const { | |
| 1315 return false; | |
| 1316 } | |
| 1317 | |
| 1318 bool DeterministicMockTCPClientSocket::GetSSLInfo(SSLInfo* ssl_info) { | |
| 1319 return false; | |
| 1320 } | |
| 1321 | |
| 1322 void DeterministicMockTCPClientSocket::OnReadComplete(const MockRead& data) {} | |
| 1323 | |
| 1324 void DeterministicMockTCPClientSocket::OnConnectComplete( | |
| 1325 const MockConnect& data) {} | |
| 1326 | |
| 1327 MockSSLClientSocket::MockSSLClientSocket( | |
| 1328 scoped_ptr<ClientSocketHandle> transport_socket, | |
| 1329 const HostPortPair& host_port_pair, | |
| 1330 const SSLConfig& ssl_config, | |
| 1331 SSLSocketDataProvider* data) | |
| 1332 : MockClientSocket( | |
| 1333 // Have to use the right BoundNetLog for LoadTimingInfo regression | |
| 1334 // tests. | |
| 1335 transport_socket->socket()->NetLog()), | |
| 1336 transport_(transport_socket.Pass()), | |
| 1337 host_port_pair_(host_port_pair), | |
| 1338 data_(data), | |
| 1339 is_npn_state_set_(false), | |
| 1340 new_npn_value_(false), | |
| 1341 is_protocol_negotiated_set_(false), | |
| 1342 protocol_negotiated_(kProtoUnknown), | |
| 1343 next_connect_state_(STATE_NONE), | |
| 1344 reached_connect_(false), | |
| 1345 weak_factory_(this) { | |
| 1346 DCHECK(data_); | |
| 1347 peer_addr_ = data->connect.peer_addr; | |
| 1348 } | |
| 1349 | |
| 1350 MockSSLClientSocket::~MockSSLClientSocket() { | |
| 1351 Disconnect(); | |
| 1352 } | |
| 1353 | |
| 1354 int MockSSLClientSocket::Read(IOBuffer* buf, int buf_len, | |
| 1355 const CompletionCallback& callback) { | |
| 1356 return transport_->socket()->Read(buf, buf_len, callback); | |
| 1357 } | |
| 1358 | |
| 1359 int MockSSLClientSocket::Write(IOBuffer* buf, int buf_len, | |
| 1360 const CompletionCallback& callback) { | |
| 1361 return transport_->socket()->Write(buf, buf_len, callback); | |
| 1362 } | |
| 1363 | |
| 1364 int MockSSLClientSocket::Connect(const CompletionCallback& callback) { | |
| 1365 next_connect_state_ = STATE_SSL_CONNECT; | |
| 1366 reached_connect_ = true; | |
| 1367 int rv = DoConnectLoop(OK); | |
| 1368 if (rv == ERR_IO_PENDING) | |
| 1369 connect_callback_ = callback; | |
| 1370 return rv; | |
| 1371 } | |
| 1372 | |
| 1373 void MockSSLClientSocket::Disconnect() { | |
| 1374 weak_factory_.InvalidateWeakPtrs(); | |
| 1375 MockClientSocket::Disconnect(); | |
| 1376 if (transport_->socket() != NULL) | |
| 1377 transport_->socket()->Disconnect(); | |
| 1378 } | |
| 1379 | |
| 1380 bool MockSSLClientSocket::IsConnected() const { | |
| 1381 return transport_->socket()->IsConnected() && connected_; | |
| 1382 } | |
| 1383 | |
| 1384 bool MockSSLClientSocket::WasEverUsed() const { | |
| 1385 return transport_->socket()->WasEverUsed(); | |
| 1386 } | |
| 1387 | |
| 1388 bool MockSSLClientSocket::UsingTCPFastOpen() const { | |
| 1389 return transport_->socket()->UsingTCPFastOpen(); | |
| 1390 } | |
| 1391 | |
| 1392 int MockSSLClientSocket::GetPeerAddress(IPEndPoint* address) const { | |
| 1393 return transport_->socket()->GetPeerAddress(address); | |
| 1394 } | |
| 1395 | |
| 1396 bool MockSSLClientSocket::GetSSLInfo(SSLInfo* ssl_info) { | |
| 1397 ssl_info->Reset(); | |
| 1398 ssl_info->cert = data_->cert; | |
| 1399 ssl_info->client_cert_sent = data_->client_cert_sent; | |
| 1400 ssl_info->channel_id_sent = data_->channel_id_sent; | |
| 1401 ssl_info->connection_status = data_->connection_status; | |
| 1402 return true; | |
| 1403 } | |
| 1404 | |
| 1405 std::string MockSSLClientSocket::GetSessionCacheKey() const { | |
| 1406 // For the purposes of these tests, |host_and_port| will serve as the | |
| 1407 // cache key. | |
| 1408 return host_port_pair_.ToString(); | |
| 1409 } | |
| 1410 | |
| 1411 bool MockSSLClientSocket::InSessionCache() const { | |
| 1412 return data_->is_in_session_cache; | |
| 1413 } | |
| 1414 | |
| 1415 void MockSSLClientSocket::SetHandshakeCompletionCallback( | |
| 1416 const base::Closure& cb) { | |
| 1417 handshake_completion_callback_ = cb; | |
| 1418 } | |
| 1419 | |
| 1420 void MockSSLClientSocket::GetSSLCertRequestInfo( | |
| 1421 SSLCertRequestInfo* cert_request_info) { | |
| 1422 DCHECK(cert_request_info); | |
| 1423 if (data_->cert_request_info) { | |
| 1424 cert_request_info->host_and_port = | |
| 1425 data_->cert_request_info->host_and_port; | |
| 1426 cert_request_info->client_certs = data_->cert_request_info->client_certs; | |
| 1427 } else { | |
| 1428 cert_request_info->Reset(); | |
| 1429 } | |
| 1430 } | |
| 1431 | |
| 1432 SSLClientSocket::NextProtoStatus MockSSLClientSocket::GetNextProto( | |
| 1433 std::string* proto) { | |
| 1434 *proto = data_->next_proto; | |
| 1435 return data_->next_proto_status; | |
| 1436 } | |
| 1437 | |
| 1438 bool MockSSLClientSocket::set_was_npn_negotiated(bool negotiated) { | |
| 1439 is_npn_state_set_ = true; | |
| 1440 return new_npn_value_ = negotiated; | |
| 1441 } | |
| 1442 | |
| 1443 bool MockSSLClientSocket::WasNpnNegotiated() const { | |
| 1444 if (is_npn_state_set_) | |
| 1445 return new_npn_value_; | |
| 1446 return data_->was_npn_negotiated; | |
| 1447 } | |
| 1448 | |
| 1449 NextProto MockSSLClientSocket::GetNegotiatedProtocol() const { | |
| 1450 if (is_protocol_negotiated_set_) | |
| 1451 return protocol_negotiated_; | |
| 1452 return data_->protocol_negotiated; | |
| 1453 } | |
| 1454 | |
| 1455 void MockSSLClientSocket::set_protocol_negotiated( | |
| 1456 NextProto protocol_negotiated) { | |
| 1457 is_protocol_negotiated_set_ = true; | |
| 1458 protocol_negotiated_ = protocol_negotiated; | |
| 1459 } | |
| 1460 | |
| 1461 bool MockSSLClientSocket::WasChannelIDSent() const { | |
| 1462 return data_->channel_id_sent; | |
| 1463 } | |
| 1464 | |
| 1465 void MockSSLClientSocket::set_channel_id_sent(bool channel_id_sent) { | |
| 1466 data_->channel_id_sent = channel_id_sent; | |
| 1467 } | |
| 1468 | |
| 1469 ChannelIDService* MockSSLClientSocket::GetChannelIDService() const { | |
| 1470 return data_->channel_id_service; | |
| 1471 } | |
| 1472 | |
| 1473 void MockSSLClientSocket::OnReadComplete(const MockRead& data) { | |
| 1474 NOTIMPLEMENTED(); | |
| 1475 } | |
| 1476 | |
| 1477 void MockSSLClientSocket::OnConnectComplete(const MockConnect& data) { | |
| 1478 NOTIMPLEMENTED(); | |
| 1479 } | |
| 1480 | |
| 1481 void MockSSLClientSocket::RestartPausedConnect() { | |
| 1482 DCHECK(data_->should_pause_on_connect); | |
| 1483 DCHECK_EQ(next_connect_state_, STATE_SSL_CONNECT_COMPLETE); | |
| 1484 OnIOComplete(data_->connect.result); | |
| 1485 } | |
| 1486 | |
| 1487 void MockSSLClientSocket::OnIOComplete(int result) { | |
| 1488 int rv = DoConnectLoop(result); | |
| 1489 if (rv != ERR_IO_PENDING) | |
| 1490 base::ResetAndReturn(&connect_callback_).Run(rv); | |
| 1491 } | |
| 1492 | |
| 1493 int MockSSLClientSocket::DoConnectLoop(int result) { | |
| 1494 DCHECK_NE(next_connect_state_, STATE_NONE); | |
| 1495 | |
| 1496 int rv = result; | |
| 1497 do { | |
| 1498 ConnectState state = next_connect_state_; | |
| 1499 next_connect_state_ = STATE_NONE; | |
| 1500 switch (state) { | |
| 1501 case STATE_SSL_CONNECT: | |
| 1502 rv = DoSSLConnect(); | |
| 1503 break; | |
| 1504 case STATE_SSL_CONNECT_COMPLETE: | |
| 1505 rv = DoSSLConnectComplete(rv); | |
| 1506 break; | |
| 1507 default: | |
| 1508 NOTREACHED() << "bad state"; | |
| 1509 rv = ERR_UNEXPECTED; | |
| 1510 break; | |
| 1511 } | |
| 1512 } while (rv != ERR_IO_PENDING && next_connect_state_ != STATE_NONE); | |
| 1513 | |
| 1514 return rv; | |
| 1515 } | |
| 1516 | |
| 1517 int MockSSLClientSocket::DoSSLConnect() { | |
| 1518 next_connect_state_ = STATE_SSL_CONNECT_COMPLETE; | |
| 1519 | |
| 1520 if (data_->should_pause_on_connect) | |
| 1521 return ERR_IO_PENDING; | |
| 1522 | |
| 1523 if (data_->connect.mode == ASYNC) { | |
| 1524 base::MessageLoop::current()->PostTask( | |
| 1525 FROM_HERE, | |
| 1526 base::Bind(&MockSSLClientSocket::OnIOComplete, | |
| 1527 weak_factory_.GetWeakPtr(), | |
| 1528 data_->connect.result)); | |
| 1529 return ERR_IO_PENDING; | |
| 1530 } | |
| 1531 | |
| 1532 return data_->connect.result; | |
| 1533 } | |
| 1534 | |
| 1535 int MockSSLClientSocket::DoSSLConnectComplete(int result) { | |
| 1536 if (result == OK) | |
| 1537 connected_ = true; | |
| 1538 | |
| 1539 if (!handshake_completion_callback_.is_null()) | |
| 1540 base::ResetAndReturn(&handshake_completion_callback_).Run(); | |
| 1541 return result; | |
| 1542 } | |
| 1543 | |
| 1544 MockUDPClientSocket::MockUDPClientSocket(SocketDataProvider* data, | |
| 1545 net::NetLog* net_log) | |
| 1546 : connected_(false), | |
| 1547 data_(data), | |
| 1548 read_offset_(0), | |
| 1549 read_data_(SYNCHRONOUS, ERR_UNEXPECTED), | |
| 1550 need_read_data_(true), | |
| 1551 source_port_(123), | |
| 1552 pending_buf_(NULL), | |
| 1553 pending_buf_len_(0), | |
| 1554 net_log_(BoundNetLog::Make(net_log, net::NetLog::SOURCE_NONE)), | |
| 1555 weak_factory_(this) { | |
| 1556 DCHECK(data_); | |
| 1557 data_->Reset(); | |
| 1558 peer_addr_ = data->connect_data().peer_addr; | |
| 1559 } | |
| 1560 | |
| 1561 MockUDPClientSocket::~MockUDPClientSocket() {} | |
| 1562 | |
| 1563 int MockUDPClientSocket::Read(IOBuffer* buf, | |
| 1564 int buf_len, | |
| 1565 const CompletionCallback& callback) { | |
| 1566 if (!connected_) | |
| 1567 return ERR_UNEXPECTED; | |
| 1568 | |
| 1569 // If the buffer is already in use, a read is already in progress! | |
| 1570 DCHECK(pending_buf_.get() == NULL); | |
| 1571 | |
| 1572 // Store our async IO data. | |
| 1573 pending_buf_ = buf; | |
| 1574 pending_buf_len_ = buf_len; | |
| 1575 pending_callback_ = callback; | |
| 1576 | |
| 1577 if (need_read_data_) { | |
| 1578 read_data_ = data_->GetNextRead(); | |
| 1579 // ERR_IO_PENDING means that the SocketDataProvider is taking responsibility | |
| 1580 // to complete the async IO manually later (via OnReadComplete). | |
| 1581 if (read_data_.result == ERR_IO_PENDING) { | |
| 1582 // We need to be using async IO in this case. | |
| 1583 DCHECK(!callback.is_null()); | |
| 1584 return ERR_IO_PENDING; | |
| 1585 } | |
| 1586 need_read_data_ = false; | |
| 1587 } | |
| 1588 | |
| 1589 return CompleteRead(); | |
| 1590 } | |
| 1591 | |
| 1592 int MockUDPClientSocket::Write(IOBuffer* buf, int buf_len, | |
| 1593 const CompletionCallback& callback) { | |
| 1594 DCHECK(buf); | |
| 1595 DCHECK_GT(buf_len, 0); | |
| 1596 | |
| 1597 if (!connected_) | |
| 1598 return ERR_UNEXPECTED; | |
| 1599 | |
| 1600 std::string data(buf->data(), buf_len); | |
| 1601 MockWriteResult write_result = data_->OnWrite(data); | |
| 1602 | |
| 1603 if (write_result.mode == ASYNC) { | |
| 1604 RunCallbackAsync(callback, write_result.result); | |
| 1605 return ERR_IO_PENDING; | |
| 1606 } | |
| 1607 return write_result.result; | |
| 1608 } | |
| 1609 | |
| 1610 int MockUDPClientSocket::SetReceiveBufferSize(int32 size) { | |
| 1611 return OK; | |
| 1612 } | |
| 1613 | |
| 1614 int MockUDPClientSocket::SetSendBufferSize(int32 size) { | |
| 1615 return OK; | |
| 1616 } | |
| 1617 | |
| 1618 void MockUDPClientSocket::Close() { | |
| 1619 connected_ = false; | |
| 1620 } | |
| 1621 | |
| 1622 int MockUDPClientSocket::GetPeerAddress(IPEndPoint* address) const { | |
| 1623 *address = peer_addr_; | |
| 1624 return OK; | |
| 1625 } | |
| 1626 | |
| 1627 int MockUDPClientSocket::GetLocalAddress(IPEndPoint* address) const { | |
| 1628 IPAddressNumber ip; | |
| 1629 bool rv = ParseIPLiteralToNumber("192.0.2.33", &ip); | |
| 1630 CHECK(rv); | |
| 1631 *address = IPEndPoint(ip, source_port_); | |
| 1632 return OK; | |
| 1633 } | |
| 1634 | |
| 1635 const BoundNetLog& MockUDPClientSocket::NetLog() const { | |
| 1636 return net_log_; | |
| 1637 } | |
| 1638 | |
| 1639 int MockUDPClientSocket::Connect(const IPEndPoint& address) { | |
| 1640 connected_ = true; | |
| 1641 peer_addr_ = address; | |
| 1642 return data_->connect_data().result; | |
| 1643 } | |
| 1644 | |
| 1645 void MockUDPClientSocket::OnReadComplete(const MockRead& data) { | |
| 1646 // There must be a read pending. | |
| 1647 DCHECK(pending_buf_.get()); | |
| 1648 // You can't complete a read with another ERR_IO_PENDING status code. | |
| 1649 DCHECK_NE(ERR_IO_PENDING, data.result); | |
| 1650 // Since we've been waiting for data, need_read_data_ should be true. | |
| 1651 DCHECK(need_read_data_); | |
| 1652 | |
| 1653 read_data_ = data; | |
| 1654 need_read_data_ = false; | |
| 1655 | |
| 1656 // The caller is simulating that this IO completes right now. Don't | |
| 1657 // let CompleteRead() schedule a callback. | |
| 1658 read_data_.mode = SYNCHRONOUS; | |
| 1659 | |
| 1660 net::CompletionCallback callback = pending_callback_; | |
| 1661 int rv = CompleteRead(); | |
| 1662 RunCallback(callback, rv); | |
| 1663 } | |
| 1664 | |
| 1665 void MockUDPClientSocket::OnConnectComplete(const MockConnect& data) { | |
| 1666 NOTIMPLEMENTED(); | |
| 1667 } | |
| 1668 | |
| 1669 int MockUDPClientSocket::CompleteRead() { | |
| 1670 DCHECK(pending_buf_.get()); | |
| 1671 DCHECK(pending_buf_len_ > 0); | |
| 1672 | |
| 1673 // Save the pending async IO data and reset our |pending_| state. | |
| 1674 scoped_refptr<IOBuffer> buf = pending_buf_; | |
| 1675 int buf_len = pending_buf_len_; | |
| 1676 CompletionCallback callback = pending_callback_; | |
| 1677 pending_buf_ = NULL; | |
| 1678 pending_buf_len_ = 0; | |
| 1679 pending_callback_.Reset(); | |
| 1680 | |
| 1681 int result = read_data_.result; | |
| 1682 DCHECK(result != ERR_IO_PENDING); | |
| 1683 | |
| 1684 if (read_data_.data) { | |
| 1685 if (read_data_.data_len - read_offset_ > 0) { | |
| 1686 result = std::min(buf_len, read_data_.data_len - read_offset_); | |
| 1687 memcpy(buf->data(), read_data_.data + read_offset_, result); | |
| 1688 read_offset_ += result; | |
| 1689 if (read_offset_ == read_data_.data_len) { | |
| 1690 need_read_data_ = true; | |
| 1691 read_offset_ = 0; | |
| 1692 } | |
| 1693 } else { | |
| 1694 result = 0; // EOF | |
| 1695 } | |
| 1696 } | |
| 1697 | |
| 1698 if (read_data_.mode == ASYNC) { | |
| 1699 DCHECK(!callback.is_null()); | |
| 1700 RunCallbackAsync(callback, result); | |
| 1701 return ERR_IO_PENDING; | |
| 1702 } | |
| 1703 return result; | |
| 1704 } | |
| 1705 | |
| 1706 void MockUDPClientSocket::RunCallbackAsync(const CompletionCallback& callback, | |
| 1707 int result) { | |
| 1708 base::MessageLoop::current()->PostTask( | |
| 1709 FROM_HERE, | |
| 1710 base::Bind(&MockUDPClientSocket::RunCallback, | |
| 1711 weak_factory_.GetWeakPtr(), | |
| 1712 callback, | |
| 1713 result)); | |
| 1714 } | |
| 1715 | |
| 1716 void MockUDPClientSocket::RunCallback(const CompletionCallback& callback, | |
| 1717 int result) { | |
| 1718 if (!callback.is_null()) | |
| 1719 callback.Run(result); | |
| 1720 } | |
| 1721 | |
| 1722 TestSocketRequest::TestSocketRequest( | |
| 1723 std::vector<TestSocketRequest*>* request_order, size_t* completion_count) | |
| 1724 : request_order_(request_order), | |
| 1725 completion_count_(completion_count), | |
| 1726 callback_(base::Bind(&TestSocketRequest::OnComplete, | |
| 1727 base::Unretained(this))) { | |
| 1728 DCHECK(request_order); | |
| 1729 DCHECK(completion_count); | |
| 1730 } | |
| 1731 | |
| 1732 TestSocketRequest::~TestSocketRequest() { | |
| 1733 } | |
| 1734 | |
| 1735 void TestSocketRequest::OnComplete(int result) { | |
| 1736 SetResult(result); | |
| 1737 (*completion_count_)++; | |
| 1738 request_order_->push_back(this); | |
| 1739 } | |
| 1740 | |
| 1741 // static | |
| 1742 const int ClientSocketPoolTest::kIndexOutOfBounds = -1; | |
| 1743 | |
| 1744 // static | |
| 1745 const int ClientSocketPoolTest::kRequestNotFound = -2; | |
| 1746 | |
| 1747 ClientSocketPoolTest::ClientSocketPoolTest() : completion_count_(0) {} | |
| 1748 ClientSocketPoolTest::~ClientSocketPoolTest() {} | |
| 1749 | |
| 1750 int ClientSocketPoolTest::GetOrderOfRequest(size_t index) const { | |
| 1751 index--; | |
| 1752 if (index >= requests_.size()) | |
| 1753 return kIndexOutOfBounds; | |
| 1754 | |
| 1755 for (size_t i = 0; i < request_order_.size(); i++) | |
| 1756 if (requests_[index] == request_order_[i]) | |
| 1757 return i + 1; | |
| 1758 | |
| 1759 return kRequestNotFound; | |
| 1760 } | |
| 1761 | |
| 1762 bool ClientSocketPoolTest::ReleaseOneConnection(KeepAlive keep_alive) { | |
| 1763 ScopedVector<TestSocketRequest>::iterator i; | |
| 1764 for (i = requests_.begin(); i != requests_.end(); ++i) { | |
| 1765 if ((*i)->handle()->is_initialized()) { | |
| 1766 if (keep_alive == NO_KEEP_ALIVE) | |
| 1767 (*i)->handle()->socket()->Disconnect(); | |
| 1768 (*i)->handle()->Reset(); | |
| 1769 base::RunLoop().RunUntilIdle(); | |
| 1770 return true; | |
| 1771 } | |
| 1772 } | |
| 1773 return false; | |
| 1774 } | |
| 1775 | |
| 1776 void ClientSocketPoolTest::ReleaseAllConnections(KeepAlive keep_alive) { | |
| 1777 bool released_one; | |
| 1778 do { | |
| 1779 released_one = ReleaseOneConnection(keep_alive); | |
| 1780 } while (released_one); | |
| 1781 } | |
| 1782 | |
| 1783 MockTransportClientSocketPool::MockConnectJob::MockConnectJob( | |
| 1784 scoped_ptr<StreamSocket> socket, | |
| 1785 ClientSocketHandle* handle, | |
| 1786 const CompletionCallback& callback) | |
| 1787 : socket_(socket.Pass()), | |
| 1788 handle_(handle), | |
| 1789 user_callback_(callback) { | |
| 1790 } | |
| 1791 | |
| 1792 MockTransportClientSocketPool::MockConnectJob::~MockConnectJob() {} | |
| 1793 | |
| 1794 int MockTransportClientSocketPool::MockConnectJob::Connect() { | |
| 1795 int rv = socket_->Connect(base::Bind(&MockConnectJob::OnConnect, | |
| 1796 base::Unretained(this))); | |
| 1797 if (rv == OK) { | |
| 1798 user_callback_.Reset(); | |
| 1799 OnConnect(OK); | |
| 1800 } | |
| 1801 return rv; | |
| 1802 } | |
| 1803 | |
| 1804 bool MockTransportClientSocketPool::MockConnectJob::CancelHandle( | |
| 1805 const ClientSocketHandle* handle) { | |
| 1806 if (handle != handle_) | |
| 1807 return false; | |
| 1808 socket_.reset(); | |
| 1809 handle_ = NULL; | |
| 1810 user_callback_.Reset(); | |
| 1811 return true; | |
| 1812 } | |
| 1813 | |
| 1814 void MockTransportClientSocketPool::MockConnectJob::OnConnect(int rv) { | |
| 1815 if (!socket_.get()) | |
| 1816 return; | |
| 1817 if (rv == OK) { | |
| 1818 handle_->SetSocket(socket_.Pass()); | |
| 1819 | |
| 1820 // Needed for socket pool tests that layer other sockets on top of mock | |
| 1821 // sockets. | |
| 1822 LoadTimingInfo::ConnectTiming connect_timing; | |
| 1823 base::TimeTicks now = base::TimeTicks::Now(); | |
| 1824 connect_timing.dns_start = now; | |
| 1825 connect_timing.dns_end = now; | |
| 1826 connect_timing.connect_start = now; | |
| 1827 connect_timing.connect_end = now; | |
| 1828 handle_->set_connect_timing(connect_timing); | |
| 1829 } else { | |
| 1830 socket_.reset(); | |
| 1831 } | |
| 1832 | |
| 1833 handle_ = NULL; | |
| 1834 | |
| 1835 if (!user_callback_.is_null()) { | |
| 1836 CompletionCallback callback = user_callback_; | |
| 1837 user_callback_.Reset(); | |
| 1838 callback.Run(rv); | |
| 1839 } | |
| 1840 } | |
| 1841 | |
| 1842 MockTransportClientSocketPool::MockTransportClientSocketPool( | |
| 1843 int max_sockets, | |
| 1844 int max_sockets_per_group, | |
| 1845 ClientSocketPoolHistograms* histograms, | |
| 1846 ClientSocketFactory* socket_factory) | |
| 1847 : TransportClientSocketPool(max_sockets, max_sockets_per_group, histograms, | |
| 1848 NULL, NULL, NULL), | |
| 1849 client_socket_factory_(socket_factory), | |
| 1850 last_request_priority_(DEFAULT_PRIORITY), | |
| 1851 release_count_(0), | |
| 1852 cancel_count_(0) { | |
| 1853 } | |
| 1854 | |
| 1855 MockTransportClientSocketPool::~MockTransportClientSocketPool() {} | |
| 1856 | |
| 1857 int MockTransportClientSocketPool::RequestSocket( | |
| 1858 const std::string& group_name, const void* socket_params, | |
| 1859 RequestPriority priority, ClientSocketHandle* handle, | |
| 1860 const CompletionCallback& callback, const BoundNetLog& net_log) { | |
| 1861 last_request_priority_ = priority; | |
| 1862 scoped_ptr<StreamSocket> socket = | |
| 1863 client_socket_factory_->CreateTransportClientSocket( | |
| 1864 AddressList(), net_log.net_log(), net::NetLog::Source()); | |
| 1865 MockConnectJob* job = new MockConnectJob(socket.Pass(), handle, callback); | |
| 1866 job_list_.push_back(job); | |
| 1867 handle->set_pool_id(1); | |
| 1868 return job->Connect(); | |
| 1869 } | |
| 1870 | |
| 1871 void MockTransportClientSocketPool::CancelRequest(const std::string& group_name, | |
| 1872 ClientSocketHandle* handle) { | |
| 1873 std::vector<MockConnectJob*>::iterator i; | |
| 1874 for (i = job_list_.begin(); i != job_list_.end(); ++i) { | |
| 1875 if ((*i)->CancelHandle(handle)) { | |
| 1876 cancel_count_++; | |
| 1877 break; | |
| 1878 } | |
| 1879 } | |
| 1880 } | |
| 1881 | |
| 1882 void MockTransportClientSocketPool::ReleaseSocket( | |
| 1883 const std::string& group_name, | |
| 1884 scoped_ptr<StreamSocket> socket, | |
| 1885 int id) { | |
| 1886 EXPECT_EQ(1, id); | |
| 1887 release_count_++; | |
| 1888 } | |
| 1889 | |
| 1890 DeterministicMockClientSocketFactory::DeterministicMockClientSocketFactory() {} | |
| 1891 | |
| 1892 DeterministicMockClientSocketFactory::~DeterministicMockClientSocketFactory() {} | |
| 1893 | |
| 1894 void DeterministicMockClientSocketFactory::AddSocketDataProvider( | |
| 1895 DeterministicSocketData* data) { | |
| 1896 mock_data_.Add(data); | |
| 1897 } | |
| 1898 | |
| 1899 void DeterministicMockClientSocketFactory::AddSSLSocketDataProvider( | |
| 1900 SSLSocketDataProvider* data) { | |
| 1901 mock_ssl_data_.Add(data); | |
| 1902 } | |
| 1903 | |
| 1904 void DeterministicMockClientSocketFactory::ResetNextMockIndexes() { | |
| 1905 mock_data_.ResetNextIndex(); | |
| 1906 mock_ssl_data_.ResetNextIndex(); | |
| 1907 } | |
| 1908 | |
| 1909 MockSSLClientSocket* DeterministicMockClientSocketFactory:: | |
| 1910 GetMockSSLClientSocket(size_t index) const { | |
| 1911 DCHECK_LT(index, ssl_client_sockets_.size()); | |
| 1912 return ssl_client_sockets_[index]; | |
| 1913 } | |
| 1914 | |
| 1915 scoped_ptr<DatagramClientSocket> | |
| 1916 DeterministicMockClientSocketFactory::CreateDatagramClientSocket( | |
| 1917 DatagramSocket::BindType bind_type, | |
| 1918 const RandIntCallback& rand_int_cb, | |
| 1919 net::NetLog* net_log, | |
| 1920 const NetLog::Source& source) { | |
| 1921 DeterministicSocketData* data_provider = mock_data().GetNext(); | |
| 1922 scoped_ptr<DeterministicMockUDPClientSocket> socket( | |
| 1923 new DeterministicMockUDPClientSocket(net_log, data_provider)); | |
| 1924 data_provider->set_delegate(socket->AsWeakPtr()); | |
| 1925 udp_client_sockets().push_back(socket.get()); | |
| 1926 if (bind_type == DatagramSocket::RANDOM_BIND) | |
| 1927 socket->set_source_port(static_cast<uint16>(rand_int_cb.Run(1025, 65535))); | |
| 1928 return socket.Pass(); | |
| 1929 } | |
| 1930 | |
| 1931 scoped_ptr<StreamSocket> | |
| 1932 DeterministicMockClientSocketFactory::CreateTransportClientSocket( | |
| 1933 const AddressList& addresses, | |
| 1934 net::NetLog* net_log, | |
| 1935 const net::NetLog::Source& source) { | |
| 1936 DeterministicSocketData* data_provider = mock_data().GetNext(); | |
| 1937 scoped_ptr<DeterministicMockTCPClientSocket> socket( | |
| 1938 new DeterministicMockTCPClientSocket(net_log, data_provider)); | |
| 1939 data_provider->set_delegate(socket->AsWeakPtr()); | |
| 1940 tcp_client_sockets().push_back(socket.get()); | |
| 1941 return socket.Pass(); | |
| 1942 } | |
| 1943 | |
| 1944 scoped_ptr<SSLClientSocket> | |
| 1945 DeterministicMockClientSocketFactory::CreateSSLClientSocket( | |
| 1946 scoped_ptr<ClientSocketHandle> transport_socket, | |
| 1947 const HostPortPair& host_and_port, | |
| 1948 const SSLConfig& ssl_config, | |
| 1949 const SSLClientSocketContext& context) { | |
| 1950 scoped_ptr<MockSSLClientSocket> socket( | |
| 1951 new MockSSLClientSocket(transport_socket.Pass(), | |
| 1952 host_and_port, ssl_config, | |
| 1953 mock_ssl_data_.GetNext())); | |
| 1954 ssl_client_sockets_.push_back(socket.get()); | |
| 1955 return socket.Pass(); | |
| 1956 } | |
| 1957 | |
| 1958 void DeterministicMockClientSocketFactory::ClearSSLSessionCache() { | |
| 1959 } | |
| 1960 | |
| 1961 MockSOCKSClientSocketPool::MockSOCKSClientSocketPool( | |
| 1962 int max_sockets, | |
| 1963 int max_sockets_per_group, | |
| 1964 ClientSocketPoolHistograms* histograms, | |
| 1965 TransportClientSocketPool* transport_pool) | |
| 1966 : SOCKSClientSocketPool(max_sockets, max_sockets_per_group, histograms, | |
| 1967 NULL, transport_pool, NULL), | |
| 1968 transport_pool_(transport_pool) { | |
| 1969 } | |
| 1970 | |
| 1971 MockSOCKSClientSocketPool::~MockSOCKSClientSocketPool() {} | |
| 1972 | |
| 1973 int MockSOCKSClientSocketPool::RequestSocket( | |
| 1974 const std::string& group_name, const void* socket_params, | |
| 1975 RequestPriority priority, ClientSocketHandle* handle, | |
| 1976 const CompletionCallback& callback, const BoundNetLog& net_log) { | |
| 1977 return transport_pool_->RequestSocket( | |
| 1978 group_name, socket_params, priority, handle, callback, net_log); | |
| 1979 } | |
| 1980 | |
| 1981 void MockSOCKSClientSocketPool::CancelRequest( | |
| 1982 const std::string& group_name, | |
| 1983 ClientSocketHandle* handle) { | |
| 1984 return transport_pool_->CancelRequest(group_name, handle); | |
| 1985 } | |
| 1986 | |
| 1987 void MockSOCKSClientSocketPool::ReleaseSocket(const std::string& group_name, | |
| 1988 scoped_ptr<StreamSocket> socket, | |
| 1989 int id) { | |
| 1990 return transport_pool_->ReleaseSocket(group_name, socket.Pass(), id); | |
| 1991 } | |
| 1992 | |
| 1993 ScopedWebSocketEndpointZeroUnlockDelay:: | |
| 1994 ScopedWebSocketEndpointZeroUnlockDelay() { | |
| 1995 old_delay_ = | |
| 1996 WebSocketEndpointLockManager::GetInstance()->SetUnlockDelayForTesting( | |
| 1997 base::TimeDelta()); | |
| 1998 } | |
| 1999 | |
| 2000 ScopedWebSocketEndpointZeroUnlockDelay:: | |
| 2001 ~ScopedWebSocketEndpointZeroUnlockDelay() { | |
| 2002 base::TimeDelta active_delay = | |
| 2003 WebSocketEndpointLockManager::GetInstance()->SetUnlockDelayForTesting( | |
| 2004 old_delay_); | |
| 2005 EXPECT_EQ(active_delay, base::TimeDelta()); | |
| 2006 } | |
| 2007 | |
| 2008 const char kSOCKS5GreetRequest[] = { 0x05, 0x01, 0x00 }; | |
| 2009 const int kSOCKS5GreetRequestLength = arraysize(kSOCKS5GreetRequest); | |
| 2010 | |
| 2011 const char kSOCKS5GreetResponse[] = { 0x05, 0x00 }; | |
| 2012 const int kSOCKS5GreetResponseLength = arraysize(kSOCKS5GreetResponse); | |
| 2013 | |
| 2014 const char kSOCKS5OkRequest[] = | |
| 2015 { 0x05, 0x01, 0x00, 0x03, 0x04, 'h', 'o', 's', 't', 0x00, 0x50 }; | |
| 2016 const int kSOCKS5OkRequestLength = arraysize(kSOCKS5OkRequest); | |
| 2017 | |
| 2018 const char kSOCKS5OkResponse[] = | |
| 2019 { 0x05, 0x00, 0x00, 0x01, 127, 0, 0, 1, 0x00, 0x50 }; | |
| 2020 const int kSOCKS5OkResponseLength = arraysize(kSOCKS5OkResponse); | |
| 2021 | |
| 2022 } // 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