Implement chrome.socket.bind/listen/accept for TCP server socket.

chrome/browser/extensions/api/socket/tcp_socket_unittest.cc

 // 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.
 
 #include "chrome/browser/extensions/api/socket/tcp_socket.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/extensions/api/api_resource_event_notifier.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/rand_callback.h"
 #include "net/socket/tcp_client_socket.h"
+#include "net/socket/tcp_server_socket.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using testing::_;
 using testing::DoAll;
 using testing::Return;
 using testing::SaveArg;
 
 namespace extensions {
 
 class MockTCPSocket : public net::TCPClientSocket {
  public:
   explicit MockTCPSocket(const net::AddressList& address_list)
       : net::TCPClientSocket(address_list, NULL, net::NetLog::Source()) {
   }
 
   MOCK_METHOD3(Read, int(net::IOBuffer* buf, int buf_len,
                          const net::CompletionCallback& callback));
   MOCK_METHOD3(Write, int(net::IOBuffer* buf, int buf_len,
                           const net::CompletionCallback& callback));
   MOCK_METHOD2(SetKeepAlive, bool(bool enable, int delay));
   MOCK_METHOD1(SetNoDelay, bool(bool no_delay));
   virtual bool IsConnected() const OVERRIDE {
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockTCPSocket);
 };
 
+class MockTCPServerSocket : public net::TCPServerSocket {
+ public:
+  explicit MockTCPServerSocket()
+      : net::TCPServerSocket(NULL, net::NetLog::Source()) {
+  }
+  MOCK_METHOD2(Listen, int(const net::IPEndPoint& address, int backlog));
+  MOCK_METHOD2(Accept, int(scoped_ptr<net::StreamSocket>* socket,
+                            const net::CompletionCallback& callback));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockTCPServerSocket);
+};
+
 class MockApiResourceEventNotifier : public ApiResourceEventNotifier {
  public:
-  MockApiResourceEventNotifier(const std::string& owner_extension_id)
+  explicit MockApiResourceEventNotifier(const std::string& owner_extension_id)
       : ApiResourceEventNotifier(NULL, NULL,
                                  owner_extension_id,
                                  0, GURL()) {}
 
   MOCK_METHOD2(OnReadComplete, void(int result_code,
                                     const std::string& message));
   MOCK_METHOD1(OnWriteComplete, void(int result_code));
 
  protected:
   virtual ~MockApiResourceEventNotifier() {}
 };
 
 class CompleteHandler {
  public:
   CompleteHandler() {}
   MOCK_METHOD1(OnComplete, void(int result_code));
   MOCK_METHOD2(OnReadComplete, void(int result_code,
       scoped_refptr<net::IOBuffer> io_buffer));
+  MOCK_METHOD2(OnAccept, void(int, net::TCPClientSocket*));
  private:
   DISALLOW_COPY_AND_ASSIGN(CompleteHandler);
 };
 
 const std::string FAKE_ID = "abcdefghijklmnopqrst";
 
 TEST(SocketTest, TestTCPSocketRead) {
   net::AddressList address_list;
   MockTCPSocket* tcp_client_socket = new MockTCPSocket(address_list);
   ApiResourceEventNotifier* notifier = new MockApiResourceEventNotifier(
@@ skipping 145 matching lines @@
   EXPECT_CALL(*tcp_client_socket, SetKeepAlive(_, _))
       .WillOnce(testing::DoAll(SaveArg<0>(&enable),
                                SaveArg<1>(&delay),
                                Return(false)));
   result = socket->SetKeepAlive(false, 0);
   EXPECT_FALSE(result);
   EXPECT_FALSE(enable);
   EXPECT_EQ(0, delay);
 }
 
+TEST(SocketTest, TestTCPServerSocketListenAccept) {
+  MockTCPServerSocket* tcp_server_socket = new MockTCPServerSocket();
+  CompleteHandler handler;
+
+  scoped_ptr<TCPSocket> socket(TCPSocket::CreateServerSocketForTesting(
+      tcp_server_socket, FAKE_ID));
+
+  EXPECT_CALL(*tcp_server_socket, Accept(_, _)).Times(1);
+  EXPECT_CALL(*tcp_server_socket, Listen(_, _)).Times(1);
+  EXPECT_CALL(handler, OnAccept(_, _));
+
+  std::string err_msg;
+  EXPECT_EQ(net::OK, socket->Listen("127.0.0.1", 9999, 10, &err_msg));
+  socket->Accept(base::Bind(&CompleteHandler::OnAccept,
+        base::Unretained(&handler)));
+}
+
 }  // namespace extensions