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