OLD | NEW |
(Empty) | |
| 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 // SRPC-abstraction wrappers around PPB_WebSocket functions. |
| 6 |
| 7 #include "native_client/src/include/nacl_scoped_ptr.h" |
| 8 #include "native_client/src/shared/ppapi_proxy/browser_callback.h" |
| 9 #include "native_client/src/shared/ppapi_proxy/browser_globals.h" |
| 10 #include "native_client/src/shared/ppapi_proxy/object_serialize.h" |
| 11 #include "native_client/src/shared/ppapi_proxy/utility.h" |
| 12 #include "ppapi/c/pp_completion_callback.h" |
| 13 #include "ppapi/c/pp_errors.h" |
| 14 #include "ppapi/c/dev/ppb_websocket_dev.h" |
| 15 #include "srpcgen/ppb_rpc.h" |
| 16 |
| 17 using ppapi_proxy::DebugPrintf; |
| 18 using ppapi_proxy::DeleteRemoteCallbackInfo; |
| 19 using ppapi_proxy::DeserializeTo; |
| 20 using ppapi_proxy::MakeRemoteCompletionCallback; |
| 21 using ppapi_proxy::PPBWebSocketInterface; |
| 22 using ppapi_proxy::SerializeTo; |
| 23 |
| 24 void PpbWebSocketRpcServer::PPB_WebSocket_Create( |
| 25 NaClSrpcRpc* rpc, |
| 26 NaClSrpcClosure* done, |
| 27 // inputs |
| 28 PP_Instance instance, |
| 29 // outputs |
| 30 PP_Resource* resource) { |
| 31 NaClSrpcClosureRunner runner(done); |
| 32 rpc->result = NACL_SRPC_RESULT_APP_ERROR; |
| 33 |
| 34 *resource = PPBWebSocketInterface()->Create(instance); |
| 35 DebugPrintf("PPB_WebSocket::Create: resource=%"NACL_PRId32"\n", *resource); |
| 36 |
| 37 rpc->result = NACL_SRPC_RESULT_OK; |
| 38 } |
| 39 |
| 40 void PpbWebSocketRpcServer::PPB_WebSocket_IsWebSocket( |
| 41 NaClSrpcRpc* rpc, |
| 42 NaClSrpcClosure* done, |
| 43 // inputs |
| 44 PP_Resource resource, |
| 45 // outputs |
| 46 int32_t* success) { |
| 47 NaClSrpcClosureRunner runner(done); |
| 48 rpc->result = NACL_SRPC_RESULT_APP_ERROR; |
| 49 |
| 50 PP_Bool pp_success = PPBWebSocketInterface()->IsWebSocket(resource); |
| 51 *success = PP_ToBool(pp_success); |
| 52 DebugPrintf("PPB_WebSocket::IsWebSocket: success=%d\n", *success); |
| 53 rpc->result = NACL_SRPC_RESULT_OK; |
| 54 } |
| 55 |
| 56 void PpbWebSocketRpcServer::PPB_WebSocket_Connect( |
| 57 NaClSrpcRpc* rpc, |
| 58 NaClSrpcClosure* done, |
| 59 // inputs |
| 60 PP_Resource ws, |
| 61 nacl_abi_size_t url_size, |
| 62 char* url_bytes, |
| 63 nacl_abi_size_t protocols_size, |
| 64 char* protocols_bytes, |
| 65 int32_t protocol_count, |
| 66 int32_t callback_id, |
| 67 // outputs |
| 68 int32_t* pp_error) { |
| 69 NaClSrpcClosureRunner runner(done); |
| 70 rpc->result = NACL_SRPC_RESULT_APP_ERROR; |
| 71 |
| 72 PP_CompletionCallback remote_callback = |
| 73 MakeRemoteCompletionCallback(rpc->channel, callback_id); |
| 74 if (NULL == remote_callback.func) |
| 75 return; |
| 76 |
| 77 PP_Var url; |
| 78 if (!DeserializeTo(url_bytes, url_size, 1, &url)) |
| 79 return; |
| 80 |
| 81 nacl::scoped_array<PP_Var> protocols(new PP_Var[protocol_count]); |
| 82 if (!DeserializeTo( |
| 83 protocols_bytes, protocols_size, protocol_count, protocols.get())) |
| 84 return; |
| 85 |
| 86 *pp_error = PPBWebSocketInterface()->Connect( |
| 87 ws, |
| 88 url, |
| 89 protocols.get(), |
| 90 static_cast<uint32_t>(protocol_count), |
| 91 remote_callback); |
| 92 DebugPrintf("PPB_WebSocket::Connect: pp_error=%"NACL_PRId32"\n", *pp_error); |
| 93 |
| 94 if (*pp_error != PP_OK_COMPLETIONPENDING) |
| 95 DeleteRemoteCallbackInfo(remote_callback); |
| 96 rpc->result = NACL_SRPC_RESULT_OK; |
| 97 } |
| 98 |
| 99 void PpbWebSocketRpcServer::PPB_WebSocket_Close( |
| 100 NaClSrpcRpc* rpc, |
| 101 NaClSrpcClosure* done, |
| 102 // inputs |
| 103 PP_Resource ws, |
| 104 int32_t code, |
| 105 nacl_abi_size_t reason_size, |
| 106 char* reason_bytes, |
| 107 int32_t callback_id, |
| 108 // outputs |
| 109 int32_t* pp_error) { |
| 110 NaClSrpcClosureRunner runner(done); |
| 111 rpc->result = NACL_SRPC_RESULT_APP_ERROR; |
| 112 |
| 113 PP_CompletionCallback remote_callback = |
| 114 MakeRemoteCompletionCallback(rpc->channel, callback_id); |
| 115 if (NULL == remote_callback.func) |
| 116 return; |
| 117 |
| 118 PP_Var reason; |
| 119 if (!DeserializeTo(reason_bytes, reason_size, 1, &reason)) |
| 120 return; |
| 121 |
| 122 *pp_error = PPBWebSocketInterface()->Close( |
| 123 ws, code, reason, remote_callback); |
| 124 DebugPrintf("PPB_WebSocket::Close: pp_error=%"NACL_PRId32"\n", *pp_error); |
| 125 |
| 126 if (*pp_error != PP_OK_COMPLETIONPENDING) |
| 127 DeleteRemoteCallbackInfo(remote_callback); |
| 128 rpc->result = NACL_SRPC_RESULT_OK; |
| 129 } |
| 130 |
| 131 void PpbWebSocketRpcServer::PPB_WebSocket_ReceiveMessage( |
| 132 NaClSrpcRpc* rpc, |
| 133 NaClSrpcClosure* done, |
| 134 // inputs |
| 135 PP_Resource ws, |
| 136 int32_t callback_id, |
| 137 // outputs |
| 138 int32_t* pp_error) { |
| 139 NaClSrpcClosureRunner runner(done); |
| 140 rpc->result = NACL_SRPC_RESULT_APP_ERROR; |
| 141 |
| 142 PP_Var* callback_var = NULL; |
| 143 PP_CompletionCallback remote_callback = |
| 144 MakeRemoteCompletionCallback(rpc->channel, callback_id, &callback_var); |
| 145 if (NULL == remote_callback.func) |
| 146 return; |
| 147 |
| 148 // The callback is always invoked asynchronously for now, so it doesn't care |
| 149 // about re-entrancy. |
| 150 *pp_error = PPBWebSocketInterface()->ReceiveMessage( |
| 151 ws, callback_var, remote_callback); |
| 152 DebugPrintf("PPB_WebSocket::ReceiveMessage: pp_error=%"NACL_PRId32"\n", |
| 153 *pp_error); |
| 154 |
| 155 if (*pp_error != PP_OK_COMPLETIONPENDING) |
| 156 DeleteRemoteCallbackInfo(remote_callback); |
| 157 rpc->result = NACL_SRPC_RESULT_OK; |
| 158 } |
| 159 |
| 160 void PpbWebSocketRpcServer::PPB_WebSocket_SendMessage( |
| 161 NaClSrpcRpc* rpc, |
| 162 NaClSrpcClosure* done, |
| 163 // inputs |
| 164 PP_Resource ws, |
| 165 nacl_abi_size_t message_size, |
| 166 char* message_bytes, |
| 167 // outputs |
| 168 int32_t* pp_error) { |
| 169 NaClSrpcClosureRunner runner(done); |
| 170 rpc->result = NACL_SRPC_RESULT_APP_ERROR; |
| 171 |
| 172 PP_Var message; |
| 173 if (!DeserializeTo(message_bytes, message_size, 1, &message)) |
| 174 return; |
| 175 |
| 176 *pp_error = PPBWebSocketInterface()->SendMessage(ws, message); |
| 177 DebugPrintf("PPB_WebSocket::SendMessage: pp_error=%"NACL_PRId32"\n", |
| 178 *pp_error); |
| 179 |
| 180 rpc->result = NACL_SRPC_RESULT_OK; |
| 181 } |
| 182 |
| 183 void PpbWebSocketRpcServer::PPB_WebSocket_GetBufferedAmount( |
| 184 NaClSrpcRpc* rpc, |
| 185 NaClSrpcClosure* done, |
| 186 // inputs |
| 187 PP_Resource ws, |
| 188 // outputs |
| 189 int64_t* buffered_amount) { |
| 190 NaClSrpcClosureRunner runner(done); |
| 191 rpc->result = NACL_SRPC_RESULT_APP_ERROR; |
| 192 |
| 193 *buffered_amount = static_cast<int64_t>( |
| 194 PPBWebSocketInterface()->GetBufferedAmount(ws)); |
| 195 DebugPrintf("PPB_WebSocket::GetBufferedAmount: buffered_amount=%lu\n", |
| 196 *buffered_amount); |
| 197 |
| 198 rpc->result = NACL_SRPC_RESULT_OK; |
| 199 } |
| 200 |
| 201 void PpbWebSocketRpcServer::PPB_WebSocket_GetCloseCode( |
| 202 NaClSrpcRpc* rpc, |
| 203 NaClSrpcClosure* done, |
| 204 // inputs |
| 205 PP_Resource ws, |
| 206 // outputs |
| 207 int32_t* close_code) { |
| 208 NaClSrpcClosureRunner runner(done); |
| 209 rpc->result = NACL_SRPC_RESULT_APP_ERROR; |
| 210 |
| 211 *close_code = static_cast<int32_t>( |
| 212 PPBWebSocketInterface()->GetCloseCode(ws)); |
| 213 DebugPrintf("PPB_WebSocket::GetCloseCode: close_code=%d\n", *close_code); |
| 214 |
| 215 rpc->result = NACL_SRPC_RESULT_OK; |
| 216 } |
| 217 |
| 218 void PpbWebSocketRpcServer::PPB_WebSocket_GetCloseReason( |
| 219 NaClSrpcRpc* rpc, |
| 220 NaClSrpcClosure* done, |
| 221 // inputs |
| 222 PP_Resource ws, |
| 223 // outputs |
| 224 nacl_abi_size_t* reason_size, |
| 225 char* reason_bytes) { |
| 226 NaClSrpcClosureRunner runner(done); |
| 227 rpc->result = NACL_SRPC_RESULT_APP_ERROR; |
| 228 |
| 229 PP_Var reason = PPBWebSocketInterface()->GetCloseReason(ws); |
| 230 DebugPrintf("PPB_WebSocket::GetCloseReason:: reason.type=%d\n", reason.type); |
| 231 |
| 232 if (SerializeTo(&reason, reason_bytes, reason_size)) |
| 233 rpc->result = NACL_SRPC_RESULT_OK; |
| 234 } |
| 235 |
| 236 void PpbWebSocketRpcServer::PPB_WebSocket_GetCloseWasClean( |
| 237 NaClSrpcRpc* rpc, |
| 238 NaClSrpcClosure* done, |
| 239 // inputs |
| 240 PP_Resource ws, |
| 241 // outputs |
| 242 int32_t* was_clean) { |
| 243 NaClSrpcClosureRunner runner(done); |
| 244 rpc->result = NACL_SRPC_RESULT_APP_ERROR; |
| 245 |
| 246 PP_Bool pp_was_clean = PPBWebSocketInterface()->GetCloseWasClean(ws); |
| 247 *was_clean = PP_ToBool(pp_was_clean); |
| 248 DebugPrintf("PPB_WebSocket::GetCloseWasClean: was_clean=%d\n", *was_clean); |
| 249 rpc->result = NACL_SRPC_RESULT_OK; |
| 250 } |
| 251 |
| 252 void PpbWebSocketRpcServer::PPB_WebSocket_GetExtensions( |
| 253 NaClSrpcRpc* rpc, |
| 254 NaClSrpcClosure* done, |
| 255 // inputs |
| 256 PP_Resource ws, |
| 257 // outputs |
| 258 nacl_abi_size_t* extensions_size, |
| 259 char* extensions_bytes) { |
| 260 NaClSrpcClosureRunner runner(done); |
| 261 rpc->result = NACL_SRPC_RESULT_APP_ERROR; |
| 262 |
| 263 PP_Var extensions = PPBWebSocketInterface()->GetExtensions(ws); |
| 264 DebugPrintf("PPB_WebSocket::GetExtensions:: extensions.type=%d\n", |
| 265 extensions.type); |
| 266 |
| 267 if (SerializeTo(&extensions, extensions_bytes, extensions_size)) |
| 268 rpc->result = NACL_SRPC_RESULT_OK; |
| 269 } |
| 270 |
| 271 void PpbWebSocketRpcServer::PPB_WebSocket_GetProtocol( |
| 272 NaClSrpcRpc* rpc, |
| 273 NaClSrpcClosure* done, |
| 274 // inputs |
| 275 PP_Resource ws, |
| 276 // outputs |
| 277 nacl_abi_size_t* protocol_size, |
| 278 char* protocol_bytes) { |
| 279 NaClSrpcClosureRunner runner(done); |
| 280 rpc->result = NACL_SRPC_RESULT_APP_ERROR; |
| 281 |
| 282 PP_Var protocol = PPBWebSocketInterface()->GetProtocol(ws); |
| 283 DebugPrintf("PPB_WebSocket::GetProtocol:: protocol.type=%d\n", |
| 284 protocol.type); |
| 285 |
| 286 if (SerializeTo(&protocol, protocol_bytes, protocol_size)) |
| 287 rpc->result = NACL_SRPC_RESULT_OK; |
| 288 } |
| 289 |
| 290 void PpbWebSocketRpcServer::PPB_WebSocket_GetReadyState( |
| 291 NaClSrpcRpc* rpc, |
| 292 NaClSrpcClosure* done, |
| 293 // inputs |
| 294 PP_Resource ws, |
| 295 // outputs |
| 296 int32_t* ready_state) { |
| 297 NaClSrpcClosureRunner runner(done); |
| 298 rpc->result = NACL_SRPC_RESULT_APP_ERROR; |
| 299 |
| 300 *ready_state = static_cast<int32_t>( |
| 301 PPBWebSocketInterface()->GetReadyState(ws)); |
| 302 DebugPrintf("PPB_WebSocket::GetReadyState:: ready_state=%d\n", ready_state); |
| 303 |
| 304 rpc->result = NACL_SRPC_RESULT_OK; |
| 305 } |
| 306 |
| 307 void PpbWebSocketRpcServer::PPB_WebSocket_GetURL( |
| 308 NaClSrpcRpc* rpc, |
| 309 NaClSrpcClosure* done, |
| 310 // inputs |
| 311 PP_Resource ws, |
| 312 // outputs |
| 313 nacl_abi_size_t* url_size, |
| 314 char* url_bytes) { |
| 315 NaClSrpcClosureRunner runner(done); |
| 316 rpc->result = NACL_SRPC_RESULT_APP_ERROR; |
| 317 |
| 318 PP_Var url = PPBWebSocketInterface()->GetURL(ws); |
| 319 DebugPrintf("PPB_WebSocket::GetURL:: url.type=%d\n", url.type); |
| 320 |
| 321 if (SerializeTo(&url, url_bytes, url_size)) |
| 322 rpc->result = NACL_SRPC_RESULT_OK; |
| 323 } |
| 324 |
| 325 void PpbWebSocketRpcServer::PPB_WebSocket_SetBinaryType( |
| 326 NaClSrpcRpc* rpc, |
| 327 NaClSrpcClosure* done, |
| 328 // inputs |
| 329 PP_Resource ws, |
| 330 int32_t binary_type, |
| 331 // outputs |
| 332 int32_t* success) { |
| 333 NaClSrpcClosureRunner runner(done); |
| 334 rpc->result = NACL_SRPC_RESULT_APP_ERROR; |
| 335 |
| 336 PP_Bool pp_success = PPBWebSocketInterface()->SetBinaryType( |
| 337 ws, static_cast<PP_WebSocketBinaryType_Dev>(binary_type)); |
| 338 *success = PP_ToBool(pp_success); |
| 339 DebugPrintf("PPB_WebSocket::SetBinaryType:: success=%d\n", *success); |
| 340 |
| 341 rpc->result = NACL_SRPC_RESULT_OK; |
| 342 } |
| 343 |
| 344 void PpbWebSocketRpcServer::PPB_WebSocket_GetBinaryType( |
| 345 NaClSrpcRpc* rpc, |
| 346 NaClSrpcClosure* done, |
| 347 // inputs |
| 348 PP_Resource ws, |
| 349 // outputs |
| 350 int32_t* binary_type) { |
| 351 NaClSrpcClosureRunner runner(done); |
| 352 rpc->result = NACL_SRPC_RESULT_APP_ERROR; |
| 353 |
| 354 *binary_type = static_cast<int32_t>( |
| 355 PPBWebSocketInterface()->GetBinaryType(ws)); |
| 356 DebugPrintf( |
| 357 "PPB_WebSocket::GetBinaryType:: binary_type=%d\n", *binary_type); |
| 358 |
| 359 rpc->result = NACL_SRPC_RESULT_OK; |
| 360 } |
OLD | NEW |