Attn: Mike Belshe

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 519 matching lines @@
   }
   std::vector<MockTCPClientSocket*>& tcp_client_sockets() {
     return tcp_client_sockets_;
   }
 
   // ClientSocketFactory
   virtual ClientSocket* CreateTCPClientSocket(
       const AddressList& addresses,
       NetLog* net_log,
       const NetLog::Source& source);
+  virtual ClientSocket* CreateSCTPClientSocket(
+      const AddressList& addresses,
+      NetLog* net_log,
+      const NetLog::Source& source);
   virtual SSLClientSocket* CreateSSLClientSocket(
       ClientSocketHandle* transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
       SSLHostInfo* ssl_host_info,
       CertVerifier* cert_verifier,
       DnsCertProvenanceChecker* dns_cert_checker);
   virtual void ClearSSLSessionCache();
 
  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<MockTCPClientSocket*> tcp_client_sockets_;
+  std::vector<MockTCPClientSocket*> sctp_client_sockets_;
   std::vector<MockSSLClientSocket*> ssl_client_sockets_;
 };
 
 class MockClientSocket : public net::SSLClientSocket {
  public:
   explicit MockClientSocket(net::NetLog* net_log);
 
   // If an async IO is pending because the SocketDataProvider returned
   // ERR_IO_PENDING, then the MockClientSocket waits until this OnReadComplete
   // is called to complete the asynchronous read operation.
@@ skipping 320 matching lines @@
     return mock_data_;
   }
   std::vector<DeterministicMockTCPClientSocket*>& tcp_client_sockets() {
     return tcp_client_sockets_;
   }
 
   // ClientSocketFactory
   virtual ClientSocket* CreateTCPClientSocket(const AddressList& addresses,
                                               NetLog* net_log,
                                               const NetLog::Source& source);
+  virtual ClientSocket* CreateSCTPClientSocket(const AddressList& addresses,
+                                               NetLog* net_log,
+                                               const NetLog::Source& source);
   virtual SSLClientSocket* CreateSSLClientSocket(
       ClientSocketHandle* transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
       SSLHostInfo* ssl_host_info,
       CertVerifier* cert_verifier,
       DnsCertProvenanceChecker* dns_cert_checker);
   virtual void ClearSSLSessionCache();
 
  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<DeterministicMockTCPClientSocket*> sctp_client_sockets_;
   std::vector<MockSSLClientSocket*> ssl_client_sockets_;
 };
 
 class MockSOCKSClientSocketPool : public SOCKSClientSocketPool {
  public:
   MockSOCKSClientSocketPool(
       int max_sockets,
       int max_sockets_per_group,
       ClientSocketPoolHistograms* histograms,
       TCPClientSocketPool* tcp_pool);
@@ skipping 28 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_