ppapi: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

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"
-#include "base/message_loop/message_loop.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/location.h"
+#include "base/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;
 
 namespace ppapi {
@@ skipping 25 matching lines @@
   // This must be called only once, so the slot must be empty.
   CHECK(!PluginGlobals::Get()->msg_loop_slot());
   // We don't add a reference for TLS here, so we don't release it. Instead,
   // this loop is owned by PluginGlobals. Contrast with AttachToCurrentThread
   // where we register ReleaseMessageLoop with TLS and call AddRef.
   base::ThreadLocalStorage::Slot* slot = new base::ThreadLocalStorage::Slot();
   PluginGlobals::Get()->set_msg_loop_slot(slot);
 
   slot->Set(this);
 
-  loop_proxy_ = base::MessageLoopProxy::current();
+  task_runner_ = base::ThreadTaskRunnerHandle::Get();
 }
 
 
 MessageLoopResource::~MessageLoopResource() {
 }
 
 PPB_MessageLoop_API* MessageLoopResource::AsPPB_MessageLoop_API() {
   return this;
 }
 
@@ skipping 13 matching lines @@
   }
   // 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 base::MessageLoop);
-  loop_proxy_ = base::MessageLoopProxy::current();
+  task_runner_ = base::ThreadTaskRunnerHandle::Get();
 
   // 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(&base::MessageLoop::Run, base::Unretained(loop_.get())));
   nested_invocations_--;
 
   if (should_destroy_ && nested_invocations_ == 0) {
-    loop_proxy_ = NULL;
+    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;
@@ skipping 25 matching lines @@
   PluginGlobals* globals = PluginGlobals::Get();
   if (!globals->msg_loop_slot())
     return NULL;
   return reinterpret_cast<MessageLoopResource*>(
       globals->msg_loop_slot()->Get());
 }
 
 void MessageLoopResource::DetachFromThread() {
   // Note that the message loop must be destroyed on the thread it was created
   // on.
-  loop_proxy_ = NULL;
+  task_runner_ = NULL;
   loop_.reset();
 
   // Cancel out the AddRef in AttachToCurrentThread().
   Release();
   // DANGER: may delete this.
 }
 
 bool MessageLoopResource::IsCurrent() const {
   PluginGlobals* globals = PluginGlobals::Get();
   if (!globals->msg_loop_slot())
     return false;  // Can't be current if there's nothing in the slot.
   return static_cast<const void*>(globals->msg_loop_slot()->Get()) ==
          static_cast<const void*>(this);
 }
 
 void MessageLoopResource::PostClosure(
     const tracked_objects::Location& from_here,
     const base::Closure& closure,
     int64 delay_ms) {
-  if (loop_proxy_.get()) {
-    loop_proxy_->PostDelayedTask(
-        from_here, closure, base::TimeDelta::FromMilliseconds(delay_ms));
+  if (task_runner_.get()) {
+    task_runner_->PostDelayedTask(from_here, closure,
+                                  base::TimeDelta::FromMilliseconds(delay_ms));
   } else {
     TaskInfo info;
     info.from_here = FROM_HERE;
     info.closure = closure;
     info.delay_ms = delay_ms;
     pending_tasks_.push_back(info);
   }
 }
 
-base::MessageLoopProxy* MessageLoopResource::GetMessageLoopProxy() {
-  return loop_proxy_.get();
+base::SingleThreadTaskRunner* MessageLoopResource::GetMessageLoopProxy() {

[bbudge, 2015/06/10 20:57:46]

Name 'GetMessageLoopProxy' is now misleading.

[Sami, 2015/06/11 18:03:46]

Done.

+  return task_runner_.get();
 }
 
 bool MessageLoopResource::CurrentlyHandlingBlockingMessage() {
   return currently_handling_blocking_message_;
 }
 
 // static
 void MessageLoopResource::ReleaseMessageLoop(void* value) {
   static_cast<MessageLoopResource*>(value)->DetachFromThread();
 }
@@ skipping 69 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