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..56e6860674c84805d6a490df62f9eeb4036650f7 100644
--- a/remoting/host/desktop_environment.cc
+++ b/remoting/host/desktop_environment.cc
@@ -25,19 +25,20 @@ namespace remoting {
 // message queue.
 class UIThreadProxy : public base::RefCountedThreadSafe<UIThreadProxy> {
  public:
-  UIThreadProxy(ChromotingHostContext* context)
-      : context_(context) {
+  UIThreadProxy(base::MessageLoopProxy* message_loop)
+      : message_loop_(message_loop) {
   }
 
   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 +46,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 +59,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);
 };

[Wez, 2011/08/15 20:28:19]

Isn't this entire class just a wannabe-MessageLoopProxy, in which case it can
disappear entirely now that |message_loop| is a MessageLoopProxy?

[Sergey Ulanov, 2011/08/15 22:39:52]

Not really. This class is used to schedule tasks for the same object and then
Detach() is called by that object to cancel these tasks.  In other words
Detach() in MessageLoopProxy detaches the thread, but Deatch() in UIThreadProxy
detaches the target of the pending tasks.
I see how it may be confusing, I will clean it up later, added TODO for this.
Maybe Detach() here should be renamed to CancelPendingTasks() or something like
that.

@@ -98,14 +100,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 +133,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 +141,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 +154,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 +168,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 +178,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 +188,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 +203,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.