Removing --host-binary parameter in preparation to the coming me2me host refactoring.

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/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"
 #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");
+
 // Match the pipe name prefix used by Chrome IPC channels.
 const wchar_t kChromePipeNamePrefix[] = L"\\\\.\\pipe\\chrome.";
 
 // The IPC channel name is passed to the host in the command line.
 const char kChromotingIpcSwitchName[] = "chromoting-ipc";
 
 // 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 };
@@ skipping 154 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::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) {
@@ skipping 10 matching lines @@
 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);
 
   launch_time_ = base::Time::Now();
 
+  // Construct the host binary name.
+  FilePath dir_path;
+  if (!PathService::Get(base::DIR_EXE, &dir_path)) {
+    LOG(ERROR) << "Failed to get the executable file name.";
+    Stop();
+    return;
+  }
+  FilePath host_binary = dir_path.Append(kMe2meHostBinaryName);
+
   std::wstring channel_name;
   ScopedHandle pipe;
   if (CreatePipeForIpcChannel(this, &channel_name, &pipe)) {
     // Wrap the pipe into an IPC channel.
     chromoting_channel_.reset(new IPC::ChannelProxy(
         IPC::ChannelHandle(pipe.Get()),
         IPC::Channel::MODE_SERVER,
         this,
         ipc_message_loop_));
 
     // 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(host_binary_);
+    CommandLine command_line(host_binary);
     command_line.AppendSwitchNative(kChromotingIpcSwitchName, channel_name);
     command_line.CopySwitchesFrom(*CommandLine::ForCurrentProcess(),
                                   kCopiedSwitchNames,
                                   _countof(kCopiedSwitchNames));
 
     // Try to launch the process and attach an object watcher to the returned
     // handle so that we get notified when the process terminates.
-    if (LaunchProcessWithToken(host_binary_,
+    if (LaunchProcessWithToken(host_binary,
                                command_line.GetCommandLineString(),
                                session_token_,
                                &process_)) {
       if (process_watcher_.StartWatching(process_.handle(), this)) {
         state_ = StateAttached;
         return;
       } else {
         LOG(ERROR) << "Failed to arm the process watcher.";
         process_.Terminate(0);
         process_.Close();
@@ skipping 186 matching lines @@
 
 void WtsSessionProcessLauncher::DoStop() {
   if (state_ != StateDetached) {
     OnSessionDetached();
   }
 
   CompleteStopping();
 }
 
 } // namespace remoting