Windows only: Move client socket functionality from TCPClientSocket into TCPSocket.

net/socket/tcp_client_socket.h

Index: net/socket/tcp_client_socket.h
diff --git a/net/socket/tcp_client_socket.h b/net/socket/tcp_client_socket.h
index 8a2c0cd73f06f944ae5aa7f5ba4520542a5b9b72..4bded803258188a0cb76cdb294daed4507ef6150 100644
--- a/net/socket/tcp_client_socket.h
+++ b/net/socket/tcp_client_socket.h
@@ -8,21 +8,27 @@
 #include "build/build_config.h"
 #include "net/base/net_export.h"
 
-#if defined(OS_WIN)
-#include "net/socket/tcp_client_socket_win.h"
-#elif defined(OS_POSIX)
+// TODO(yzshen): Switch OS_POSIX to use the same platform-independent
+// TCPClientSocket.
+#if defined(OS_POSIX)
+
 #include "net/socket/tcp_client_socket_libevent.h"
-#endif
 
-namespace net {
+#elif defined(OS_WIN)
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/memory/scoped_ptr.h"
+#include "net/base/address_list.h"
+#include "net/base/completion_callback.h"
+#include "net/base/net_log.h"
+#include "net/socket/stream_socket.h"
+#include "net/socket/tcp_socket.h"
 
-// A client socket that uses TCP as the transport layer.
-#if defined(OS_WIN)
-typedef TCPClientSocketWin TCPClientSocket;
-#elif defined(OS_POSIX)
-typedef TCPClientSocketLibevent TCPClientSocket;
 #endif
 
+namespace net {
+
 // Enable/disable experimental TCP FastOpen option.
 // Not thread safe.  Must be called during initialization/startup only.
 NET_EXPORT void SetTCPFastOpenEnabled(bool value);
@@ -30,6 +36,111 @@ NET_EXPORT void SetTCPFastOpenEnabled(bool value);
 // Check if the TCP FastOpen option is enabled.
 bool IsTCPFastOpenEnabled();
 
+// A client socket that uses TCP as the transport layer.
+#if defined(OS_POSIX)
+typedef TCPClientSocketLibevent TCPClientSocket;
+#elif defined(OS_WIN)
+
+class NET_EXPORT TCPClientSocket : public StreamSocket {
+ public:
+  // The IP address(es) and port number to connect to.  The TCP socket will try
+  // each IP address in the list until it succeeds in establishing a
+  // connection.
+  TCPClientSocket(const AddressList& addresses,
+                  net::NetLog* net_log,
+                  const net::NetLog::Source& source);
+
+  // Adopts the given, connected socket and then acts as if Connect() had been
+  // called. This function is used by TCPServerSocket and for testing.
+  TCPClientSocket(scoped_ptr<TCPSocket> connected_socket,
+                  const IPEndPoint& peer_address);
+
+  virtual ~TCPClientSocket();
+
+  // Binds the socket to a local IP address and port.
+  int Bind(const IPEndPoint& address);
+
+  // StreamSocket implementation.
+  virtual int Connect(const CompletionCallback& callback);

[akalin, 2013/09/12 23:21:37]

can you mark these functions as OVERRIDE here? (I know you do it in your other
CL)

[yzshen1, 2013/09/13 05:07:52]

Done.

+  virtual void Disconnect();
+  virtual bool IsConnected() const;
+  virtual bool IsConnectedAndIdle() const;
+  virtual int GetPeerAddress(IPEndPoint* address) const;
+  virtual int GetLocalAddress(IPEndPoint* address) const;
+  virtual const BoundNetLog& NetLog() const { return socket_->net_log(); }
+  virtual void SetSubresourceSpeculation();
+  virtual void SetOmniboxSpeculation();
+  virtual bool WasEverUsed() const;
+  virtual bool UsingTCPFastOpen() const;
+  virtual bool WasNpnNegotiated() const OVERRIDE;
+  virtual NextProto GetNegotiatedProtocol() const OVERRIDE;
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+
+  // Socket implementation.
+  // Multiple outstanding requests are not supported.
+  // Full duplex mode (reading and writing at the same time) is supported.
+  virtual int Read(IOBuffer* buf, int buf_len,
+                   const CompletionCallback& callback) OVERRIDE;
+  virtual int Write(IOBuffer* buf, int buf_len,
+                    const CompletionCallback& callback) OVERRIDE;
+  virtual bool SetReceiveBufferSize(int32 size) OVERRIDE;
+  virtual bool SetSendBufferSize(int32 size) OVERRIDE;
+
+  virtual bool SetKeepAlive(bool enable, int delay);
+  virtual bool SetNoDelay(bool no_delay);
+
+ private:
+  // State machine for connecting the socket.
+  enum ConnectState {
+    CONNECT_STATE_CONNECT,
+    CONNECT_STATE_CONNECT_COMPLETE,
+    CONNECT_STATE_NONE,
+  };
+
+  // State machine used by Connect().
+  int DoConnectLoop(int result);
+  int DoConnect();
+  int DoConnectComplete(int result);
+
+  // Helper used by Disconnect(), which disconnects minus resetting
+  // current_address_index_ and bind_address_.
+  void DoDisconnect();
+
+  void DidCompleteConnect(int result);
+  void DidCompleteReadWrite(const CompletionCallback& callback, int result);
+
+  int OpenSocket(AddressFamily family);
+
+  scoped_ptr<TCPSocket> socket_;
+
+  // Local IP address and port we are bound to. Set to NULL if Bind()
+  // wasn't called (in that case OS chooses address/port).
+  scoped_ptr<IPEndPoint> bind_address_;
+
+  // The list of addresses we should try in order to establish a connection.
+  AddressList addresses_;
+
+  // Where we are in above list. Set to -1 if uninitialized.
+  int current_address_index_;
+
+  // External callback; called when connect is complete.
+  CompletionCallback connect_callback_;
+
+  // The next state for the Connect() state machine.
+  ConnectState next_connect_state_;
+
+  // This socket was previously disconnected and has not been re-connected.
+  bool previously_disconnected_;
+
+  // Record of connectivity and transmissions, for use in speculative connection
+  // histograms.
+  UseHistory use_history_;
+
+  DISALLOW_COPY_AND_ASSIGN(TCPClientSocket);
+};
+
+#endif
+
 }  // namespace net
 
 #endif  // NET_SOCKET_TCP_CLIENT_SOCKET_H_