PPAPI: Make PPP_MessageHandler work in PNaCl

ppapi/tests/test_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/tests/test_message_handler.h"
 
 #include <string.h>
 #include <algorithm>
 #include <map>
 #include <sstream>
 
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_file_io.h"
+#include "ppapi/c/ppb_messaging.h"
 #include "ppapi/c/ppp_message_handler.h"
 #include "ppapi/cpp/file_io.h"
 #include "ppapi/cpp/file_ref.h"
 #include "ppapi/cpp/file_system.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module_impl.h"
 #include "ppapi/cpp/var.h"
 #include "ppapi/cpp/var_array.h"
 #include "ppapi/cpp/var_array_buffer.h"
 #include "ppapi/cpp/var_dictionary.h"
@@ skipping 12 matching lines @@
 
 // Created and destroyed on the main thread. All public methods should be called
 // on the main thread. Most data members are only accessed on the main thread.
 // (Though it handles messages on the background thread).
 class EchoingMessageHandler {
  public:
   explicit EchoingMessageHandler(PP_Instance instance,
                                  const pp::MessageLoop& loop)
       : pp_instance_(instance),
         message_handler_loop_(loop),
-        ppb_messaging_if_(static_cast<const PPB_Messaging_1_1*>(
+        ppb_messaging_if_(static_cast<const PPB_Messaging_1_2*>(
             pp::Module::Get()->GetBrowserInterface(
-                PPB_MESSAGING_INTERFACE_1_1))),
+                PPB_MESSAGING_INTERFACE_1_2))),
         ppp_message_handler_if_(),
         is_registered_(false),
         test_finished_event_(instance),
         destroy_event_(instance) {
     AssertOnMainThread();
     ppp_message_handler_if_.HandleMessage = &HandleMessage;
     ppp_message_handler_if_.HandleBlockingMessage = &HandleBlockingMessage;
     ppp_message_handler_if_.Destroy = &Destroy;
   }
   void Register() {
@@ skipping 48 matching lines @@
   }
   void AddError(const std::string& error) {
     if (!error.empty()) {
       if (!errors_.empty())
         errors_ += "<p>";
       errors_ += error;
     }
   }
   static void HandleMessage(PP_Instance instance,
                             void* user_data,
-                            struct PP_Var message_data) {
+                            const PP_Var* message_data) {
     EchoingMessageHandler* thiz =
         static_cast<EchoingMessageHandler*>(user_data);
     if (pp::MessageLoop::GetCurrent() != thiz->message_handler_loop_)
       thiz->AddError("HandleMessage was called on the wrong thread!");
     if (instance != thiz->pp_instance_)
       thiz->AddError("HandleMessage was passed the wrong instance!");
-    pp::Var var(message_data);
+    pp::Var var(*message_data);
     if (var.is_string() && var.AsString() == "FINISHED_TEST")
       thiz->test_finished_event_.Signal();
     else
-      thiz->ppb_messaging_if_->PostMessage(instance, message_data);
+      thiz->ppb_messaging_if_->PostMessage(instance, *message_data);
   }
 
