PPAPI: Add more error testing for postMessageAndAwaitResponse

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>
@@ skipping 166 matching lines @@
                                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) {
+      handler_thread_(instance),
+      message_received_(instance->pp_instance()) {
 }
 
 TestMessageHandler::~TestMessageHandler() {
   handler_thread_.Join();
 }
 
 bool TestMessageHandler::Init() {
   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);
+  RUN_TEST(Exceptions, filter);
 }
 
 void TestMessageHandler::HandleMessage(const pp::Var& message_data) {
-  // All messages should go to the background thread message handler.
-  assert(false);
+  if (instance()->current_test_name() == "Exceptions") {
+    // For TestPostMessageAndAwaitResponse(), all messages should go to the
+    // background thread message handler.
+    assert(false);
+  } else {
+    if (message_data.is_string()) {
+      last_message_ = message_data.AsString();
+    } else {
+      last_message_ = "message_data was not a string!";
+    }
+    message_received_.Signal();
+  }
 }
 
 std::string TestMessageHandler::TestRegisterErrorConditions() {
   {
     // Test registering with the main thread as the message loop.
     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(
@@ skipping 17 matching lines @@
           handler_thread_.message_loop().pp_resource());
       ASSERT_EQ(PP_ERROR_BADARGUMENT, result);
     }
   }
   PASS();
 }
 
 std::string TestMessageHandler::TestPostMessageAndAwaitResponse() {
   EchoingMessageHandler handler(instance(),
                                 handler_thread_.message_loop());
+  // Test doing a sync call before the handler is registered.
   handler.Register();
   std::string js_code("var plugin = document.getElementById('plugin');\n");
   js_code += "var result = undefined;\n";
   const char* const values_to_test[] = {
       "5",
       "undefined",
       "1.5",
       "'hello'",
       "{'key': 'value', 'array_key': [1, 2, 3, 4, 5]}",
       NULL
@@ skipping 11 matching lines @@
   }
   instance_->EvalScript(js_code);
   instance_->EvalScript("plugin.postMessage('FINISHED_TEST');\n");
   handler.WaitForTestFinishedMessage();
   handler.Unregister();
   ASSERT_SUBTEST_SUCCESS(handler.WaitForDestroy());
 
   PASS();
 }
 
+std::string TestMessageHandler::TestExceptions() {
+  EchoingMessageHandler handler(instance(),
+                                handler_thread_.message_loop());
+  {
+    // First, try sending a blocking message when there is no handler
+    // registered. It should throw an exception.
+    std::string js_code(
+        "var plugin = document.getElementById('plugin');\n"
+        "var caught_exception = false;\n"
+        "try {\n"
+        "  plugin.postMessageAndAwaitResponse('Hello!');\n"
+        "} catch (err) {\n"
+        "  caught_exception = true;\n"
+        "}\n"
+        "plugin.postMessage(caught_exception ? 'SUCCESS' : 'FAIL');\n");
+    instance_->EvalScript(js_code);
+    message_received_.Wait();
+    ASSERT_EQ("SUCCESS", last_message_);
+  }
+  handler.Register();
+  {
+    // Now that a handler is registered, try requesting and sending a
+    // FileSystem. It should throw an exception. The file system is opened
+    // asynchronously. What *should* happen is that it opens successfully, then
+    // we try to send it via postMessageAndAwaitResponse, which fails with an
+    // exception. The test could fail either because the filesystem doesn't
+    // open or because postMessageAndAwaitResponse doesn't throw an exception.
+    std::string js_code(
+        "var plugin = document.getElementById('plugin');\n"
+        "function gotFileSystem(fs) {\n"
+        "  var caught_exception = false;\n"
+        "  try {\n"
+        "    plugin.postMessageAndAwaitResponse(fs);\n"
+        "  } catch (err) {\n"
+        "    caught_exception = true;\n"
+        "  }\n"
+        "  plugin.postMessage(caught_exception ? 'SUCCESS' : 'FAIL');\n"
+        "}\n"
+        "function fileSystemError() {\n"
+        "  plugin.postMessage('Failed to open filesystem');\n"
+        "}\n"
+        "window.webkitRequestFileSystem(\n"
+        "    window.Temporary, 1024, gotFileSystem, fileSystemError)\n");
+    instance_->EvalScript(js_code);
+    message_received_.Wait();
+    ASSERT_EQ("SUCCESS", last_message_);
+  }
+  handler.Unregister();
+  ASSERT_SUBTEST_SUCCESS(handler.WaitForDestroy());
+
+  PASS();
+}
+