Fix race condition disconnecting hosts.

remoting/host/it2me_host_user_interface.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/host/it2me_host_user_interface.h"
 
 #include "base/bind.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/continue_window.h"
@@ skipping 14 matching lines @@
  private:
   ScopedThreadProxy thread_proxy_;
 };
 
 
 It2MeHostUserInterface::It2MeHostUserInterface(ChromotingHost* host,
                                                ChromotingHostContext* context)
     : host_(host),
       context_(context),
       is_monitoring_local_inputs_(false),
-      ui_thread_proxy_(context->ui_message_loop()) {
+      ui_thread_proxy_(context->ui_message_loop()),
+      callback_complete_(false, false) {
 }
 
 It2MeHostUserInterface::~It2MeHostUserInterface() {
 }
 
 void It2MeHostUserInterface::Init() {
   InitFrom(DisconnectWindow::Create(),
            ContinueWindow::Create(),
            LocalInputMonitor::Create());
 }
@@ skipping 13 matching lines @@
 void It2MeHostUserInterface::OnSignallingDisconnected() {
 }
 
 void It2MeHostUserInterface::OnClientAuthenticated(const std::string& jid) {
   // There should not be more than one concurrent authenticated connection.
   DCHECK(authenticated_jid_.empty());
   authenticated_jid_ = jid;
 
   std::string username = jid.substr(0, jid.find('/'));
   ui_thread_proxy_.PostTask(FROM_HERE, base::Bind(
-    &It2MeHostUserInterface::ProcessOnConnect, base::Unretained(this),
+    &It2MeHostUserInterface::ProcessOnClientAuthenticated,
+    base::Unretained(this),
     username));
+  CHECK(callback_complete_.TimedWait(base::TimeDelta::FromSeconds(10)));
 }
 
 void It2MeHostUserInterface::OnClientDisconnected(const std::string& jid) {
   if (jid == authenticated_jid_) {
     authenticated_jid_.clear();
     ui_thread_proxy_.PostTask(FROM_HERE, base::Bind(
-        &It2MeHostUserInterface::ProcessOnLastDisconnect,
+        &It2MeHostUserInterface::ProcessOnClientDisconnected,
         base::Unretained(this)));
+    CHECK(callback_complete_.TimedWait(base::TimeDelta::FromSeconds(10)));

[Sergey Ulanov, 2011/12/01 20:35:24]

I don't think that blocking network thread on the UI thread is the right thing
to do. 

   }
 }
 
 void It2MeHostUserInterface::OnAccessDenied() {
 }
 
 void It2MeHostUserInterface::OnShutdown() {
 }
 
 void It2MeHostUserInterface::Shutdown() {
   DCHECK(context_->ui_message_loop()->BelongsToCurrentThread());
 
   MonitorLocalInputs(false);
   ShowDisconnectWindow(false, std::string());
   ShowContinueWindow(false);
   StartContinueWindowTimer(false);
 
   ui_thread_proxy_.Detach();
 }
 
-void It2MeHostUserInterface::OnConnect(const std::string& username) {
-  ui_thread_proxy_.PostTask(FROM_HERE, base::Bind(
-      &It2MeHostUserInterface::ProcessOnConnect, base::Unretained(this),
-      username));
-}
-
-void It2MeHostUserInterface::OnLastDisconnect() {
-  ui_thread_proxy_.PostTask(FROM_HERE, base::Bind(
-      &It2MeHostUserInterface::ProcessOnLastDisconnect,
-      base::Unretained(this)));
-}
-
-void It2MeHostUserInterface::ProcessOnConnect(const std::string& username) {
+void It2MeHostUserInterface::ProcessOnClientAuthenticated(
+    const std::string& username) {
   DCHECK(context_->ui_message_loop()->BelongsToCurrentThread());
 
   MonitorLocalInputs(true);
   ShowDisconnectWindow(true, username);
   StartContinueWindowTimer(true);
+  callback_complete_.Signal();
 }
 
-void It2MeHostUserInterface::ProcessOnLastDisconnect() {
+void It2MeHostUserInterface::ProcessOnClientDisconnected() {
   DCHECK(context_->ui_message_loop()->BelongsToCurrentThread());
 
   MonitorLocalInputs(false);
   ShowDisconnectWindow(false, std::string());
   ShowContinueWindow(false);
   StartContinueWindowTimer(false);
+  callback_complete_.Signal();
 }
 
 void It2MeHostUserInterface::MonitorLocalInputs(bool enable) {
   DCHECK(context_->ui_message_loop()->BelongsToCurrentThread());
 
   if (enable == is_monitoring_local_inputs_)
     return;
   if (enable) {
     local_input_monitor_->Start(host_);
   } else {
@@ skipping 64 matching lines @@
 }
 
 void It2MeHostUserInterface::OnShutdownHostTimer() {
   DCHECK(context_->ui_message_loop()->BelongsToCurrentThread());
 
   ShowContinueWindow(false);
   host_->Shutdown(base::Closure());
 }
 
 }  // namespace remoting