Home | History | Annotate | Download | only in cpp 
      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/cpp/tcp_socket.h"
      6 
      7 #include "ppapi/c/pp_errors.h"
      8 #include "ppapi/cpp/completion_callback.h"
      9 #include "ppapi/cpp/instance_handle.h"
     10 #include "ppapi/cpp/module_impl.h"
     11 
     12 namespace pp {
     13 
     14 namespace {
     15 
     16 template <> const char* interface_name<PPB_TCPSocket_1_0>() {
     17   return PPB_TCPSOCKET_INTERFACE_1_0;
     18 }
     19 
     20 template <> const char* interface_name<PPB_TCPSocket_1_1>() {
     21   return PPB_TCPSOCKET_INTERFACE_1_1;
     22 }
     23 
     24 }  // namespace
     25 
     26 TCPSocket::TCPSocket() {
     27 }
     28 
     29 TCPSocket::TCPSocket(const InstanceHandle& instance) {
     30   if (has_interface<PPB_TCPSocket_1_1>()) {
     31     PassRefFromConstructor(get_interface<PPB_TCPSocket_1_1>()->Create(
     32         instance.pp_instance()));
     33   } else if (has_interface<PPB_TCPSocket_1_0>()) {
     34     PassRefFromConstructor(get_interface<PPB_TCPSocket_1_0>()->Create(
     35         instance.pp_instance()));
     36   }
     37 }
     38 
     39 TCPSocket::TCPSocket(PassRef, PP_Resource resource)
     40     : Resource(PASS_REF, resource) {
     41 }
     42 
     43 TCPSocket::TCPSocket(const TCPSocket& other) : Resource(other) {
     44 }
     45 
     46 TCPSocket::~TCPSocket() {
     47 }
     48 
     49 TCPSocket& TCPSocket::operator=(const TCPSocket& other) {
     50   Resource::operator=(other);
     51   return *this;
     52 }
     53 
     54 // static
     55 bool TCPSocket::IsAvailable() {
     56   return has_interface<PPB_TCPSocket_1_1>() ||
     57          has_interface<PPB_TCPSocket_1_0>();
     58 }
     59 
     60 int32_t TCPSocket::Bind(const NetAddress& addr,
     61                         const CompletionCallback& callback) {
     62   if (has_interface<PPB_TCPSocket_1_1>()) {
     63     return get_interface<PPB_TCPSocket_1_1>()->Bind(
     64         pp_resource(), addr.pp_resource(), callback.pp_completion_callback());
     65   }
     66   return callback.MayForce(PP_ERROR_NOINTERFACE);
     67 }
     68 
     69 int32_t TCPSocket::Connect(const NetAddress& addr,
     70                            const CompletionCallback& callback) {
     71   if (has_interface<PPB_TCPSocket_1_1>()) {
     72     return get_interface<PPB_TCPSocket_1_1>()->Connect(
     73         pp_resource(), addr.pp_resource(), callback.pp_completion_callback());
     74   }
     75   if (has_interface<PPB_TCPSocket_1_0>()) {
     76     return get_interface<PPB_TCPSocket_1_0>()->Connect(
     77         pp_resource(), addr.pp_resource(), callback.pp_completion_callback());
     78   }
     79   return callback.MayForce(PP_ERROR_NOINTERFACE);
     80 }
     81 
     82 NetAddress TCPSocket::GetLocalAddress() const {
     83   if (has_interface<PPB_TCPSocket_1_1>()) {
     84     return NetAddress(
     85         PASS_REF,
     86         get_interface<PPB_TCPSocket_1_1>()->GetLocalAddress(pp_resource()));
     87   }
     88   if (has_interface<PPB_TCPSocket_1_0>()) {
     89     return NetAddress(
     90         PASS_REF,
     91         get_interface<PPB_TCPSocket_1_0>()->GetLocalAddress(pp_resource()));
     92   }
     93   return NetAddress();
     94 }
     95 
     96 NetAddress TCPSocket::GetRemoteAddress() const {
     97   if (has_interface<PPB_TCPSocket_1_1>()) {
     98     return NetAddress(
     99         PASS_REF,
    100         get_interface<PPB_TCPSocket_1_1>()->GetRemoteAddress(pp_resource()));
    101   }
    102   if (has_interface<PPB_TCPSocket_1_0>()) {
    103     return NetAddress(
    104         PASS_REF,
    105         get_interface<PPB_TCPSocket_1_0>()->GetRemoteAddress(pp_resource()));
    106   }
    107   return NetAddress();
    108 }
    109 
    110 int32_t TCPSocket::Read(char* buffer,
    111                         int32_t bytes_to_read,
    112                         const CompletionCallback& callback) {
    113   if (has_interface<PPB_TCPSocket_1_1>()) {
    114     return get_interface<PPB_TCPSocket_1_1>()->Read(
    115         pp_resource(), buffer, bytes_to_read,
    116         callback.pp_completion_callback());
    117   }
    118   if (has_interface<PPB_TCPSocket_1_0>()) {
    119     return get_interface<PPB_TCPSocket_1_0>()->Read(
    120         pp_resource(), buffer, bytes_to_read,
    121         callback.pp_completion_callback());
    122   }
    123   return callback.MayForce(PP_ERROR_NOINTERFACE);
    124 }
    125 
    126 int32_t TCPSocket::Write(const char* buffer,
    127                          int32_t bytes_to_write,
    128                          const CompletionCallback& callback) {
    129   if (has_interface<PPB_TCPSocket_1_1>()) {
    130     return get_interface<PPB_TCPSocket_1_1>()->Write(
    131         pp_resource(), buffer, bytes_to_write,
    132         callback.pp_completion_callback());
    133   }
    134   if (has_interface<PPB_TCPSocket_1_0>()) {
    135     return get_interface<PPB_TCPSocket_1_0>()->Write(
    136         pp_resource(), buffer, bytes_to_write,
    137         callback.pp_completion_callback());
    138   }
    139   return callback.MayForce(PP_ERROR_NOINTERFACE);
    140 }
    141 
    142 int32_t TCPSocket::Listen(int32_t backlog,
    143                           const CompletionCallback& callback) {
    144   if (has_interface<PPB_TCPSocket_1_1>()) {
    145     return get_interface<PPB_TCPSocket_1_1>()->Listen(
    146         pp_resource(), backlog, callback.pp_completion_callback());
    147   }
    148   return callback.MayForce(PP_ERROR_NOINTERFACE);
    149 }
    150 
    151 int32_t TCPSocket::Accept(
    152     const CompletionCallbackWithOutput<TCPSocket>& callback) {
    153   if (has_interface<PPB_TCPSocket_1_1>()) {
    154     return get_interface<PPB_TCPSocket_1_1>()->Accept(
    155         pp_resource(), callback.output(), callback.pp_completion_callback());
    156   }
    157   return callback.MayForce(PP_ERROR_NOINTERFACE);
    158 }
    159 
    160 void TCPSocket::Close() {
    161   if (has_interface<PPB_TCPSocket_1_1>()) {
    162     get_interface<PPB_TCPSocket_1_1>()->Close(pp_resource());
    163   } else if (has_interface<PPB_TCPSocket_1_0>()) {
    164     get_interface<PPB_TCPSocket_1_0>()->Close(pp_resource());
    165   }
    166 }
    167 
    168 int32_t TCPSocket::SetOption(PP_TCPSocket_Option name,
    169                              const Var& value,
    170                              const CompletionCallback& callback) {
    171   if (has_interface<PPB_TCPSocket_1_1>()) {
    172     return get_interface<PPB_TCPSocket_1_1>()->SetOption(
    173         pp_resource(), name, value.pp_var(), callback.pp_completion_callback());
    174   }
    175   if (has_interface<PPB_TCPSocket_1_0>()) {
    176     return get_interface<PPB_TCPSocket_1_0>()->SetOption(
    177         pp_resource(), name, value.pp_var(), callback.pp_completion_callback());
    178   }
    179   return callback.MayForce(PP_ERROR_NOINTERFACE);
    180 }
    181 
    182 }  // namespace pp
    183