WebSocket Pepper API: SRPC proxy implementation

ppapi/native_client/src/shared/ppapi_proxy/browser_ppb_websocket_rpc_server.cc

+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// SRPC-abstraction wrappers around PPB_WebSocket functions.
+
+#include "native_client/src/include/nacl_scoped_ptr.h"
+#include "native_client/src/shared/ppapi_proxy/browser_callback.h"
+#include "native_client/src/shared/ppapi_proxy/browser_globals.h"
+#include "native_client/src/shared/ppapi_proxy/object_serialize.h"
+#include "native_client/src/shared/ppapi_proxy/utility.h"
+#include "ppapi/c/pp_completion_callback.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/c/dev/ppb_websocket_dev.h"
+#include "srpcgen/ppb_rpc.h"
+
+using ppapi_proxy::DebugPrintf;
+using ppapi_proxy::DeleteRemoteCallbackInfo;
+using ppapi_proxy::DeserializeTo;
+using ppapi_proxy::MakeRemoteCompletionCallback;
+using ppapi_proxy::PPBWebSocketInterface;
+using ppapi_proxy::SerializeTo;
+
+void PpbWebSocketRpcServer::PPB_WebSocket_Create(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // inputsless

[dmichael (off chromium), 2012/01/17 23:32:45]

inputsless -> inputs?

[Takashi Toyoshima, 2012/01/18 11:07:16]

Done.
PPB_URLLoader_Create looks having the same nits.

+    PP_Instance instance,
+    // outputs
+    PP_Resource* resource) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  *resource = PPBWebSocketInterface()->Create(instance);
+  DebugPrintf("PPB_WebSocket::Create: resource=%"NACL_PRIu32"\n", *resource);

[dmichael (off chromium), 2012/01/17 23:32:45]

Should that be NACL_PRId32?

[Takashi Toyoshima, 2012/01/18 11:07:16]

I see. PP_Resource is defined as typedef int32_t PP_Resource;.
As you said, I must use d32 instead of u32.
I fixed this line, but many implements in ppapi_proxy use the same idiom.
I'll prepare another CL to fix nits in them.

[dmichael (off chromium), 2012/01/18 17:04:40]

Thanks!

+
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbWebSocketRpcServer::PPB_WebSocket_IsWebSocket(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // inputs
+    PP_Resource resource,
+    // outputs
+    int32_t* success) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  PP_Bool pp_success = PPBWebSocketInterface()->IsWebSocket(resource);
+  DebugPrintf("PPB_WebSocket::IsWebSocket: pp_success=%d\n", pp_success);

[dmichael (off chromium), 2012/01/17 23:32:45]

nit: It's probably safest to do static_cast<int>(pp_success)

[Takashi Toyoshima, 2012/01/18 11:07:16]

I found a good sample which use *success after PP_ToBool().
I'll follow this style.

+
+  *success = (pp_success == PP_TRUE);

[dmichael (off chromium), 2012/01/17 23:32:45]

We usually use PP_ToBool() and PP_FromBool for these conversions.

[Takashi Toyoshima, 2012/01/18 11:07:16]

Oh, sorry.
I remember you taught me this before.
Done.

