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

net/socket/tcp_socket_libevent.h

 // Copyright 2013 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_TCP_SOCKET_LIBEVENT_H_
 #define NET_SOCKET_TCP_SOCKET_LIBEVENT_H_
 
 #include "base/basictypes.h"
+#include "base/callback.h"
 #include "base/compiler_specific.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/non_thread_safe.h"
 #include "net/base/address_family.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_export.h"
 #include "net/base/net_log.h"
+#include "net/socket/socket_descriptor.h"
 
 namespace net {
 
+class AddressList;
+class IOBuffer;
 class IPEndPoint;
 
-// TODO(yzshen): This class is incomplete. TCP client operations (Connect/Read/
-// Write/etc.) will be added. And TCPClientSocket will be changed to be a
-// wrapper around TCPSocket.
-class NET_EXPORT TCPSocketLibevent : public base::NonThreadSafe,
-                                     public base::MessageLoopForIO::Watcher {
+class NET_EXPORT TCPSocketLibevent : public base::NonThreadSafe {
  public:
   TCPSocketLibevent(NetLog* net_log, const NetLog::Source& source);
   virtual ~TCPSocketLibevent();
 
   int Open(AddressFamily family);
   // Takes ownership of |socket|.
-  int Adopt(int socket);
-  // Returns a socket file descriptor. The ownership is transferred to the
-  // caller.
-  int Release();
+  int AdoptConnectedSocket(int socket, const IPEndPoint& peer_address);
+
   int Bind(const IPEndPoint& address);
-  int GetLocalAddress(IPEndPoint* address) const;
+
   int Listen(int backlog);
   int Accept(scoped_ptr<TCPSocketLibevent>* socket,
              IPEndPoint* address,
              const CompletionCallback& callback);
+
+  int Connect(const IPEndPoint& address, const CompletionCallback& callback);
+  bool IsConnected() const;
+  bool IsConnectedAndIdle() const;
+
+  // Multiple outstanding requests are not supported.
+  // Full duplex mode (reading and writing at the same time) is supported.
+  int Read(IOBuffer* buf, int buf_len, const CompletionCallback& callback);
+  int Write(IOBuffer* buf, int buf_len, const CompletionCallback& callback);
+
+  int GetLocalAddress(IPEndPoint* address) const;
+  int GetPeerAddress(IPEndPoint* address) const;
+
+  // Sets various socket options.
+  // The commonly used options for server listening sockets:
+  // - SetAddressReuse(true).
   int SetDefaultOptionsForServer();
+  // The commonly used options for client sockets and accepted sockets:
+  // - SetNoDelay(true);
+  // - SetKeepAlive(true, 45).
+  void SetDefaultOptionsForClient();
   int SetAddressReuse(bool allow);
+  bool SetReceiveBufferSize(int32 size);
+  bool SetSendBufferSize(int32 size);
+  bool SetKeepAlive(bool enable, int delay);
+  bool SetNoDelay(bool no_delay);
+
   void Close();
 
+  bool UsingTCPFastOpen() const;
+  bool IsValid() const { return socket_ != kInvalidSocket; }
+
+  // Marks the start/end of a series of connect attempts for logging purpose.
+  //
+  // TCPClientSocket may attempt to connect to multiple addresses until it
+  // succeeds in establishing a connection. The corresponding log will have
+  // multiple NetLog::TYPE_TCP_CONNECT_ATTEMPT entries nested within a
+  // NetLog::TYPE_TCP_CONNECT. These methods set the start/end of
+  // NetLog::TYPE_TCP_CONNECT.
+  //
+  // TODO(yzshen): Change logging format and let TCPClientSocket log the
+  // start/end of a series of connect attempts itself.
+  void StartLoggingMultipleConnectAttempts(const AddressList& addresses);
+  void EndLoggingMultipleConnectAttempts(int net_error);
+
   const BoundNetLog& net_log() const { return net_log_; }
 
-  // MessageLoopForIO::Watcher implementation.
-  virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
-  virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE;
-
  private:
+  // States that a fast open socket attempt can result in.
+  enum FastOpenStatus {
+    FAST_OPEN_STATUS_UNKNOWN,
+
+    // The initial fast open connect attempted returned synchronously,
+    // indicating that we had and sent a cookie along with the initial data.
+    FAST_OPEN_FAST_CONNECT_RETURN,
+
+    // The initial fast open connect attempted returned asynchronously,
+    // indicating that we did not have a cookie for the server.
+    FAST_OPEN_SLOW_CONNECT_RETURN,
+
+    // Some other error occurred on connection, so we couldn't tell if
+    // fast open would have worked.
+    FAST_OPEN_ERROR,
+
+    // An attempt to do a fast open succeeded immediately
+    // (FAST_OPEN_FAST_CONNECT_RETURN) and we later confirmed that the server
+    // had acked the data we sent.
+    FAST_OPEN_SYN_DATA_ACK,
+
+    // An attempt to do a fast open succeeded immediately
+    // (FAST_OPEN_FAST_CONNECT_RETURN) and we later confirmed that the server
+    // had nacked the data we sent.
+    FAST_OPEN_SYN_DATA_NACK,
+
+    // An attempt to do a fast open succeeded immediately
+    // (FAST_OPEN_FAST_CONNECT_RETURN) and our probe to determine if the
+    // socket was using fast open failed.
+    FAST_OPEN_SYN_DATA_FAILED,
+
+    // An attempt to do a fast open failed (FAST_OPEN_SLOW_CONNECT_RETURN)
+    // and we later confirmed that the server had acked initial data.  This
+    // should never happen (we didn't send data, so it shouldn't have
+    // been acked).
+    FAST_OPEN_NO_SYN_DATA_ACK,
+
+    // An attempt to do a fast open failed (FAST_OPEN_SLOW_CONNECT_RETURN)
+    // and we later discovered that the server had nacked initial data.  This
+    // is the expected case results for FAST_OPEN_SLOW_CONNECT_RETURN.
+    FAST_OPEN_NO_SYN_DATA_NACK,
+
+    // An attempt to do a fast open failed (FAST_OPEN_SLOW_CONNECT_RETURN)
+    // and our later probe for ack/nack state failed.
+    FAST_OPEN_NO_SYN_DATA_FAILED,
+
+    FAST_OPEN_MAX_VALUE
+  };
+
+  // Watcher simply forwards notifications to Closure objects set via the
+  // constructor.
+  class Watcher: public base::MessageLoopForIO::Watcher {
+   public:
+    Watcher(const base::Closure& read_ready_callback,
+            const base::Closure& write_ready_callback);
+    virtual ~Watcher();
+
+    // base::MessageLoopForIO::Watcher methods.
+    virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
+    virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE;
+
+   private:
+    base::Closure read_ready_callback_;
+    base::Closure write_ready_callback_;
+
+    DISALLOW_COPY_AND_ASSIGN(Watcher);
+  };
+
   int AcceptInternal(scoped_ptr<TCPSocketLibevent>* socket,
                      IPEndPoint* address);
 
+  int DoConnect();
+  void DoConnectComplete(int result);
+
+  void LogConnectBegin(const AddressList& addresses);
+  void LogConnectEnd(int net_error);
+
+  void DidCompleteRead();
+  void DidCompleteWrite();
+  void DidCompleteConnect();
+  void DidCompleteConnectOrWrite();
+  void DidCompleteAccept();
+
+  // Internal function to write to a socket. Returns an OS error.
+  int InternalWrite(IOBuffer* buf, int buf_len);
+
+  // Called when the socket is known to be in a connected state.
+  void RecordFastOpenStatus();
+
   int socket_;
 
   base::MessageLoopForIO::FileDescriptorWatcher accept_socket_watcher_;
+  Watcher accept_watcher_;
 
   scoped_ptr<TCPSocketLibevent>* accept_socket_;
   IPEndPoint* accept_address_;
   CompletionCallback accept_callback_;
 
+  base::MessageLoopForIO::FileDescriptorWatcher read_socket_watcher_;
+  base::MessageLoopForIO::FileDescriptorWatcher write_socket_watcher_;
+
+  Watcher read_watcher_;
+  Watcher write_watcher_;

[wtc, 2013/09/13 22:22:44]

Since Watcher has both a read_ready_callback_ and a write_ready_callback_,
it seems that we need just one Watcher object for both Read and Write.
Will that work?

[yzshen1, 2013/09/13 23:52:40]

I slightly prefer to have one Watcher object for each FileDescriptorWatcher.
That is also what the original code did. What do you think?

On 2013/09/13 22:22:44, wtc wrote:

[wtc, 2013/09/18 23:26:17]

We should use Watcher in the intended way. It is fine to
match the original code in the first iteration. If one
Watcher object can handle both Read and Write, we should
give that a try. (I am not familiar with Watcher, so I
don't know if this is a good idea.)

[yzshen1, 2013/09/18 23:40:35]

I see. I will look into the code and see whether it is okay to merge the two.

On 2013/09/18 23:26:17, wtc wrote:

+
+  scoped_refptr<IOBuffer> read_buf_;
+  int read_buf_len_;
+
+  scoped_refptr<IOBuffer> write_buf_;
+  int write_buf_len_;

[wtc, 2013/09/13 22:22:44]

Should we keep the original comments for these members (from
read_socket_watcher_
to write_buf_len_)?

[yzshen1, 2013/09/13 23:52:40]

Done. Some of the comments were outdated and I updated them.

+
+  // External callback; called when read is complete.
+  CompletionCallback read_callback_;
+
+  // External callback; called when write or connect is complete.
+  CompletionCallback write_callback_;
+
+  // Enables experimental TCP FastOpen option.
+  const bool use_tcp_fastopen_;
+
+  // True when TCP FastOpen is in use and we have done the connect.
+  bool tcp_fastopen_connected_;
+
+  enum FastOpenStatus fast_open_status_;

[wtc, 2013/09/13 22:22:44]

I think in C++ we don't need to say "enum" here.

[yzshen1, 2013/09/13 23:52:40]

Done.

[yzshen1, 2013/09/13 23:52:40]

Done.

+
+  // A connect operation is pending. In this case, |write_callback_| needs to be

[wtc, 2013/09/13 22:22:44]

In tcp_socket_win.h we use the read_callback_ for connect. Would be nice to
be consistent. (I think it is better to use the write callback.)

[yzshen1, 2013/09/13 23:52:40]

Here we have to use write_callback_ because connect is notified by
OnFileCanWriteWithoutBlocking().

So I think we will need to change tcp_socket_win to be consistent.
Do you mind if that happens in a separate CL?

[wtc, 2013/09/18 23:26:17]

No problem. Please feel free to do code improvements in a
separate CL.

+  // called when connect is complete.
+  bool waiting_connect_;
+
+  scoped_ptr<IPEndPoint> peer_address_;
+  // The OS error that a connect attempt last completed with.
+  int connect_os_error_;
+
+  bool logging_multiple_connect_attempts_;
+
   BoundNetLog net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(TCPSocketLibevent);
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_TCP_SOCKET_LIBEVENT_H_