Add HostState enum to track host process status.

remoting/host/remoting_me2me_host.cc

 // Copyright (c) 2012 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.
 //
 // This file implements a standalone host process for Me2Me.
 
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
@@ skipping 148 matching lines @@
   virtual void OnConfigWatcherError() OVERRIDE;
 
   // IPC::Listener implementation.
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
   virtual void OnChannelError() OVERRIDE;
 
   // HeartbeatSender::Listener overrides.
   virtual void OnUnknownHostIdError() OVERRIDE;
 
  private:
+  enum HostState {
+    // Host process has just been started. Waiting for config and policies to be
+    // read from the disk.
+    HOST_INITIALIZING,
+
+    // Host is started and running.
+    HOST_STARTED,
+
+    // Host is being stopped and will need to be started again.
+    HOST_STOPPING_TO_RESTART,
+
+    // Host is being stopped.
+    HOST_STOPPING,
+
+    // Host has been stopped.
+    HOST_STOPPED,
+
+    // Allowed state transitions:
+    //   INITIALIZING->STARTED
+    //   INITIALIZING->STOPPED
+    //   STARTED->STOPPING_TO_RESTART
+    //   STARTED->STOPPING
+    //   STOPPING_TO_RESTART->STARTED
+    //   STOPPING_TO_RESTART->STOPPING
+    //   STOPPING->STOPPED
+    //   STOPPED->STARTED
+    //
+    // |host_| must be NULL in INITIALIZING and STOPPED states and not-NULL in
+    // all other states.
+  };
+
   friend class base::RefCountedThreadSafe<HostProcess>;
   virtual ~HostProcess();
 
+  void StartOnNetworkThread();
+
 #if defined(OS_POSIX)
-  // Registers a SIGTERM handler on the network thread, to shutdown the host.
-  void ListenForShutdownSignal();
-
   // Callback passed to RegisterSignalHandler() to handle SIGTERM events.
   void SigTermHandler(int signal_number);
 #endif
 
   // Called to initialize resources on the UI thread.
   void StartOnUiThread();
 
   // Initializes IPC control channel and config file path from |cmd_line|.
   // Called on the UI thread.
   bool InitWithCommandLine(const CommandLine* cmd_line);
@@ skipping 13 matching lines @@
   // Applies the host config, returning true if successful.
   bool ApplyConfig(scoped_ptr<JsonHostConfig> config);
 
   void OnPolicyUpdate(scoped_ptr<base::DictionaryValue> policies);
   bool OnHostDomainPolicyUpdate(const std::string& host_domain);
   bool OnUsernamePolicyUpdate(bool username_match_required);
   bool OnNatPolicyUpdate(bool nat_traversal_enabled);
   bool OnCurtainPolicyUpdate(bool curtain_required);
   bool OnHostTalkGadgetPrefixPolicyUpdate(const std::string& talkgadget_prefix);
 
-  void StartHostStatusService();
-
   void StartHost();
 
   void OnAuthFailed();
 
   void OnCurtainModeFailed();
 
   void OnRemoteSessionSwitchedToConsole();
 
   // Invoked when the user uses the Disconnect windows to terminate
   // the sessions, or when the local session is activated in curtain mode.
   void OnDisconnectRequested();
 
   void RestartHost();
 
-  void RestartOnHostShutdown();
-
-  void Shutdown(int exit_code);
+  // Stops the host and shuts down the process with the specified |exit_code|.
+  void ShutdownHost(int exit_code);
 
   void ShutdownOnNetworkThread();
 
-  void ResetHost();
-
   // Crashes the process in response to a daemon's request. The daemon passes
   // the location of the code that detected the fatal error resulted in this
   // request.
   void OnCrash(const std::string& function_name,
                const std::string& file_name,
                const int& line_number);
 
   scoped_ptr<ChromotingHostContext> context_;
 
   // Created on the UI thread but used from the network thread.
   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
 
   // Accessed on the UI thread.
   scoped_ptr<IPC::ChannelProxy> daemon_channel_;
   FilePath host_config_path_;
