Introducing remoting::Stoppable helper base class implementing asynchronous shutdown on a specific t

remoting/host/win/wts_session_process_launcher.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 the Windows service controlling Me2Me host processes
 // running within user sessions.
 
 #include "remoting/host/win/wts_session_process_launcher.h"
 
 #include <windows.h>
 #include <sddl.h>
 #include <limits>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
-#include "base/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
 #include "base/process_util.h"
 #include "base/rand_util.h"
 #include "base/stringprintf.h"
 #include "base/win/scoped_handle.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "remoting/host/constants.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/sas_injector.h"
@@ skipping 175 matching lines @@
 }
 
 } // namespace
 
 namespace remoting {
 
 // Session id that does not represent any session.
 const uint32 kInvalidSessionId = 0xffffffff;
 
 WtsSessionProcessLauncher::WtsSessionProcessLauncher(
+    const base::Closure& stopped_callback,
     WtsConsoleMonitor* monitor,
     const FilePath& host_binary,
-    scoped_refptr<base::MessageLoopProxy> main_message_loop,
-    scoped_refptr<base::MessageLoopProxy> ipc_message_loop)
-    : host_binary_(host_binary),
+    scoped_refptr<base::SingleThreadTaskRunner> main_message_loop,
+    scoped_refptr<base::SingleThreadTaskRunner> ipc_message_loop)
+    : Stoppable(main_message_loop, stopped_callback),
+      host_binary_(host_binary),
       main_message_loop_(main_message_loop),
       ipc_message_loop_(ipc_message_loop),
       monitor_(monitor),
       state_(StateDetached) {
   monitor_->AddWtsConsoleObserver(this);
 }
 
 WtsSessionProcessLauncher::~WtsSessionProcessLauncher() {
+  monitor_->RemoveWtsConsoleObserver(this);
+  if (state_ != StateDetached) {
+    OnSessionDetached();
+  }
+
   DCHECK(state_ == StateDetached);
   DCHECK(!timer_.IsRunning());
   DCHECK(process_.handle() == NULL);
   DCHECK(process_watcher_.GetWatchedObject() == NULL);
   DCHECK(chromoting_channel_.get() == NULL);
-  if (monitor_ != NULL) {
-    monitor_->RemoveWtsConsoleObserver(this);
-  }
 }
 
 void WtsSessionProcessLauncher::LaunchProcess() {
   DCHECK(main_message_loop_->BelongsToCurrentThread());
   DCHECK(state_ == StateStarting);
   DCHECK(!timer_.IsRunning());
   DCHECK(process_.handle() == NULL);
   DCHECK(process_watcher_.GetWatchedObject() == NULL);
   DCHECK(chromoting_channel_.get() == NULL);
 
@@ skipping 75 matching lines @@
       kMinPermanentErrorExitCode <= exit_code &&
       exit_code <= kMaxPermanentErrorExitCode;
 
   // The host process has been terminated for some reason. The handle can now be
   // closed.
   process_.Close();
   chromoting_channel_.reset();
   state_ = StateStarting;
 
   if (stop_trying) {
-    OnSessionDetached();
-
-    // N.B. The service will stop once the last observer is removed from
-    // the list.
-    monitor_->RemoveWtsConsoleObserver(this);
-    monitor_ = NULL;
+    Stop();
     return;
   }
 
   // Expand the backoff interval if the process has died quickly or reset it if
   // it was up longer than the maximum backoff delay.
   base::TimeDelta delta = base::Time::Now() - launch_time_;
   if (delta < base::TimeDelta() ||
       delta >= base::TimeDelta::FromSeconds(kMaxLaunchDelaySeconds)) {
     launch_backoff_ = base::TimeDelta();
   } else {
@@ skipping 32 matching lines @@
     }
 
     if (sas_injector_.get() != NULL) {
       sas_injector_->InjectSas();
     }
   }
 }
 
 void WtsSessionProcessLauncher::OnSessionAttached(uint32 session_id) {
   DCHECK(main_message_loop_->BelongsToCurrentThread());
+
+  if (stoppable_state() != Stoppable::kRunning) {
+    return;
+  }
+
   DCHECK(state_ == StateDetached);
   DCHECK(!timer_.IsRunning());
   DCHECK(process_.handle() == NULL);
   DCHECK(process_watcher_.GetWatchedObject() == NULL);
   DCHECK(chromoting_channel_.get() == NULL);
 
   // Temporarily enable the SE_TCB_NAME privilege. The privileged token is
   // created as needed and kept for later reuse.
   if (privileged_token_.Get() == NULL) {
     if (!CreatePrivilegedToken(&privileged_token_)) {
@@ skipping 57 matching lines @@
       process_.Terminate(0);
       process_.Close();
       chromoting_channel_.reset();
       state_ = StateDetached;
       break;
   }
 
   session_token_.Close();
 }
 
+void WtsSessionProcessLauncher::DoStop() {
+  if (state_ != StateDetached) {
+    OnSessionDetached();
+  }
+
+  CompleteStopping();
+}
+
 } // namespace remoting