net/socket/socket_test_util.cc

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