WebSocket Pepper API: synchronous completion support

ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_websocket.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.
 
 #include "native_client/src/shared/ppapi_proxy/plugin_ppb_websocket.h"
 
 #include "native_client/src/include/nacl_scoped_ptr.h"
 #include "native_client/src/shared/ppapi_proxy/object_serialize.h"
 #include "native_client/src/shared/ppapi_proxy/plugin_callback.h"
 #include "native_client/src/shared/ppapi_proxy/plugin_globals.h"
@@ skipping 102 matching lines @@
   if (srpc_result != NACL_SRPC_RESULT_OK)
     pp_error = PP_ERROR_FAILED;
   return MayForceCallback(callback, pp_error);
 }
 
 int32_t ReceiveMessage(PP_Resource ws,
                        PP_Var* message,
                        PP_CompletionCallback callback) {
   DebugPrintf("PPB_WebSocket::ReceiveMessage: ws=%"NACL_PRId32"\n", ws);
 
+  if (message == NULL)
+    return PP_ERROR_FAILED;
   int32_t callback_id =
       CompletionCallbackTable::Get()->AddCallback(callback, message);
   if (callback_id == 0)
     return PP_ERROR_BLOCKS_MAIN_THREAD;
 
-  // TODO(toyoshim): ReceiveMessage needs performance optimization to reduce
-  // chances to call RPC.
+  nacl_abi_size_t async_message_size = kMaxReturnVarSize;
+  nacl::scoped_array<char> async_message_bytes(new char[async_message_size]);
+
   int32_t pp_error;
   NaClSrpcError srpc_result =
       PpbWebSocketRpcClient::PPB_WebSocket_ReceiveMessage(
           GetMainSrpcChannel(),
           ws,
           callback_id,
-          &pp_error);
+          &pp_error,
+          &async_message_size,
+          async_message_bytes.get());
   DebugPrintf("PPB_WebSocket::ReceiveMessage: %s\n",
       NaClSrpcErrorString(srpc_result));
 
   if (srpc_result != NACL_SRPC_RESULT_OK)
     pp_error = PP_ERROR_FAILED;
+
+  if (pp_error != PP_OK_COMPLETIONPENDING) {
+    // Consumes plugin callback and deserialize received data.
+    void* plugin_buffer;
+    PP_Var* plugin_var;
+    PP_CompletionCallback plugin_callback =
+        CompletionCallbackTable::Get()->RemoveCallback(callback_id,
+                                                       &plugin_buffer,
+                                                       &plugin_var);
+    if (plugin_callback.func != callback.func) {
+      DebugPrintf("PPB_WebSocket::ReceiveMessage: callbacks doesn't match\n");
+    } else if (plugin_var != message) {
+      DebugPrintf("PPB_WebSocket::ReceiveMessage: PP_Var doesn't match\n");

[dmichael (off chromium), 2012/04/02 03:28:01]

These two checks are just temporary while you debug, right? Could they be
DCHECKs once you have it working as you intend?

[Takashi Toyoshima, 2012/04/05 06:44:00]

Oops... yes that's right.
I should use DCHECK here.

+    } else {
+      DebugPrintf("PPB_WebSocket::ReceiveMessage: asynchronous completion\n");
+      if (pp_error == PP_OK) {
+        *message = PP_MakeUndefined();
+        if (!DeserializeTo(async_message_bytes.get(), async_message_size, 1,
+            message))
+          return PP_ERROR_FAILED;
+      }
+    }
+  }
+
   return MayForceCallback(callback, pp_error);
 }
 
 int32_t SendMessage(PP_Resource ws,
                     PP_Var message) {
   DebugPrintf("PPB_WebSocket::SendMessage: ws=%"NACL_PRId32"\n", ws);
 
   nacl_abi_size_t message_size = 0;
   nacl::scoped_array<char> message_bytes(
       Serialize(&message, 1, &message_size));
@@ skipping 167 matching lines @@
     &GetCloseWasClean,
     &GetExtensions,
     &GetProtocol,
     &GetReadyState,
     &GetURL
   };
   return &websocket_interface;
 }
 
 }  // namespace ppapi_proxy