PPAPI: Make blocking completion callbacks work.

ppapi/tests/test_case.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_case.h"
 
 #include <sstream>
 
+#include "ppapi/tests/pp_thread.h"
 #include "ppapi/tests/test_utils.h"
 #include "ppapi/tests/testing_instance.h"
 
 TestCase::TestCase(TestingInstance* instance)
     : instance_(instance),
       testing_interface_(NULL),
       callback_type_(PP_REQUIRED) {
   // Get the testing_interface_ if it is available, so that we can do Resource
   // and Var checks on shutdown (see CheckResourcesAndVars). If it is not
   // available, testing_interface_ will be NULL. Some tests do not require it.
@@ skipping 81 matching lines @@
   }
 
   return true;
 }
 
 bool TestCase::MatchesFilter(const std::string& test_name,
                              const std::string& filter) {
   return filter.empty() || (test_name == filter);
 }
 
-std::string TestCase::CheckResourcesAndVars() {
-  std::string errors;
+std::string TestCase::CheckResourcesAndVars(std::string errors) {
+  if (!errors.empty())
+    return errors;
+
   if (testing_interface_) {
     // TODO(dmichael): Fix tests that leak resources and enable the following:
     /*
     uint32_t leaked_resources =
         testing_interface_->GetLiveObjectsForInstance(instance_->pp_instance());
     if (leaked_resources) {
       std::ostringstream output;
       output << "FAILED: Test leaked " << leaked_resources << " resources.\n";
       errors += output.str();
     }
@@ skipping 14 matching lines @@
     }
     for (int i = 0; i < std::min(found_vars, kVarsToPrint); ++i) {
       pp::Var leaked_var(pp::PASS_REF, vars[i]);
       if (ignored_leaked_vars_.count(leaked_var.pp_var().value.as_id) == 0)
         errors += leaked_var.DebugString() + "<p>";
     }
   }
   return errors;
 }
 
+// static
+void TestCase::QuitMainMessageLoop(PP_Instance instance) {
+  PP_Instance* heap_instance = new PP_Instance(instance);
+  pp::CompletionCallback callback(&DoQuitMainMessageLoop, heap_instance);
+  pp::Module::Get()->core()->CallOnMainThread(0, callback);
+}
 
+// static
+void TestCase::DoQuitMainMessageLoop(void* pp_instance, int32_t result) {
+  PP_Instance* instance = static_cast<PP_Instance*>(pp_instance);
+  GetTestingInterface()->QuitMessageLoop(*instance);
+  delete instance;
+}
+
+void TestCase::RunOnThreadInternal(void (*thread_func)(void*),
+                                   void* thread_param,
+                                   const PPB_Testing_Dev* testing_interface) {
+    PP_ThreadType thread;
+    PP_CreateThread(&thread, thread_func, thread_param);
+    // Run a message loop so pepper calls can be dispatched. The background
+    // thread will set result_ and make us Quit when it's done.
+    testing_interface->RunMessageLoop(instance_->pp_instance());
+    PP_JoinThread(thread);
+}