-  scoped_ptr<ConfigFileWatcher> config_watcher_;
   scoped_ptr<DesktopEnvironmentFactory> desktop_environment_factory_;
 
   // Accessed on the network thread.
+  HostState state_;
 
+  scoped_ptr<ConfigFileWatcher> config_watcher_;
   scoped_ptr<HostStatusService> status_service_;
 
   std::string host_id_;
   protocol::SharedSecretHash host_secret_hash_;
   HostKeyPair key_pair_;
   std::string oauth_refresh_token_;
   std::string serialized_config_;
   std::string xmpp_login_;
   std::string xmpp_auth_token_;
   std::string xmpp_auth_service_;
 
   scoped_ptr<policy_hack::PolicyWatcher> policy_watcher_;
   bool allow_nat_traversal_;
   std::string talkgadget_prefix_;
 
   scoped_ptr<CurtainMode> curtain_;
   scoped_ptr<CurtainingHostObserver> curtaining_host_observer_;
   bool curtain_required_;
 
-  bool restarting_;
-  bool shutting_down_;
-
   scoped_ptr<DesktopResizer> desktop_resizer_;
   scoped_ptr<ResizingHostObserver> resizing_host_observer_;
   scoped_ptr<XmppSignalStrategy> signal_strategy_;
   scoped_ptr<SignalingConnector> signaling_connector_;
   scoped_ptr<HeartbeatSender> heartbeat_sender_;
   scoped_ptr<LogToServer> log_to_server_;
   scoped_ptr<HostEventLogger> host_event_logger_;
 
   // Created on the UI thread and used on the network thread.
   scoped_ptr<HostUserInterface> host_user_interface_;
 
   scoped_refptr<ChromotingHost> host_;
 
   // Used to keep this HostProcess alive until it is shutdown.
   scoped_refptr<HostProcess> self_;
 
 #if defined(REMOTING_MULTI_PROCESS)
   DesktopSessionConnector* desktop_session_connector_;
 #endif  // defined(REMOTING_MULTI_PROCESS)
 
   int* exit_code_out_;
 };
 
 HostProcess::HostProcess(scoped_ptr<ChromotingHostContext> context,
                          int* exit_code_out)
     : context_(context.Pass()),
+      state_(HOST_INITIALIZING),
       allow_nat_traversal_(true),
       curtain_required_(false),
