Change DeterministicSocketData to no longer inherit from SocketDataProvider

net/socket/socket_test_util.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/socket/socket_test_util.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 588 matching lines @@
   NET_TRACE(1, " *** ") << " Completing socket write for: "
                         << data.sequence_number;
   socket()->OnWriteComplete(rv);
   NET_TRACE(1, " *** ") << "Done";
 }
 
 SequencedSocketData::~SequencedSocketData() {
 }
 
 DeterministicSocketData::DeterministicSocketData(MockRead* reads,
-    size_t reads_count, MockWrite* writes, size_t writes_count)
-    : StaticSocketDataProvider(reads, reads_count, writes, writes_count),
+                                                 size_t reads_count,
+                                                 MockWrite* writes,
+                                                 size_t writes_count)
+    : helper_(reads, reads_count, writes, writes_count),
       sequence_number_(0),
       current_read_(),
       current_write_(),
       stopping_sequence_number_(0),
       stopped_(false),
       print_debug_(false),
       is_running_(false) {
   VerifyCorrectSequenceNumbers(reads, reads_count, writes, writes_count);
 }
 
@@ skipping 39 matching lines @@
   DCHECK_LT(sequence_number_, seq);
   stopping_sequence_number_ = seq;
   stopped_ = false;
 }
 
 void DeterministicSocketData::StopAfter(int seq) {
   SetStop(sequence_number_ + seq);
 }
 
 MockRead DeterministicSocketData::OnRead() {
-  current_read_ = helper()->PeekRead();
+  current_read_ = helper_.PeekRead();
 
   // Synchronous read while stopped is an error
   if (stopped() && current_read_.mode == SYNCHRONOUS) {
     LOG(ERROR) << "Unable to perform synchronous IO while stopped";
     return MockRead(SYNCHRONOUS, ERR_UNEXPECTED);
   }
 
   // Async read which will be called back in a future step.
   if (sequence_number_ < current_read_.sequence_number) {
     NET_TRACE(1, "  *** ") << "Stage " << sequence_number_ << ": I/O Pending";
     MockRead result = MockRead(SYNCHRONOUS, ERR_IO_PENDING);
     if (current_read_.mode == SYNCHRONOUS) {
       LOG(ERROR) << "Unable to perform synchronous read: "
           << current_read_.sequence_number
           << " at stage: " << sequence_number_;
       result = MockRead(SYNCHRONOUS, ERR_UNEXPECTED);
     }
     if (print_debug_)
       DumpMockReadWrite(result);
     return result;
   }
 
   NET_TRACE(1, "  *** ") << "Stage " << sequence_number_ << ": Read "
-                         << read_index();
+                         << helper_.read_index();
   if (print_debug_)
     DumpMockReadWrite(current_read_);
 
   // Increment the sequence number if IO is complete
   if (current_read_.mode == SYNCHRONOUS)
     NextStep();
 
   DCHECK_NE(ERR_IO_PENDING, current_read_.result);
-  StaticSocketDataProvider::OnRead();
 
+  helper_.AdvanceRead();
   return current_read_;
 }
 
 MockWriteResult DeterministicSocketData::OnWrite(const std::string& data) {
-  const MockWrite& next_write = helper()->PeekWrite();
+  const MockWrite& next_write = helper_.PeekWrite();
   current_write_ = next_write;
 
   // Synchronous write while stopped is an error
   if (stopped() && next_write.mode == SYNCHRONOUS) {
     LOG(ERROR) << "Unable to perform synchronous IO while stopped";
     return MockWriteResult(SYNCHRONOUS, ERR_UNEXPECTED);
   }
 
   // Async write which will be called back in a future step.
   if (sequence_number_ < next_write.sequence_number) {
     NET_TRACE(1, "  *** ") << "Stage " << sequence_number_ << ": I/O Pending";
     if (next_write.mode == SYNCHRONOUS) {
       LOG(ERROR) << "Unable to perform synchronous write: "
           << next_write.sequence_number << " at stage: " << sequence_number_;
       return MockWriteResult(SYNCHRONOUS, ERR_UNEXPECTED);
     }
   } else {
     NET_TRACE(1, "  *** ") << "Stage " << sequence_number_ << ": Write "
-                           << write_index();
+                           << helper_.write_index();
   }
 
   if (print_debug_)
     DumpMockReadWrite(next_write);
 
   // Move to the next step if I/O is synchronous, since the operation will
   // complete when this method returns.
   if (next_write.mode == SYNCHRONOUS)
     NextStep();
 
-  // This is either a sync write for this step, or an async write.
-  return StaticSocketDataProvider::OnWrite(data);
+  // Check that what we are writing matches the expectation.
+  // Then give the mocked return value.
+  if (!helper_.VerifyWriteData(data))
+    return MockWriteResult(SYNCHRONOUS, ERR_UNEXPECTED);
+
+  helper_.AdvanceWrite();
+
+  // In the case that the write was successful, return the number of bytes
+  // // written. Otherwise return the error code.

[ramant (doing other things), 2015/05/19 17:06:35]

overly nit: " // // written" -> " // written"

[Ryan Hamilton, 2015/05/19 17:33:26]

Done.

+  int result =
+      next_write.result == OK ? next_write.data_len : next_write.result;
+  return MockWriteResult(next_write.mode, result);
 }
 
