ppapi/thunk/ppb_tcp_socket_private_thunk.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/c/pp_completion_callback.h"
   6 #include "ppapi/c/pp_errors.h"
   7 #include "ppapi/c/private/ppb_tcp_socket_private.h"
   8 #include "ppapi/shared_impl/tracked_callback.h"
   9 #include "ppapi/thunk/enter.h"
  10 #include "ppapi/thunk/thunk.h"
  11 #include "ppapi/thunk/ppb_tcp_socket_private_api.h"
  12 #include "ppapi/thunk/resource_creation_api.h"
  13
  14 namespace ppapi {
  15 namespace thunk {
  16
  17 namespace {
  18
  19 typedef EnterResource<PPB_TCPSocket_Private_API> EnterTCP;
  20
  21 PP_Resource Create(PP_Instance instance) {
  22   EnterResourceCreation enter(instance);
  23   if (enter.failed())
  24     return 0;
  25   return enter.functions()->CreateTCPSocketPrivate(instance);
  26 }
  27
  28 PP_Bool IsTCPSocket(PP_Resource resource) {
  29   EnterTCP enter(resource, false);
  30   return PP_FromBool(enter.succeeded());
  31 }
  32
  33 int32_t Connect(PP_Resource tcp_socket,
  34                 const char* host,
  35                 uint16_t port,
  36                 PP_CompletionCallback callback) {
  37   EnterTCP enter(tcp_socket, callback, true);
  38   if (enter.failed())
  39     return enter.retval();
  40   return enter.SetResult(enter.object()->Connect(host, port, enter.callback()));
  41 }
  42
  43 int32_t ConnectWithNetAddress(PP_Resource tcp_socket,
  44                               const PP_NetAddress_Private* addr,
  45                               PP_CompletionCallback callback) {
  46   EnterTCP enter(tcp_socket, callback, true);
  47   if (enter.failed())
  48     return enter.retval();
  49   return enter.SetResult(
  50       enter.object()->ConnectWithNetAddress(addr, enter.callback()));
  51 }
  52
  53 PP_Bool GetLocalAddress(PP_Resource tcp_socket,
  54                         PP_NetAddress_Private* local_addr) {
  55   EnterTCP enter(tcp_socket, true);
  56   if (enter.failed())
  57     return PP_FALSE;
  58   return enter.object()->GetLocalAddress(local_addr);
  59 }
  60
  61 PP_Bool GetRemoteAddress(PP_Resource tcp_socket,
  62                          PP_NetAddress_Private* remote_addr) {
  63   EnterTCP enter(tcp_socket, true);
  64   if (enter.failed())
  65     return PP_FALSE;
  66   return enter.object()->GetRemoteAddress(remote_addr);
  67 }
  68
  69 int32_t SSLHandshake(PP_Resource tcp_socket,
  70                      const char* server_name,
  71                      uint16_t server_port,
  72                      PP_CompletionCallback callback) {
  73   EnterTCP enter(tcp_socket, callback, true);
  74   if (enter.failed())
  75     return enter.retval();
  76   return enter.SetResult(enter.object()->SSLHandshake(server_name, server_port,
  77                                                       enter.callback()));
  78 }
  79
  80 PP_Resource GetServerCertificate(PP_Resource tcp_socket) {
  81   EnterTCP enter(tcp_socket, true);
  82   if (enter.failed())
  83     return 0;
  84   return enter.object()->GetServerCertificate();
  85 }
  86
  87 PP_Bool AddChainBuildingCertificate(PP_Resource tcp_socket,
  88                                     PP_Resource certificate,
  89                                     PP_Bool trusted) {
  90   EnterTCP enter(tcp_socket, true);
  91   if (enter.failed())
  92     return PP_FALSE;
  93   return enter.object()->AddChainBuildingCertificate(certificate, trusted);
  94 }
  95
  96 int32_t Read(PP_Resource tcp_socket,
  97              char* buffer,
  98              int32_t bytes_to_read,
  99              PP_CompletionCallback callback) {
 100   EnterTCP enter(tcp_socket, callback, true);
 101   if (enter.failed())
 102     return enter.retval();
 103   return enter.SetResult(enter.object()->Read(buffer, bytes_to_read,
 104                                               enter.callback()));
 105 }
 106
 107 int32_t Write(PP_Resource tcp_socket,
 108               const char* buffer,
 109               int32_t bytes_to_write,
 110               PP_CompletionCallback callback) {
 111   EnterTCP enter(tcp_socket, callback, true);
 112   if (enter.failed())
 113     return enter.retval();
 114   return enter.SetResult(enter.object()->Write(buffer, bytes_to_write,
 115                                                enter.callback()));
 116 }
 117
 118 void Disconnect(PP_Resource tcp_socket) {
 119   EnterTCP enter(tcp_socket, true);
 120   if (enter.succeeded())
 121     enter.object()->Disconnect();
 122 }
 123
 124 int32_t SetOption(PP_Resource tcp_socket,
 125                   PP_TCPSocketOption_Private name,
 126                   PP_Var value,
 127                   PP_CompletionCallback callback) {
 128   EnterTCP enter(tcp_socket, callback, true);
 129   if (enter.failed())
 130     return enter.retval();
 131   return enter.SetResult(
 132       enter.object()->SetOption(name, value, enter.callback()));
 133 }
 134
 135 const PPB_TCPSocket_Private_0_3 g_ppb_tcp_socket_thunk_0_3 = {
 136   &Create,
 137   &IsTCPSocket,
 138   &Connect,
 139   &ConnectWithNetAddress,
 140   &GetLocalAddress,
 141   &GetRemoteAddress,
 142   &SSLHandshake,
 143   &Read,
 144   &Write,
 145   &Disconnect
 146 };
 147
 148 const PPB_TCPSocket_Private_0_4 g_ppb_tcp_socket_thunk_0_4 = {
 149   &Create,
 150   &IsTCPSocket,
 151   &Connect,
 152   &ConnectWithNetAddress,
 153   &GetLocalAddress,
 154   &GetRemoteAddress,
 155   &SSLHandshake,
 156   &GetServerCertificate,
 157   &AddChainBuildingCertificate,
 158   &Read,
 159   &Write,
 160   &Disconnect
 161 };
 162
 163 const PPB_TCPSocket_Private_0_5 g_ppb_tcp_socket_thunk_0_5 = {
 164   &Create,
 165   &IsTCPSocket,
 166   &Connect,
 167   &ConnectWithNetAddress,
 168   &GetLocalAddress,
 169   &GetRemoteAddress,
 170   &SSLHandshake,
 171   &GetServerCertificate,
 172   &AddChainBuildingCertificate,
 173   &Read,
 174   &Write,
 175   &Disconnect,
 176   &SetOption
 177 };
 178
 179 }  // namespace
 180
 181 const PPB_TCPSocket_Private_0_3* GetPPB_TCPSocket_Private_0_3_Thunk() {
 182   return &g_ppb_tcp_socket_thunk_0_3;
 183 }
 184
 185 const PPB_TCPSocket_Private_0_4* GetPPB_TCPSocket_Private_0_4_Thunk() {
 186   return &g_ppb_tcp_socket_thunk_0_4;
 187 }
 188
 189 const PPB_TCPSocket_Private_0_5* GetPPB_TCPSocket_Private_0_5_Thunk() {
 190   return &g_ppb_tcp_socket_thunk_0_5;
 191 }
 192
 193 }  // namespace thunk
 194 }  // namespace ppapi