Introducing the DaemonProcess class that will implements core of the daemon process functionality. …

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 <windows.h>
 #include <wtsapi32.h>
 #include <stdio.h>
 
 #include "base/at_exit.h"
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/wrapped_window_proc.h"
 #include "remoting/base/breakpad.h"
 #include "remoting/base/scoped_sc_handle_win.h"
 #include "remoting/base/stoppable.h"
 #include "remoting/host/branding.h"
+
+#if defined(REMOTING_MULTI_PROCESS)
+#include "remoting/host/daemon_process.h"
+#endif  // defined(REMOTING_MULTI_PROCESS)
+
 #include "remoting/host/usage_stats_consent.h"
 #include "remoting/host/win/host_service_resource.h"
 #include "remoting/host/win/wts_console_observer.h"
+
+#if !defined(REMOTING_MULTI_PROCESS)
 #include "remoting/host/win/wts_session_process_launcher.h"
+#endif  // !defined(REMOTING_MULTI_PROCESS)
 
 using base::StringPrintf;
 
 namespace {
 
+// Session id that does not represent any session.
+const uint32 kInvalidSessionId = 0xffffffffu;
+
 const char kIoThreadName[] = "I/O thread";
 
 // A window class for the session change notifications window.
 const wchar_t kSessionNotificationWindowClass[] =
   L"Chromoting_SessionNotificationWindow";
 
 // Command line actions and switches:
 // "run" sumply runs the service as usual.
 const wchar_t kRunActionName[] = L"run";
 
@@ skipping 44 matching lines @@
 
   console_observers_.AddObserver(observer);
 }
 
 void HostService::RemoveWtsConsoleObserver(WtsConsoleObserver* observer) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   console_observers_.RemoveObserver(observer);
 }
 
-void HostService::OnLauncherShutdown() {
-  launcher_.reset(NULL);
+void HostService::OnChildStopped() {
+  child_.reset(NULL);
   main_task_runner_->PostTask(FROM_HERE, MessageLoop::QuitClosure());
 }
 
 void HostService::OnSessionChange() {
   // WTSGetActiveConsoleSessionId is a very cheap API. It basically reads
   // a single value from shared memory. Therefore it is better to check if
   // the console session is still the same every time a session change
   // notification event is posted. This also takes care of coalescing multiple
   // events into one since we look at the latest state.
   uint32 console_session_id = WTSGetActiveConsoleSessionId();
@@ skipping 16 matching lines @@
 
 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(
-          &WtsSessionProcessLauncher::Stop,
-          base::Unretained(self->launcher_.get())));
+          &Stoppable::Stop, base::Unretained(self->child_.get())));
       self->stopped_event_.Wait();
       return TRUE;
 
     default:
       return FALSE;
   }
 }
 
 HostService* HostService::GetInstance() {
   return Singleton<HostService>::get();
@@ skipping 22 matching lines @@
   }
 
   return true;
 }
 
 int HostService::Run() {
   return (this->*run_routine_)();
 }
 
 void HostService::RunMessageLoop(MessageLoop* message_loop) {
+#if defined(REMOTING_MULTI_PROCESS)
+
+  child_ = DaemonProcess::Create(
+      main_task_runner_,
+      base::Bind(&HostService::OnChildStopped,
+                 base::Unretained(this))).PassAs<Stoppable>();
+
+#else  // !defined(REMOTING_MULTI_PROCESS)
+
   // Launch the I/O thread.
   base::Thread io_thread(kIoThreadName);
   base::Thread::Options io_thread_options(MessageLoop::TYPE_IO, 0);
   if (!io_thread.StartWithOptions(io_thread_options)) {
-    LOG(FATAL) << "Failed to start the I/O thread";
+    LOG(ERROR) << "Failed to start the I/O thread";
     stopped_event_.Signal();
     return;
   }
 
   // Create the session process launcher.
-  launcher_.reset(new WtsSessionProcessLauncher(
-      base::Bind(&HostService::OnLauncherShutdown, base::Unretained(this)),
+  child_.reset(new WtsSessionProcessLauncher(
+      base::Bind(&HostService::OnChildStopped, base::Unretained(this)),
       this,
       main_task_runner_,
       io_thread.message_loop_proxy()));
 
+#endif  // !defined(REMOTING_MULTI_PROCESS)
+
   // Run the service.
   message_loop->Run();
 
   // Release the control handler.
   stopped_event_.Signal();
 }
 
 int HostService::RunAsService() {
   SERVICE_TABLE_ENTRYW dispatch_table[] = {
     { const_cast<LPWSTR>(service_name_.c_str()), &HostService::ServiceMain },
@@ skipping 86 matching lines @@
                                                 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(
-          &WtsSessionProcessLauncher::Stop,
-          base::Unretained(self->launcher_.get())));
+          &Stoppable::Stop, base::Unretained(self->child_.get())));
       self->stopped_event_.Wait();
       return NO_ERROR;
 
     case SERVICE_CONTROL_SESSIONCHANGE:
       self->main_task_runner_->PostTask(FROM_HERE, base::Bind(
           &HostService::OnSessionChange, base::Unretained(self)));
       return NO_ERROR;
 
     default:
       return ERROR_CALL_NOT_IMPLEMENTED;
@@ skipping 102 matching lines @@
   }
 
   remoting::HostService* service = remoting::HostService::GetInstance();
   if (!service->InitWithCommandLine(command_line)) {
     usage(argv[0]);
     return kUsageExitCode;
   }
 
   return service->Run();
 }