Change DeterministicSocketData to no longer inherit from SocketDataProvider

net/socket/socket_test_util.h

 // 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.
 
 #ifndef NET_SOCKET_SOCKET_TEST_UTIL_H_
 #define NET_SOCKET_SOCKET_TEST_UTIL_H_
 
 #include <cstring>
 #include <deque>
 #include <string>
@@ skipping 480 matching lines @@
 // complete in this step, but is marked asynchronous.  Write() returns
 // ERR_IO_PENDING.  The current step is still 1.  At this point RunFor(1) is
 // called which will cause the write callback to be invoked, and will then
 // stop.  The current state is now 2.  RunFor(1) is called again, which
 // causes the read callback to be invoked, and will then stop.  Then current
 // step is 2.  Write() is called again.  Then next available write is
 // synchronous so the call to Write() returns length.
 //
 // For examples of how to use this class, see:
 //   deterministic_socket_data_unittests.cc
-class DeterministicSocketData : public StaticSocketDataProvider {
+class DeterministicSocketData {
  public:
   // The Delegate is an abstract interface which handles the communication from
   // the DeterministicSocketData to the Deterministic MockSocket.  The
   // MockSockets directly store a pointer to the DeterministicSocketData,
   // whereas the DeterministicSocketData only stores a pointer to the
   // abstract Delegate interface.
   class Delegate {
    public:
     // Returns true if there is currently a write pending. That is to say, if
     // an asynchronous write has been started but the callback has not been
@@ skipping 11 matching lines @@
    protected:
     virtual ~Delegate() {}
   };
 
   // |reads| the list of MockRead completions.
   // |writes| the list of MockWrite completions.
   DeterministicSocketData(MockRead* reads,
                           size_t reads_count,
                           MockWrite* writes,
                           size_t writes_count);
-  ~DeterministicSocketData() override;
+  ~DeterministicSocketData();
 
   // Consume all the data up to the give stop point (via SetStop()).
   void Run();
 
   // Set the stop point to be |steps| from now, and then invoke Run().
   void RunFor(int steps);
 
   // Stop at step |seq|, which must be in the future.
-  virtual void SetStop(int seq);
+  void SetStop(int seq);
 
   // Stop |seq| steps after the current step.
-  virtual void StopAfter(int seq);
+  void StopAfter(int seq);
+
   bool stopped() const { return stopped_; }
   void SetStopped(bool val) { stopped_ = val; }
   MockRead& current_read() { return current_read_; }
   MockWrite& current_write() { return current_write_; }
   int sequence_number() const { return sequence_number_; }
   void set_delegate(base::WeakPtr<Delegate> delegate) { delegate_ = delegate; }
-
-  // StaticSocketDataProvider:
+  MockConnect connect_data() const { return connect_; }
+  void set_connect_data(const MockConnect& connect) { connect_ = connect; }
 
   // When the socket calls Read(), that calls OnRead(), and expects either
   // ERR_IO_PENDING or data.
-  MockRead OnRead() override;
+  MockRead OnRead();
 
   // When the socket calls Write(), it always completes synchronously. OnWrite()
   // checks to make sure the written data matches the expected data. The
   // callback will not be invoked until its sequence number is reached.
-  MockWriteResult OnWrite(const std::string& data) override;
-  void Reset() override;
-  void CompleteRead() override {}
+  MockWriteResult OnWrite(const std::string& data);
+
+  bool AllReadDataConsumed() const;
+  bool AllWriteDataConsumed() const;
 
  private:
   // Invoke the read and write callbacks, if the timing is appropriate.
   void InvokeCallbacks();
 
   void NextStep();
 
   void VerifyCorrectSequenceNumbers(MockRead* reads,
                                     size_t reads_count,
                                     MockWrite* writes,
                                     size_t writes_count);
-
+  StaticSocketDataHelper helper_;
+  MockConnect connect_;
   int sequence_number_;
   MockRead current_read_;
   MockWrite current_write_;
   int stopping_sequence_number_;
   bool stopped_;
   base::WeakPtr<Delegate> delegate_;
   bool print_debug_;
   bool is_running_;
 };
 
@@ skipping 242 matching lines @@
   CompletionCallback read_callback_;
   DeterministicSocketData* data_;
   bool was_used_to_convey_data_;
   bool peer_closed_connection_;
   BoundNetLog net_log_;
 };
 
 // Mock UDP socket to be used in conjunction with DeterministicSocketData.
 class DeterministicMockUDPClientSocket
     : public DatagramClientSocket,
-      public AsyncSocket,
       public DeterministicSocketData::Delegate,
       public base::SupportsWeakPtr<DeterministicMockUDPClientSocket> {
  public:
   DeterministicMockUDPClientSocket(net::NetLog* net_log,
                                    DeterministicSocketData* data);
   ~DeterministicMockUDPClientSocket() override;
 
   // DeterministicSocketData::Delegate:
   bool WritePending() const override;
   bool ReadPending() const override;
@@ skipping 12 matching lines @@
 
   // DatagramSocket implementation.
   void Close() override;
   int GetPeerAddress(IPEndPoint* address) const override;
   int GetLocalAddress(IPEndPoint* address) const override;
   const BoundNetLog& NetLog() const override;
 
   // DatagramClientSocket implementation.
   int Connect(const IPEndPoint& address) override;
 
-  // AsyncSocket implementation.
-  void OnReadComplete(const MockRead& data) override;
-  void OnWriteComplete(int rv) override;
-  void OnConnectComplete(const MockConnect& data) override;
-
   void set_source_port(uint16 port) { source_port_ = port; }
 
  private:
   bool connected_;
   IPEndPoint peer_address_;
   DeterministicSocketHelper helper_;
   uint16 source_port_;  // Ephemeral source port.
 
   DISALLOW_COPY_AND_ASSIGN(DeterministicMockUDPClientSocket);
 };
 
 // Mock TCP socket to be used in conjunction with DeterministicSocketData.
 class DeterministicMockTCPClientSocket
     : public MockClientSocket,
-      public AsyncSocket,
       public DeterministicSocketData::Delegate,
       public base::SupportsWeakPtr<DeterministicMockTCPClientSocket> {
  public:
   DeterministicMockTCPClientSocket(net::NetLog* net_log,
                                    DeterministicSocketData* data);
   ~DeterministicMockTCPClientSocket() override;
 
   // DeterministicSocketData::Delegate:
   bool WritePending() const override;
   bool ReadPending() const override;
@@ skipping 11 matching lines @@
   // StreamSocket:
   int Connect(const CompletionCallback& callback) override;
   void Disconnect() override;
   bool IsConnected() const override;
   bool IsConnectedAndIdle() const override;
   bool WasEverUsed() const override;
   bool UsingTCPFastOpen() const override;
   bool WasNpnNegotiated() const override;
   bool GetSSLInfo(SSLInfo* ssl_info) override;
 
-  // AsyncSocket:
-  void OnReadComplete(const MockRead& data) override;
-  void OnWriteComplete(int rv) override;
-  void OnConnectComplete(const MockConnect& data) override;
-
  private:
   DeterministicSocketHelper helper_;
 
   DISALLOW_COPY_AND_ASSIGN(DeterministicMockTCPClientSocket);
 };
 
 class MockSSLClientSocket : public MockClientSocket, public AsyncSocket {
  public:
   MockSSLClientSocket(scoped_ptr<ClientSocketHandle> transport_socket,
                       const HostPortPair& host_and_port,
@@ skipping 356 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_