ppapi: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

ppapi/proxy/message_handler.cc

 // Copyright 2014 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/message_handler.h"
 
+#include "base/location.h"
+#include "base/single_thread_task_runner.h"
 #include "ipc/ipc_message.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppb_message_loop_proxy.h"
 #include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/shared_impl/scoped_pp_var.h"
 #include "ppapi/thunk/enter.h"
 
 namespace ppapi {
 namespace proxy {
@@ skipping 69 matching lines @@
   *error = PP_OK;
   return result.Pass();
 }
 
 MessageHandler::~MessageHandler() {
   // It's possible the message_loop_proxy is NULL if that loop has been quit.
   // In that case, we unfortunately just can't call Destroy.
   if (message_loop_->message_loop_proxy().get()) {
     // The posted task won't have the proxy lock, but that's OK, it doesn't
     // touch any internal state; it's a direct call on the plugin's function.
-    message_loop_->message_loop_proxy()->PostTask(FROM_HERE,
-        base::Bind(handler_if_->Destroy,
-                   instance_,
-                   user_data_));
+    message_loop_->message_loop_proxy()->PostTask(
+        FROM_HERE, base::Bind(handler_if_->Destroy, instance_, user_data_));
   }
 }
 
 bool MessageHandler::LoopIsValid() const {
   return !!message_loop_->message_loop_proxy().get();
 }
 
 void MessageHandler::HandleMessage(ScopedPPVar var) {
-  message_loop_->message_loop_proxy()->PostTask(FROM_HERE,
-      RunWhileLocked(base::Bind(&HandleMessageWrapper,
-                                handler_if_->HandleMessage,
-                                instance_,
-                                user_data_,
-                                var)));
+  message_loop_->message_loop_proxy()->PostTask(
+      FROM_HERE, RunWhileLocked(base::Bind(&HandleMessageWrapper,
+                                           handler_if_->HandleMessage,
+                                           instance_, user_data_, var)));
 }
 
 void MessageHandler::HandleBlockingMessage(ScopedPPVar var,
                                            scoped_ptr<IPC::Message> reply_msg) {
-  message_loop_->message_loop_proxy()->PostTask(FROM_HERE,
-      RunWhileLocked(base::Bind(&HandleBlockingMessageWrapper,
-                                handler_if_->HandleBlockingMessage,
-                                instance_,
-                                user_data_,
-                                var,
-                                base::Passed(reply_msg.Pass()))));
+  message_loop_->message_loop_proxy()->PostTask(

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

Looks like this was missed.

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

message_loop_ is a MessageLoopResource, not a base::MessageLoop, so I wasn't
sure if I should be reworking it or not. I was under the impression that PPAPI
defines some interfaces that are called from the runtime, so I was careful about
not changing too many things. Do you think this function should be renamed too?

Edit: scratch that, I've now renamed it too.

+      FROM_HERE,
+      RunWhileLocked(base::Bind(
+          &HandleBlockingMessageWrapper, handler_if_->HandleBlockingMessage,
+          instance_, user_data_, var, base::Passed(reply_msg.Pass()))));
 }
 
 MessageHandler::MessageHandler(
     PP_Instance instance,
     const PPP_MessageHandler_0_2* handler_if,
     void* user_data,
     scoped_refptr<MessageLoopResource> message_loop)
     : instance_(instance),
       handler_if_(handler_if),
       user_data_(user_data),
       message_loop_(message_loop) {
 }
 
 }  // namespace proxy
 }  // namespace ppapi