-  static PP_Var HandleBlockingMessage(PP_Instance instance,
-                                      void* user_data,
-                                      struct PP_Var message_data) {
+  static void HandleBlockingMessage(PP_Instance instance,
+                                    void* user_data,
+                                    const PP_Var* message_data,
+                                    PP_Var* result) {
     EchoingMessageHandler* thiz =
         static_cast<EchoingMessageHandler*>(user_data);
     if (pp::MessageLoop::GetCurrent() != thiz->message_handler_loop_)
       thiz->AddError("HandleBlockingMessage was called on the wrong thread!");
     if (instance != thiz->pp_instance_)
       thiz->AddError("HandleBlockingMessage was passed the wrong instance!");
 
     // The PP_Var we are passed is an in-parameter, so the browser is not
     // giving us a ref-count. The ref-count it has will be decremented after we
     // return. But we need to add a ref when returning a PP_Var, to pass to the
     // caller.
-    pp::Var take_ref(message_data);
+    pp::Var take_ref(*message_data);
     take_ref.Detach();
-    return message_data;
+    *result = *message_data;
   }
 
   static void Destroy(PP_Instance instance, void* user_data) {
     EchoingMessageHandler* thiz =
         static_cast<EchoingMessageHandler*>(user_data);
     if (pp::MessageLoop::GetCurrent() != thiz->message_handler_loop_)
       thiz->AddError("Destroy was called on the wrong thread!");
     if (instance != thiz->pp_instance_)
       thiz->AddError("Destroy was passed the wrong instance!");
     thiz->destroy_event_.Signal();
   }
 
   // These data members are initialized on the main thread, but don't change for
   // the life of the object, so are safe to access on the background thread,
   // because there will be a memory barrier before the the MessageHandler calls
   // are invoked.
   const PP_Instance pp_instance_;
   const pp::MessageLoop message_handler_loop_;
   const pp::MessageLoop main_loop_;
-  const PPB_Messaging_1_1* const ppb_messaging_if_;
+  const PPB_Messaging_1_2* const ppb_messaging_if_;
   // Spiritually, this member is const, but we can't initialize it in C++03,
   // so it has to be non-const to be set in the constructor body.
-  PPP_MessageHandler_0_1 ppp_message_handler_if_;
+  PPP_MessageHandler_0_2 ppp_message_handler_if_;
 
   // is_registered_ is only read/written on the main thread.
   bool is_registered_;
 
   // errors_ is written on the MessageHandler thread. When Destroy() is
   // called, we stop writing to errors_ and signal destroy_event_. This causes
   // a memory barrier, so it's safe to read errors_ after that.
   std::string errors_;
   NestedEvent test_finished_event_;
   NestedEvent destroy_event_;
 
   // Undefined & private to disallow copy and assign.
   EchoingMessageHandler(const EchoingMessageHandler&);
   EchoingMessageHandler& operator=(const EchoingMessageHandler&);
 };
 
 void FakeHandleMessage(PP_Instance instance,
                        void* user_data,
-                       struct PP_Var message_data) {}
-PP_Var FakeHandleBlockingMessage(PP_Instance instance,
-                                 void* user_data,
-                                 struct PP_Var message_data) {
-  return PP_MakeUndefined();
-}
+                       const PP_Var* message_data) {}
+void FakeHandleBlockingMessage(PP_Instance instance,
+                               void* user_data,
+                               const PP_Var* message_data,
+                               PP_Var* result) {}
 void FakeDestroy(PP_Instance instance, void* user_data) {}
 
 }  // namespace
 
 TestMessageHandler::TestMessageHandler(TestingInstance* instance)
     : TestCase(instance),
       ppb_messaging_if_(NULL),
       handler_thread_(instance) {
 }
 
 TestMessageHandler::~TestMessageHandler() {
   handler_thread_.Join();
 }
 
 bool TestMessageHandler::Init() {
-  ppb_messaging_if_ = static_cast<const PPB_Messaging_1_1*>(
-      pp::Module::Get()->GetBrowserInterface(PPB_MESSAGING_INTERFACE_1_1));
+  ppb_messaging_if_ = static_cast<const PPB_Messaging_1_2*>(
+      pp::Module::Get()->GetBrowserInterface(PPB_MESSAGING_INTERFACE_1_2));
   return ppb_messaging_if_ &&
          CheckTestingInterface() &&
          handler_thread_.Start();
 }
 
 void TestMessageHandler::RunTests(const std::string& filter) {
   RUN_TEST(RegisterErrorConditions, filter);
   RUN_TEST(PostMessageAndAwaitResponse, filter);
 }
 
 void TestMessageHandler::HandleMessage(const pp::Var& message_data) {
   // All messages should go to the background thread message handler.
   assert(false);
 }
 
 std::string TestMessageHandler::TestRegisterErrorConditions() {
   {
     // Test registering with the main thread as the message loop.
-    PPP_MessageHandler_0_1 fake_ppp_message_handler = {
+    PPP_MessageHandler_0_2 fake_ppp_message_handler = {
       &FakeHandleMessage, &FakeHandleBlockingMessage, &FakeDestroy
     };
     pp::MessageLoop main_loop = pp::MessageLoop::GetForMainThread();
     int32_t result = ppb_messaging_if_->RegisterMessageHandler(
         instance()->pp_instance(),
         reinterpret_cast<void*>(0xdeadbeef),
         &fake_ppp_message_handler,
         main_loop.pp_resource());
     ASSERT_EQ(PP_ERROR_WRONG_THREAD, result);
   }
   {
     // Test registering with incomplete PPP_Messaging interface.
-    PPP_MessageHandler_0_1 bad_ppp_ifs[] = {
+    PPP_MessageHandler_0_2 bad_ppp_ifs[] = {
         { NULL, &FakeHandleBlockingMessage, &FakeDestroy },
         { &FakeHandleMessage, NULL, &FakeDestroy },
         { &FakeHandleMessage, &FakeHandleBlockingMessage, NULL }};
     for (size_t i = 0; i < sizeof(bad_ppp_ifs)/sizeof(bad_ppp_ifs[0]); ++i) {
       int32_t result = ppb_messaging_if_->RegisterMessageHandler(
           instance()->pp_instance(),
           reinterpret_cast<void*>(0xdeadbeef),
           &bad_ppp_ifs[i],
           handler_thread_.message_loop().pp_resource());
       ASSERT_EQ(PP_ERROR_BADARGUMENT, result);
@@ skipping 34 matching lines @@
   // That should be fixed before this API goes to stable. See crbug.com/384528
   js_code += "plugin.postMessage('FINISHED_TEST');\n";
   instance_->EvalScript(js_code);
   handler.WaitForTestFinishedMessage();
   handler.Unregister();
   ASSERT_SUBTEST_SUCCESS(handler.WaitForDestroy());
 
   PASS();
 }