Use a weak pointer to post service control events and session change notifications.

remoting/host/win/host_service.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/host_service.h"
 
 #include <sddl.h>
 #include <windows.h>
 #include <wtsapi32.h>
 
 #include "base/base_paths.h"
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/scoped_com_initializer.h"
 #include "base/win/windows_version.h"
 #include "remoting/base/auto_thread.h"
 #include "remoting/base/scoped_sc_handle_win.h"
-#include "remoting/base/stoppable.h"
 #include "remoting/host/branding.h"
 #include "remoting/host/daemon_process.h"
 #include "remoting/host/host_exit_codes.h"
 #include "remoting/host/logging.h"
 #include "remoting/host/win/core_resource.h"
 #include "remoting/host/win/security_descriptor.h"
 #include "remoting/host/win/wts_terminal_observer.h"
 
 namespace remoting {
 
@@ skipping 157 matching lines @@
     if (i->observer == observer) {
       observers_.erase(i);
       return;
     }
   }
 }
 
 HostService::HostService() :
   run_routine_(&HostService::RunAsService),
   service_status_handle_(0),
-  stopped_event_(true, false) {
+  stopped_event_(true, false),
+  weak_factory_(this) {
 }
 
 HostService::~HostService() {
 }
 
 void HostService::OnSessionChange(uint32 event, uint32 session_id) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK_NE(session_id, kInvalidSessionId);
 
   // Process only attach/detach notifications.
@@ skipping 51 matching lines @@
     scoped_refptr<AutoThreadTaskRunner> task_runner) {
   // Launch the I/O thread.
   scoped_refptr<AutoThreadTaskRunner> io_task_runner =
       AutoThread::CreateWithType(
           kIoThreadName, task_runner, base::MessageLoop::TYPE_IO);
   if (!io_task_runner) {
     LOG(FATAL) << "Failed to start the I/O thread";
     return;
   }
 
-  child_ = DaemonProcess::Create(
+  daemon_process_ = DaemonProcess::Create(
       task_runner,
       io_task_runner,
-      base::Bind(&HostService::OnChildStopped,
-                 base::Unretained(this))).PassAs<Stoppable>();
-}
-
-void HostService::OnChildStopped() {
-  DCHECK(main_task_runner_->BelongsToCurrentThread());
-
-  child_.reset(NULL);
+      base::Bind(&HostService::StopDaemonProcess, weak_self_));
 }
 
 int HostService::RunAsService() {
   SERVICE_TABLE_ENTRYW dispatch_table[] = {
     { const_cast<LPWSTR>(kWindowsServiceName), &HostService::ServiceMain },
     { NULL, NULL }
   };
 
   if (!StartServiceCtrlDispatcherW(dispatch_table)) {
     LOG_GETLASTERROR(ERROR)
         << "Failed to connect to the service control manager";
     return kInitializationFailed;
   }
 
   // Wait until the service thread completely exited to avoid concurrent
   // teardown of objects registered with base::AtExitManager and object
   // destoyed by the service thread.
   stopped_event_.Wait();
 
   return kSuccessExitCode;
 }
 
 void HostService::RunAsServiceImpl() {
   base::MessageLoop message_loop(base::MessageLoop::TYPE_UI);
   base::RunLoop run_loop;
   main_task_runner_ = message_loop.message_loop_proxy();
+  weak_self_ = weak_factory_.GetWeakPtr();
 
   // Register the service control handler.
   service_status_handle_ = RegisterServiceCtrlHandlerExW(
       kWindowsServiceName, &HostService::ServiceControlHandler, this);
   if (service_status_handle_ == 0) {
     LOG_GETLASTERROR(ERROR)
         << "Failed to register the service control handler";
     return;
   }
 
@@ skipping 19 matching lines @@
 
   if (!InitializeComSecurity())
     return;
 
   CreateLauncher(scoped_refptr<AutoThreadTaskRunner>(
       new AutoThreadTaskRunner(main_task_runner_,
                                run_loop.QuitClosure())));
 
   // Run the service.
   run_loop.Run();
+  weak_factory_.InvalidateWeakPtrs();
 
   // Tell SCM that the service is stopped.
   service_status.dwCurrentState = SERVICE_STOPPED;
   service_status.dwControlsAccepted = 0;
   if (!SetServiceStatus(service_status_handle_, &service_status)) {
     LOG_GETLASTERROR(ERROR)
         << "Failed to report service status to the service control manager";
     return;
   }
 }
 
 int HostService::RunInConsole() {
   base::MessageLoop message_loop(base::MessageLoop::TYPE_UI);
   base::RunLoop run_loop;
   main_task_runner_ = message_loop.message_loop_proxy();
+  weak_self_ = weak_factory_.GetWeakPtr();
 
   int result = kInitializationFailed;
 
   // Initialize COM.
   base::win::ScopedCOMInitializer com_initializer;
   if (!com_initializer.succeeded())
     return result;
 
   if (!InitializeComSecurity())
     return result;
@@ skipping 24 matching lines @@
     run_loop.Run();
 
     // Release the control handler.
     stopped_event_.Signal();
 
     WTSUnRegisterSessionNotification(window.hwnd());
     result = kSuccessExitCode;
   }
 
 cleanup:
