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

chrome/browser/extensions/api/socket/socket_api.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/socket_api.h"
 
 #include "base/bind.h"
 #include "chrome/common/extensions/permissions/socket_permission.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/dns/host_resolver_wrapper.h"
@@ skipping 129 matching lines @@
   result->SetInteger(kSocketIdKey, manager_->Add(socket));
   SetResult(result);
 }
 
 bool SocketDestroyFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   return true;
 }
 
 void SocketDestroyFunction::Work() {
   manager_->Remove(socket_id_);

[Peng, 2012/09/11 14:01:18]

Could we check if the listen port is release after destroy.

[justinlin, 2012/09/12 07:29:42]

I think the only way is to bind() again, but there's no easy way to do this
here.

On 2012/09/11 14:01:18, Peng wrote:

[Peng, 2012/09/12 19:49:49]

That's fine. I think we could file an issue to remind us. So we could do it
later.

 }
 
 SocketConnectFunction::SocketConnectFunction()
     : socket_id_(0),
       port_(0) {
 }
 
 SocketConnectFunction::~SocketConnectFunction() {
 }
 
@@ skipping 97 matching lines @@
       error_ = kPermissionError;
       SetResult(Value::CreateIntegerValue(result));
       return;
     }
   }
 
   result = socket->Bind(address_, port_);
   SetResult(Value::CreateIntegerValue(result));
 }
 
+SocketListenFunction::SocketListenFunction()
+    : params_(NULL) {
+}
+
+SocketListenFunction::~SocketListenFunction() {}
+
+bool SocketListenFunction::Prepare() {
+  params_ = api::socket::Listen::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params_.get());
+  return true;
+}
+
+void SocketListenFunction::Work() {
+  int result = -1;
+  Socket* socket = manager_->Get(params_->socket_id);
+  if (socket) {
+    result = socket->Listen(params_->backlog, error_);
+  } else {
+    error_ = kSocketNotFoundError;
+  }
+
+  SetResult(Value::CreateIntegerValue(result));
+}
+
+SocketAcceptFunction::SocketAcceptFunction()
+  : params_(NULL) {
+}
+
+SocketAcceptFunction::~SocketAcceptFunction() {}
+
+bool SocketAcceptFunction::Prepare() {
+  params_ = api::socket::Accept::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params_.get());
+  return true;
+}
+
+void SocketAcceptFunction::AsyncWorkStart() {
+  Socket* socket = manager_->Get(params_->socket_id);
+  if (socket) {
+    socket->Accept(base::Bind(&SocketAcceptFunction::OnAccept, this));
+  } else {
+    error_ = kSocketNotFoundError;
+    OnAccept(-1, NULL);
+  }
+}
+
+void SocketAcceptFunction::OnAccept(int result_code,
+                                    net::TCPClientSocket *socket) {
+  DCHECK(socket);
+  // TODO(justinlin): This socket won't have an event notifier, but it's not
+  // used for anything right now.
+  Socket *client_socket = new TCPSocket(socket, NULL, true);
+
+  DictionaryValue* result = new DictionaryValue();
+  result->SetInteger(kResultCodeKey, result_code);
+  result->SetInteger(kSocketIdKey, manager_->Add(client_socket));
+  SetResult(result);
+
+  AsyncWorkCompleted();
+}
+
 SocketReadFunction::SocketReadFunction()
     : params_(NULL) {
 }
 
 SocketReadFunction::~SocketReadFunction() {}
 
 bool SocketReadFunction::Prepare() {
   params_ = api::socket::Read::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
@@ skipping 278 matching lines @@
           new std::string(localAddress.ToStringWithoutPort()));
       info.local_port.reset(new int(localAddress.port()));
     }
   } else {
     error_ = kSocketNotFoundError;
   }
   SetResult(info.ToValue().release());
 }
 
 }  // namespace extensions