PPAPI: Take PPB_MessageLoop out of Dev

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>
 #include <string>
 
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/dev/ppb_testing_dev.h"
-#include "ppapi/cpp/dev/message_loop_dev.h"
 #include "ppapi/cpp/dev/scrollbar_dev.h"
+#include "ppapi/cpp/message_loop.h"
 #include "ppapi/cpp/view.h"
 #include "ppapi/tests/test_utils.h"
 #include "ppapi/tests/testing_instance.h"
 
 #if (defined __native_client__)
 #include "ppapi/cpp/var.h"
 #else
 #include "ppapi/cpp/private/var_private.h"
 #endif
 
@@ skipping 91 matching lines @@
   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). For in-process, just consider it a pass.
     if (!testing_interface_->IsOutOfProcess())
       return std::string();
-    pp::MessageLoop_Dev background_loop(instance_);
+    pp::MessageLoop background_loop(instance_);
     ThreadedTestRunner<T> runner(instance_->pp_instance(),
         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
   }
@@ skipping 18 matching lines @@
   }
 
  private:
   template <class T>
   class ThreadedTestRunner {
    public:
     typedef std::string(T::*TestMethodType)();
     ThreadedTestRunner(PP_Instance instance,
                        T* test_case,
                        TestMethodType test_to_run,
-                       pp::MessageLoop_Dev loop)
+                       pp::MessageLoop loop)
         : instance_(instance),
           test_case_(test_case),
           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() {
       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_;
+    pp::MessageLoop 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 128 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_