[Chromoting] The daemon process now starts the networking process and passes the host configuration…

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/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/path_service.h"
-#include "base/process_util.h"
 #include "base/rand_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.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/win/launch_process_with_token.h"
 #include "remoting/host/win/wts_console_monitor.h"
 
 using base::win::ScopedHandle;
 using base::TimeDelta;
 
 namespace {
 
 // The minimum and maximum delays between attempts to inject host process into
 // a session.
 const int kMaxLaunchDelaySeconds = 60;
 const int kMinLaunchDelaySeconds = 1;
 
 const FilePath::CharType kMe2meHostBinaryName[] =
     FILE_PATH_LITERAL("remoting_me2me_host.exe");
 
 const FilePath::CharType kMe2meServiceBinaryName[] =
     FILE_PATH_LITERAL("remoting_service.exe");
 
-// The IPC channel name is passed to the host in the command line.
-const char kChromotingIpcSwitchName[] = "chromoting-ipc";
+// The command line switch specifying the name of the daemon IPC endpoint.
+const char kDaemonIpcSwitchName[] = "daemon-pipe";
 
 const char kElevateSwitchName[] = "elevate";
 
 // The command line parameters that should be copied from the service's command
 // line to the host process.
 const char* kCopiedSwitchNames[] = {
-    "auth-config", "host-config", switches::kV, switches::kVModule };
+    "host-config", switches::kV, switches::kVModule };
 
-// The security descriptor of the Chromoting IPC channel. It gives full access
+// The security descriptor of the daemon IPC endpoint. It gives full access
 // to LocalSystem and denies access by anyone else.
-const char kChromotingChannelSecurityDescriptor[] = "O:SYG:SYD:(A;;GA;;;SY)";
+const char kDaemonIpcSecurityDescriptor[] = "O:SYG:SYD:(A;;GA;;;SY)";
 
 } // namespace
 
 namespace remoting {
 
 WtsSessionProcessLauncher::WtsSessionProcessLauncher(
     const base::Closure& stopped_callback,
     WtsConsoleMonitor* monitor,
     scoped_refptr<base::SingleThreadTaskRunner> main_message_loop,
     scoped_refptr<base::SingleThreadTaskRunner> ipc_message_loop)
@@ skipping 12 matching lines @@
   // port represented by |ipc_message_loop|. The registration has to be done on
   // the I/O thread because MessageLoopForIO::RegisterJobObject() can only be
   // called via MessageLoopForIO::current().
   ipc_message_loop_->PostTask(FROM_HERE, base::Bind(
       &WtsSessionProcessLauncher::InitializeJob,
       base::Unretained(this)));
 }
 
 WtsSessionProcessLauncher::~WtsSessionProcessLauncher() {
   // Make sure that the object is completely stopped. The same check exists
-  // in Stoppable::~Stoppable() but this one allows us to examine the state of
-  // the object before destruction.
+  // in Stoppable::~Stoppable() but this one helps us to fail early and
+  // predictably.
   CHECK_EQ(stoppable_state(), Stoppable::kStopped);
 
   monitor_->RemoveWtsConsoleObserver(this);
 
   CHECK(!attached_);
   CHECK(!timer_.IsRunning());
 }
 
 void WtsSessionProcessLauncher::OnIOCompleted(
     base::MessagePumpForIO::IOContext* context,
@@ skipping 25 matching lines @@
     LOG(ERROR) << "Failed to get the executable file name.";
     return false;
   }
   FilePath host_binary = dir_path.Append(kMe2meHostBinaryName);
   FilePath service_binary = dir_path.Append(kMe2meServiceBinaryName);
 
   // Create the host process command line passing the name of the IPC channel
   // to use and copying known switches from the service's command line.
   CommandLine command_line(service_binary);
   command_line.AppendSwitchPath(kElevateSwitchName, host_binary);
-  command_line.AppendSwitchNative(kChromotingIpcSwitchName,
+  command_line.AppendSwitchNative(kDaemonIpcSwitchName,
                                   UTF8ToWide(channel_name));
   command_line.CopySwitchesFrom(*CommandLine::ForCurrentProcess(),
                                 kCopiedSwitchNames,
                                 _countof(kCopiedSwitchNames));
 
   CHECK(ResetEvent(process_exit_event_));
 
   // Try to launch the process and attach an object watcher to the returned
   // handle so that we get notified when the process terminates.
   base::win::ScopedHandle worker_process;
@@ skipping 213 matching lines @@
 }
 
 void WtsSessionProcessLauncher::LaunchProcess() {
   DCHECK(main_message_loop_->BelongsToCurrentThread());
   DCHECK(attached_);
   DCHECK(launcher_.get() == NULL);
   DCHECK(!timer_.IsRunning());
 
   launch_time_ = base::Time::Now();
   launcher_.reset(new WorkerProcessLauncher(
-      this,
+      this, this,
       base::Bind(&WtsSessionProcessLauncher::OnLauncherStopped,
                  base::Unretained(this)),
       main_message_loop_,
       ipc_message_loop_));
-  launcher_->Start(kChromotingChannelSecurityDescriptor);
+  launcher_->Start(kDaemonIpcSecurityDescriptor);
 }
 
 void WtsSessionProcessLauncher::OnLauncherStopped() {
   DCHECK(main_message_loop_->BelongsToCurrentThread());
 
   DWORD exit_code = CONTROL_C_EXIT;
   if (worker_process_.IsValid()) {
     if (!::GetExitCodeProcess(worker_process_, &exit_code)) {
       LOG_GETLASTERROR(INFO)
           << "Failed to query the exit code of the worker process";
@@ skipping 34 matching lines @@
           launch_backoff_, TimeDelta::FromSeconds(kMaxLaunchDelaySeconds));
     }
 
     // Try to launch the worker process.
     timer_.Start(FROM_HERE, launch_backoff_,
                  this, &WtsSessionProcessLauncher::LaunchProcess);
   }
 }
 
 } // namespace remoting