ppapi: Use base::MessageLoop.

ppapi/proxy/ppb_message_loop_proxy.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/proxy/ppb_message_loop_proxy.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 68 matching lines @@
       return PP_ERROR_INPROGRESS;
   }
   // TODO(dmichael) check that the current thread can support a message loop.
 
   // Take a ref to the MessageLoop on behalf of the TLS. Note that this is an
   // internal ref and not a plugin ref so the plugin can't accidentally
   // release it. This is released by ReleaseMessageLoop().
   AddRef();
   slot->Set(this);
 
-  loop_.reset(new MessageLoop(MessageLoop::TYPE_DEFAULT));
+  loop_.reset(new base::MessageLoop(base::MessageLoop::TYPE_DEFAULT));
   loop_proxy_ = base::MessageLoopProxy::current();
 
   // Post all pending work to the message loop.
   for (size_t i = 0; i < pending_tasks_.size(); i++) {
     const TaskInfo& info = pending_tasks_[i];
     PostClosure(info.from_here, info.closure, info.delay_ms);
   }
   pending_tasks_.clear();
 
   return PP_OK;
 }
 
 int32_t MessageLoopResource::Run() {
   if (!IsCurrent())
     return PP_ERROR_WRONG_THREAD;
   if (is_main_thread_loop_)
     return PP_ERROR_INPROGRESS;
 
   nested_invocations_++;
-  CallWhileUnlocked(base::Bind(&MessageLoop::Run,
-                               base::Unretained(loop_.get())));
+  CallWhileUnlocked(
+      base::Bind(&base::MessageLoop::Run, base::Unretained(loop_.get())));
   nested_invocations_--;
 
   if (should_destroy_ && nested_invocations_ == 0) {
     loop_proxy_ = NULL;
     loop_.reset();
     destroyed_ = true;
   }
   return PP_OK;
 }
 
@@ skipping 13 matching lines @@
 int32_t MessageLoopResource::PostQuit(PP_Bool should_destroy) {
   if (is_main_thread_loop_)
     return PP_ERROR_WRONG_THREAD;
 
   if (PP_ToBool(should_destroy))
     should_destroy_ = true;
 
   if (IsCurrent() && nested_invocations_ > 0)
     loop_->Quit();
   else
-    PostClosure(FROM_HERE, MessageLoop::QuitClosure(), 0);
+    PostClosure(FROM_HERE, base::MessageLoop::QuitClosure(), 0);
   return PP_OK;
 }
 
 // static
 MessageLoopResource* MessageLoopResource::GetCurrent() {
   PluginGlobals* globals = PluginGlobals::Get();
   if (!globals->msg_loop_slot())
     return NULL;
   return reinterpret_cast<MessageLoopResource*>(
       globals->msg_loop_slot()->Get());
@@ skipping 111 matching lines @@
 PPB_MessageLoop_Proxy::~PPB_MessageLoop_Proxy() {
 }
 
 // static
 const PPB_MessageLoop_1_0* PPB_MessageLoop_Proxy::GetInterface() {
   return &ppb_message_loop_interface;
 }
 
 }  // namespace proxy
 }  // namespace ppapi