ppapi/proxy/tcp_server_socket_private_resource.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ppapi/proxy/tcp_server_socket_private_resource.h"
   6
   7 #include "ppapi/proxy/ppapi_messages.h"
   8 #include "ppapi/proxy/tcp_socket_private_resource.h"
   9
  10 namespace ppapi {
  11 namespace proxy {
  12
  13 TCPServerSocketPrivateResource::TCPServerSocketPrivateResource(
  14     Connection connection,
  15     PP_Instance instance)
  16     : PluginResource(connection, instance),
  17       state_(STATE_BEFORE_LISTENING),
  18       local_addr_() {
  19   SendCreate(BROWSER, PpapiHostMsg_TCPServerSocket_CreatePrivate());
  20 }
  21
  22 TCPServerSocketPrivateResource::~TCPServerSocketPrivateResource() {
  23 }
  24
  25 thunk::PPB_TCPServerSocket_Private_API*
  26 TCPServerSocketPrivateResource::AsPPB_TCPServerSocket_Private_API() {
  27   return this;
  28 }
  29
  30 int32_t TCPServerSocketPrivateResource::Listen(
  31     const PP_NetAddress_Private* addr,
  32     int32_t backlog,
  33     scoped_refptr<TrackedCallback> callback) {
  34   if (!addr)
  35     return PP_ERROR_BADARGUMENT;
  36   if (state_ != STATE_BEFORE_LISTENING)
  37     return PP_ERROR_FAILED;
  38   if (TrackedCallback::IsPending(listen_callback_))
  39     return PP_ERROR_INPROGRESS;
  40
  41   listen_callback_ = callback;
  42
  43   // Send the request, the browser will call us back via ListenACK
  44   Call<PpapiPluginMsg_TCPServerSocket_ListenReply>(
  45       BROWSER,
  46       PpapiHostMsg_TCPServerSocket_Listen(*addr, backlog),
  47       base::Bind(&TCPServerSocketPrivateResource::OnPluginMsgListenReply,
  48                  base::Unretained(this)));
  49   return PP_OK_COMPLETIONPENDING;
  50 }
  51
  52 int32_t TCPServerSocketPrivateResource::Accept(
  53     PP_Resource* tcp_socket,
  54     scoped_refptr<TrackedCallback> callback) {
  55   if (!tcp_socket)
  56     return PP_ERROR_BADARGUMENT;
  57   if (state_ != STATE_LISTENING)
  58     return PP_ERROR_FAILED;
  59   if (TrackedCallback::IsPending(accept_callback_))
  60     return PP_ERROR_INPROGRESS;
  61
  62   accept_callback_ = callback;
  63
  64   Call<PpapiPluginMsg_TCPServerSocket_AcceptReply>(
  65       BROWSER,
  66       PpapiHostMsg_TCPServerSocket_Accept(),
  67       base::Bind(&TCPServerSocketPrivateResource::OnPluginMsgAcceptReply,
  68                  base::Unretained(this), tcp_socket));
  69   return PP_OK_COMPLETIONPENDING;
  70 }
  71
  72 int32_t TCPServerSocketPrivateResource::GetLocalAddress(
  73     PP_NetAddress_Private* addr) {
  74   if (!addr)
  75     return PP_ERROR_BADARGUMENT;
  76   if (state_ != STATE_LISTENING)
  77     return PP_ERROR_FAILED;
  78   *addr = local_addr_;
  79   return PP_OK;
  80 }
  81
  82 void TCPServerSocketPrivateResource::StopListening() {
  83   if (state_ == STATE_CLOSED)
  84     return;
  85   state_ = STATE_CLOSED;
  86   Post(BROWSER, PpapiHostMsg_TCPServerSocket_StopListening());
  87   if (TrackedCallback::IsPending(listen_callback_))
  88     listen_callback_->PostAbort();
  89   if (TrackedCallback::IsPending(accept_callback_))
  90     accept_callback_->PostAbort();
  91 }
  92
  93 void TCPServerSocketPrivateResource::OnPluginMsgListenReply(
  94     const ResourceMessageReplyParams& params,
  95     const PP_NetAddress_Private& local_addr) {
  96   if (state_ != STATE_BEFORE_LISTENING ||
  97       !TrackedCallback::IsPending(listen_callback_)) {
  98     return;
  99   }
 100   if (params.result() == PP_OK) {
 101     local_addr_ = local_addr;
 102     state_ = STATE_LISTENING;
 103   }
 104   listen_callback_->Run(params.result());
 105 }
 106
 107 void TCPServerSocketPrivateResource::OnPluginMsgAcceptReply(
 108     PP_Resource* tcp_socket,
 109     const ResourceMessageReplyParams& params,
 110     int pending_resource_id,
 111     const PP_NetAddress_Private& local_addr,
 112     const PP_NetAddress_Private& remote_addr) {
 113   DCHECK(tcp_socket);
 114   if (state_ != STATE_LISTENING ||
 115       !TrackedCallback::IsPending(accept_callback_)) {
 116     return;
 117   }
 118   if (params.result() == PP_OK) {
 119     *tcp_socket = (new TCPSocketPrivateResource(connection(), pp_instance(),
 120                                                 pending_resource_id,
 121                                                 local_addr,
 122                                                 remote_addr))->GetReference();
 123   }
 124   accept_callback_->Run(params.result());
 125 }
 126
 127 }  // namespace proxy
 128 }  // namespace ppapi