tcp_socket_private.cc revision 5821806d5e7f356e8fa4b058a389a808ea183019 
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
14namespace pp {
15
16namespace {
17
18template <> const char* interface_name<PPB_TCPSocket_Private_0_4>() {
19  return PPB_TCPSOCKET_PRIVATE_INTERFACE_0_4;
20}
21
22template <> const char* interface_name<PPB_TCPSocket_Private_0_3>() {
23  return PPB_TCPSOCKET_PRIVATE_INTERFACE_0_3;
24}
25
26}  // namespace
27
28TCPSocketPrivate::TCPSocketPrivate(const InstanceHandle& instance) {
29  if (has_interface<PPB_TCPSocket_Private_0_4>()) {
30    PassRefFromConstructor(get_interface<PPB_TCPSocket_Private_0_4>()->Create(
31        instance.pp_instance()));
32  } else if (has_interface<PPB_TCPSocket_Private_0_3>()) {
33    PassRefFromConstructor(get_interface<PPB_TCPSocket_Private_0_3>()->Create(
34        instance.pp_instance()));
35  }
36}
37
38TCPSocketPrivate::TCPSocketPrivate(PassRef, PP_Resource resource)
39    : Resource(PASS_REF, resource) {
40}
41
42// static
43bool TCPSocketPrivate::IsAvailable() {
44  return has_interface<PPB_TCPSocket_Private_0_4>() ||
45      has_interface<PPB_TCPSocket_Private_0_3>();
46}
47
48int32_t TCPSocketPrivate::Connect(const char* host,
49                                  uint16_t port,
50                                  const CompletionCallback& callback) {
51  if (has_interface<PPB_TCPSocket_Private_0_4>()) {
52    return get_interface<PPB_TCPSocket_Private_0_4>()->Connect(
53        pp_resource(), host, port, callback.pp_completion_callback());
54  }
55  if (has_interface<PPB_TCPSocket_Private_0_3>()) {
56    return get_interface<PPB_TCPSocket_Private_0_3>()->Connect(
57        pp_resource(), host, port, callback.pp_completion_callback());
58  }
59  return callback.MayForce(PP_ERROR_NOINTERFACE);
60}
61
62int32_t TCPSocketPrivate::ConnectWithNetAddress(
63    const PP_NetAddress_Private* addr,
64    const CompletionCallback& callback) {
65  if (has_interface<PPB_TCPSocket_Private_0_4>()) {
66    return get_interface<PPB_TCPSocket_Private_0_4>()->ConnectWithNetAddress(
67        pp_resource(), addr, callback.pp_completion_callback());
68  }
69  if (has_interface<PPB_TCPSocket_Private_0_3>()) {
70    return get_interface<PPB_TCPSocket_Private_0_3>()->ConnectWithNetAddress(
71        pp_resource(), addr, callback.pp_completion_callback());
72  }
73  return callback.MayForce(PP_ERROR_NOINTERFACE);
74}
75
76bool TCPSocketPrivate::GetLocalAddress(PP_NetAddress_Private* local_addr) {
77  if (has_interface<PPB_TCPSocket_Private_0_4>()) {
78    PP_Bool result = get_interface<PPB_TCPSocket_Private_0_4>()->
79        GetLocalAddress(pp_resource(), local_addr);
80    return PP_ToBool(result);
81  }
82  if (has_interface<PPB_TCPSocket_Private_0_3>()) {
83    PP_Bool result = get_interface<PPB_TCPSocket_Private_0_3>()->
84        GetLocalAddress(pp_resource(), local_addr);
85    return PP_ToBool(result);
86  }
87  return false;
88}
89
90bool TCPSocketPrivate::GetRemoteAddress(PP_NetAddress_Private* remote_addr) {
91  if (has_interface<PPB_TCPSocket_Private_0_4>()) {
92    PP_Bool result = get_interface<PPB_TCPSocket_Private_0_4>()->
93        GetRemoteAddress(pp_resource(), remote_addr);
94    return PP_ToBool(result);
95  }
96  if (has_interface<PPB_TCPSocket_Private_0_3>()) {
97    PP_Bool result = get_interface<PPB_TCPSocket_Private_0_3>()->
98        GetRemoteAddress(pp_resource(), remote_addr);
99    return PP_ToBool(result);
100  }
101  return false;
102}
103
104int32_t TCPSocketPrivate::SSLHandshake(const char* server_name,
105                                       uint16_t server_port,
106                                       const CompletionCallback& callback) {
107  if (has_interface<PPB_TCPSocket_Private_0_4>()) {
108    return get_interface<PPB_TCPSocket_Private_0_4>()->SSLHandshake(
109        pp_resource(), server_name, server_port,
110        callback.pp_completion_callback());
111  }
112  if (has_interface<PPB_TCPSocket_Private_0_3>()) {
113    return get_interface<PPB_TCPSocket_Private_0_3>()->SSLHandshake(
114        pp_resource(), server_name, server_port,
115        callback.pp_completion_callback());
116  }
117  return callback.MayForce(PP_ERROR_NOINTERFACE);
118}
119
120X509CertificatePrivate TCPSocketPrivate::GetServerCertificate() {
121  if (has_interface<PPB_TCPSocket_Private_0_4>()) {
122    return X509CertificatePrivate(PASS_REF,
123        get_interface<PPB_TCPSocket_Private_0_4>()->GetServerCertificate(
124            pp_resource()));
125  }
126  return X509CertificatePrivate();
127}
128
129bool TCPSocketPrivate::AddChainBuildingCertificate(
130    const X509CertificatePrivate& cert,
131    bool trusted) {
132  if (has_interface<PPB_TCPSocket_Private_0_4>()) {
133    return PP_ToBool(get_interface<PPB_TCPSocket_Private_0_4>()->
134        AddChainBuildingCertificate(pp_resource(), cert.pp_resource(),
135                                    PP_FromBool(trusted)));
136  }
137  return false;
138}
139
140int32_t TCPSocketPrivate::Read(char* buffer,
141                               int32_t bytes_to_read,
142                               const CompletionCallback& callback) {
143  if (has_interface<PPB_TCPSocket_Private_0_4>()) {
144    return get_interface<PPB_TCPSocket_Private_0_4>()->Read(
145        pp_resource(), buffer, bytes_to_read,
146        callback.pp_completion_callback());
147  }
148  if (has_interface<PPB_TCPSocket_Private_0_3>()) {
149    return get_interface<PPB_TCPSocket_Private_0_3>()->Read(
150        pp_resource(), buffer, bytes_to_read,
151        callback.pp_completion_callback());
152  }
153  return callback.MayForce(PP_ERROR_NOINTERFACE);
154}
155
156int32_t TCPSocketPrivate::Write(const char* buffer,
157                                int32_t bytes_to_write,
158                                const CompletionCallback& callback) {
159  if (has_interface<PPB_TCPSocket_Private_0_4>()) {
160    return get_interface<PPB_TCPSocket_Private_0_4>()->Write(
161        pp_resource(), buffer, bytes_to_write,
162        callback.pp_completion_callback());
163  }
164  if (has_interface<PPB_TCPSocket_Private_0_3>()) {
165    return get_interface<PPB_TCPSocket_Private_0_3>()->Write(
166        pp_resource(), buffer, bytes_to_write,
167        callback.pp_completion_callback());
168  }
169  return callback.MayForce(PP_ERROR_NOINTERFACE);
170}
171
172void TCPSocketPrivate::Disconnect() {
173  if (has_interface<PPB_TCPSocket_Private_0_4>()) {
174    return get_interface<PPB_TCPSocket_Private_0_4>()->Disconnect(
175        pp_resource());
176  }
177  if (has_interface<PPB_TCPSocket_Private_0_3>()) {
178    return get_interface<PPB_TCPSocket_Private_0_3>()->Disconnect(
179        pp_resource());
180  }
181}
182
183}  // namespace pp
184