-      restarting_(false),
-      shutting_down_(false),
       desktop_resizer_(DesktopResizer::Create()),
 #if defined(REMOTING_MULTI_PROCESS)
       desktop_session_connector_(NULL),
 #endif  // defined(REMOTING_MULTI_PROCESS)
       ALLOW_THIS_IN_INITIALIZER_LIST(self_(this)),
       exit_code_out_(exit_code_out) {
   // Create a NetworkChangeNotifier for use by the signalling connector.
   network_change_notifier_.reset(net::NetworkChangeNotifier::Create());
 
   // Create the platform-specific curtain-mode implementation.
@@ skipping 83 matching lines @@
   // Filter out duplicates.
   if (serialized_config_ == serialized_config)
     return;
 
   LOG(INFO) << "Processing new host configuration.";
 
   serialized_config_ = serialized_config;
   scoped_ptr<JsonHostConfig> config(new JsonHostConfig(FilePath()));
   if (!config->SetSerializedData(serialized_config)) {
     LOG(ERROR) << "Invalid configuration.";
-    Shutdown(kInvalidHostConfigurationExitCode);
+    ShutdownHost(kInvalidHostConfigurationExitCode);
     return;
   }
 
   if (!ApplyConfig(config.Pass())) {
     LOG(ERROR) << "Failed to apply the configuration.";
-    Shutdown(kInvalidHostConfigurationExitCode);
+    ShutdownHost(kInvalidHostConfigurationExitCode);
     return;
   }
 
-  // Start watching the policy (and eventually start the host) if this is
-  // the first configuration update. Otherwise, create new authenticator
-  // factory in case PIN has changed.
-  if (!policy_watcher_) {
+  if (state_ == HOST_INITIALIZING) {
+    // TODO(sergeyu): Currently OnPolicyUpdate() assumes that host config is
+    // already loaded so PolicyWatcher has to be started here. Separate policy
+    // loading from policy verifications and move |policy_watcher_|
+    // initialization to StartOnNetworkThread().
     policy_watcher_.reset(
         policy_hack::PolicyWatcher::Create(context_->file_task_runner()));
     policy_watcher_->StartWatching(
         base::Bind(&HostProcess::OnPolicyUpdate, base::Unretained(this)));
-  } else {
+  } else if (state_ == HOST_STARTED) {
+    // TODO(sergeyu): Here we assume that PIN is the only part of the config
+    // that may change while the service is running. Change ApplyConfig() to
+    // detect other changes in the config and restart host if necessary here.
     CreateAuthenticatorFactory();
   }
 }
 
 void HostProcess::OnConfigWatcherError() {
-  DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
-
-  context_->network_task_runner()->PostTask(FROM_HERE,
-      base::Bind(&HostProcess::Shutdown, this,
-                 kInvalidHostConfigurationExitCode));
+  DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
+  ShutdownHost(kInvalidHostConfigurationExitCode);
 }
 
-void HostProcess::StartWatchingConfigChanges() {
-  DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
+void HostProcess::StartOnNetworkThread() {
+  DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
+
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          kEnableStatusServiceSwitchName)) {
+    status_service_.reset(new HostStatusService());
+  }
 
 #if !defined(REMOTING_MULTI_PROCESS)
   // Start watching the host configuration file.
-  config_watcher_.reset(new ConfigFileWatcher(context_->ui_task_runner(),
+  config_watcher_.reset(new ConfigFileWatcher(context_->network_task_runner(),
                                               context_->file_task_runner(),
                                               this));
   config_watcher_->Watch(host_config_path_);
 #endif  // !defined(REMOTING_MULTI_PROCESS)
+
+#if defined(OS_POSIX)
+  remoting::RegisterSignalHandler(
+      SIGTERM,
+      base::Bind(&HostProcess::SigTermHandler, base::Unretained(this)));
+#endif  // defined(OS_POSIX)
 }
 
 #if defined(OS_POSIX)
-void HostProcess::ListenForShutdownSignal() {
-  DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
-
-  remoting::RegisterSignalHandler(
-      SIGTERM,
-      base::Bind(&HostProcess::SigTermHandler, base::Unretained(this)));
-}
-
 void HostProcess::SigTermHandler(int signal_number) {
   DCHECK(signal_number == SIGTERM);
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
   LOG(INFO) << "Caught SIGTERM: Shutting down...";
-  Shutdown(kSuccessExitCode);
+  ShutdownHost(kSuccessExitCode);
 }
 #endif  // OS_POSIX
 
 void HostProcess::CreateAuthenticatorFactory() {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
-  if (!host_ || shutting_down_)
+  if (state_ != HOST_STARTED)
     return;
 
   std::string local_certificate = key_pair_.GenerateCertificate();
   if (local_certificate.empty()) {
     LOG(ERROR) << "Failed to generate host certificate.";
-    Shutdown(kInitializationFailed);
+    ShutdownHost(kInitializationFailed);
     return;
   }
 
   scoped_ptr<protocol::AuthenticatorFactory> factory(
       new protocol::Me2MeHostAuthenticatorFactory(
           local_certificate, *key_pair_.private_key(), host_secret_hash_));
 #if defined(OS_POSIX)
   // On Linux and Mac, perform a PAM authorization step after authentication.
   factory.reset(new PamAuthorizationFactory(factory.Pass()));
 #endif
@@ skipping 25 matching lines @@
   return false;
 #endif  // !defined(REMOTING_MULTI_PROCESS)
 }
 
 void HostProcess::OnChannelError() {
   DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
 
   // Shutdown the host if the daemon process disconnects the IPC channel.
   context_->network_task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&HostProcess::Shutdown, this, kSuccessExitCode));
+      base::Bind(&HostProcess::ShutdownHost, this, kSuccessExitCode));
 }
 
 void HostProcess::StartOnUiThread() {
   DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
 
   if (!InitWithCommandLine(CommandLine::ForCurrentProcess())) {
     OnConfigWatcherError();
     return;
   }
 
 #if defined(OS_LINUX)
   // TODO(sergeyu): Pass configuration parameters to the Linux-specific version
   // of DesktopEnvironmentFactory when we have it.
   remoting::VideoFrameCapturer::EnableXDamage(true);
 
   // If an audio pipe is specific on the command-line then initialize
   // AudioCapturerLinux to capture from it.
   FilePath audio_pipe_name = CommandLine::ForCurrentProcess()->
       GetSwitchValuePath(kAudioPipeSwitchName);
   if (!audio_pipe_name.empty()) {
     remoting::AudioCapturerLinux::InitializePipeReader(
         context_->audio_task_runner(), audio_pipe_name);
   }
 #endif  // defined(OS_LINUX)
 
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          kEnableStatusServiceSwitchName)) {
-    context_->network_task_runner()->PostTask(
-        FROM_HERE,
-        base::Bind(&HostProcess::StartHostStatusService,
-                   base::Unretained(this)));
-  }
-
   // Create a desktop environment factory appropriate to the build type &
   // platform.
 #if defined(OS_WIN)
 
 #if defined(REMOTING_MULTI_PROCESS)
   IpcDesktopEnvironmentFactory* desktop_environment_factory =
       new IpcDesktopEnvironmentFactory(
           daemon_channel_.get(),
           context_->input_task_runner(),
           context_->network_task_runner(),
           context_->ui_task_runner(),
           context_->video_capture_task_runner());
   desktop_session_connector_ = desktop_environment_factory;
 #else // !defined(REMOTING_MULTI_PROCESS)
   DesktopEnvironmentFactory* desktop_environment_factory =
       new SessionDesktopEnvironmentFactory(
           context_->input_task_runner(), context_->ui_task_runner(),
           base::Bind(&HostProcess::SendSasToConsole, this));
 #endif  // !defined(REMOTING_MULTI_PROCESS)
 
 #else  // !defined(OS_WIN)
   DesktopEnvironmentFactory* desktop_environment_factory =
       new DesktopEnvironmentFactory(
           context_->input_task_runner(), context_->ui_task_runner());
 #endif  // !defined(OS_WIN)
 
   desktop_environment_factory_.reset(desktop_environment_factory);
 
