ppapi/cpp/private/tcp_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/tcp_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
  14 namespace pp {
  15
  16 namespace {
  17
  18 template <> const char* interface_name<PPB_TCPSocket_Private_0_5>() {
  19   return PPB_TCPSOCKET_PRIVATE_INTERFACE_0_5;
  20 }
  21
  22 template <> const char* interface_name<PPB_TCPSocket_Private_0_4>() {
  23   return PPB_TCPSOCKET_PRIVATE_INTERFACE_0_4;
  24 }
  25
  26 template <> const char* interface_name<PPB_TCPSocket_Private_0_3>() {
  27   return PPB_TCPSOCKET_PRIVATE_INTERFACE_0_3;
  28 }
  29
  30 }  // namespace
  31
  32 TCPSocketPrivate::TCPSocketPrivate(const InstanceHandle& instance) {
  33   if (has_interface<PPB_TCPSocket_Private_0_5>()) {
  34     PassRefFromConstructor(get_interface<PPB_TCPSocket_Private_0_5>()->Create(
  35         instance.pp_instance()));
  36   } else if (has_interface<PPB_TCPSocket_Private_0_4>()) {
  37     PassRefFromConstructor(get_interface<PPB_TCPSocket_Private_0_4>()->Create(
  38         instance.pp_instance()));
  39   } else if (has_interface<PPB_TCPSocket_Private_0_3>()) {
  40     PassRefFromConstructor(get_interface<PPB_TCPSocket_Private_0_3>()->Create(
  41         instance.pp_instance()));
  42   }
  43 }
  44
  45 TCPSocketPrivate::TCPSocketPrivate(PassRef, PP_Resource resource)
  46     : Resource(PASS_REF, resource) {
  47 }
  48
  49 // static
  50 bool TCPSocketPrivate::IsAvailable() {
  51   return has_interface<PPB_TCPSocket_Private_0_5>() ||
  52       has_interface<PPB_TCPSocket_Private_0_4>() ||
  53       has_interface<PPB_TCPSocket_Private_0_3>();
  54 }
  55
  56 int32_t TCPSocketPrivate::Connect(const char* host,
  57                                   uint16_t port,
  58                                   const CompletionCallback& callback) {
  59   if (has_interface<PPB_TCPSocket_Private_0_5>()) {
  60     return get_interface<PPB_TCPSocket_Private_0_5>()->Connect(
  61         pp_resource(), host, port, callback.pp_completion_callback());
  62   }
  63   if (has_interface<PPB_TCPSocket_Private_0_4>()) {
  64     return get_interface<PPB_TCPSocket_Private_0_4>()->Connect(
  65         pp_resource(), host, port, callback.pp_completion_callback());
  66   }
  67   if (has_interface<PPB_TCPSocket_Private_0_3>()) {
  68     return get_interface<PPB_TCPSocket_Private_0_3>()->Connect(
  69         pp_resource(), host, port, callback.pp_completion_callback());
  70   }
  71   return callback.MayForce(PP_ERROR_NOINTERFACE);
  72 }
  73
  74 int32_t TCPSocketPrivate::ConnectWithNetAddress(
  75     const PP_NetAddress_Private* addr,
  76     const CompletionCallback& callback) {
  77   if (has_interface<PPB_TCPSocket_Private_0_5>()) {
  78     return get_interface<PPB_TCPSocket_Private_0_5>()->ConnectWithNetAddress(
  79         pp_resource(), addr, callback.pp_completion_callback());
  80   }
  81   if (has_interface<PPB_TCPSocket_Private_0_4>()) {
  82     return get_interface<PPB_TCPSocket_Private_0_4>()->ConnectWithNetAddress(
  83         pp_resource(), addr, callback.pp_completion_callback());
  84   }
  85   if (has_interface<PPB_TCPSocket_Private_0_3>()) {
  86     return get_interface<PPB_TCPSocket_Private_0_3>()->ConnectWithNetAddress(
  87         pp_resource(), addr, callback.pp_completion_callback());
  88   }
  89   return callback.MayForce(PP_ERROR_NOINTERFACE);
  90 }
  91
  92 bool TCPSocketPrivate::GetLocalAddress(PP_NetAddress_Private* local_addr) {
  93   if (has_interface<PPB_TCPSocket_Private_0_5>()) {
  94     PP_Bool result = get_interface<PPB_TCPSocket_Private_0_5>()->
  95         GetLocalAddress(pp_resource(), local_addr);
  96     return PP_ToBool(result);
  97   }
  98   if (has_interface<PPB_TCPSocket_Private_0_4>()) {
  99     PP_Bool result = get_interface<PPB_TCPSocket_Private_0_4>()->
 100         GetLocalAddress(pp_resource(), local_addr);
 101     return PP_ToBool(result);
 102   }
 103   if (has_interface<PPB_TCPSocket_Private_0_3>()) {
 104     PP_Bool result = get_interface<PPB_TCPSocket_Private_0_3>()->
 105         GetLocalAddress(pp_resource(), local_addr);
 106     return PP_ToBool(result);
 107   }
 108   return false;
 109 }
 110
 111 bool TCPSocketPrivate::GetRemoteAddress(PP_NetAddress_Private* remote_addr) {
 112   if (has_interface<PPB_TCPSocket_Private_0_5>()) {
 113     PP_Bool result = get_interface<PPB_TCPSocket_Private_0_5>()->
 114         GetRemoteAddress(pp_resource(), remote_addr);
 115     return PP_ToBool(result);
 116   }
 117   if (has_interface<PPB_TCPSocket_Private_0_4>()) {
 118     PP_Bool result = get_interface<PPB_TCPSocket_Private_0_4>()->
 119         GetRemoteAddress(pp_resource(), remote_addr);
 120     return PP_ToBool(result);
 121   }
 122   if (has_interface<PPB_TCPSocket_Private_0_3>()) {
 123     PP_Bool result = get_interface<PPB_TCPSocket_Private_0_3>()->
 124         GetRemoteAddress(pp_resource(), remote_addr);
 125     return PP_ToBool(result);
 126   }
 127   return false;
 128 }
 129
 130 int32_t TCPSocketPrivate::SSLHandshake(const char* server_name,
 131                                        uint16_t server_port,
 132                                        const CompletionCallback& callback) {
 133   if (has_interface<PPB_TCPSocket_Private_0_5>()) {
 134     return get_interface<PPB_TCPSocket_Private_0_5>()->SSLHandshake(
 135         pp_resource(), server_name, server_port,
 136         callback.pp_completion_callback());
 137   }
 138   if (has_interface<PPB_TCPSocket_Private_0_4>()) {
 139     return get_interface<PPB_TCPSocket_Private_0_4>()->SSLHandshake(
 140         pp_resource(), server_name, server_port,
 141         callback.pp_completion_callback());
 142   }
 143   if (has_interface<PPB_TCPSocket_Private_0_3>()) {
 144     return get_interface<PPB_TCPSocket_Private_0_3>()->SSLHandshake(
 145         pp_resource(), server_name, server_port,
 146         callback.pp_completion_callback());
 147   }
 148   return callback.MayForce(PP_ERROR_NOINTERFACE);
 149 }
 150
 151 X509CertificatePrivate TCPSocketPrivate::GetServerCertificate() {
 152   if (has_interface<PPB_TCPSocket_Private_0_5>()) {
 153     return X509CertificatePrivate(PASS_REF,
 154         get_interface<PPB_TCPSocket_Private_0_5>()->GetServerCertificate(
 155             pp_resource()));
 156   }
 157   if (has_interface<PPB_TCPSocket_Private_0_4>()) {
 158     return X509CertificatePrivate(PASS_REF,
 159         get_interface<PPB_TCPSocket_Private_0_4>()->GetServerCertificate(
 160             pp_resource()));
 161   }
 162   return X509CertificatePrivate();
 163 }
 164
 165 bool TCPSocketPrivate::AddChainBuildingCertificate(
 166     const X509CertificatePrivate& cert,
 167     bool trusted) {
 168   if (has_interface<PPB_TCPSocket_Private_0_5>()) {
 169     return PP_ToBool(get_interface<PPB_TCPSocket_Private_0_5>()->
 170         AddChainBuildingCertificate(pp_resource(), cert.pp_resource(),
 171                                     PP_FromBool(trusted)));
 172   }
 173   if (has_interface<PPB_TCPSocket_Private_0_4>()) {
 174     return PP_ToBool(get_interface<PPB_TCPSocket_Private_0_4>()->
 175         AddChainBuildingCertificate(pp_resource(), cert.pp_resource(),
 176                                     PP_FromBool(trusted)));
 177   }
 178   return false;
 179 }
 180
 181 int32_t TCPSocketPrivate::Read(char* buffer,
 182                                int32_t bytes_to_read,
 183                                const CompletionCallback& callback) {
 184   if (has_interface<PPB_TCPSocket_Private_0_5>()) {
 185     return get_interface<PPB_TCPSocket_Private_0_5>()->Read(
 186         pp_resource(), buffer, bytes_to_read,
 187         callback.pp_completion_callback());
 188   }
 189   if (has_interface<PPB_TCPSocket_Private_0_4>()) {
 190     return get_interface<PPB_TCPSocket_Private_0_4>()->Read(
 191         pp_resource(), buffer, bytes_to_read,
 192         callback.pp_completion_callback());
 193   }
 194   if (has_interface<PPB_TCPSocket_Private_0_3>()) {
 195     return get_interface<PPB_TCPSocket_Private_0_3>()->Read(
 196         pp_resource(), buffer, bytes_to_read,
 197         callback.pp_completion_callback());
 198   }
 199   return callback.MayForce(PP_ERROR_NOINTERFACE);
 200 }
 201
 202 int32_t TCPSocketPrivate::Write(const char* buffer,
 203                                 int32_t bytes_to_write,
 204                                 const CompletionCallback& callback) {
 205   if (has_interface<PPB_TCPSocket_Private_0_5>()) {
 206     return get_interface<PPB_TCPSocket_Private_0_5>()->Write(
 207         pp_resource(), buffer, bytes_to_write,
 208         callback.pp_completion_callback());
 209   }
 210   if (has_interface<PPB_TCPSocket_Private_0_4>()) {
 211     return get_interface<PPB_TCPSocket_Private_0_4>()->Write(
 212         pp_resource(), buffer, bytes_to_write,
 213         callback.pp_completion_callback());
 214   }
 215   if (has_interface<PPB_TCPSocket_Private_0_3>()) {
 216     return get_interface<PPB_TCPSocket_Private_0_3>()->Write(
 217         pp_resource(), buffer, bytes_to_write,
 218         callback.pp_completion_callback());
 219   }
 220   return callback.MayForce(PP_ERROR_NOINTERFACE);
 221 }
 222
 223 void TCPSocketPrivate::Disconnect() {
 224   if (has_interface<PPB_TCPSocket_Private_0_5>()) {
 225     return get_interface<PPB_TCPSocket_Private_0_5>()->Disconnect(
 226         pp_resource());
 227   }
 228   if (has_interface<PPB_TCPSocket_Private_0_4>()) {
 229     return get_interface<PPB_TCPSocket_Private_0_4>()->Disconnect(
 230         pp_resource());
 231   }
 232   if (has_interface<PPB_TCPSocket_Private_0_3>()) {
 233     return get_interface<PPB_TCPSocket_Private_0_3>()->Disconnect(
 234         pp_resource());
 235   }
 236 }
 237
 238 int32_t TCPSocketPrivate::SetOption(PP_TCPSocketOption_Private name,
 239                                     const Var& value,
 240                                     const CompletionCallback& callback) {
 241   if (has_interface<PPB_TCPSocket_Private_0_5>()) {
 242     return get_interface<PPB_TCPSocket_Private_0_5>()->SetOption(
 243         pp_resource(), name, value.pp_var(), callback.pp_completion_callback());
 244   }
 245   return callback.MayForce(PP_ERROR_NOINTERFACE);
 246 }
 247
 248 }  // namespace pp