PPAPI: Make CompletionCallbacks work right on background threads.

ppapi/tests/test_case.h

 // 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.
 
 #ifndef PPAPI_TESTS_TEST_CASE_H_
 #define PPAPI_TESTS_TEST_CASE_H_
 
 #include <cmath>
 #include <limits>
 #include <set>
@@ skipping 104 matching lines @@
 
   // Run the given test method on a background thread and return the result.
   template <class T>
   std::string RunOnThread(std::string(T::*test_to_run)()) {
 #ifdef ENABLE_PEPPER_THREADING
     if (!testing_interface_) {
       return "Testing blocking callbacks requires the testing interface. In "
              "Chrome, use the --enable-pepper-testing flag.";
     }
     // These tests are only valid if running out-of-process (threading is not
-    // supported in-process). Just consider it a pass.
+    // supported in-process). For in-process, just consider it a pass.
     if (!testing_interface_->IsOutOfProcess())
       return std::string();
+    pp::MessageLoop_Dev background_loop(instance_);
     ThreadedTestRunner<T> runner(instance_->pp_instance(),
-        static_cast<T*>(this), test_to_run);
+        static_cast<T*>(this), test_to_run, background_loop);
     RunOnThreadInternal(&ThreadedTestRunner<T>::ThreadFunction, &runner,
                         testing_interface_);
     return runner.result();
 #else
     // If threading's not enabled, just treat it as success.
     return std::string();
 #endif
   }
 
   // Pointer to the instance that owns us.
@@ skipping 15 matching lines @@
     return callback_type_;
   }
 
  private:
   template <class T>
   class ThreadedTestRunner {
    public:
     typedef std::string(T::*TestMethodType)();
     ThreadedTestRunner(PP_Instance instance,
                        T* test_case,
-                       TestMethodType test_to_run)
+                       TestMethodType test_to_run,
+                       pp::MessageLoop_Dev loop)
         : instance_(instance),
           test_case_(test_case),
-          test_to_run_(test_to_run) {
+          test_to_run_(test_to_run),
+          loop_(loop) {
     }
     const std::string& result() { return result_; }
     static void ThreadFunction(void* runner) {
       static_cast<ThreadedTestRunner<T>*>(runner)->Run();
     }
 
    private:
     void Run() {
-      // TODO(dmichael): Create and attach a pp::MessageLoop for this thread so
-      //                 nested loops work.
+      PP_DCHECK(PP_OK == loop_.AttachToCurrentThread());
       result_ = (test_case_->*test_to_run_)();
+      // Now give the loop a chance to clean up.
+      loop_.PostQuit(true /* should_destroy */);
+      loop_.Run();
       // Tell the main thread to quit its nested message loop, now that the test
       // is complete.
       TestCase::QuitMainMessageLoop(instance_);
     }
 
     std::string result_;
     PP_Instance instance_;
     T* test_case_;
     TestMethodType test_to_run_;
+    pp::MessageLoop_Dev loop_;
   };
 
   // The internals for RunOnThread. This allows us to avoid including
   // pp_thread.h in this header file, since it includes system headers like
   // windows.h.
   // RunOnThreadInternal launches a new thread to run |thread_func|, waits
   // for it to complete using RunMessageLoop(), then joins.
   void RunOnThreadInternal(void (*thread_func)(void*),
                            void* thread_param,
                            const PPB_Testing_Dev* testing_interface);
@@ skipping 69 matching lines @@
                        CheckResourcesAndVars(Test##name())); \
   }
 
 #define RUN_TEST_BLOCKING(test_case, name, test_filter) \
   if (MatchesFilter(#name, test_filter)) { \
     set_callback_type(PP_BLOCKING); \
     instance_->LogTest(#name"Blocking", \
         CheckResourcesAndVars(RunOnThread(&test_case::Test##name))); \
   }
 
+#define RUN_TEST_BACKGROUND(test_case, name, test_filter) \
+  if (MatchesFilter(#name, test_filter)) { \
+    instance_->LogTest(#name"Background", \
+        CheckResourcesAndVars(RunOnThread(&test_case::Test##name))); \
+  }
+
 #define RUN_TEST_FORCEASYNC_AND_NOT(name, test_filter) \
   do { \
     RUN_TEST_FORCEASYNC(name, test_filter); \
     RUN_TEST(name, test_filter); \
   } while (false)
 
 // Run a test with all possible callback types.
 #define RUN_CALLBACK_TEST(test_case, name, test_filter) \
   do { \
     RUN_TEST_FORCEASYNC(name, test_filter); \
     RUN_TEST(name, test_filter); \
     RUN_TEST_BLOCKING(test_case, name, test_filter); \
+    RUN_TEST_BACKGROUND(test_case, name, test_filter); \
   } while (false)
 
 #define RUN_TEST_WITH_REFERENCE_CHECK(name, test_filter) \
   if (MatchesFilter(#name, test_filter)) { \
     set_callback_type(PP_OPTIONAL); \
     uint32_t objects = testing_interface_->GetLiveObjectsForInstance( \
         instance_->pp_instance()); \
     std::string error_message = Test##name(); \
     if (error_message.empty() && \
         testing_interface_->GetLiveObjectsForInstance( \
@@ skipping 20 matching lines @@
 #define ASSERT_SUBTEST_SUCCESS(function) \
   do { \
     std::string result = (function); \
     if (!result.empty()) \
       return result; \
   } while (false)
 
 #define PASS() return std::string()
 
 #endif  // PPAPI_TESTS_TEST_CASE_H_