-void DeterministicSocketData::Reset() {
-  NET_TRACE(1, "  *** ") << "Stage " << sequence_number_ << ": Reset()";
-  sequence_number_ = 0;
-  StaticSocketDataProvider::Reset();
-  NOTREACHED();
+bool DeterministicSocketData::AllReadDataConsumed() const {
+  return helper_.AllReadDataConsumed();
+}
+
+bool DeterministicSocketData::AllWriteDataConsumed() const {
+  return helper_.AllWriteDataConsumed();
 }
 
 void DeterministicSocketData::InvokeCallbacks() {
   if (delegate_.get() && delegate_->WritePending() &&
       (current_write().sequence_number == sequence_number())) {
     NextStep();
     delegate_->CompleteWrite();
     return;
   }
   if (delegate_.get() && delegate_->ReadPending() &&
@@ skipping 626 matching lines @@
   bool rv = ParseIPLiteralToNumber("192.0.2.33", &ip);
   CHECK(rv);
   *address = IPEndPoint(ip, source_port_);
   return OK;
 }
 
 const BoundNetLog& DeterministicMockUDPClientSocket::NetLog() const {
   return helper_.net_log();
 }
 
-void DeterministicMockUDPClientSocket::OnReadComplete(const MockRead& data) {}
-
-void DeterministicMockUDPClientSocket::OnWriteComplete(int rv) {
-}
-
-void DeterministicMockUDPClientSocket::OnConnectComplete(
-    const MockConnect& data) {
-  NOTIMPLEMENTED();
-}
-
 DeterministicMockTCPClientSocket::DeterministicMockTCPClientSocket(
     net::NetLog* net_log,
     DeterministicSocketData* data)
     : MockClientSocket(BoundNetLog::Make(net_log, NetLog::SOURCE_NONE)),
       helper_(net_log, data) {
   peer_addr_ = data->connect_data().peer_addr;
 }
 
 DeterministicMockTCPClientSocket::~DeterministicMockTCPClientSocket() {}
 
@@ skipping 67 matching lines @@
 }
 
 bool DeterministicMockTCPClientSocket::WasNpnNegotiated() const {
   return false;
 }
 
 bool DeterministicMockTCPClientSocket::GetSSLInfo(SSLInfo* ssl_info) {
   return false;
 }
 
-void DeterministicMockTCPClientSocket::OnReadComplete(const MockRead& data) {}
-
-void DeterministicMockTCPClientSocket::OnWriteComplete(int rv) {
-}
-
-void DeterministicMockTCPClientSocket::OnConnectComplete(
-    const MockConnect& data) {}
-
 // static
 void MockSSLClientSocket::ConnectCallback(
     MockSSLClientSocket* ssl_client_socket,
     const CompletionCallback& callback,
     int rv) {
   if (rv == OK)
     ssl_client_socket->connected_ = true;
   callback.Run(rv);
 }
 
@@ skipping 600 matching lines @@
 
 const char kSOCKS5OkRequest[] =
     { 0x05, 0x01, 0x00, 0x03, 0x04, 'h', 'o', 's', 't', 0x00, 0x50 };
 const int kSOCKS5OkRequestLength = arraysize(kSOCKS5OkRequest);
 
 const char kSOCKS5OkResponse[] =
     { 0x05, 0x00, 0x00, 0x01, 127, 0, 0, 1, 0x00, 0x50 };
 const int kSOCKS5OkResponseLength = arraysize(kSOCKS5OkResponse);
 
 }  // namespace net