[Chromoting] Fix DCHECK when shutting down It2Me host from client side

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 <stddef.h>
 
 #include <utility>
 
@@ skipping 78 matching lines @@
       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() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   host_context_->network_task_runner()->PostTask(
-      FROM_HERE, base::Bind(&It2MeHost::Shutdown, this));
+      FROM_HERE, base::Bind(&It2MeHost::DisconnectOnNetworkThread, this));
 }
 
-void It2MeHost::Shutdown() {
+void It2MeHost::DisconnectOnNetworkThread() {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
+  // Disconnect() may be called even when after the host been already stopped.
+  // Ignore repeated calls.
+  if (state_ == kDisconnected) {
+    return;
+  }
+
   confirmation_dialog_proxy_.reset();
 
   host_event_logger_.reset();
   if (host_) {
     host_->RemoveStatusObserver(this);
     host_.reset();
   }
 
   register_request_.reset();
   host_status_logger_.reset();
@@ skipping 42 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:
-      Shutdown();
+      DisconnectOnNetworkThread();
       break;
 
     default:
       NOTREACHED();
       return;
   }
 }
 
 void It2MeHost::ReadPolicyAndConnect() {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
@@ skipping 99 matching lines @@
 
   SetState(kRequestedAccessCode, "");
   return;
 }
 
 void It2MeHost::OnAccessDenied(const std::string& jid) {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
   ++failed_login_attempts_;
   if (failed_login_attempts_ == kMaxLoginAttempts) {
-    Shutdown();
+    DisconnectOnNetworkThread();
   }
 }
 
 void It2MeHost::OnClientConnected(const std::string& jid) {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
   // 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());
 
-  Shutdown();
+  DisconnectOnNetworkThread();
 }
 
 void It2MeHost::OnPolicyUpdate(
     std::unique_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 27 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()) {
-    Shutdown();
+    DisconnectOnNetworkThread();
   }
 
   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()) {
-    Shutdown();
+    DisconnectOnNetworkThread();
   }
 
   required_host_domain_ = host_domain;
 }
 
 void It2MeHost::UpdateClientDomainPolicy(const std::string& client_domain) {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
   VLOG(2) << "UpdateClientDomainPolicy: " << client_domain;
 
   // When setting a client  domain policy, disconnect any existing session.
   if (!client_domain.empty() && IsConnected()) {
-    Shutdown();
+    DisconnectOnNetworkThread();
   }
 
   required_client_domain_ = client_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());
 }
@@ skipping 49 matching lines @@
 }
 
 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);
-    Shutdown();
+    DisconnectOnNetworkThread();
     return;
   }
 
   std::string host_secret = GenerateSupportHostSecret();
   std::string access_code = support_id + host_secret;
   std::string access_code_hash =
       protocol::GetSharedSecretHash(support_id, access_code);
 
   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);
-    Shutdown();
+    DisconnectOnNetworkThread();
     return;
   }
 
   std::unique_ptr<protocol::AuthenticatorFactory> factory(
       new protocol::It2MeHostAuthenticatorFactory(
           local_certificate, host_key_pair_, access_code_hash,
           required_client_domain_));
   host_->SetAuthenticatorFactory(std::move(factory));
 
   // Pass the Access Code to the script object before changing state.
@@ skipping 26 matching lines @@
   std::unique_ptr<It2MeConfirmationDialogFactory> confirmation_dialog_factory(
       new It2MeConfirmationDialogFactory());
   std::unique_ptr<PolicyWatcher> policy_watcher =
       PolicyWatcher::Create(policy_service_, context->file_task_runner());
   return new It2MeHost(std::move(context), std::move(policy_watcher),
                        std::move(confirmation_dialog_factory), observer,
                        xmpp_server_config, directory_bot_jid);
 }
 
 }  // namespace remoting