MessageLoopProxy cleanups in remoting client.

remoting/base/scoped_thread_proxy.cc

 // Copyright (c) 2011 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 "remoting/base/scoped_thread_proxy.h"
 
 #include "base/bind.h"
+#include "base/single_thread_task_runner.h"
 
 namespace remoting {
 
 class ScopedThreadProxy::Core : public base::RefCountedThreadSafe<Core> {
  public:
-  Core(base::MessageLoopProxy* message_loop)
-      : message_loop_(message_loop),
+  Core(base::SingleThreadTaskRunner* task_runner)
+      : task_runner_(task_runner),
         canceled_(false) {
   }
 
   void PostTask(const tracked_objects::Location& from_here,
                 const base::Closure& closure) {
     if (!canceled_)
-      message_loop_->PostTask(from_here, Wrap(closure));
+      task_runner_->PostTask(from_here, Wrap(closure));
   }
 
   void PostDelayedTask(
       const tracked_objects::Location& from_here,
       const base::Closure& closure,
       int64 delay_ms) {
     if (!canceled_) {
-      message_loop_->PostDelayedTask(from_here, Wrap(closure), delay_ms);
+      task_runner_->PostDelayedTask(from_here, Wrap(closure), delay_ms);
     }
   }
 
   void Detach() {
-    DCHECK(message_loop_->BelongsToCurrentThread());
+    DCHECK(task_runner_->BelongsToCurrentThread());
     canceled_ = true;
   }
 
  private:
   friend class base::RefCountedThreadSafe<Core>;
 
   ~Core() {
     DCHECK(canceled_);
   }
 
   base::Closure Wrap(const base::Closure& closure) {
     return base::Bind(&Core::CallClosure, this, closure);
   }
 
   void CallClosure(const base::Closure& closure) {
-    DCHECK(message_loop_->BelongsToCurrentThread());
+    DCHECK(task_runner_->BelongsToCurrentThread());
 
     if (!canceled_)
       closure.Run();
   }
 
-  scoped_refptr<base::MessageLoopProxy> message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   bool canceled_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
-ScopedThreadProxy::ScopedThreadProxy(base::MessageLoopProxy* message_loop)
-    : core_(new Core(message_loop)) {
+ScopedThreadProxy::ScopedThreadProxy(base::SingleThreadTaskRunner* task_runner)
+    : core_(new Core(task_runner)) {
 }
 
 ScopedThreadProxy::~ScopedThreadProxy() {
   Detach();
 }
 
 void ScopedThreadProxy::PostTask(const tracked_objects::Location& from_here,
                                  const base::Closure& closure) {
   core_->PostTask(from_here, closure);
 }
 
 void ScopedThreadProxy::PostDelayedTask(
     const tracked_objects::Location& from_here,
     const base::Closure& closure,
     int64 delay_ms) {
   core_->PostDelayedTask(from_here, closure, delay_ms);
 }
 
 void ScopedThreadProxy::Detach() {
   core_->Detach();
 }
 
 }  // namespace remoting