Remove use of DeterministicSocketData from QUIC tests.

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 <stdint.h>
 
 #include <cstring>
@@ skipping 647 matching lines @@
       const AddressList& addresses,
       NetLog* net_log,
       const NetLog::Source& source) override;
   scoped_ptr<SSLClientSocket> CreateSSLClientSocket(
       scoped_ptr<ClientSocketHandle> transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
       const SSLClientSocketContext& context) override;
   void ClearSSLSessionCache() override;
 
+  const std::vector<uint16>& udp_client_socket_ports() const {
+    return udp_client_socket_ports_;
+  }
+
  private:
   SocketDataProviderArray<SocketDataProvider> mock_data_;
   SocketDataProviderArray<SSLSocketDataProvider> mock_ssl_data_;
+  std::vector<uint16> udp_client_socket_ports_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockClientSocketFactory);
 };
 
 class MockClientSocket : public SSLClientSocket {
  public:
   // Value returned by GetTLSUniqueChannelBinding().
   static const char kTlsUnique[];
 
   // The BoundNetLog is needed to test LoadTimingInfo, which uses NetLog IDs as
   // unique socket IDs.
   explicit MockClientSocket(const BoundNetLog& net_log);
@@ skipping 157 matching lines @@
   IOBuffer* read_buf_;
   int read_buf_len_;
   bool read_pending_;
   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 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;
-  void CompleteWrite() override;
-  int CompleteRead() override;
-
-  // Socket implementation.
-  int Read(IOBuffer* buf,
-           int buf_len,
-           const CompletionCallback& callback) override;
-  int Write(IOBuffer* buf,
-            int buf_len,
-            const CompletionCallback& callback) override;
-  int SetReceiveBufferSize(int32 size) override;
-  int SetSendBufferSize(int32 size) override;
-
-  // 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 BindToNetwork(NetworkChangeNotifier::NetworkHandle network) override;
-  int BindToDefaultNetwork() override;
-  NetworkChangeNotifier::NetworkHandle GetBoundNetwork() override;
-  int Connect(const IPEndPoint& address) 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 DeterministicSocketData::Delegate,
       public base::SupportsWeakPtr<DeterministicMockTCPClientSocket> {
  public:
   DeterministicMockTCPClientSocket(net::NetLog* net_log,
                                    DeterministicSocketData* data);
   ~DeterministicMockTCPClientSocket() override;
 
@@ skipping 106 matching lines @@
   NetworkChangeNotifier::NetworkHandle GetBoundNetwork() override;
   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 OnDataProviderDestroyed() override;
 
   void set_source_port(uint16 port) { source_port_ = port;}
+  uint16 source_port() const { return source_port_; }
 
  private:
   int CompleteRead();
 
   void RunCallbackAsync(const CompletionCallback& callback, int result);
   void RunCallback(const CompletionCallback& callback, int result);
 
   bool connected_;
   SocketDataProvider* data_;
   int read_offset_;
@@ skipping 184 matching lines @@
   // Return |index|-th MockSSLClientSocket (starting from 0) that the factory
   // created.
   MockSSLClientSocket* GetMockSSLClientSocket(size_t index) const;
 
   SocketDataProviderArray<DeterministicSocketData>& mock_data() {
     return mock_data_;
   }
   std::vector<DeterministicMockTCPClientSocket*>& tcp_client_sockets() {
     return tcp_client_sockets_;
   }
-  std::vector<DeterministicMockUDPClientSocket*>& udp_client_sockets() {
-    return udp_client_sockets_;
-  }
 
   // ClientSocketFactory
   scoped_ptr<DatagramClientSocket> CreateDatagramClientSocket(
       DatagramSocket::BindType bind_type,
       const RandIntCallback& rand_int_cb,
       NetLog* net_log,
       const NetLog::Source& source) override;
   scoped_ptr<StreamSocket> CreateTransportClientSocket(
       const AddressList& addresses,
       NetLog* net_log,
       const NetLog::Source& source) override;
   scoped_ptr<SSLClientSocket> CreateSSLClientSocket(
       scoped_ptr<ClientSocketHandle> transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
       const SSLClientSocketContext& context) override;
   void ClearSSLSessionCache() override;
 
  private:
   SocketDataProviderArray<DeterministicSocketData> mock_data_;
   SocketDataProviderArray<SSLSocketDataProvider> mock_ssl_data_;
 
   // Store pointers to handed out sockets in case the test wants to get them.
   std::vector<DeterministicMockTCPClientSocket*> tcp_client_sockets_;
-  std::vector<DeterministicMockUDPClientSocket*> udp_client_sockets_;
   std::vector<MockSSLClientSocket*> ssl_client_sockets_;
 
   DISALLOW_COPY_AND_ASSIGN(DeterministicMockClientSocketFactory);
 };
 
 class MockSOCKSClientSocketPool : public SOCKSClientSocketPool {
  public:
   MockSOCKSClientSocketPool(int max_sockets,
                             int max_sockets_per_group,
                             TransportClientSocketPool* transport_pool);
@@ skipping 47 matching lines @@
 
 // Helper function to get the total data size of the MockReads in |reads|.
 int64_t CountReadBytes(const MockRead reads[], size_t reads_size);
 
 // Helper function to get the total data size of the MockWrites in |writes|.
 int64_t CountWriteBytes(const MockWrite writes[], size_t writes_size);
 
 }  // namespace net
 
 #endif  // NET_SOCKET_SOCKET_TEST_UTIL_H_