Fixes to socket_test_util.cc.

net/socket/socket_test_util.h

 // 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.
 
 #ifndef NET_SOCKET_SOCKET_TEST_UTIL_H_
 #define NET_SOCKET_SOCKET_TEST_UTIL_H_
 #pragma once
 
 #include <cstring>
 #include <deque>
@@ skipping 255 matching lines @@
   std::string server_protos;
   bool was_npn_negotiated;
   SSLClientSocket::NextProto protocol_negotiated;
   bool client_cert_sent;
   SSLCertRequestInfo* cert_request_info;
   scoped_refptr<X509Certificate> cert;
 };
 
 // A DataProvider where the client must write a request before the reads (e.g.
 // the response) will complete.
-class DelayedSocketData : public StaticSocketDataProvider,
-                          public base::RefCounted<DelayedSocketData> {
+class DelayedSocketData : public StaticSocketDataProvider {
  public:
   // |write_delay| the number of MockWrites to complete before allowing
   //               a MockRead to complete.
   // |reads| the list of MockRead completions.
   // |writes| the list of MockWrite completions.
   // Note: All MockReads and MockWrites must be async.
-  // Note: The MockRead and MockWrite lists musts end with a EOF
-  //       e.g. a MockRead(true, 0, 0);
+  // Note: For stream sockets, the MockRead list must end with a EOF, e.g., a
+  //       MockRead(true, 0, 0);
   DelayedSocketData(int write_delay,
                     MockRead* reads, size_t reads_count,
                     MockWrite* writes, size_t writes_count);
 
   // |connect| the result for the connect phase.
   // |reads| the list of MockRead completions.
   // |write_delay| the number of MockWrites to complete before allowing
   //               a MockRead to complete.
   // |writes| the list of MockWrite completions.
   // Note: All MockReads and MockWrites must be async.
-  // Note: The MockRead and MockWrite lists musts end with a EOF
-  //       e.g. a MockRead(true, 0, 0);
+  // Note: For stream sockets, the MockRead list must end with a EOF, e.g., a
+  //       MockRead(true, 0, 0);
   DelayedSocketData(const MockConnect& connect, int write_delay,
                     MockRead* reads, size_t reads_count,
                     MockWrite* writes, size_t writes_count);
   virtual ~DelayedSocketData();
 
   void ForceNextRead();
 
   // StaticSocketDataProvider:
   virtual MockRead GetNextRead() OVERRIDE;
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE;
   virtual void Reset() OVERRIDE;
   virtual void CompleteRead() OVERRIDE;
 
  private:
   int write_delay_;
+  bool blocked_;

[eroman, 2012/01/21 01:18:30]

something like "read_pending_" or "read_in_progress_" would be clearer IMO.

   base::WeakPtrFactory<DelayedSocketData> weak_factory_;
 };
 
 // A DataProvider where the reads are ordered.
 // If a read is requested before its sequence number is reached, we return an
 // ERR_IO_PENDING (that way we don't have to explicitly add a MockRead just to
 // wait).
 // The sequence number is incremented on every read and write operation.
 // The message loop may be interrupted by setting the high bit of the sequence
 // number in the MockRead's sequence number.  When that MockRead is reached,
 // we post a Quit message to the loop.  This allows us to interrupt the reading
 // of data before a complete message has arrived, and provides support for
 // testing server push when the request is issued while the response is in the
 // middle of being received.
-class OrderedSocketData : public StaticSocketDataProvider,
-                          public base::RefCounted<OrderedSocketData> {
+class OrderedSocketData : public StaticSocketDataProvider {
  public:
   // |reads| the list of MockRead completions.
   // |writes| the list of MockWrite completions.
   // Note: All MockReads and MockWrites must be async.
-  // Note: The MockRead and MockWrite lists musts end with a EOF
-  //       e.g. a MockRead(true, 0, 0);
+  // Note: For stream sockets, the MockRead list must end with a EOF, e.g., a
+  //       MockRead(true, 0, 0);
   OrderedSocketData(MockRead* reads, size_t reads_count,
                     MockWrite* writes, size_t writes_count);
+  virtual ~OrderedSocketData();
 
   // |connect| the result for the connect phase.
   // |reads| the list of MockRead completions.
   // |writes| the list of MockWrite completions.
   // Note: All MockReads and MockWrites must be async.
-  // Note: The MockRead and MockWrite lists musts end with a EOF
-  //       e.g. a MockRead(true, 0, 0);
+  // Note: For stream sockets, the MockRead list must end with a EOF, e.g., a
+  //       MockRead(true, 0, 0);
   OrderedSocketData(const MockConnect& connect,
                     MockRead* reads, size_t reads_count,
                     MockWrite* writes, size_t writes_count);
 
   // Posts a quit message to the current message loop, if one is running.
   void EndLoop();
 
   // StaticSocketDataProvider:
   virtual MockRead GetNextRead() OVERRIDE;
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE;
   virtual void Reset() OVERRIDE;
   virtual void CompleteRead() OVERRIDE;
 
  private:
-  friend class base::RefCounted<OrderedSocketData>;
-  virtual ~OrderedSocketData();
-
   int sequence_number_;
   int loop_stop_stage_;
   bool blocked_;
   base::WeakPtrFactory<OrderedSocketData> weak_factory_;
 };
 
 class DeterministicMockTCPClientSocket;
 
 // This class gives the user full control over the network activity,
 // specifically the timing of the COMPLETION of I/O operations.  Regardless of
@@ skipping 152 matching lines @@
 // socket types.
 class MockClientSocketFactory : public ClientSocketFactory {
  public:
   MockClientSocketFactory();
   virtual ~MockClientSocketFactory();
 
   void AddSocketDataProvider(SocketDataProvider* socket);
   void AddSSLSocketDataProvider(SSLSocketDataProvider* socket);
   void ResetNextMockIndexes();
 
-  // Return |index|-th MockTCPClientSocket (starting from 0) that the factory
-  // created.
-  MockTCPClientSocket* GetMockTCPClientSocket(size_t index) const;
-
-  // Return |index|-th MockSSLClientSocket (starting from 0) that the factory
-  // created.
-  MockSSLClientSocket* GetMockSSLClientSocket(size_t index) const;
-
   SocketDataProviderArray<SocketDataProvider>& mock_data() {
     return mock_data_;
   }
-  std::vector<MockTCPClientSocket*>& tcp_client_sockets() {
-    return tcp_client_sockets_;
-  }
-  std::vector<MockUDPClientSocket*>& udp_client_sockets() {
-    return udp_client_sockets_;
-  }
 
   // ClientSocketFactory
   virtual DatagramClientSocket* CreateDatagramClientSocket(
       DatagramSocket::BindType bind_type,
       const RandIntCallback& rand_int_cb,
       NetLog* net_log,
       const NetLog::Source& source) OVERRIDE;
   virtual StreamSocket* CreateTransportClientSocket(
       const AddressList& addresses,
       NetLog* net_log,
       const NetLog::Source& source) OVERRIDE;
   virtual SSLClientSocket* CreateSSLClientSocket(
       ClientSocketHandle* transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
       SSLHostInfo* ssl_host_info,
       const SSLClientSocketContext& context) OVERRIDE;
   virtual void ClearSSLSessionCache() OVERRIDE;
 
  private:
   SocketDataProviderArray<SocketDataProvider> mock_data_;
   SocketDataProviderArray<SSLSocketDataProvider> mock_ssl_data_;
-
-  // Store pointers to handed out sockets in case the test wants to get them.
-  std::vector<MockUDPClientSocket*> udp_client_sockets_;
-  std::vector<MockTCPClientSocket*> tcp_client_sockets_;
-  std::vector<MockSSLClientSocket*> ssl_client_sockets_;
 };
 
 class MockClientSocket : public SSLClientSocket {
  public:
   // TODO(ajwong): Why do we need net::NetLog?
   explicit MockClientSocket(net::NetLog* net_log);
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf, int buf_len,
                    const CompletionCallback& callback) = 0;
@@ skipping 457 matching lines @@
 
 extern const char kSOCKS5OkRequest[];
 extern const int kSOCKS5OkRequestLength;
 
 extern const char kSOCKS5OkResponse[];
 extern const int kSOCKS5OkResponseLength;
 
 }  // namespace net
 
 #endif  // NET_SOCKET_SOCKET_TEST_UTIL_H_