Revert of Use ChannelMojo between the remoting daemon and network processes.

remoting/host/win/launch_process_with_token.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.
 
 #include "remoting/host/win/launch_process_with_token.h"
 
 #include <windows.h>
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/scoped_process_information.h"
-#include "base/win/startup_information.h"
 
 using base::win::ScopedHandle;
 
 namespace {
 
 // Copies the process token making it a primary impersonation token.
 // The returned handle will have |desired_access| rights.
 bool CopyProcessToken(DWORD desired_access, ScopedHandle* token_out) {
   HANDLE temp_handle;
   if (!OpenProcessToken(GetCurrentProcess(),
@@ skipping 44 matching lines @@
   }
 
   *token_out = std::move(privileged_token);
   return true;
 }
 
 }  // namespace
 
 namespace remoting {
 
+base::LazyInstance<base::Lock>::Leaky g_inherit_handles_lock =
+    LAZY_INSTANCE_INITIALIZER;
+
 // Creates a copy of the current process token for the given |session_id| so
 // it can be used to launch a process in that session.
 bool CreateSessionToken(uint32_t session_id, ScopedHandle* token_out) {
   ScopedHandle session_token;
   DWORD desired_access = TOKEN_ADJUST_DEFAULT | TOKEN_ADJUST_SESSIONID |
                          TOKEN_ASSIGN_PRIMARY | TOKEN_DUPLICATE | TOKEN_QUERY;
   if (!CopyProcessToken(desired_access, &session_token)) {
     return false;
   }
 
@@ skipping 21 matching lines @@
     return false;
   }
 
   // Revert to the default token.
   CHECK(RevertToSelf());
 
   *token_out = std::move(session_token);
   return true;
 }
 
-bool LaunchProcessWithToken(
-    const base::FilePath& binary,
-    const base::CommandLine::StringType& command_line,
-    HANDLE user_token,
-    SECURITY_ATTRIBUTES* process_attributes,
-    SECURITY_ATTRIBUTES* thread_attributes,
-    const base::HandlesToInheritVector& handles_to_inherit,
-    DWORD creation_flags,
-    const base::char16* desktop_name,
-    ScopedHandle* process_out,
-    ScopedHandle* thread_out) {
+bool LaunchProcessWithToken(const base::FilePath& binary,
+                            const base::CommandLine::StringType& command_line,
+                            HANDLE user_token,
+                            SECURITY_ATTRIBUTES* process_attributes,
+                            SECURITY_ATTRIBUTES* thread_attributes,
+                            bool inherit_handles,
+                            DWORD creation_flags,
+                            const base::char16* desktop_name,
+                            ScopedHandle* process_out,
+                            ScopedHandle* thread_out) {
   base::FilePath::StringType application_name = binary.value();
 
-  base::win::StartupInformation startup_info_wrapper;
-  STARTUPINFO* startup_info = startup_info_wrapper.startup_info();
+  STARTUPINFOW startup_info;
+  memset(&startup_info, 0, sizeof(startup_info));
+  startup_info.cb = sizeof(startup_info);
   if (desktop_name)
-    startup_info->lpDesktop = const_cast<base::char16*>(desktop_name);
+    startup_info.lpDesktop = const_cast<base::char16*>(desktop_name);
 
-  bool inherit_handles = false;
-  if (!handles_to_inherit.empty()) {
-    if (handles_to_inherit.size() >
-        std::numeric_limits<DWORD>::max() / sizeof(HANDLE)) {
-      DLOG(ERROR) << "Too many handles to inherit.";
-      return false;
-    }
-
-    // Ensure the handles can be inherited.
-    for (HANDLE handle : handles_to_inherit) {
-      BOOL result = SetHandleInformation(handle, HANDLE_FLAG_INHERIT,
-                                         HANDLE_FLAG_INHERIT);
-      PCHECK(result);
-    }
-
-    if (!startup_info_wrapper.InitializeProcThreadAttributeList(
-            /* attribute_count= */ 1)) {
-      PLOG(ERROR) << "InitializeProcThreadAttributeList()";
-      return false;
-    }
-
-    if (!startup_info_wrapper.UpdateProcThreadAttribute(
-            PROC_THREAD_ATTRIBUTE_HANDLE_LIST,
-            const_cast<HANDLE*>(&handles_to_inherit.at(0)),
-            static_cast<DWORD>(handles_to_inherit.size() * sizeof(HANDLE)))) {
-      PLOG(ERROR) << "UpdateProcThreadAttribute()";
-      return false;
-    }
-
-    inherit_handles = true;
-    creation_flags |= EXTENDED_STARTUPINFO_PRESENT;
-  }
   PROCESS_INFORMATION temp_process_info = {};
-  BOOL result = CreateProcessAsUser(user_token, application_name.c_str(),
+  BOOL result = CreateProcessAsUser(user_token,
+                                    application_name.c_str(),
                                     const_cast<LPWSTR>(command_line.c_str()),
-                                    process_attributes, thread_attributes,
-                                    inherit_handles, creation_flags, nullptr,
-                                    nullptr, startup_info, &temp_process_info);
+                                    process_attributes,
+                                    thread_attributes,
+                                    inherit_handles,
+                                    creation_flags,
+                                    nullptr,
+                                    nullptr,
+                                    &startup_info,
+                                    &temp_process_info);
 
   if (!result) {
     PLOG(ERROR) << "Failed to launch a process with a user token";
     return false;
   }
 
   base::win::ScopedProcessInformation process_info(temp_process_info);
 
   CHECK(process_info.IsValid());
   process_out->Set(process_info.TakeProcessHandle());
   thread_out->Set(process_info.TakeThreadHandle());
   return true;
 }
 
 }  // namespace remoting