[Chromoting] Refactored worker process launching code and speeded up the desktop process launch.

remoting/host/win/unprivileged_process_delegate.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/unprivileged_process_delegate.h"
 
 #include <sddl.h>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/process_util.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/string16.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/windows_version.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_message.h"
 #include "remoting/base/typed_buffer.h"
-#include "remoting/host/host_exit_codes.h"
 #include "remoting/host/ipc_constants.h"
 #include "remoting/host/win/launch_process_with_token.h"
 #include "remoting/host/win/security_descriptor.h"
 #include "remoting/host/win/window_station_and_desktop.h"
 #include "sandbox/win/src/restricted_token.h"
 
 using base::win::ScopedHandle;
 
 namespace remoting {
 
@@ skipping 168 matching lines @@
     return false;
   }
 
   handles.Swap(*handles_out);
   return true;
 }
 
 }  // namespace
 
 UnprivilegedProcessDelegate::UnprivilegedProcessDelegate(
-    scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     scoped_ptr<CommandLine> target_command)
-    : main_task_runner_(main_task_runner),
-      io_task_runner_(io_task_runner),
+    : io_task_runner_(io_task_runner),
+      event_handler_(NULL),
       target_command_(target_command.Pass()) {
 }
 
 UnprivilegedProcessDelegate::~UnprivilegedProcessDelegate() {
-  KillProcess(CONTROL_C_EXIT);
+  DCHECK(CalledOnValidThread());
+  DCHECK(!channel_);
+  DCHECK(!worker_process_.IsValid());
 }
 
-bool UnprivilegedProcessDelegate::Send(IPC::Message* message) {
-  DCHECK(main_task_runner_->BelongsToCurrentThread());
+void UnprivilegedProcessDelegate::LaunchProcess(
+    WorkerProcessLauncher* event_handler) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(!event_handler_);
 
-  return channel_->Send(message);
-}
-
-void UnprivilegedProcessDelegate::CloseChannel() {
-  DCHECK(main_task_runner_->BelongsToCurrentThread());
-
-  channel_.reset();
-}
-
-DWORD UnprivilegedProcessDelegate::GetProcessId() const {
-  if (worker_process_.IsValid()) {
-    return ::GetProcessId(worker_process_);
-  } else {
-    return 0;
-  }
-}
-
-bool UnprivilegedProcessDelegate::IsPermanentError(int failure_count) const {
-  // Get exit code of the worker process if it is available.
-  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";
-      exit_code = CONTROL_C_EXIT;
-    }
-  }
-
-  // Stop trying to restart the worker process if it exited due to
-  // misconfiguration.
-  return (kMinPermanentErrorExitCode <= exit_code &&
-      exit_code <= kMaxPermanentErrorExitCode);
-}
-
-void UnprivilegedProcessDelegate::KillProcess(DWORD exit_code) {
-  DCHECK(main_task_runner_->BelongsToCurrentThread());
-
-  channel_.reset();
-
-  if (worker_process_.IsValid()) {
-    TerminateProcess(worker_process_, exit_code);
-  }
-}
-
-bool UnprivilegedProcessDelegate::LaunchProcess(
-    IPC::Listener* delegate,
-    ScopedHandle* process_exit_event_out) {
-  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  event_handler_ = event_handler;
 
   scoped_ptr<IPC::ChannelProxy> server;
 
   // Generate a unique name for the channel.
   std::string channel_name = IPC::Channel::GenerateUniqueRandomChannelID();
 
   // Create a restricted token that will be used to run the worker process.
   ScopedHandle token;
   if (!CreateRestrictedToken(&token)) {
     LOG_GETLASTERROR(ERROR)
         << "Failed to create a restricted LocalService token";
-    return false;
+    ReportFatalError();
+    return;
   }
 
   // Determine our logon SID, so we can grant it access to our window station
   // and desktop.
   ScopedSid logon_sid = GetLogonSid(token);
   if (!logon_sid) {
     LOG_GETLASTERROR(ERROR) << "Failed to retrieve the logon SID";
-    return false;
+    ReportFatalError();
+    return;
   }
 
   // Create the process and thread security descriptors.
   ScopedSd process_sd = ConvertSddlToSd(kWorkerProcessSd);
   ScopedSd thread_sd = ConvertSddlToSd(kWorkerThreadSd);
   if (!process_sd || !thread_sd) {
     LOG_GETLASTERROR(ERROR) << "Failed to create a security descriptor";
-    return false;
+    ReportFatalError();
+    return;
   }
 
   SECURITY_ATTRIBUTES process_attributes;
   process_attributes.nLength = sizeof(process_attributes);
   process_attributes.lpSecurityDescriptor = process_sd.get();
   process_attributes.bInheritHandle = FALSE;
 
   SECURITY_ATTRIBUTES thread_attributes;
   thread_attributes.nLength = sizeof(thread_attributes);
   thread_attributes.lpSecurityDescriptor = thread_sd.get();
   thread_attributes.bInheritHandle = FALSE;
 
+  ScopedHandle worker_process;
   {
     // Take a lock why any inheritable handles are open to make sure that only
     // one process inherits them.
     base::AutoLock lock(g_inherit_handles_lock.Get());
 
     // Create a connected IPC channel.
     ScopedHandle client;
     if (!CreateConnectedIpcChannel(channel_name, kDaemonIpcSd, io_task_runner_,
-                                   delegate, &client, &server)) {
-      return false;
+                                   this, &client, &server)) {
+      ReportFatalError();
+      return;
     }
 
     // Convert the handle value into a decimal integer. Handle values are 32bit
     // even on 64bit platforms.
     std::string pipe_handle = base::StringPrintf(
         "%d", reinterpret_cast<ULONG_PTR>(client.Get()));
 
     // Pass the IPC channel via the command line.
     CommandLine command_line(target_command_->argv());
     command_line.AppendSwitchASCII(kDaemonPipeSwitchName, pipe_handle);
 
     // Create our own window station and desktop accessible by |logon_sid|.
     WindowStationAndDesktop handles;
     if (!CreateWindowStationAndDesktop(logon_sid.Pass(), &handles)) {
       LOG_GETLASTERROR(ERROR)
           << "Failed to create a window station and desktop";
-      return false;
+      ReportFatalError();
+      return;
     }
 
     // Try to launch the worker process. The launched process inherits
     // the window station, desktop and pipe handles, created above.
     ScopedHandle worker_thread;
-    worker_process_.Close();
     if (!LaunchProcessWithToken(command_line.GetProgram(),
                                 command_line.GetCommandLineString(),
                                 token,
                                 &process_attributes,
                                 &thread_attributes,
                                 true,
                                 0,
                                 NULL,
-                                &worker_process_,
+                                &worker_process,
                                 &worker_thread)) {
-      return false;
+      ReportFatalError();
+      return;
     }
   }
 
