Fixes to socket_test_util.cc.

net/socket/socket_test_util.cc

 // Copyright (c) 2011 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 235 matching lines @@
 }
 
 SSLSocketDataProvider::~SSLSocketDataProvider() {
 }
 
 DelayedSocketData::DelayedSocketData(
     int write_delay, MockRead* reads, size_t reads_count,
     MockWrite* writes, size_t writes_count)
     : StaticSocketDataProvider(reads, reads_count, writes, writes_count),
       write_delay_(write_delay),
+      read_in_progress_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   DCHECK_GE(write_delay_, 0);
 }
 
 DelayedSocketData::DelayedSocketData(
     const MockConnect& connect, int write_delay, MockRead* reads,
     size_t reads_count, MockWrite* writes, size_t writes_count)
     : StaticSocketDataProvider(reads, reads_count, writes, writes_count),
       write_delay_(write_delay),
+      read_in_progress_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   DCHECK_GE(write_delay_, 0);
   set_connect_data(connect);
 }
 
 DelayedSocketData::~DelayedSocketData() {
 }
 
 void DelayedSocketData::ForceNextRead() {
+  DCHECK(read_in_progress_);
   write_delay_ = 0;
   CompleteRead();
 }
 
 MockRead DelayedSocketData::GetNextRead() {
-  if (write_delay_ > 0)
-    return MockRead(true, ERR_IO_PENDING);
-  return StaticSocketDataProvider::GetNextRead();
+  MockRead out = MockRead(true, ERR_IO_PENDING);
+  if (write_delay_ <= 0)
+    out = StaticSocketDataProvider::GetNextRead();
+  read_in_progress_ = (out.result == ERR_IO_PENDING);
+  return out;
 }
 
 MockWriteResult DelayedSocketData::OnWrite(const std::string& data) {
   MockWriteResult rv = StaticSocketDataProvider::OnWrite(data);
   // Now that our write has completed, we can allow reads to continue.
-  if (!--write_delay_)
+  if (!--write_delay_ && read_in_progress_)
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&DelayedSocketData::CompleteRead,
                    weak_factory_.GetWeakPtr()),
         100);
   return rv;
 }
 
 void DelayedSocketData::Reset() {
   set_socket(NULL);
+  read_in_progress_ = false;
   weak_factory_.InvalidateWeakPtrs();
   StaticSocketDataProvider::Reset();
 }
 
 void DelayedSocketData::CompleteRead() {
-  if (socket())
+  if (socket() && read_in_progress_)
     socket()->OnReadComplete(GetNextRead());
 }
 
 OrderedSocketData::OrderedSocketData(
     MockRead* reads, size_t reads_count, MockWrite* writes, size_t writes_count)
     : StaticSocketDataProvider(reads, reads_count, writes, writes_count),
       sequence_number_(0), loop_stop_stage_(0),
       blocked_(false), ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
 }
 
@@ skipping 32 matching lines @@
   weak_factory_.InvalidateWeakPtrs();
   blocked_ = false;
   const MockRead& next_read = StaticSocketDataProvider::PeekRead();
   if (next_read.sequence_number & MockRead::STOPLOOP)
     EndLoop();
   if ((next_read.sequence_number & ~MockRead::STOPLOOP) <=
       sequence_number_++) {
     NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_ - 1
                               << ": Read " << read_index();
     DumpMockRead(next_read);
+    blocked_ = (next_read.result == ERR_IO_PENDING);
     return StaticSocketDataProvider::GetNextRead();
   }
   NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_ - 1
                             << ": I/O Pending";
   MockRead result = MockRead(true, ERR_IO_PENDING);
   DumpMockRead(result);
   blocked_ = true;
   return result;
 }
 
@@ skipping 21 matching lines @@
   NET_TRACE(INFO, "  *** ") << "Stage "
                             << sequence_number_ << ": Reset()";
   sequence_number_ = 0;
   loop_stop_stage_ = 0;
   set_socket(NULL);
   weak_factory_.InvalidateWeakPtrs();
   StaticSocketDataProvider::Reset();
 }
 
 void OrderedSocketData::CompleteRead() {
-  if (socket()) {
+  if (socket() && blocked_) {
     NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_;
     socket()->OnReadComplete(GetNextRead());
   }
 }
 
 OrderedSocketData::~OrderedSocketData() {}
 
 DeterministicSocketData::DeterministicSocketData(MockRead* reads,
     size_t reads_count, MockWrite* writes, size_t writes_count)
     : StaticSocketDataProvider(reads, reads_count, writes, writes_count),
@@ skipping 167 matching lines @@
 void MockClientSocketFactory::AddSSLSocketDataProvider(
     SSLSocketDataProvider* data) {
   mock_ssl_data_.Add(data);
 }
 
 void MockClientSocketFactory::ResetNextMockIndexes() {
   mock_data_.ResetNextIndex();
   mock_ssl_data_.ResetNextIndex();
 }
 
-MockTCPClientSocket* MockClientSocketFactory::GetMockTCPClientSocket(
-    size_t index) const {
-  DCHECK_LT(index, tcp_client_sockets_.size());
-  return tcp_client_sockets_[index];
-}
-
-MockSSLClientSocket* MockClientSocketFactory::GetMockSSLClientSocket(
-    size_t index) const {
-  DCHECK_LT(index, ssl_client_sockets_.size());
-  return ssl_client_sockets_[index];
-}
-
 DatagramClientSocket* MockClientSocketFactory::CreateDatagramClientSocket(
     DatagramSocket::BindType bind_type,
     const RandIntCallback& rand_int_cb,
     net::NetLog* net_log,
     const net::NetLog::Source& source) {
   SocketDataProvider* data_provider = mock_data_.GetNext();
   MockUDPClientSocket* socket = new MockUDPClientSocket(data_provider, net_log);
   data_provider->set_socket(socket);
-  udp_client_sockets_.push_back(socket);
   return socket;
 }
 
 StreamSocket* MockClientSocketFactory::CreateTransportClientSocket(
     const AddressList& addresses,
     net::NetLog* net_log,
     const net::NetLog::Source& source) {
   SocketDataProvider* data_provider = mock_data_.GetNext();
   MockTCPClientSocket* socket =
       new MockTCPClientSocket(addresses, net_log, data_provider);
   data_provider->set_socket(socket);
-  tcp_client_sockets_.push_back(socket);
   return socket;
 }
 
 SSLClientSocket* MockClientSocketFactory::CreateSSLClientSocket(
     ClientSocketHandle* transport_socket,
     const HostPortPair& host_and_port,
     const SSLConfig& ssl_config,
     SSLHostInfo* ssl_host_info,
     const SSLClientSocketContext& context) {
   MockSSLClientSocket* socket =
       new MockSSLClientSocket(transport_socket, host_and_port, ssl_config,
                               ssl_host_info, mock_ssl_data_.GetNext());
-  ssl_client_sockets_.push_back(socket);
   return socket;
 }
 
 void MockClientSocketFactory::ClearSSLSessionCache() {
 }
 
 MockClientSocket::MockClientSocket(net::NetLog* net_log)
     : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       connected_(false),
       net_log_(net::NetLog::Source(), net_log) {
@@ skipping 956 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