Disable chromoting service on permanent errors.

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 131 matching lines @@
 const char kWindowIdSwitchName[] = "window-id";
 
 // Maximum time to wait for clean shutdown to occur, before forcing termination
 // of the process.
 const int kShutdownTimeoutSeconds = 15;
 
 // Maximum time to wait for reporting host-offline-reason to the service,
 // before continuing normal process shutdown.
 const int kHostOfflineReasonTimeoutSeconds = 10;
 
-// Host offline reasons not associated with shutting down the host process
-// and therefore not expressible through HostExitCodes enum.
-const char kHostOfflineReasonPolicyReadError[] = "POLICY_READ_ERROR";
-const char kHostOfflineReasonPolicyChangeRequiresRestart[] =
-    "POLICY_CHANGE_REQUIRES_RESTART";
-
 }  // namespace
 
 namespace remoting {
 
 class HostProcess : public ConfigWatcher::Delegate,
                     public HostSignalingManager::Listener,
                     public HostChangeNotificationListener::Listener,
                     public IPC::Listener,
                     public base::RefCountedThreadSafe<HostProcess> {
  public:
@@ skipping 108 matching lines @@
   scoped_ptr<HostSignalingManager> CreateHostSignalingManager();
 
   void StartHostIfReady();
   void StartHost();
 
   // Overrides for HostSignalingManager::Listener interface.
   void OnHeartbeatSuccessful() override;
   void OnUnknownHostIdError() override;
   void OnAuthFailed() override;
 
-  void RestartHost(const std::string& host_offline_reason);
+  void RestartHost(HostExitCodes exit_code);
   void ShutdownHost(HostExitCodes exit_code);
 
   // Helper methods doing the work needed by RestartHost and ShutdownHost.
-  void GoOffline(const std::string& host_offline_reason);
+  void GoOffline(HostExitCodes exit_code);
   void OnHostOfflineReasonAck(bool success);
 
 #if defined(OS_WIN)
   // Initializes the pairing registry on Windows. This should be invoked on the
   // network thread.
   void InitializePairingRegistry(
       IPC::PlatformFileForTransit privileged_key,
       IPC::PlatformFileForTransit unprivileged_key);
 #endif  // defined(OS_WIN)
 
@@ skipping 706 matching lines @@
   restart_required |= OnHostTokenUrlPolicyUpdate(policies.get());
   restart_required |= OnPairingPolicyUpdate(policies.get());
   restart_required |= OnGnubbyAuthPolicyUpdate(policies.get());
 
   policy_state_ = POLICY_LOADED;
 
   if (state_ == HOST_STARTING) {
     StartHostIfReady();
   } else if (state_ == HOST_STARTED) {
     if (restart_required)
-      RestartHost(kHostOfflineReasonPolicyChangeRequiresRestart);
+      RestartHost(kPolicyChangeRequiresRestart);
   }
 }
 
 void HostProcess::OnPolicyError() {
   if (!context_->network_task_runner()->BelongsToCurrentThread()) {
     context_->network_task_runner()->PostTask(
         FROM_HERE, base::Bind(&HostProcess::OnPolicyError, this));
     return;
   }
 
   if (policy_state_ != POLICY_ERROR_REPORTED) {
     policy_state_ = POLICY_ERROR_REPORT_PENDING;
     if ((state_ == HOST_STARTED) ||
         (state_ == HOST_STARTING && !serialized_config_.empty())) {
       ReportPolicyErrorAndRestartHost();
     }
   }
 }
 
 void HostProcess::ReportPolicyErrorAndRestartHost() {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
   DCHECK(!serialized_config_.empty());
 
   DCHECK_EQ(policy_state_, POLICY_ERROR_REPORT_PENDING);
   policy_state_ = POLICY_ERROR_REPORTED;
 
   LOG(INFO) << "Restarting the host due to policy errors.";
-  RestartHost(kHostOfflineReasonPolicyReadError);
+  RestartHost(kPolicyReadError);
 }
 
 void HostProcess::ApplyHostDomainPolicy() {
   if (state_ != HOST_STARTED)
     return;
 
   HOST_LOG << "Policy sets host domain: " << host_domain_;
 
   if (!host_domain_.empty()) {
     // If the user does not have a Google email, their client JID will not be
@@ skipping 350 matching lines @@
   CreateAuthenticatorFactory();
 
   ApplyHostDomainPolicy();
   ApplyUsernamePolicy();
 }
 
 void HostProcess::OnAuthFailed() {
   ShutdownHost(kInvalidOauthCredentialsExitCode);
 }
 
-void HostProcess::RestartHost(const std::string& host_offline_reason) {
+void HostProcess::RestartHost(HostExitCodes exit_code) {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
-  DCHECK(!host_offline_reason.empty());
 
   SetState(HOST_GOING_OFFLINE_TO_RESTART);
-  GoOffline(host_offline_reason);
+  GoOffline(exit_code);
 }
 
 void HostProcess::ShutdownHost(HostExitCodes exit_code) {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
   *exit_code_out_ = exit_code;
 
   switch (state_) {
     case HOST_STARTING:
     case HOST_STARTED:
       SetState(HOST_GOING_OFFLINE_TO_STOP);
-      GoOffline(ExitCodeToString(exit_code));
+      GoOffline(exit_code);
       break;
 
     case HOST_GOING_OFFLINE_TO_RESTART:
       SetState(HOST_GOING_OFFLINE_TO_STOP);
       break;
 
     case HOST_GOING_OFFLINE_TO_STOP:
     case HOST_STOPPED:
       // Host is already stopped or being stopped. No action is required.
       break;
   }
 }
 
-void HostProcess::GoOffline(const std::string& host_offline_reason) {
+void HostProcess::GoOffline(HostExitCodes exit_code) {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
-  DCHECK(!host_offline_reason.empty());
   DCHECK((state_ == HOST_GOING_OFFLINE_TO_STOP) ||
          (state_ == HOST_GOING_OFFLINE_TO_RESTART));
 
+  std::string host_offline_reason = ExitCodeToString(exit_code);
   // Shut down everything except the HostSignalingManager.
+  host_->SetExitCode(exit_code);
   host_.reset();
   host_event_logger_.reset();
   host_status_logger_.reset();
   host_change_notification_listener_.reset();
 
   // Before shutting down HostSignalingManager, send the |host_offline_reason|
   // if possible (i.e. if we have the config).
   if (!serialized_config_.empty()) {
     if (!host_signaling_manager_) {
       host_signaling_manager_ = CreateHostSignalingManager();
@@ skipping 96 matching lines @@
       base::TimeDelta::FromSeconds(kShutdownTimeoutSeconds));
   new HostProcess(context.Pass(), &exit_code, &shutdown_watchdog);
 
   // Run the main (also UI) message loop until the host no longer needs it.
   message_loop.Run();
 
   return exit_code;
 }
 
 }  // namespace remoting