Simplify It2Me host shutdown

remoting/host/it2me/it2me_host.cc

 // Copyright 2013 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/it2me_host.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/strings/string_util.h"
 #include "base/threading/platform_thread.h"
@@ skipping 64 matching lines @@
   policy_watcher_->StartWatching(
       base::Bind(&It2MeHost::OnPolicyUpdate, this),
       base::Bind(&It2MeHost::OnPolicyError, this));
 
   // Switch to the network thread to start the actual connection.
   host_context_->network_task_runner()->PostTask(
       FROM_HERE, base::Bind(&It2MeHost::ShowConfirmationPrompt, this));
 }
 
 void It2MeHost::Disconnect() {
-  if (!host_context_->network_task_runner()->BelongsToCurrentThread()) {
-    DCHECK(task_runner_->BelongsToCurrentThread());
-    host_context_->network_task_runner()->PostTask(
-        FROM_HERE, base::Bind(&It2MeHost::Disconnect, this));
-    return;
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  host_context_->network_task_runner()->PostTask(
+      FROM_HERE, base::Bind(&It2MeHost::Shutdown, this));
+}
+
+void It2MeHost::Shutdown() {
+  DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
+
+  confirmation_dialog_proxy_.reset();
+
+  host_event_logger_.reset();
+  if (host_) {
+    host_->RemoveStatusObserver(this);
+    host_.reset();
   }
 
-  switch (state_) {
-    case kDisconnected:
-      ShutdownOnNetworkThread();
-      return;
+  register_request_.reset();
+  host_status_logger_.reset();
+  signal_strategy_.reset();
 
-    case kStarting:
-      SetState(kDisconnecting, "");
-      SetState(kDisconnected, "");
-      ShutdownOnNetworkThread();
-      return;
+  // Post tasks to delete UI objects on the UI thread.
+  host_context_->ui_task_runner()->DeleteSoon(
+      FROM_HERE, desktop_environment_factory_.release());
+  host_context_->ui_task_runner()->DeleteSoon(FROM_HERE,
+                                              policy_watcher_.release());
 
-    case kDisconnecting:
-      return;
-
-    default:
-      SetState(kDisconnecting, "");
-
-      if (!host_) {
-        SetState(kDisconnected, "");
-        ShutdownOnNetworkThread();
-        return;
-      }
-
-      // Deleting the host destroys SignalStrategy synchronously, but
-      // SignalStrategy::Listener handlers are not allowed to destroy
-      // SignalStrategy, so post task to destroy the host later.
-      host_context_->network_task_runner()->PostTask(
-          FROM_HERE, base::Bind(&It2MeHost::ShutdownOnNetworkThread, this));
-      return;
-  }
+  SetState(kDisconnected, "");
 }
 
 void It2MeHost::RequestNatPolicy() {
   if (!host_context_->network_task_runner()->BelongsToCurrentThread()) {
     DCHECK(task_runner_->BelongsToCurrentThread());
     host_context_->network_task_runner()->PostTask(
         FROM_HERE, base::Bind(&It2MeHost::RequestNatPolicy, this));
     return;
   }
 
@@ skipping 23 matching lines @@
       base::Bind(&It2MeHost::OnConfirmationResult, base::Unretained(this)));
 }
 
 void It2MeHost::OnConfirmationResult(It2MeConfirmationDialog::Result result) {
   switch (result) {
     case It2MeConfirmationDialog::Result::OK:
       ReadPolicyAndConnect();
       break;
 
     case It2MeConfirmationDialog::Result::CANCEL:
-      Disconnect();
+      Shutdown();
       break;
 
     default:
       NOTREACHED();
       return;
   }
 }
 
 void It2MeHost::ReadPolicyAndConnect() {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
@@ skipping 89 matching lines @@
       HostEventLogger::Create(host_->AsWeakPtr(), kApplicationName);
 
   // Connect signaling and start the host.
   signal_strategy_->Connect();
   host_->Start(xmpp_server_config_.username);
 
   SetState(kRequestedAccessCode, "");
   return;
 }
 
-void It2MeHost::ShutdownOnNetworkThread() {
-  DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
-  DCHECK(state_ == kDisconnecting || state_ == kDisconnected);
-
-  confirmation_dialog_proxy_.reset();
-
-  if (state_ == kDisconnecting) {
-    host_event_logger_.reset();
-    host_->RemoveStatusObserver(this);
-    host_.reset();
-
-    register_request_.reset();
-    host_status_logger_.reset();
-    signal_strategy_.reset();
-    SetState(kDisconnected, "");
-  }
-
-  host_context_->ui_task_runner()->PostTask(
-      FROM_HERE, base::Bind(&It2MeHost::ShutdownOnUiThread, this));
-}
-
-void It2MeHost::ShutdownOnUiThread() {
-  DCHECK(host_context_->ui_task_runner()->BelongsToCurrentThread());
-
-  // Destroy the DesktopEnvironmentFactory, to free thread references.
-  desktop_environment_factory_.reset();
-
-  // Stop listening for policy updates.
-  policy_watcher_.reset();
-}
-
 void It2MeHost::OnAccessDenied(const std::string& jid) {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
   ++failed_login_attempts_;
   if (failed_login_attempts_ == kMaxLoginAttempts) {
-    Disconnect();
+    Shutdown();
   }
 }
 
