Change the daemon start type to 'manual' if the host ID has been deleted.

remoting/host/desktop_session_win.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.
 
 #include "remoting/host/desktop_session_win.h"
 
 #include <limits>
 #include <sddl.h>
 
 #include "base/base_switches.h"
@@ skipping 255 matching lines @@
 void RdpSession::OnRdpConnected(const net::IPEndPoint& client_endpoint) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   StopMonitoring();
   StartMonitoring(client_endpoint);
 }
 
 void RdpSession::OnRdpClosed() {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
-  OnPermanentError();
+  TerminateSession();
 }
 
 void RdpSession::SetScreenResolution(const ScreenResolution& resolution) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   // TODO(alexeypa): implement resize-to-client for RDP sessions here.
   // See http://crbug.com/137696.
   NOTIMPLEMENTED();
 }
 
@@ skipping 131 matching lines @@
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   StopMonitoring();
 }
 
 void DesktopSessionWin::OnSessionAttachTimeout() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   LOG(ERROR) << "Session attach notification didn't arrived within "
              << kSessionAttachTimeoutSeconds << " seconds.";
-  OnPermanentError();
+  TerminateSession();
 }
 
 void DesktopSessionWin::StartMonitoring(
     const net::IPEndPoint& client_endpoint) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
   DCHECK(!monitoring_notifications_);
   DCHECK(!session_attach_timer_.IsRunning());
 
   ReportElapsedTime("started monitoring");
 
@@ skipping 12 matching lines @@
     ReportElapsedTime("stopped monitoring");
 
     monitoring_notifications_ = false;
     monitor_->RemoveWtsTerminalObserver(this);
   }
 
   session_attach_timer_.Stop();
   OnSessionDetached();
 }
 
+void DesktopSessionWin::TerminateSession() {
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
+
+  StopMonitoring();
+
+  // This call will delete |this| so it should be at the very end of the method.
+  daemon_process()->CloseDesktopSession(id());
+}
+
 void DesktopSessionWin::OnChannelConnected(int32 peer_pid) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   ReportElapsedTime("channel connected");
 
   // Obtain the handle of the desktop process. It will be passed to the network
   // process to use to duplicate handles of shared memory objects from
   // the desktop process.
   desktop_process_.Set(OpenProcess(PROCESS_DUP_HANDLE, false, peer_pid));
   if (!desktop_process_.IsValid()) {
@@ skipping 17 matching lines @@
   IPC_END_MESSAGE_MAP()
 
   if (!handled) {
     LOG(ERROR) << "Received unexpected IPC type: " << message.type();
     CrashDesktopProcess(FROM_HERE);
   }
 
   return handled;
 }
 
-void DesktopSessionWin::OnPermanentError() {
+void DesktopSessionWin::OnPermanentError(int exit_code) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  StopMonitoring();
-
-  // This call will delete |this| so it should be at the very end of the method.
-  daemon_process()->CloseDesktopSession(id());
+  TerminateSession();
 }
 
 void DesktopSessionWin::OnSessionAttached(uint32 session_id) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
   DCHECK(!launcher_);
   DCHECK(monitoring_notifications_);
 
   ReportElapsedTime("attached");
 
   // Launch elevated on Win8 to be able to inject Alt+Tab.
   bool launch_elevated = base::win::GetVersion() >= base::win::VERSION_WIN8;
 
   // Get the name of the executable to run. |kDesktopBinaryName| specifies
   // uiAccess="true" in it's manifest.
   base::FilePath desktop_binary;
   bool result;
   if (launch_elevated) {
     result = GetInstalledBinaryPath(kDesktopBinaryName, &desktop_binary);
   } else {
     result = GetInstalledBinaryPath(kHostBinaryName, &desktop_binary);
   }
 
   if (!result) {
-    OnPermanentError();
+    TerminateSession();
     return;
   }
 
   session_attach_timer_.Stop();
 
   scoped_ptr<CommandLine> target(new CommandLine(desktop_binary));
   target->AppendSwitchASCII(kProcessTypeSwitchName, kProcessTypeDesktop);
   // Copy the command line switches enabling verbose logging.
   target->CopySwitchesFrom(*CommandLine::ForCurrentProcess(),
                            kCopiedSwitchNames,
                            arraysize(kCopiedSwitchNames));
 
   // Create a delegate capable of launching a process in a different session.
   scoped_ptr<WtsSessionProcessDelegate> delegate(
       new WtsSessionProcessDelegate(io_task_runner_,
                                     target.Pass(),
                                     launch_elevated,
                                     WideToUTF8(kDaemonIpcSecurityDescriptor)));
   if (!delegate->Initialize(session_id)) {
-    OnPermanentError();
+    TerminateSession();
     return;
   }
 
   // Create a launcher for the desktop process, using the per-session delegate.
   launcher_.reset(new WorkerProcessLauncher(delegate.Pass(), this));
 }
 
 void DesktopSessionWin::OnSessionDetached() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
@@ skipping 41 matching lines @@
                                 exploded.hour,
                                 exploded.minute,
                                 exploded.second,
                                 exploded.millisecond,
                                 passed.c_str());
 
   last_timestamp_ = now;
 }
 
 }  // namespace remoting