-#if defined(OS_POSIX)
-  context_->network_task_runner()->PostTask(
-      FROM_HERE, base::Bind(&HostProcess::ListenForShutdownSignal, this));
-#endif // OS_POSIX
-
   // The host UI should be created on the UI thread.
   bool want_user_interface = true;
 #if defined(OS_LINUX)
   want_user_interface = false;
 #elif defined(OS_MACOSX)
   // Don't try to display any UI on top of the system's login screen as this
   // is rejected by the Window Server on OS X 10.7.4, and prevents the
   // capturer from working (http://crbug.com/140984).
 
   // TODO(lambroslambrou): Use a better technique of detecting whether we're
   // running in the LoginWindow context, and refactor this into a separate
   // function to be used here and in CurtainMode::ActivateCurtain().
   want_user_interface = getuid() != 0;
 #endif  // OS_MACOSX
 
   if (want_user_interface) {
     host_user_interface_.reset(
         new HostUserInterface(context_->network_task_runner(),
                               context_->ui_task_runner()));
     host_user_interface_->Init();
   }
 
-  StartWatchingConfigChanges();
+  context_->network_task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&HostProcess::StartOnNetworkThread, this));
 }
 
 void HostProcess::SendSasToConsole() {
   DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
 
   if (daemon_channel_)
     daemon_channel_->Send(new ChromotingNetworkDaemonMsg_SendSasToConsole());
 }
 
 void HostProcess::ShutdownOnUiThread() {
   DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
 
   // Tear down resources that need to be torn down on the UI thread.
   network_change_notifier_.reset();
-  config_watcher_.reset();
   daemon_channel_.reset();
   desktop_environment_factory_.reset();
   host_user_interface_.reset();
 
   // It is now safe for the HostProcess to be deleted.
   self_ = NULL;
 
 #if defined(OS_LINUX)
   // Cause the global AudioPipeReader to be freed, otherwise the audio
   // thread will remain in-use and prevent the process from exiting.
   // TODO(wez): DesktopEnvironmentFactory should own the pipe reader.
   // See crbug.com/161373 and crbug.com/104544.
   AudioCapturerLinux::InitializePipeReader(NULL, FilePath());
 #endif
 }
 
 // Overridden from HeartbeatSender::Listener
 void HostProcess::OnUnknownHostIdError() {
   LOG(ERROR) << "Host ID not found.";
-  Shutdown(kInvalidHostIdExitCode);
+  ShutdownHost(kInvalidHostIdExitCode);
 }
 
 // Applies the host config, returning true if successful.
 bool HostProcess::ApplyConfig(scoped_ptr<JsonHostConfig> config) {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
   if (!config->GetString(kHostIdConfigPath, &host_id_)) {
     LOG(ERROR) << "host_id is not defined in the config.";
     return false;
   }
@@ skipping 30 matching lines @@
     // For the me2me host, we default to ClientLogin token for chromiumsync
     // because earlier versions of the host had no HTTP stack with which to
     // request an OAuth2 access token.
     xmpp_auth_service_ = kChromotingTokenDefaultServiceName;
   }
   return true;
 }
 
 void HostProcess::OnPolicyUpdate(scoped_ptr<base::DictionaryValue> policies) {
   // TODO(rmsousa): Consolidate all On*PolicyUpdate methods into this one.
+  // TODO(sergeyu): Currently polices are verified only when they are loaded.
+  // Separate policy loading from policy verifications - this will allow to
+  // check policies again later, e.g. when host config changes.
+
   if (!context_->network_task_runner()->BelongsToCurrentThread()) {
     context_->network_task_runner()->PostTask(FROM_HERE, base::Bind(
         &HostProcess::OnPolicyUpdate, this, base::Passed(&policies)));
     return;
   }
 
   bool restart_required = false;
   bool bool_value;
   std::string string_value;
   if (policies->GetString(policy_hack::PolicyWatcher::kHostDomainPolicyName,
@@ skipping 10 matching lines @@
     restart_required |= OnNatPolicyUpdate(bool_value);
   }
   if (policies->GetString(
           policy_hack::PolicyWatcher::kHostTalkGadgetPrefixPolicyName,
           &string_value)) {
     restart_required |= OnHostTalkGadgetPrefixPolicyUpdate(string_value);
   }
   if (policies->GetBoolean(
           policy_hack::PolicyWatcher::kHostRequireCurtainPolicyName,
           &bool_value)) {
-      restart_required |= OnCurtainPolicyUpdate(bool_value);
+    restart_required |= OnCurtainPolicyUpdate(bool_value);
   }
-  if (!host_) {
+
+  if (state_ == HOST_INITIALIZING) {
     StartHost();
-  } else if (restart_required) {
+  } else if (state_ == HOST_STARTED && restart_required) {
     RestartHost();
   }
 }
 
 bool HostProcess::OnHostDomainPolicyUpdate(const std::string& host_domain) {
   // Returns true if the host has to be restarted after this policy update.
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
   LOG(INFO) << "Policy sets host domain: " << host_domain;
 
   if (!host_domain.empty() &&
       !EndsWith(xmpp_login_, std::string("@") + host_domain, false)) {
-    Shutdown(kInvalidHostDomainExitCode);
+    ShutdownHost(kInvalidHostDomainExitCode);
   }
   return false;
 }
 
 bool HostProcess::OnUsernamePolicyUpdate(bool host_username_match_required) {
   // Returns false: never restart the host after this policy update.
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
   if (host_username_match_required) {
     LOG(INFO) << "Policy requires host username match.";
     bool shutdown = !CanGetUsername() ||
         !StartsWithASCII(xmpp_login_, GetUsername() + std::string("@"),
                          false);
 
 #if defined(OS_MACOSX)
     // On Mac, we run as root at the login screen, so the username won't match.
     // However, there's no need to enforce the policy at the login screen, as
     // the client will have to reconnect if a login occurs.
     if (shutdown && getuid() == 0) {
       shutdown = false;
     }
 #endif
 
     if (shutdown) {
-      Shutdown(kUsernameMismatchExitCode);
+      ShutdownHost(kUsernameMismatchExitCode);
     }
   } else {
     LOG(INFO) << "Policy does not require host username match.";
   }
 
   return false;
 }
 
 bool HostProcess::OnNatPolicyUpdate(bool nat_traversal_enabled) {
   // Returns true if the host has to be restarted after this policy update.
@@ skipping 19 matching lines @@
     // When curtain mode is in effect on Mac, the host process runs in the
     // user's switched-out session, but launchd will also run an instance at
     // the console login screen.  Even if no user is currently logged-on, we
     // can't support remote-access to the login screen because the current host
     // process model disconnects the client during login, which would leave
     // the logged in session un-curtained on the console until they reconnect.
     //
     // TODO(jamiewalch): Fix this once we have implemented the multi-process
     // daemon architecture (crbug.com/134894)
     if (getuid() == 0) {
-      Shutdown(kLoginScreenNotSupportedExitCode);
+      ShutdownHost(kLoginScreenNotSupportedExitCode);
       return false;
     }
   }
 #endif
 
   if (curtain_required_ != curtain_required) {
     if (curtain_required)
       LOG(ERROR) << "Policy requires curtain-mode.";
     else
       LOG(ERROR) << "Policy does not require curtain-mode.";
@@ skipping 11 matching lines @@
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
   if (talkgadget_prefix != talkgadget_prefix_) {
     LOG(INFO) << "Policy sets talkgadget prefix: " << talkgadget_prefix;
     talkgadget_prefix_ = talkgadget_prefix;
     return true;
   }
   return false;
 }
 
-void HostProcess::StartHostStatusService() {
-  DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
-  status_service_.reset(new HostStatusService());
-}
-
 void HostProcess::StartHost() {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
   DCHECK(!host_);
   DCHECK(!signal_strategy_.get());
-
-  if (shutting_down_)
-    return;
+  DCHECK(state_ == HOST_INITIALIZING || state_ == HOST_STOPPING_TO_RESTART ||
+         state_ == HOST_STOPPED) << state_;
+  state_ = HOST_STARTED;
 
   signal_strategy_.reset(
       new XmppSignalStrategy(context_->url_request_context_getter(),
                              xmpp_login_, xmpp_auth_token_,
                              xmpp_auth_service_));
 
   scoped_ptr<DnsBlackholeChecker> dns_blackhole_checker(
       new DnsBlackholeChecker(context_->url_request_context_getter(),
                               talkgadget_prefix_));
 
@@ skipping 62 matching lines @@
 
   if (status_service_)
     status_service_->SetHostIsUp(host_id_);
 
   host_->Start(xmpp_login_);
 
   CreateAuthenticatorFactory();
 }
 
 void HostProcess::OnAuthFailed() {
-  Shutdown(kInvalidOauthCredentialsExitCode);
+  ShutdownHost(kInvalidOauthCredentialsExitCode);
 }
 
 void HostProcess::OnCurtainModeFailed() {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
   DCHECK(host_);
   LOG(ERROR) << "Curtain mode failed to activate. Closing connection.";
   host_->RejectAuthenticatingClient();
 }
 
 void HostProcess::OnRemoteSessionSwitchedToConsole() {
@@ skipping 10 matching lines @@
         base::Bind(&HostProcess::OnDisconnectRequested, this));
     return;
   }
   if (host_) {
     host_->DisconnectAllClients();
   }
 }
 
 void HostProcess::RestartHost() {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
+  DCHECK_EQ(state_, HOST_STARTED);
 
-  if (restarting_ || shutting_down_)
-    return;
-
-  restarting_ = true;
-  host_->Shutdown(base::Bind(&HostProcess::RestartOnHostShutdown, this));
+  state_ = HOST_STOPPING_TO_RESTART;
+  host_->Shutdown(base::Bind(&HostProcess::ShutdownOnNetworkThread, this));
 }
 