-void It2MeHost::OnClientAuthenticated(const std::string& jid) {
+void It2MeHost::OnClientConnected(const std::string& jid) {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
-  if (state_ == kDisconnecting) {
-    // Ignore the new connection if we are disconnecting.
-    return;
-  }
-  if (state_ == kConnected) {
-    // If we already connected another client then one of the connections may be
-    // an attacker, so both are suspect and we have to reject the second
-    // connection and shutdown the host.
-    host_->RejectAuthenticatingClient();
-    Disconnect();
-    return;
-  }
+  // ChromotingHost doesn't allow multiple concurrent connection and the
+  // host is destroyed in OnClientDisconnected() after the first connection.
+  CHECK_NE(state_, kConnected);
 
   std::string client_username = jid;
   size_t pos = client_username.find('/');
   if (pos != std::string::npos)
     client_username.replace(pos, std::string::npos, "");
 
   HOST_LOG << "Client " << client_username << " connected.";
 
   // Pass the client user name to the script object before changing state.
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&It2MeHost::Observer::OnClientAuthenticated,
                             observer_, client_username));
 
   SetState(kConnected, "");
 }
 
 void It2MeHost::OnClientDisconnected(const std::string& jid) {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
-  Disconnect();
+  Shutdown();
 }
 
 void It2MeHost::OnPolicyUpdate(scoped_ptr<base::DictionaryValue> policies) {
   // The policy watcher runs on the |ui_task_runner|.
   if (!host_context_->network_task_runner()->BelongsToCurrentThread()) {
     host_context_->network_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&It2MeHost::OnPolicyUpdate, this, base::Passed(&policies)));
     return;
   }
@@ skipping 21 matching lines @@
 }
 
 void It2MeHost::UpdateNatPolicy(bool nat_traversal_enabled) {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
   VLOG(2) << "UpdateNatPolicy: " << nat_traversal_enabled;
 
   // When transitioning from enabled to disabled, force disconnect any
   // existing session.
   if (nat_traversal_enabled_ && !nat_traversal_enabled && IsConnected()) {
-    Disconnect();
+    Shutdown();
   }
 
   nat_traversal_enabled_ = nat_traversal_enabled;
 
   // Notify the web-app of the policy setting.
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&It2MeHost::Observer::OnNatPolicyChanged,
                             observer_, nat_traversal_enabled_));
 }
 
 void It2MeHost::UpdateHostDomainPolicy(const std::string& host_domain) {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
   VLOG(2) << "UpdateHostDomainPolicy: " << host_domain;
 
   // When setting a host domain policy, force disconnect any existing session.
   if (!host_domain.empty() && IsConnected()) {
-    Disconnect();
+    Shutdown();
   }
 
   required_host_domain_ = host_domain;
 }
 
 It2MeHost::~It2MeHost() {
   // Check that resources that need to be torn down on the UI thread are gone.
   DCHECK(!desktop_environment_factory_.get());
   DCHECK(!policy_watcher_.get());
 }
 
 void It2MeHost::SetState(It2MeHostState state,
                          const std::string& error_message) {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
   switch (state_) {
     case kDisconnected:
       DCHECK(state == kStarting ||
              state == kError) << state;
       break;
     case kStarting:
       DCHECK(state == kRequestedAccessCode ||
-             state == kDisconnecting ||
+             state == kDisconnected ||
              state == kError ||
              state == kInvalidDomainError) << state;
       break;
     case kRequestedAccessCode:
       DCHECK(state == kReceivedAccessCode ||
-             state == kDisconnecting ||
+             state == kDisconnected ||
              state == kError) << state;
       break;
     case kReceivedAccessCode:
       DCHECK(state == kConnected ||
-             state == kDisconnecting ||
+             state == kDisconnected ||
              state == kError) << state;
       break;
     case kConnected:
-      DCHECK(state == kDisconnecting ||
-             state == kDisconnected ||
+      DCHECK(state == kDisconnected ||
              state == kError) << state;
       break;
-    case kDisconnecting:
+    case kError:
       DCHECK(state == kDisconnected) << state;
       break;
-    case kError:
-      DCHECK(state == kDisconnecting) << state;
-      break;
     case kInvalidDomainError:
-      DCHECK(state == kDisconnecting) << state;
+      DCHECK(state == kDisconnected) << state;
       break;
   };
 
   state_ = state;
 
   // Post a state-change notification to the web-app.
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&It2MeHost::Observer::OnStateChanged,
                             observer_, state, error_message));
 }
 
 bool It2MeHost::IsConnected() const {
   return state_ == kRequestedAccessCode || state_ == kReceivedAccessCode ||
       state_ == kConnected;
 }
 
 void It2MeHost::OnReceivedSupportID(
     const std::string& support_id,
     const base::TimeDelta& lifetime,
     const std::string& error_message) {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
   if (!error_message.empty()) {
     SetState(kError, error_message);
-    Disconnect();
+    Shutdown();
     return;
   }
 
   std::string host_secret = GenerateSupportHostSecret();
   std::string access_code = support_id + host_secret;
 
   std::string local_certificate = host_key_pair_->GenerateCertificate();
   if (local_certificate.empty()) {
     std::string error_message = "Failed to generate host certificate.";
     LOG(ERROR) << error_message;
     SetState(kError, error_message);
-    Disconnect();
+    Shutdown();
     return;
   }
 
   scoped_ptr<protocol::AuthenticatorFactory> factory(
       new protocol::It2MeHostAuthenticatorFactory(
           local_certificate, host_key_pair_, access_code));
   host_->SetAuthenticatorFactory(factory.Pass());
 
   // Pass the Access Code to the script object before changing state.
   task_runner_->PostTask(
@@ skipping 25 matching lines @@
   scoped_ptr<It2MeConfirmationDialogFactory> confirmation_dialog_factory(
       new It2MeConfirmationDialogFactory());
   scoped_ptr<PolicyWatcher> policy_watcher =
       PolicyWatcher::Create(policy_service_, context->file_task_runner());
   return new It2MeHost(context.Pass(), policy_watcher.Pass(),
                        confirmation_dialog_factory.Pass(),
                        observer, xmpp_server_config, directory_bot_jid);
 }
 
 }  // namespace remoting