Remove remaining calls to deprecated MessageLoop methods on Mac.

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 <stddef.h>
 
 #include <vector>
 
 #include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
-#include "base/location.h"
+#include "base/logging.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_message_loop.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_globals.h"
 #include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/thunk/enter.h"
 
 using ppapi::thunk::PPB_MessageLoop_API;
 
@@ skipping 78 matching lines @@
 
   return PP_OK;
 }
 
 int32_t MessageLoopResource::Run() {
   if (!IsCurrent())
     return PP_ERROR_WRONG_THREAD;
   if (is_main_thread_loop_)
     return PP_ERROR_INPROGRESS;
 
+  base::RunLoop* previous_run_loop = run_loop_;
+  base::RunLoop run_loop;
+  run_loop_ = &run_loop;
+
   nested_invocations_++;
   CallWhileUnlocked(
-      base::Bind(&base::MessageLoop::Run, base::Unretained(loop_.get())));
+      base::Bind(&base::RunLoop::Run, base::Unretained(run_loop_)));
   nested_invocations_--;
 
+  run_loop_ = previous_run_loop;
+
   if (should_destroy_ && nested_invocations_ == 0) {
     task_runner_ = NULL;
     loop_.reset();
     destroyed_ = true;
   }
   return PP_OK;
 }
 
 int32_t MessageLoopResource::PostWork(PP_CompletionCallback callback,
                                       int64_t delay_ms) {
   if (!callback.func)
     return PP_ERROR_BADARGUMENT;
   if (destroyed_)
     return PP_ERROR_FAILED;
   PostClosure(FROM_HERE,
               base::Bind(callback.func, callback.user_data,
                          static_cast<int32_t>(PP_OK)),
               delay_ms);
   return PP_OK;
 }
 
 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_->QuitWhenIdle();
-  else
-    PostClosure(FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(), 0);
+  if (IsCurrent() && nested_invocations_ > 0) {
+    run_loop_->QuitWhenIdle();
+  } else {
+    PostClosure(FROM_HERE, base::Bind(&MessageLoopResource::QuitRunLoopWhenIdle,
+                                      Unretained(this)),
+                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 35 matching lines @@
 }
 
 base::SingleThreadTaskRunner* MessageLoopResource::GetTaskRunner() {
   return task_runner_.get();
 }
 
 bool MessageLoopResource::CurrentlyHandlingBlockingMessage() {
   return currently_handling_blocking_message_;
 }
 
+void MessageLoopResource::QuitRunLoopWhenIdle() {
+  DCHECK(IsCurrent());
+  DCHECK(run_loop_);
+  run_loop_->QuitWhenIdle();
+}
+
 // static
 void MessageLoopResource::ReleaseMessageLoop(void* value) {
   static_cast<MessageLoopResource*>(value)->DetachFromThread();
 }
 
 // -----------------------------------------------------------------------------
 
 PP_Resource Create(PP_Instance instance) {
   ProxyAutoLock lock;
   // Validate the instance.
@@ skipping 63 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