-  // Return a handle that the caller can wait on to get notified when
-  // the process terminates.
-  ScopedHandle process_exit_event;
+  channel_ = server.Pass();
+  ReportProcessLaunched(worker_process.Pass());
+}
+
+void UnprivilegedProcessDelegate::Send(IPC::Message* message) {
+  DCHECK(CalledOnValidThread());
+
+  if (channel_) {
+    channel_->Send(message);
+  } else {
+    delete message;
+  }
+}
+
+void UnprivilegedProcessDelegate::CloseChannel() {
+  DCHECK(CalledOnValidThread());
+
+  channel_.reset();
+}
+
+void UnprivilegedProcessDelegate::KillProcess() {
+  DCHECK(CalledOnValidThread());
+
+  channel_.reset();
+
+  if (worker_process_.IsValid()) {
+    TerminateProcess(worker_process_, CONTROL_C_EXIT);
+    worker_process_.Close();
+  }
+}
+
+bool UnprivilegedProcessDelegate::OnMessageReceived(
+    const IPC::Message& message) {
+  DCHECK(CalledOnValidThread());
+
+  return event_handler_->OnMessageReceived(message);
+}
+
+void UnprivilegedProcessDelegate::OnChannelConnected(int32 peer_pid) {
+  DCHECK(CalledOnValidThread());
+
+  DWORD pid = GetProcessId(worker_process_);
+  if (pid != static_cast<DWORD>(peer_pid)) {
+    LOG(ERROR) << "The actual client PID " << pid
+               << " does not match the one reported by the client: "
+               << peer_pid;
+    ReportFatalError();
+    return;
+  }
+
+  event_handler_->OnChannelConnected(peer_pid);
+}
+
+void UnprivilegedProcessDelegate::OnChannelError() {
+  DCHECK(CalledOnValidThread());
+
+  event_handler_->OnChannelError();
+}
+
+void UnprivilegedProcessDelegate::ReportFatalError() {
+  DCHECK(CalledOnValidThread());
+
+  channel_.reset();
+
+  WorkerProcessLauncher* event_handler = event_handler_;
+  event_handler_ = NULL;
+  event_handler->OnFatalError();
+}
+
+void UnprivilegedProcessDelegate::ReportProcessLaunched(
+    base::win::ScopedHandle worker_process) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(!worker_process_.IsValid());
+
+  worker_process_ = worker_process.Pass();
+
+  // Report a handle that can be used to wait for the worker process completion,
+  // query information about the process and duplicate handles.
+  DWORD desired_access =
+      SYNCHRONIZE | PROCESS_DUP_HANDLE | PROCESS_QUERY_INFORMATION;
+  ScopedHandle limited_handle;
   if (!DuplicateHandle(GetCurrentProcess(),
                        worker_process_,
                        GetCurrentProcess(),
-                       process_exit_event.Receive(),
-                       SYNCHRONIZE,
+                       limited_handle.Receive(),
+                       desired_access,
                        FALSE,
                        0)) {
     LOG_GETLASTERROR(ERROR) << "Failed to duplicate a handle";
-    KillProcess(CONTROL_C_EXIT);
-    return false;
+    ReportFatalError();
+    return;
   }
 
-  channel_ = server.Pass();
-  *process_exit_event_out = process_exit_event.Pass();
-  return true;
+  event_handler_->OnProcessLaunched(limited_handle.Pass());
 }
 
 } // namespace remoting