ppapi/proxy/udp_socket_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/udp_socket_resource.h"
   6
   7 #include "ppapi/shared_impl/tracked_callback.h"
   8 #include "ppapi/thunk/enter.h"
   9 #include "ppapi/thunk/ppb_net_address_api.h"
  10 #include "ppapi/thunk/resource_creation_api.h"
  11
  12 namespace ppapi {
  13 namespace proxy {
  14
  15 namespace {
  16
  17 typedef thunk::EnterResourceNoLock<thunk::PPB_NetAddress_API>
  18     EnterNetAddressNoLock;
  19
  20 }  // namespace
  21
  22 UDPSocketResource::UDPSocketResource(Connection connection,
  23                                      PP_Instance instance)
  24     : UDPSocketResourceBase(connection, instance, false) {
  25 }
  26
  27 UDPSocketResource::~UDPSocketResource() {
  28 }
  29
  30 thunk::PPB_UDPSocket_API* UDPSocketResource::AsPPB_UDPSocket_API() {
  31   return this;
  32 }
  33
  34 int32_t UDPSocketResource::Bind(PP_Resource addr,
  35                                 scoped_refptr<TrackedCallback> callback) {
  36   EnterNetAddressNoLock enter(addr, true);
  37   if (enter.failed())
  38     return PP_ERROR_BADARGUMENT;
  39
  40   return BindImpl(&enter.object()->GetNetAddressPrivate(), callback);
  41 }
  42
  43 PP_Resource UDPSocketResource::GetBoundAddress() {
  44   PP_NetAddress_Private addr_private;
  45   if (!GetBoundAddressImpl(&addr_private))
  46     return 0;
  47
  48   thunk::EnterResourceCreationNoLock enter(pp_instance());
  49   if (enter.failed())
  50     return 0;
  51   return enter.functions()->CreateNetAddressFromNetAddressPrivate(
  52       pp_instance(), addr_private);
  53 }
  54
  55 int32_t UDPSocketResource::RecvFrom(char* buffer,
  56                                     int32_t num_bytes,
  57                                     PP_Resource* addr,
  58                                     scoped_refptr<TrackedCallback> callback) {
  59   return RecvFromImpl(buffer, num_bytes, addr, callback);
  60 }
  61
  62 int32_t UDPSocketResource::SendTo(const char* buffer,
  63                                   int32_t num_bytes,
  64                                   PP_Resource addr,
  65                                   scoped_refptr<TrackedCallback> callback) {
  66   EnterNetAddressNoLock enter(addr, true);
  67   if (enter.failed())
  68     return PP_ERROR_BADARGUMENT;
  69
  70   return SendToImpl(buffer, num_bytes, &enter.object()->GetNetAddressPrivate(),
  71                     callback);
  72 }
  73
  74 void UDPSocketResource::Close() {
  75   CloseImpl();
  76 }
  77
  78 int32_t UDPSocketResource::SetOption1_0(
  79     PP_UDPSocket_Option name,
  80     const PP_Var& value,
  81     scoped_refptr<TrackedCallback> callback) {
  82   if (name > PP_UDPSOCKET_OPTION_RECV_BUFFER_SIZE)
  83     return PP_ERROR_BADARGUMENT;
  84
  85   return SetOptionImpl(name, value,
  86                        true,  // Check bind() state.
  87                        callback);
  88 }
  89
  90 int32_t UDPSocketResource::SetOption1_1(
  91     PP_UDPSocket_Option name,
  92     const PP_Var& value,
  93     scoped_refptr<TrackedCallback> callback) {
  94   if (name > PP_UDPSOCKET_OPTION_RECV_BUFFER_SIZE)
  95     return PP_ERROR_BADARGUMENT;
  96
  97   return SetOptionImpl(name, value,
  98                        false,  // Check bind() state.
  99                        callback);
 100 }
 101
 102 int32_t UDPSocketResource::SetOption(
 103     PP_UDPSocket_Option name,
 104     const PP_Var& value,
 105     scoped_refptr<TrackedCallback> callback) {
 106   return SetOptionImpl(name, value,
 107                        false,  // Check bind() state.
 108                        callback);
 109 }
 110
 111 int32_t UDPSocketResource::JoinGroup(
 112     PP_Resource group,
 113     scoped_refptr<TrackedCallback> callback) {
 114   EnterNetAddressNoLock enter(group, true);
 115   if (enter.failed())
 116     return PP_ERROR_BADRESOURCE;
 117
 118   return JoinGroupImpl(&enter.object()->GetNetAddressPrivate(),
 119                        callback);
 120 }
 121
 122 int32_t UDPSocketResource::LeaveGroup(
 123     PP_Resource group,
 124     scoped_refptr<TrackedCallback> callback) {
 125   EnterNetAddressNoLock enter(group, true);
 126   if (enter.failed())
 127     return PP_ERROR_BADRESOURCE;
 128
 129   return LeaveGroupImpl(&enter.object()->GetNetAddressPrivate(),
 130                         callback);
 131 }
 132
 133 }  // namespace proxy
 134 }  // namespace ppapi