Exposed Listen and Accept methods to plugin.

ppapi/shared_impl/private/ppb_tcp_server_socket_shared.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 "ppapi/shared_impl/private/ppb_tcp_server_socket_shared.h"
+
+#include <cstddef>
+#include <cstring>

[yzshen1, 2012/02/14 00:42:04]

why do we need cstring?

[ygorshenin1, 2012/02/14 09:34:44]

Thanks, You're right. <cstring> isn't needed here. Inclusion of
"base/message_loop.h" also deleted.

On 2012/02/14 00:42:04, yzshen1 wrote:

+
+#include "base/logging.h"
+#include "base/message_loop.h"
+#include "ppapi/c/pp_errors.h"
+
+namespace ppapi {
+
+PPB_TCPServerSocket_Shared::PPB_TCPServerSocket_Shared(PP_Instance instance)
+    : Resource(instance),
+      real_socket_id_(0),
+      temp_socket_id_(GenerateTempSocketID()),
+      state_(BEFORE_LISTENING),
+      tcp_socket_buffer_(NULL) {
+}
+
+PPB_TCPServerSocket_Shared::PPB_TCPServerSocket_Shared(
+    const HostResource& resource)
+    : Resource(resource),
+      real_socket_id_(0),
+      temp_socket_id_(GenerateTempSocketID()),
+      state_(BEFORE_LISTENING),
+      tcp_socket_buffer_(NULL) {
+}
+
+PPB_TCPServerSocket_Shared::~PPB_TCPServerSocket_Shared() {
+}
+
+thunk::PPB_TCPServerSocket_Private_API*
+PPB_TCPServerSocket_Shared::AsPPB_TCPServerSocket_Private_API() {
+  return this;
+}
+
+int32_t PPB_TCPServerSocket_Shared::Listen(const PP_NetAddress_Private* addr,
+                                           int32_t backlog,
+                                           PP_CompletionCallback callback) {
+  if (!addr)
+    return PP_ERROR_BADARGUMENT;
+  if (!callback.func)
+    return PP_ERROR_BLOCKS_MAIN_THREAD;
+  if (state_ != BEFORE_LISTENING)
+    return PP_ERROR_FAILED;
+  if (TrackedCallback::IsPending(listen_callback_))
+    return PP_ERROR_INPROGRESS;  // Can only have one pending request.
+
+  listen_callback_ = new TrackedCallback(this, callback);
+  // Send the request, the browser will call us back via ListenACK
+  SendListen(temp_socket_id_, *addr, backlog);
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t PPB_TCPServerSocket_Shared::Accept(PP_Resource* tcp_socket,
+                                           PP_CompletionCallback callback) {
+  if (!tcp_socket)
+    return PP_ERROR_BADARGUMENT;
+  if (!callback.func)
+    return PP_ERROR_BLOCKS_MAIN_THREAD;
+
+  if (state_ != LISTENING)
+    return PP_ERROR_FAILED;
+  if (TrackedCallback::IsPending(accept_callback_))
+    return PP_ERROR_INPROGRESS;
+
+  tcp_socket_buffer_ = tcp_socket;
+  accept_callback_ = new TrackedCallback(this, callback);
+
+  SendAccept();
+  return PP_OK_COMPLETIONPENDING;
+}
+
+void PPB_TCPServerSocket_Shared::StopListening() {
+  if (state_ != LISTENING)

[yzshen1, 2012/02/14 00:42:04]

(1) This is incorrect according to the API spec. Consider the following example:
- Listen() is called;
- Before it completes, StopListening() is called.

With your current implementation, StopListening() doesn't take effect, so the
pending listen will complete in the future. (Very likely it won't be
PP_ERROR_ABORTED.)

(2) One more thing you need to consider: You need to handle the case that the
tcp server socket goes away when it is still waiting for ListenACK.

One way to do it: in TCPServerSocketStopListening, if you already have a
real_socket_id, then send a StopListening msg to the browser; otherwise, clean
up uninitialized_tcp_server_socket_.

In OnTCPServerSocketListenACK, if temp_socket_id_ cannot be found in the
uninitialized map, send a StopListening msg to the browser.

+    return;
+  state_ = CLOSED;
+
+  SendStopListening();
+  real_socket_id_ = 0;
+
+  if (listen_callback_.get())
+    listen_callback_->PostAbort();
+  if (accept_callback_.get())
+    accept_callback_->PostAbort();
+  tcp_socket_buffer_ = NULL;
+}
+
+void PPB_TCPServerSocket_Shared::OnListenCompleted(uint32 real_socket_id,
+                                                   int32_t status) {
+  if (state_ != BEFORE_LISTENING ||
+      !TrackedCallback::IsPending(listen_callback_)) {
+    NOTREACHED();
+    return;
+  }
+
+  if (status == PP_OK) {
+    real_socket_id_ = real_socket_id;
+    state_ = LISTENING;
+  }
+
+  TrackedCallback::ClearAndRun(&listen_callback_, status);
+}
+
+uint32 PPB_TCPServerSocket_Shared::GenerateTempSocketID() {
+  static uint32 socket_id = 0;
+  return socket_id++;
+}
+
+}  // namespace ppapi