PPAPI: Take PPB_MessageLoop out of Dev

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 167 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();
+  target_loop_ = pp::MessageLoop::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;
@@ skipping 11 matching lines @@
   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;
     callback->QuitMessageLoop();
   }
-  if (callback->target_loop_ != pp::MessageLoop_Dev::GetCurrent()) {
+  if (callback->target_loop_ != pp::MessageLoop::GetCurrent()) {
     // 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());
+  pp::MessageLoop loop(pp::MessageLoop::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())
+  if (loop.is_null() || loop == pp::MessageLoop::GetForMainThread())
     GetTestingInterface()->RunMessageLoop(instance_);
   else
     loop.Run();
 }
 
 void TestCompletionCallback::QuitMessageLoop() {
-  pp::MessageLoop_Dev loop(pp::MessageLoop_Dev::GetCurrent());
+  pp::MessageLoop loop(pp::MessageLoop::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()) {
+  if (loop.is_null() || loop == pp::MessageLoop::GetForMainThread()) {
     GetTestingInterface()->QuitMessageLoop(instance_);
   } else {
     const bool should_quit = false;
     loop.PostQuit(should_quit);
   }
 }