PPAPI: Make CompletionCallbacks work right on background threads.

ppapi/tests/test_utils.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_utils.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #if defined(_MSC_VER)
 #include <windows.h>
 #else
 #include <unistd.h>
 #endif
 
 #include "ppapi/c/pp_errors.h"
+#include "ppapi/cpp/dev/message_loop_dev.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/var.h"
 
 const int kActionTimeoutMs = 10000;
 
 const PPB_Testing_Dev* GetTestingInterface() {
   static const PPB_Testing_Dev* g_testing_interface =
       static_cast<const PPB_Testing_Dev*>(
           pp::Module::Get()->GetBrowserInterface(PPB_TESTING_DEV_INTERFACE));
   return g_testing_interface;
@@ skipping 105 matching lines @@
       instance_(instance),
       delegate_(NULL) {
 }
 
 int32_t TestCompletionCallback::WaitForResult() {
   PP_DCHECK(!wait_for_result_called_);
   wait_for_result_called_ = true;
   errors_.clear();
   if (!have_result_) {
     post_quit_task_ = true;
-    GetTestingInterface()->RunMessageLoop(instance_);
+    RunMessageLoop();
   }
   return result_;
 }
 
 void TestCompletionCallback::WaitForResult(int32_t result) {
   PP_DCHECK(!wait_for_result_called_);
   wait_for_result_called_ = true;
   errors_.clear();
   if (result == PP_OK_COMPLETIONPENDING) {
     if (!have_result_) {
       post_quit_task_ = true;
-      GetTestingInterface()->RunMessageLoop(instance_);
+      RunMessageLoop();
     }
     if (callback_type_ == PP_BLOCKING) {
       errors_.assign(
           ReportError("TestCompletionCallback: Call did not run synchronously "
                       "when passed a blocking completion callback!",
                       result_));
       return;
     }
   } else {
     result_ = result;
@@ skipping 29 matching lines @@
   }
 }
 
 pp::CompletionCallback TestCompletionCallback::GetCallback() {
   Reset();
   int32_t flags = 0;
   if (callback_type_ == PP_BLOCKING)
     return pp::CompletionCallback();
   else if (callback_type_ == PP_OPTIONAL)
     flags = PP_COMPLETIONCALLBACK_FLAG_OPTIONAL;
+  target_loop_ = pp::MessageLoop_Dev::GetCurrent();
   return pp::CompletionCallback(&TestCompletionCallback::Handler,
                                 const_cast<TestCompletionCallback*>(this),
                                 flags);
 }
 
 void TestCompletionCallback::Reset() {
   wait_for_result_called_ = false;
   result_ = PP_OK_COMPLETIONPENDING;
   have_result_ = false;
   post_quit_task_ = false;
   run_count_ = 0;  // TODO(dmichael): Remove when all tests are updated.
   delegate_ = NULL;
   errors_.clear();
 }
 
 // static
 void TestCompletionCallback::Handler(void* user_data, int32_t result) {
   TestCompletionCallback* callback =
       static_cast<TestCompletionCallback*>(user_data);
   // If this check fails, it means that the callback was invoked twice or that
   // the PPAPI call completed synchronously, but also ran the callback.
   PP_DCHECK(!callback->have_result_);
   callback->result_ = result;
   callback->have_result_ = true;
   callback->run_count_++;  // TODO(dmichael): Remove when all tests are updated.
   if (callback->delegate_)
     callback->delegate_->OnCallback(user_data, result);
   if (callback->post_quit_task_) {
     callback->post_quit_task_ = false;
-    GetTestingInterface()->QuitMessageLoop(callback->instance_);
+    callback->QuitMessageLoop();
+  }
+  if (!(callback->target_loop_ == pp::MessageLoop_Dev::GetCurrent())) {

[brettw, 2012/11/06 23:16:28]

Use != instead?

[dmichael (off chromium), 2012/11/06 23:39:26]

I was being lazy, since pp::Resource didn't have operator!=.

Added it, done.

+    // Note, in-process, loop_ and GetCurrent() will both be NULL, so should
+    // still be equal.
+    callback->errors_.assign(
+        ReportError("TestCompletionCallback: Callback ran on the wrong message "
+                    "loop!",
+                    result));
   }
 }
 
+void TestCompletionCallback::RunMessageLoop() {
+  pp::MessageLoop_Dev loop(pp::MessageLoop_Dev::GetCurrent());
+  // If we don't have a message loop, we're probably running in process, where
+  // PPB_MessageLoop is not supported. Just use the Testing message loop.
+  if (loop.is_null() || loop == pp::MessageLoop_Dev::GetForMainThread())
+    GetTestingInterface()->RunMessageLoop(instance_);
+  else
+    loop.Run();
+}
+
+void TestCompletionCallback::QuitMessageLoop() {
+  pp::MessageLoop_Dev loop(pp::MessageLoop_Dev::GetCurrent());
+  // If we don't have a message loop, we're probably running in process, where
+  // PPB_MessageLoop is not supported. Just use the Testing message loop.
+  if (loop.is_null() || loop == pp::MessageLoop_Dev::GetForMainThread()) {
+    GetTestingInterface()->QuitMessageLoop(instance_);
+  } else {
+    const bool should_quit = false;
+    loop.PostQuit(should_quit);
+  }
+}