-void HostProcess::RestartOnHostShutdown() {
+void HostProcess::ShutdownHost(int exit_code) {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
-  if (shutting_down_)
-    return;
+  *exit_code_out_ = exit_code;
 
-  restarting_ = false;
-  host_ = NULL;
-  ResetHost();
+  switch (state_) {
+    case HOST_INITIALIZING:
+      state_ = HOST_STOPPED;
+      ShutdownOnNetworkThread();
+      break;
 
-  StartHost();
-}
+    case HOST_STARTED:
+      state_ = HOST_STOPPING;
+      if (status_service_)
+        status_service_->SetHostIsDown();
+      host_->Shutdown(base::Bind(&HostProcess::ShutdownOnNetworkThread, this));
+      break;
 
-void HostProcess::Shutdown(int exit_code) {
-  DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
+    case HOST_STOPPING_TO_RESTART:
+      state_ = HOST_STOPPING;
+      break;
 
-  if (shutting_down_)
-    return;
-
-  if (status_service_)
-    status_service_->SetHostIsDown();
-
-  shutting_down_ = true;
-  *exit_code_out_ = exit_code;
-  if (host_) {
-    host_->Shutdown(base::Bind(&HostProcess::ShutdownOnNetworkThread, this));
-  } else {
-    ShutdownOnNetworkThread();
+    case HOST_STOPPING:
+    case HOST_STOPPED:
+      // Host is already stopped or being stopped. No action is required.
+      break;
   }
 }
 
 void HostProcess::ShutdownOnNetworkThread() {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
-  // Destroy networking objects while we are on the network thread.
   host_ = NULL;
-  ResetHost();
-
-  if (policy_watcher_.get()) {
-    base::WaitableEvent done_event(true, false);
-    policy_watcher_->StopWatching(&done_event);
-    done_event.Wait();
-    policy_watcher_.reset();
-  }
-
-  status_service_.reset();
-
-  // Complete the rest of shutdown on the main thread.
-  context_->ui_task_runner()->PostTask(FROM_HERE,
-      base::Bind(&HostProcess::ShutdownOnUiThread, this));
-}
-
-void HostProcess::ResetHost() {
-  DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
-
   curtaining_host_observer_.reset();
   host_event_logger_.reset();
   log_to_server_.reset();
   heartbeat_sender_.reset();
   signaling_connector_.reset();
   signal_strategy_.reset();
   resizing_host_observer_.reset();
+
+  if (state_ == HOST_STOPPING_TO_RESTART) {
+    StartHost();
+  } else if (state_ == HOST_STOPPING) {
+    state_ = HOST_STOPPED;
+
+    if (policy_watcher_.get()) {
+      base::WaitableEvent done_event(true, false);
+      policy_watcher_->StopWatching(&done_event);
+      done_event.Wait();
+      policy_watcher_.reset();
+    }
+
+    config_watcher_.reset();
+    status_service_.reset();
+
+    // Complete the rest of shutdown on the main thread.
+    context_->ui_task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&HostProcess::ShutdownOnUiThread, this));
+  } else {
+    // This method is used as a callback for ChromotingHost::Shutdown() which is
+    // called only in STOPPING_TO_RESTART and STOPPING states.
+    NOTREACHED();
+  }
 }
 
 void HostProcess::OnCrash(const std::string& function_name,
                           const std::string& file_name,
                           const int& line_number) {
   CHECK(false);
 }
 
 }  // namespace remoting
 
@@ skipping 95 matching lines @@
             user32.GetFunctionPointer("SetProcessDPIAware"));
     set_process_dpi_aware();
   }
 
   // CommandLine::Init() ignores the passed |argc| and |argv| on Windows getting
   // the command line from GetCommandLineW(), so we can safely pass NULL here.
   return main(0, NULL);
 }
 
 #endif  // defined(OS_WIN)