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 "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), instance_(instance), state_(NOT_INITIALIZED) {
+}
+
+PPB_TCPServerSocket_Shared::PPB_TCPServerSocket_Shared(
+    const HostResource& resource)
+    : Resource(resource), instance_(0), state_(NOT_INITIALIZED) {
+}
+
+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::Initialize(PP_CompletionCallback callback) {
+  if (state_ != NOT_INITIALIZED)
+    return PP_ERROR_FAILED;
+  if (!callback.func)
+    return PP_ERROR_BLOCKS_MAIN_THREAD;
+  if (TrackedCallback::IsPending(initialize_callback_))
+    return PP_ERROR_INPROGRESS;
+
+  initialize_callback_ = new TrackedCallback(this, callback);
+  // Send the request, the browser will call us back via InitializeACK
+  SendInitialize();
+  return PP_OK_COMPLETIONPENDING;
+}
+
+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(*addr, backlog);
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t PPB_TCPServerSocket_Shared::Accept(char* 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_ == CLOSED)
+    return;
+
+  state_ = CLOSED;
+
+  SendStopListening();
+  socket_id_ = 0;
+
+  PostAbortAndClearIfNecessary(&listen_callback_);
+  PostAbortAndClearIfNecessary(&accept_callback_);
+  tcp_socket_buffer_ = NULL;
+}
+
+void PPB_TCPServerSocket_Shared::OnInitializeCompleted(uint32 socket_id) {
+  if (state_ != NOT_INITIALIZED ||
+      !TrackedCallback::IsPending(initialize_callback_)) {
+    NOTREACHED();
+    return;
+  }
+
+  InternalInitialize(socket_id);
+  TrackedCallback::ClearAndRun(&initialize_callback_,
+                               socket_id != 0 ? PP_OK : PP_ERROR_FAILED);
+}
+
+void PPB_TCPServerSocket_Shared::OnListenCompleted(bool succeeded) {
+  if (state_ != BEFORE_LISTENING ||
+      !TrackedCallback::IsPending(listen_callback_)) {
+    NOTREACHED();
+    return;
+  }
+
+  if (succeeded)
+    state_ = LISTENING;
+
+  TrackedCallback::ClearAndRun(&listen_callback_,
+                               succeeded ? PP_OK : PP_ERROR_FAILED);
+}
+
+void PPB_TCPServerSocket_Shared::InternalInitialize(uint32 socket_id) {
+  DCHECK(socket_id != 0);
+
+  socket_id_ = socket_id;
+  state_ = BEFORE_LISTENING;
+  tcp_socket_buffer_ = NULL;
+}
+
+void PPB_TCPServerSocket_Shared::PostAbortAndClearIfNecessary(
+    scoped_refptr<TrackedCallback>* callback) {
+  if (callback->get())
+    (*callback)->PostAbort();
+}
+
+}  // namespace ppapi