Add support for alternate window station.

sandbox/src/target_process.cc

-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2006-2009 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 "sandbox/src/target_process.h"
 
 #include "base/basictypes.h"
 #include "base/scoped_ptr.h"
 #include "sandbox/src/crosscall_server.h"
 #include "sandbox/src/crosscall_client.h"
 #include "sandbox/src/pe_image.h"
@@ skipping 64 matching lines @@
     : lockdown_token_(lockdown_token),
       initial_token_(initial_token),
       job_(job),
       shared_section_(NULL),
       ipc_server_(NULL),
       thread_pool_(thread_pool),
       base_address_(NULL),
       exe_name_(NULL),
       sandbox_process_(NULL),
       sandbox_thread_(NULL),
-      desktop_handle_(NULL),
       sandbox_process_id_(0) {
 }
 
 TargetProcess::~TargetProcess() {
   DWORD exit_code = 0;
   // Give a chance to the process to die. In most cases the JOB_KILL_ON_CLOSE
   // will take effect only when the context changes. As far as the testing went,
   // this wait was enough to switch context and kill the processes in the job.
   // If this process is already dead, the function will return without waiting.
   // TODO(nsylvain):  If the process is still alive at the end, we should kill
   // it. http://b/893891
   // For now, this wait is there only to do a best effort to prevent some leaks
   // from showing up in purify.
   ::WaitForSingleObject(sandbox_process_, 50);
   if (!::GetExitCodeProcess(sandbox_process_, &exit_code) ||
       (STILL_ACTIVE == exit_code)) {
     // It is an error to destroy this object while the target process is still
     // alive because we need to destroy the IPC subsystem and cannot risk to
     // have an IPC reach us after this point.
     return;
   }
 
   delete ipc_server_;
 
   ::CloseHandle(lockdown_token_);
   ::CloseHandle(initial_token_);
   ::CloseHandle(sandbox_process_);
   if (shared_section_)
     ::CloseHandle(shared_section_);
-  if (desktop_handle_)
-    ::CloseDesktop(desktop_handle_);
   free(exe_name_);
 }
 
 // Creates the target (child) process suspended and assigns it to the job
 // object.
 DWORD TargetProcess::Create(const wchar_t* exe_path,
                             const wchar_t* command_line,
                             const wchar_t* desktop,
                             PROCESS_INFORMATION* target_info) {
   exe_name_ = _wcsdup(exe_path);
 
   // the command line needs to be writable by CreateProcess().
   scoped_ptr_malloc<wchar_t> cmd_line(_wcsdup(command_line));
   scoped_ptr_malloc<wchar_t> desktop_name(desktop ? _wcsdup(desktop) : NULL);
 
+  // Start the target process suspended.
   const DWORD flags = CREATE_SUSPENDED | CREATE_BREAKAWAY_FROM_JOB |
                       CREATE_UNICODE_ENVIRONMENT | DETACHED_PROCESS;
 
-  // Start the target process suspended
   STARTUPINFO startup_info = {sizeof(STARTUPINFO)};
   if (desktop) {
-    // Ensure that the desktop exists
-    desktop_handle_ = ::CreateDesktop(desktop_name.get(), NULL, NULL, 0,
-                                      DESKTOP_CREATEWINDOW, NULL);
     startup_info.lpDesktop = desktop_name.get();
   }
 
   PROCESS_INFORMATION process_info = {0};
 
   if (!::CreateProcessAsUserW(lockdown_token_,
                               exe_path,
                               cmd_line.get(),
                               NULL,   // No security attribute.
                               NULL,   // No thread attribute.
@@ skipping 171 matching lines @@
 
 
 TargetProcess* MakeTestTargetProcess(HANDLE process, HMODULE base_address) {
   TargetProcess* target = new TargetProcess(NULL, NULL, NULL, NULL);
   target->sandbox_process_ = process;
   target->base_address_ = base_address;
   return target;
 }
 
 }  // namespace sandbox