ppapi/cpp/private/udp_socket_private.cc

   1 // Copyright (c) 2012 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/cpp/private/udp_socket_private.h"
   6
   7 #include "ppapi/c/pp_bool.h"
   8 #include "ppapi/c/pp_errors.h"
   9 #include "ppapi/cpp/completion_callback.h"
  10 #include "ppapi/cpp/instance_handle.h"
  11 #include "ppapi/cpp/module.h"
  12 #include "ppapi/cpp/module_impl.h"
  13 #include "ppapi/cpp/var.h"
  14
  15 namespace pp {
  16
  17 namespace {
  18
  19 template <> const char* interface_name<PPB_UDPSocket_Private_0_4>() {
  20   return PPB_UDPSOCKET_PRIVATE_INTERFACE_0_4;
  21 }
  22
  23 template <> const char* interface_name<PPB_UDPSocket_Private_0_3>() {
  24   return PPB_UDPSOCKET_PRIVATE_INTERFACE_0_3;
  25 }
  26
  27 }  // namespace
  28
  29 UDPSocketPrivate::UDPSocketPrivate(const InstanceHandle& instance) {
  30   if (has_interface<PPB_UDPSocket_Private_0_4>()) {
  31     PassRefFromConstructor(get_interface<PPB_UDPSocket_Private_0_4>()->Create(
  32         instance.pp_instance()));
  33   } else if (has_interface<PPB_UDPSocket_Private_0_3>()) {
  34     PassRefFromConstructor(get_interface<PPB_UDPSocket_Private_0_3>()->Create(
  35         instance.pp_instance()));
  36   }
  37 }
  38
  39 // static
  40 bool UDPSocketPrivate::IsAvailable() {
  41   return has_interface<PPB_UDPSocket_Private_0_4>() ||
  42       has_interface<PPB_UDPSocket_Private_0_3>();
  43 }
  44
  45 int32_t UDPSocketPrivate::SetSocketFeature(PP_UDPSocketFeature_Private name,
  46                                            const Var& value) {
  47   if (has_interface<PPB_UDPSocket_Private_0_4>()) {
  48     return get_interface<PPB_UDPSocket_Private_0_4>()->SetSocketFeature(
  49         pp_resource(), name, value.pp_var());
  50   }
  51   return PP_ERROR_NOINTERFACE;
  52 }
  53
  54 int32_t UDPSocketPrivate::Bind(const PP_NetAddress_Private* addr,
  55                                const CompletionCallback& callback) {
  56   if (has_interface<PPB_UDPSocket_Private_0_4>()) {
  57     return get_interface<PPB_UDPSocket_Private_0_4>()->Bind(
  58         pp_resource(), addr, callback.pp_completion_callback());
  59   }
  60   if (has_interface<PPB_UDPSocket_Private_0_3>()) {
  61     return get_interface<PPB_UDPSocket_Private_0_3>()->Bind(
  62         pp_resource(), addr, callback.pp_completion_callback());
  63   }
  64   return callback.MayForce(PP_ERROR_NOINTERFACE);
  65 }
  66
  67 bool UDPSocketPrivate::GetBoundAddress(PP_NetAddress_Private* addr) {
  68   if (has_interface<PPB_UDPSocket_Private_0_4>()) {
  69     PP_Bool result =
  70         get_interface<PPB_UDPSocket_Private_0_4>()->GetBoundAddress(
  71             pp_resource(), addr);
  72     return PP_ToBool(result);
  73   }
  74   if (has_interface<PPB_UDPSocket_Private_0_3>()) {
  75     PP_Bool result =
  76         get_interface<PPB_UDPSocket_Private_0_3>()->GetBoundAddress(
  77             pp_resource(), addr);
  78     return PP_ToBool(result);
  79   }
  80   return false;
  81 }
  82
  83 int32_t UDPSocketPrivate::RecvFrom(char* buffer,
  84                                    int32_t num_bytes,
  85                                    const CompletionCallback& callback) {
  86   if (has_interface<PPB_UDPSocket_Private_0_4>()) {
  87     return get_interface<PPB_UDPSocket_Private_0_4>()->RecvFrom(
  88         pp_resource(), buffer, num_bytes, callback.pp_completion_callback());
  89   }
  90   if (has_interface<PPB_UDPSocket_Private_0_3>()) {
  91     return get_interface<PPB_UDPSocket_Private_0_3>()->RecvFrom(
  92         pp_resource(), buffer, num_bytes, callback.pp_completion_callback());
  93   }
  94   return callback.MayForce(PP_ERROR_NOINTERFACE);
  95 }
  96
  97 bool UDPSocketPrivate::GetRecvFromAddress(PP_NetAddress_Private* addr) {
  98   if (has_interface<PPB_UDPSocket_Private_0_4>()) {
  99     PP_Bool result =
 100         get_interface<PPB_UDPSocket_Private_0_4>()->GetRecvFromAddress(
 101             pp_resource(), addr);
 102     return PP_ToBool(result);
 103   }
 104   if (has_interface<PPB_UDPSocket_Private_0_3>()) {
 105     PP_Bool result =
 106         get_interface<PPB_UDPSocket_Private_0_3>()->GetRecvFromAddress(
 107             pp_resource(), addr);
 108     return PP_ToBool(result);
 109   }
 110   return false;
 111 }
 112
 113 int32_t UDPSocketPrivate::SendTo(const char* buffer,
 114                                  int32_t num_bytes,
 115                                  const PP_NetAddress_Private* addr,
 116                                  const CompletionCallback& callback) {
 117   if (has_interface<PPB_UDPSocket_Private_0_4>()) {
 118     return get_interface<PPB_UDPSocket_Private_0_4>()->SendTo(
 119         pp_resource(), buffer, num_bytes, addr,
 120         callback.pp_completion_callback());
 121   }
 122   if (has_interface<PPB_UDPSocket_Private_0_3>()) {
 123     return get_interface<PPB_UDPSocket_Private_0_3>()->SendTo(
 124         pp_resource(), buffer, num_bytes, addr,
 125         callback.pp_completion_callback());
 126   }
 127   return callback.MayForce(PP_ERROR_NOINTERFACE);
 128 }
 129
 130 void UDPSocketPrivate::Close() {
 131   if (has_interface<PPB_UDPSocket_Private_0_4>())
 132     return get_interface<PPB_UDPSocket_Private_0_4>()->Close(pp_resource());
 133   if (has_interface<PPB_UDPSocket_Private_0_3>())
 134     return get_interface<PPB_UDPSocket_Private_0_3>()->Close(pp_resource());
 135 }
 136
 137 }  // namespace pp