+  weak_factory_.InvalidateWeakPtrs();
+
   // Unsubscribe from console events. Ignore the exit code. There is nothing
   // we can do about it now and the program is about to exit anyway. Even if
   // it crashes nothing is going to be broken because of it.
   SetConsoleCtrlHandler(&HostService::ConsoleControlHandler, FALSE);
 
   return result;
 }
 
+void HostService::StopDaemonProcess() {
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+
+  daemon_process_.reset(NULL);

[Wez, 2013/06/07 17:48:24]

nit: No need for explicit NULL.

[alexeypa (please no reviews), 2013/06/07 18:30:23]

Done.

+}
+
 bool HostService::HandleMessage(
     HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam, LRESULT* result) {
   if (message == WM_WTSSESSION_CHANGE) {
     OnSessionChange(wparam, lparam);
     *result = 0;
     return true;
   }
 
   return false;
 }
 
 // static
 BOOL WINAPI HostService::ConsoleControlHandler(DWORD event) {
   HostService* self = HostService::GetInstance();
   switch (event) {
     case CTRL_C_EVENT:
     case CTRL_BREAK_EVENT:
     case CTRL_CLOSE_EVENT:
     case CTRL_LOGOFF_EVENT:
     case CTRL_SHUTDOWN_EVENT:
-      self->main_task_runner_->PostTask(FROM_HERE, base::Bind(
-          &Stoppable::Stop, base::Unretained(self->child_.get())));
-      self->stopped_event_.Wait();
+      self->main_task_runner_->PostTask(
+          FROM_HERE, base::Bind(&HostService::StopDaemonProcess,
+                                self->weak_self_));
       return TRUE;
 
     default:
       return FALSE;
   }
 }
 
 // static
 DWORD WINAPI HostService::ServiceControlHandler(DWORD control,
                                                 DWORD event_type,
                                                 LPVOID event_data,
                                                 LPVOID context) {
   HostService* self = reinterpret_cast<HostService*>(context);
   switch (control) {
     case SERVICE_CONTROL_INTERROGATE:
       return NO_ERROR;
 
     case SERVICE_CONTROL_SHUTDOWN:
     case SERVICE_CONTROL_STOP:
-      self->main_task_runner_->PostTask(FROM_HERE, base::Bind(
-          &Stoppable::Stop, base::Unretained(self->child_.get())));
-      self->stopped_event_.Wait();
+      self->main_task_runner_->PostTask(
+          FROM_HERE, base::Bind(&HostService::StopDaemonProcess,
+                                self->weak_self_));
       return NO_ERROR;
 
     case SERVICE_CONTROL_SESSIONCHANGE:
       self->main_task_runner_->PostTask(FROM_HERE, base::Bind(
-          &HostService::OnSessionChange, base::Unretained(self), event_type,
+          &HostService::OnSessionChange, self->weak_self_, event_type,
           reinterpret_cast<WTSSESSION_NOTIFICATION*>(event_data)->dwSessionId));
       return NO_ERROR;
 
     default:
       return ERROR_CALL_NOT_IMPLEMENTED;
   }
 }
 
 // static
 VOID WINAPI HostService::ServiceMain(DWORD argc, WCHAR* argv[]) {
@@ skipping 10 matching lines @@
 int DaemonProcessMain() {
   HostService* service = HostService::GetInstance();
   if (!service->InitWithCommandLine(CommandLine::ForCurrentProcess())) {
     return kUsageExitCode;
   }
 
   return service->Run();
 }
 
 } // namespace remoting