Add PluginMessageLoopProxy and use it for Host plugin UI thread.

remoting/host/desktop_environment.cc

Index: remoting/host/desktop_environment.cc
diff --git a/remoting/host/desktop_environment.cc b/remoting/host/desktop_environment.cc
index 8377ac755792b48993eff76963a6b401cc28e84c..bdc7dedca1c7700af7ef4ba8e039a8dd0de9f62a 100644
--- a/remoting/host/desktop_environment.cc
+++ b/remoting/host/desktop_environment.cc
@@ -23,21 +23,30 @@ namespace remoting {
 // thread. This is neccessary so that DesktopEnvironment can be
 // deleted synchronously even while there are pending tasks on the
 // message queue.
+//
+// TODO(sergeyu): Merge this code with remoting::TaskThreadProxy. The
+// problem solved by this class is very simular to the one solved by
+// ScopedRunnableMethodFactory. The main difference is that this class
+// is thread-safe. Change the interface to make it look more like
+// ScopedRunnableMethodFactory and rename it to avoid confusion with
+// MessageLoopProxy.
 class UIThreadProxy : public base::RefCountedThreadSafe<UIThreadProxy> {
  public:
-  UIThreadProxy(ChromotingHostContext* context)
-      : context_(context) {
+  UIThreadProxy(base::MessageLoopProxy* message_loop)
+      : message_loop_(message_loop) {
   }
 
+  // TODO(sergeyu): Rename this method.
   void Detach() {
-    DCHECK(context_->IsUIThread());
-    context_ = NULL;
+    DCHECK(message_loop_->BelongsToCurrentThread());
+    message_loop_ = NULL;
   }
 
   void CallOnUIThread(const tracked_objects::Location& from_here,
                       const base::Closure& closure) {
-    if (context_) {
-      context_->PostTaskToUIThread(from_here, base::Bind(
+    scoped_refptr<base::MessageLoopProxy> message_loop = message_loop_;
+    if (message_loop) {
+      message_loop->PostTask(from_here, base::Bind(
           &UIThreadProxy::CallClosure, this, closure));
     }
   }
@@ -45,8 +54,9 @@ class UIThreadProxy : public base::RefCountedThreadSafe<UIThreadProxy> {
   void CallOnUIThreadDelayed(const tracked_objects::Location& from_here,
                              const base::Closure& closure,
                              int delay_ms) {
-    if (context_) {
-      context_->PostDelayedTaskToUIThread(from_here, base::Bind(
+    scoped_refptr<base::MessageLoopProxy> message_loop = message_loop_;
+    if (message_loop) {
+      message_loop->PostDelayedTask(from_here, base::Bind(
           &UIThreadProxy::CallClosure, this, closure), delay_ms);
     }
   }
@@ -57,11 +67,11 @@ class UIThreadProxy : public base::RefCountedThreadSafe<UIThreadProxy> {
   virtual ~UIThreadProxy() { }
 
   void CallClosure(const base::Closure& closure) {
-    if (context_)
+    if (message_loop_)
       closure.Run();
   }
 
-  ChromotingHostContext* context_;
+  scoped_refptr<base::MessageLoopProxy> message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(UIThreadProxy);
 };
@@ -98,14 +108,14 @@ DesktopEnvironment::DesktopEnvironment(ChromotingHostContext* context,
       local_input_monitor_(local_input_monitor),
       is_monitoring_local_inputs_(false),
       continue_timer_started_(false),
-      proxy_(new UIThreadProxy(context)) {
+      proxy_(new UIThreadProxy(context->ui_message_loop())) {
 }
 
 DesktopEnvironment::~DesktopEnvironment() {
 }
 
 void DesktopEnvironment::Shutdown() {
-  DCHECK(context_->IsUIThread());
+  DCHECK(context_->ui_message_loop()->BelongsToCurrentThread());
 
   MonitorLocalInputs(false);
   ShowDisconnectWindow(false, std::string());
@@ -131,7 +141,7 @@ void DesktopEnvironment::OnPause(bool pause) {
 }
 
 void DesktopEnvironment::ProcessOnConnect(const std::string& username) {
-  DCHECK(context_->IsUIThread());
+  DCHECK(context_->ui_message_loop()->BelongsToCurrentThread());
 
   MonitorLocalInputs(true);
   ShowDisconnectWindow(true, username);
@@ -139,7 +149,7 @@ void DesktopEnvironment::ProcessOnConnect(const std::string& username) {
 }
 
 void DesktopEnvironment::ProcessOnLastDisconnect() {
-  DCHECK(context_->IsUIThread());
+  DCHECK(context_->ui_message_loop()->BelongsToCurrentThread());
 
   MonitorLocalInputs(false);
   ShowDisconnectWindow(false, std::string());
@@ -152,7 +162,7 @@ void DesktopEnvironment::ProcessOnPause(bool pause) {
 }
 
 void DesktopEnvironment::MonitorLocalInputs(bool enable) {
-  DCHECK(context_->IsUIThread());
+  DCHECK(context_->ui_message_loop()->BelongsToCurrentThread());
 
   if (enable == is_monitoring_local_inputs_)
     return;
@@ -166,7 +176,7 @@ void DesktopEnvironment::MonitorLocalInputs(bool enable) {
 
 void DesktopEnvironment::ShowDisconnectWindow(bool show,
                                               const std::string& username) {
-  DCHECK(context_->IsUIThread());
+  DCHECK(context_->ui_message_loop()->BelongsToCurrentThread());
 
   if (show) {
     disconnect_window_->Show(host_, username);
@@ -176,7 +186,7 @@ void DesktopEnvironment::ShowDisconnectWindow(bool show,
 }
 
 void DesktopEnvironment::ShowContinueWindow(bool show) {
-  DCHECK(context_->IsUIThread());
+  DCHECK(context_->ui_message_loop()->BelongsToCurrentThread());
 
   if (show) {
     continue_window_->Show(host_);
@@ -186,7 +196,7 @@ void DesktopEnvironment::ShowContinueWindow(bool show) {
 }
 
 void DesktopEnvironment::StartContinueWindowTimer(bool start) {
-  DCHECK(context_->IsUIThread());
+  DCHECK(context_->ui_message_loop()->BelongsToCurrentThread());
 
   if (start && !continue_timer_started_) {
     continue_timer_target_time_ = base::Time::Now() +
@@ -201,7 +211,7 @@ void DesktopEnvironment::StartContinueWindowTimer(bool start) {
 }
 
 void DesktopEnvironment::ContinueWindowTimerFunc() {
-  DCHECK(context_->IsUIThread());
+  DCHECK(context_->ui_message_loop()->BelongsToCurrentThread());
 
   // This function may be called prematurely if timer was stopped and
   // then started again. In that case we just ignore this call.