PPAPI: Make PPP_MessageHandler work in PNaCl

ppapi/proxy/message_handler.cc

 // Copyright 2014 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 "ppapi/proxy/message_handler.h"
 
 #include "ipc/ipc_message.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppb_message_loop_proxy.h"
 #include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/shared_impl/scoped_pp_var.h"
 #include "ppapi/thunk/enter.h"
 
 namespace ppapi {
 namespace proxy {
 namespace {
 
-typedef void (*HandleMessageFunc)(PP_Instance, void*, PP_Var);
-typedef PP_Var (*HandleBlockingMessageFunc)(PP_Instance, void*, PP_Var);
+typedef void (*HandleMessageFunc)(PP_Instance, void*, const PP_Var*);
+typedef void (*HandleBlockingMessageFunc)(
+    PP_Instance, void*, const PP_Var*, PP_Var*);
 
 void HandleMessageWrapper(HandleMessageFunc function,
                           PP_Instance instance,
                           void* user_data,
                           ScopedPPVar message_data) {
-  CallWhileUnlocked(function, instance, user_data, message_data.get());
+  CallWhileUnlocked(function, instance, user_data,
+                    const_cast<const PP_Var*>(&message_data.get()));

[teravest, 2014/09/11 15:42:41]

As discussed off-thread, the const_cast<> here looks weird, but I don't think
you need to make any changes to CallWhileUnlocked to handle that better in this
change.

 }
 
 void HandleBlockingMessageWrapper(HandleBlockingMessageFunc function,
                                   PP_Instance instance,
                                   void* user_data,
                                   ScopedPPVar message_data,
                                   scoped_ptr<IPC::Message> reply_msg) {
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return;
-  PP_Var return_value = CallWhileUnlocked(function,
-                                          instance,
-                                          user_data,
-                                          message_data.get());
+  PP_Var result = PP_MakeUndefined();
+  CallWhileUnlocked(function, instance, user_data,
+      const_cast<const PP_Var*>(&message_data.get()), &result);
   PpapiMsg_PPPMessageHandler_HandleBlockingMessage::WriteReplyParams(
       reply_msg.get(),
-      SerializedVarReturnValue::Convert(dispatcher, return_value),
+      SerializedVarReturnValue::Convert(dispatcher, result),
       true /* was_handled */);
   dispatcher->Send(reply_msg.release());
 }
 
 }  // namespace
 
 // static
 scoped_ptr<MessageHandler> MessageHandler::Create(
       PP_Instance instance,
-      const PPP_MessageHandler_0_1* handler_if,
+      const PPP_MessageHandler_0_2* handler_if,
       void* user_data,
       PP_Resource message_loop,
       int32_t* error) {
   scoped_ptr<MessageHandler> result;
   // The interface and all function pointers must be valid.
   if (!handler_if ||
       !handler_if->HandleMessage ||
       !handler_if->HandleBlockingMessage ||
       !handler_if->Destroy) {
     *error = PP_ERROR_BADARGUMENT;
@@ skipping 50 matching lines @@
       RunWhileLocked(base::Bind(&HandleBlockingMessageWrapper,
                                 handler_if_->HandleBlockingMessage,
                                 instance_,
                                 user_data_,
                                 var,
                                 base::Passed(reply_msg.Pass()))));
 }
 
 MessageHandler::MessageHandler(
     PP_Instance instance,
-    const PPP_MessageHandler_0_1* handler_if,
+    const PPP_MessageHandler_0_2* handler_if,
     void* user_data,
     scoped_refptr<MessageLoopResource> message_loop)
     : instance_(instance),
       handler_if_(handler_if),
       user_data_(user_data),
       message_loop_(message_loop) {
 }
 
 }  // namespace proxy
 }  // namespace ppapi