+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbWebSocketRpcServer::PPB_WebSocket_Connect(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // inputs
+    PP_Resource ws,
+    nacl_abi_size_t url_size,
+    char* url_bytes,
+    nacl_abi_size_t protocols_size,
+    char* protocols_bytes,
+    int32_t protocol_count,
+    int32_t callback_id,
+    // outputs
+    int32_t* pp_error) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  PP_CompletionCallback remote_callback =
+      MakeRemoteCompletionCallback(rpc->channel, callback_id);
+  if (NULL == remote_callback.func)
+    return;
+
+  PP_Var url;
+  if (!DeserializeTo(url_bytes, url_size, 1, &url))
+    return;
+
+  nacl::scoped_array<PP_Var> protocols(new PP_Var[protocol_count]);
+  if (!DeserializeTo(
+      protocols_bytes, protocols_size, protocol_count, protocols.get()))
+    return;
+
+  *pp_error = PPBWebSocketInterface()->Connect(
+      ws,
+      url,
+      protocols.get(),
+      static_cast<uint32_t>(protocol_count),
+      remote_callback);
+  DebugPrintf("PPB_WebSocket::Connect: pp_error=%"NACL_PRId32"\n", *pp_error);
+
+  if (*pp_error != PP_OK_COMPLETIONPENDING)
+    DeleteRemoteCallbackInfo(remote_callback);
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbWebSocketRpcServer::PPB_WebSocket_Close(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // inputs
+    PP_Resource ws,
+    int32_t code,
+    nacl_abi_size_t reason_size,
+    char* reason_bytes,
+    int32_t callback_id,
+    // outputs
+    int32_t* pp_error) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  PP_CompletionCallback remote_callback =
+      MakeRemoteCompletionCallback(rpc->channel, callback_id);
+  if (NULL == remote_callback.func)
+    return;
+
+  PP_Var reason;
+  if (!DeserializeTo(reason_bytes, reason_size, 1, &reason))
+    return;
+
+  *pp_error = PPBWebSocketInterface()->Close(
+      ws, code, reason, remote_callback);
+  DebugPrintf("PPB_WebSocket::Close: pp_error=%"NACL_PRId32"\n", *pp_error);
+
+  if (*pp_error != PP_OK_COMPLETIONPENDING)
+    DeleteRemoteCallbackInfo(remote_callback);
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbWebSocketRpcServer::PPB_WebSocket_ReceiveMessage(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // inputs
+    PP_Resource ws,
+    int32_t callback_id,
+    // outputs
+    int32_t* pp_error) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  PP_Var* callback_var = NULL;
+  PP_CompletionCallback remote_callback =
+      MakeRemoteCompletionCallback(rpc->channel, callback_id, &callback_var);
+  if (NULL == remote_callback.func)
+    return;
+
+  *pp_error = PPBWebSocketInterface()->ReceiveMessage(
+      ws, callback_var, remote_callback);
+  DebugPrintf("PPB_WebSocket::ReceiveMessage: pp_error=%"NACL_PRId32"\n",
+      *pp_error);
+
+  if (*pp_error != PP_OK_COMPLETIONPENDING)
+    DeleteRemoteCallbackInfo(remote_callback);
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbWebSocketRpcServer::PPB_WebSocket_SendMessage(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // inputs
+    PP_Resource ws,
+    nacl_abi_size_t message_size,
+    char* message_bytes,
+    // outputs
+    int32_t* pp_error) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  PP_Var message;
+  if (!DeserializeTo(message_bytes, message_size, 1, &message))
+    return;
+
+  *pp_error = PPBWebSocketInterface()->SendMessage(ws, message);
+  DebugPrintf("PPB_WebSocket::SendMessage: pp_error=%"NACL_PRId32"\n",
+      *pp_error);
+
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbWebSocketRpcServer::PPB_WebSocket_GetBufferedAmount(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // inputs
+    PP_Resource ws,
+    // outputs
+    int64_t* buffered_amount) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  *buffered_amount = static_cast<int64_t>(
+      PPBWebSocketInterface()->GetBufferedAmount(ws));
+  DebugPrintf("PPB_WebSocket::GetBufferedAmount: buffered_amount=%lu\n",
+      *buffered_amount);
+
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbWebSocketRpcServer::PPB_WebSocket_GetCloseCode(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // inputs
+    PP_Resource ws,
+    // outputs
+    int32_t* close_code) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  *close_code = static_cast<int32_t>(
+      PPBWebSocketInterface()->GetCloseCode(ws));
+  DebugPrintf("PPB_WebSocket::GetCloseCode: close_code=%d\n", *close_code);
+
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbWebSocketRpcServer::PPB_WebSocket_GetCloseReason(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // inputs
+    PP_Resource ws,
+    // outputs
+    nacl_abi_size_t* reason_size,
+    char* reason_bytes) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  PP_Var reason = PPBWebSocketInterface()->GetCloseReason(ws);
+  DebugPrintf("PPB_WebSocket::GetCloseReason:: reason.type=%d\n", reason.type);
+
+  if (SerializeTo(&reason, reason_bytes, reason_size))
+    rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbWebSocketRpcServer::PPB_WebSocket_GetCloseWasClean(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // inputs
+    PP_Resource ws,
+    // outputs
+    int32_t* was_clean) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  PP_Bool pp_was_clean = PPBWebSocketInterface()->GetCloseWasClean(ws);
+  DebugPrintf("PPB_WebSocket::GetCloseWasClean: pp_was_clean=%d\n",
+      pp_was_clean);
+
+  *was_clean = (pp_was_clean == PP_TRUE);
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbWebSocketRpcServer::PPB_WebSocket_GetExtensions(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // inputs
+    PP_Resource ws,
+    // outputs
+    nacl_abi_size_t* extensions_size,
+    char* extensions_bytes) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  PP_Var extensions = PPBWebSocketInterface()->GetExtensions(ws);
+  DebugPrintf("PPB_WebSocket::GetExtensions:: extensions.type=%d\n",
+      extensions.type);
+
+  if (SerializeTo(&extensions, extensions_bytes, extensions_size))
+    rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbWebSocketRpcServer::PPB_WebSocket_GetProtocol(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // inputs
+    PP_Resource ws,
+    // outputs
+    nacl_abi_size_t* protocol_size,
+    char* protocol_bytes) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  PP_Var protocol = PPBWebSocketInterface()->GetProtocol(ws);
+  DebugPrintf("PPB_WebSocket::GetProtocol:: protocol.type=%d\n",
+      protocol.type);
+
+  if (SerializeTo(&protocol, protocol_bytes, protocol_size))
+    rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbWebSocketRpcServer::PPB_WebSocket_GetReadyState(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // inputs
+    PP_Resource ws,
+    // outputs
+    int32_t* ready_state) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  *ready_state = static_cast<int32_t>(
+      PPBWebSocketInterface()->GetReadyState(ws));
+  DebugPrintf("PPB_WebSocket::GetReadyState:: ready_state=%d\n", ready_state);
+
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbWebSocketRpcServer::PPB_WebSocket_GetURL(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // inputs
+    PP_Resource ws,
+    // outputs
+    nacl_abi_size_t* url_size,
+    char* url_bytes) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  PP_Var url = PPBWebSocketInterface()->GetURL(ws);
+  DebugPrintf("PPB_WebSocket::GetURL:: url.type=%d\n", url.type);
+
+  if (SerializeTo(&url, url_bytes, url_size))
+    rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbWebSocketRpcServer::PPB_WebSocket_SetBinaryType(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // inputs
+    PP_Resource ws,
+    int32_t binary_type,
+    // outputs
+    int32_t* success) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  PP_Bool pp_success = PPBWebSocketInterface()->SetBinaryType(
+      ws, static_cast<PP_WebSocketBinaryType_Dev>(binary_type));
+  DebugPrintf("PPB_WebSocket::SetBinaryType:: success=%d\n", pp_success);
+
+  *success = (pp_success == PP_TRUE);
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void PpbWebSocketRpcServer::PPB_WebSocket_GetBinaryType(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // inputs
+    PP_Resource ws,
+    // outputs
+    int32_t* binary_type) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  *binary_type = static_cast<int32_t>(
+      PPBWebSocketInterface()->GetBinaryType(ws));
+  DebugPrintf(
+      "PPB_WebSocket::GetBinaryType:: binary_type=%d\n", *binary_type);
+
+  rpc->result = NACL_SRPC_RESULT_OK;
+}