ppapi: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

ppapi/shared_impl/tracked_callback.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/shared_impl/tracked_callback.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
+#include "base/location.h"
 #include "base/logging.h"
-#include "base/message_loop/message_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
+#include "base/thread_task_runner_handle.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_message_loop.h"
 #include "ppapi/shared_impl/callback_tracker.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/ppb_message_loop_shared.h"
 #include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/shared_impl/resource.h"
 
 namespace ppapi {
@@ skipping 226 matching lines @@
   } else {
     base::Closure callback_closure(
         RunWhileLocked(base::Bind(&TrackedCallback::Run, this, result)));
     if (target_loop_) {
       target_loop_->PostClosure(FROM_HERE, callback_closure, 0);
     } else {
       // We must be running in-process and on the main thread (the Enter
       // classes protect against having a null target_loop_ otherwise).
       DCHECK(IsMainThread());
       DCHECK(PpapiGlobals::Get()->IsHostGlobals());
-      base::MessageLoop::current()->PostTask(FROM_HERE, callback_closure);
+      base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                    callback_closure);
     }
   }
   is_scheduled_ = true;
 }
 
 void TrackedCallback::SignalBlockingCallback(int32_t result) {
   lock_.AssertAcquired();
   DCHECK(is_blocking());
   if (!operation_completed_condvar_) {
     // If the condition variable is invalid, there are two possibilities. One,
     // we're running in-process, in which case the call should have come in on
     // the main thread and we should have returned PP_ERROR_BLOCKS_MAIN_THREAD
     // well before this. Otherwise, this callback was not created as a
     // blocking callback. Either way, there's some internal error.
     NOTREACHED();
     return;
   }
   result_for_blocked_callback_ = result;
   // Retain ourselves, since MarkAsCompleted will remove us from the
   // tracker. Then MarkAsCompleted before waking up the blocked thread,
   // which could potentially re-enter.
   scoped_refptr<TrackedCallback> thiz(this);
   MarkAsCompletedWithLock();
   // Wake up the blocked thread. See BlockUntilComplete for where the thread
   // Wait()s.
   operation_completed_condvar_->Signal();
 }
 
 }  // namespace ppapi