Fix PPB_Flash_MessageLoop.

ppapi/tests/test_flash_message_loop.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 "ppapi/tests/test_flash_message_loop.h"
 
 #include "ppapi/c/pp_macros.h"
+#include "ppapi/c/ppb_var.h"
 #include "ppapi/cpp/core.h"
+#include "ppapi/cpp/dev/scriptable_object_deprecated.h"
 #include "ppapi/cpp/logging.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/private/flash_message_loop.h"
 #include "ppapi/tests/testing_instance.h"
 
+namespace {
+
+const char kDidRunScriptCallback[] = "DidRunScriptCallback";
+
+}  // namespace
+
+class TestFlashMessageLoop::InstanceSO
+    : public pp::deprecated::ScriptableObject {
+ public:
+  explicit InstanceSO(TestFlashMessageLoop* owner) : owner_(owner) {}
+
+  ~InstanceSO() override {
+    if (owner_)
+      owner_->clear_instance_so();
+  }
+
+  // pp::deprecated::ScriptableObject overrides.
+  bool HasMethod(const pp::Var& name, pp::Var* exception) override {
+    if (!name.is_string())
+      return false;
+    return name.AsString() == kDidRunScriptCallback;
+  }
+
+  pp::Var Call(const pp::Var& method_name,
+               const std::vector<pp::Var>& args,
+               pp::Var* exception) override {
+    if (!method_name.is_string())
+      return false;
+    std::string name = method_name.AsString();
+
+    if (name == kDidRunScriptCallback) {
+      if (args.size() != 0) {
+        *exception = pp::Var("Bad argument to DidRunScriptCallback()");
+      } else if (owner_) {
+        owner_->DidRunScriptCallback();
+      }
+    } else {
+      *exception = pp::Var("Bad function call");
+    }
+
+    return pp::Var();
+  }
+
+  void clear_owner() { owner_ = nullptr; }
+
+ private:
+  TestFlashMessageLoop* owner_;
+};
+
 REGISTER_TEST_CASE(FlashMessageLoop);
 
 TestFlashMessageLoop::TestFlashMessageLoop(TestingInstance* instance)
     : TestCase(instance),
-      message_loop_(NULL),
-      callback_factory_(this) {
-}
+      message_loop_(nullptr),
+      instance_so_(nullptr),
+      suspend_script_callback_result_(false),
+      callback_factory_(this) {}
 
 TestFlashMessageLoop::~TestFlashMessageLoop() {
   PP_DCHECK(!message_loop_);
+
+  ResetTestObject();
+  if (instance_so_)
+    instance_so_->clear_owner();
 }
 
 void TestFlashMessageLoop::RunTests(const std::string& filter) {
   RUN_TEST(Basics, filter);
   RUN_TEST(RunWithoutQuit, filter);
+  RUN_TEST(SuspendScriptCallbackWhileRunning, filter);
+}
+
+void TestFlashMessageLoop::DidRunScriptCallback() {
+  // Script callbacks are not supposed to run while the Flash message loop is
+  // running.
+  if (message_loop_)
+    suspend_script_callback_result_ = false;
+}
+
+pp::deprecated::ScriptableObject* TestFlashMessageLoop::CreateTestObject() {
+  if (!instance_so_)
+    instance_so_ = new InstanceSO(this);
+  return instance_so_;
 }
 
 std::string TestFlashMessageLoop::TestBasics() {
   message_loop_ = new pp::flash::MessageLoop(instance_);
 
   pp::CompletionCallback callback = callback_factory_.NewCallback(
       &TestFlashMessageLoop::QuitMessageLoopTask);
   pp::Module::Get()->core()->CallOnMainThread(0, callback);
   int32_t result = message_loop_->Run();
 
   ASSERT_TRUE(message_loop_);
   delete message_loop_;
-  message_loop_ = NULL;
+  message_loop_ = nullptr;
 
   ASSERT_EQ(PP_OK, result);
   PASS();
 }
 
 std::string TestFlashMessageLoop::TestRunWithoutQuit() {
   message_loop_ = new pp::flash::MessageLoop(instance_);
 
   pp::CompletionCallback callback = callback_factory_.NewCallback(
       &TestFlashMessageLoop::DestroyMessageLoopResourceTask);
   pp::Module::Get()->core()->CallOnMainThread(0, callback);
   int32_t result = message_loop_->Run();
 
   if (message_loop_) {
     delete message_loop_;
-    message_loop_ = NULL;
+    message_loop_ = nullptr;
     ASSERT_TRUE(false);
   }
 
   ASSERT_EQ(PP_ERROR_ABORTED, result);
   PASS();
 }
 
+std::string TestFlashMessageLoop::TestSuspendScriptCallbackWhileRunning() {
+  suspend_script_callback_result_ = true;
+  message_loop_ = new pp::flash::MessageLoop(instance_);
+
+  pp::CompletionCallback callback = callback_factory_.NewCallback(
+      &TestFlashMessageLoop::TestSuspendScriptCallbackTask);
+  pp::Module::Get()->core()->CallOnMainThread(0, callback);
+  message_loop_->Run();
+
+  ASSERT_TRUE(message_loop_);
+  delete message_loop_;
+  message_loop_ = nullptr;
+
+  ASSERT_TRUE(suspend_script_callback_result_);
+  PASS();
+}
+
+void TestFlashMessageLoop::TestSuspendScriptCallbackTask(int32_t unused) {
+  pp::Var exception;
+  pp::Var rev = instance_->ExecuteScript(
+      "(function() {"
+      "  function delayedHandler() {"
+      "    document.getElementById('plugin').DidRunScriptCallback();"
+      "  }"
+      "  setTimeout(delayedHandler, 1);"
+      "})()",
+      &exception);
+  if (!exception.is_undefined())
+    suspend_script_callback_result_ = false;
+
+  pp::CompletionCallback callback =
+      callback_factory_.NewCallback(&TestFlashMessageLoop::QuitMessageLoopTask);
+  pp::Module::Get()->core()->CallOnMainThread(500, callback);
+}
+
 void TestFlashMessageLoop::QuitMessageLoopTask(int32_t unused) {
   if (message_loop_)
     message_loop_->Quit();
   else
     PP_NOTREACHED();
 }
 
 void TestFlashMessageLoop::DestroyMessageLoopResourceTask(int32_t unused) {
   if (message_loop_) {
     delete message_loop_;
-    message_loop_ = NULL;
+    message_loop_ = nullptr;
   } else {
     PP_NOTREACHED();
   }
 }