Exposed Listen and Accept methods to plugin.

ppapi/shared_impl/private/tcp_server_socket_private_impl.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/tcp_server_socket_private_impl.h"
+
+#include <cstddef>
+
+#include "base/logging.h"
+#include "base/message_loop.h"
+#include "ppapi/c/pp_errors.h"
+
+namespace ppapi {
+
+TCPServerSocketPrivateImpl::TCPServerSocketPrivateImpl(PP_Instance instance,
+                                                       uint32 socket_id)
+    : Resource(instance), instance_(instance) {
+  Init(socket_id);
+}
+
+TCPServerSocketPrivateImpl::TCPServerSocketPrivateImpl(
+    const HostResource& resource,
+    uint32 socket_id)
+    : Resource(resource), instance_(0) {
+  Init(socket_id);
+}
+
+TCPServerSocketPrivateImpl::~TCPServerSocketPrivateImpl() {
+}
+
+thunk::PPB_TCPServerSocket_Private_API*
+TCPServerSocketPrivateImpl::AsPPB_TCPServerSocket_Private_API() {
+  return this;
+}
+
+int32_t TCPServerSocketPrivateImpl::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 TCPServerSocketPrivateImpl::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 TCPServerSocketPrivateImpl::StopListening() {
+  if (state_ == CLOSED)
+    return;
+
+  state_ = CLOSED;
+
+  SendStopListening();
+  socket_id_ = 0;
+
+  PostAbortAndClearIfNecessary(&listen_callback_);
+  PostAbortAndClearIfNecessary(&accept_callback_);
+  tcp_socket_buffer_ = NULL;
+}
+
+void TCPServerSocketPrivateImpl::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 TCPServerSocketPrivateImpl::Init(uint32 socket_id) {
+  DCHECK(socket_id != 0);
+
+  socket_id_ = socket_id;
+  state_ = BEFORE_LISTENING;
+  tcp_socket_buffer_ = NULL;
+}
+
+void TCPServerSocketPrivateImpl::PostAbortAndClearIfNecessary(
+    scoped_refptr<TrackedCallback>* callback) {
+  if (callback->get())
+    (*callback)->PostAbort();
+}
+
+}  // namespace ppapi