Refactor tcp socket and unix domain socket.

net/socket/socket_libevent.h

Index: net/socket/socket_libevent.h
diff --git a/net/socket/socket_libevent.h b/net/socket/socket_libevent.h
new file mode 100644
index 0000000000000000000000000000000000000000..1e42d32e2dff66971dfab85a29269633fc497840
--- /dev/null
+++ b/net/socket/socket_libevent.h
@@ -0,0 +1,118 @@
+// Copyright 2014 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_LIBEVENT_H_
+#define NET_SOCKET_SOCKET_LIBEVENT_H_
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop/message_loop.h"
+#include "base/threading/thread_checker.h"
+#include "net/base/completion_callback.h"
+#include "net/base/net_util.h"
+#include "net/socket/socket_descriptor.h"
+
+namespace net {
+
+class IOBuffer;
+class IPEndPoint;
+
+// Socket class to provide asynchronous read/write operations on top of the
+// posix socket api. It supports AF_INET, AF_INET6, and AF_UNIX addresses.
+class SocketLibevent : public base::MessageLoopForIO::Watcher{

[mmenke, 2014/06/30 18:26:51]

nit:  Space before open brace.

[byungchul, 2014/06/30 19:38:35]

Done.

Do you think NET_EXPORT is necessary here? Not necessary if it will be used only
by tcp and by unix domain.

+ public:
+  SocketLibevent();
+  virtual ~SocketLibevent();
+
+  // Opens a socket and returns net::OK if |address_family| is AF_INET, AF_INET6
+  // or AF_UNIX. Otherwise, returns a net error.

[mmenke, 2014/06/30 18:26:51]

We now DCHECK on address family.

[byungchul, 2014/06/30 19:38:34]

DCHECK() is only for debug build. Modified the comment.

+  int Open(int address_family);
+  // Takes ownership of |socket|.
+  int AdoptConnectedSocket(SocketDescriptor socket,
+                           const SockaddrStorage& peer_address);
+
+  int Bind(const SockaddrStorage& address);
+
+  int Listen(int backlog);
+  int Accept(scoped_ptr<SocketLibevent>* socket,
+             const CompletionCallback& callback);
+
+  int Connect(const SockaddrStorage& address,
+              const CompletionCallback& callback);
+  bool IsConnected() const;
+  bool IsConnectedAndIdle() const;
+
+  // Multiple outstanding requests are not supported.

[mmenke, 2014/06/30 18:26:51]

nit:  "...requests of the same type..."

[byungchul, 2014/06/30 19:38:34]

Done.

+  // 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);
+
+  // Waits for next write event. This os called by TCPsocketLibevent for TCP

[mmenke, 2014/06/30 18:26:51]

os -> is

[byungchul, 2014/06/30 19:38:34]

Done.

+  // fastopen after sending first data. Returns ERR_IO_PENDING if it starts
+  // waiting for write event successfully. Otherwise, returns net_error.

[mmenke, 2014/06/30 18:26:51]

nit:  "Otherwise, return a net error code."

[mmenke, 2014/06/30 18:26:51]

nit:  Think it's worth explicitly saying this must not be called when using
Write.

[byungchul, 2014/06/30 19:38:34]

Done.

[byungchul, 2014/06/30 19:38:34]

Done.

+  int WaitForWrite(IOBuffer* buf, int buf_len,
+                   const CompletionCallback& callback);
+
+  int GetLocalAddress(SockaddrStorage* address) const;
+  int GetPeerAddress(SockaddrStorage* address) const;
+  void SetPeerAddress(const SockaddrStorage& address);
+  // Returns true if peer address has been set regardless of socket state.
+  bool HasPeerAddress() const;
+
+  void Close();
+
+  SocketDescriptor socket_fd() const { return socket_fd_; }
+
+ private:
+  // base::MessageLoopForIO::Watcher methods.
+  virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
+  virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE;
+
+  int DoAccept(scoped_ptr<SocketLibevent>* socket);
+  void AcceptCompleted();
+
+  int DoConnect();
+  void ConnectCompleted();
+
+  int DoRead(IOBuffer* buf, int buf_len);
+  void ReadCompleted();
+
+  int DoWrite(IOBuffer* buf, int buf_len);
+  void WriteCompleted();
+
+  SocketDescriptor socket_fd_;
+
+  base::MessageLoopForIO::FileDescriptorWatcher accept_socket_watcher_;
+  scoped_ptr<SocketLibevent>* accept_socket_;
+  CompletionCallback accept_callback_;
+
+  base::MessageLoopForIO::FileDescriptorWatcher read_socket_watcher_;
+  scoped_refptr<IOBuffer> read_buf_;
+  int read_buf_len_;
+  // External callback; called when read is complete.
+  CompletionCallback read_callback_;
+
+  base::MessageLoopForIO::FileDescriptorWatcher write_socket_watcher_;
+  scoped_refptr<IOBuffer> write_buf_;
+  int write_buf_len_;
+  // External callback; called when write or connect is complete.
+  CompletionCallback write_callback_;
+
+  // A connect operation is pending. In this case, |write_callback_| needs to be
+  // called when connect is complete.
+  bool waiting_connect_;
+
+  scoped_ptr<SockaddrStorage> peer_address_;
+
+  base::ThreadChecker thread_checker_;
+
+  DISALLOW_COPY_AND_ASSIGN(SocketLibevent);
+};
+
+}  // namespace net
+
+#endif  // NET_SOCKET_SOCKET_LIBEVENT_H_