Use ScopedProcessInformation and other RAII types in sandbox.

content/common/sandbox_policy.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 "content/common/sandbox_policy.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/debug/debugger.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/stringprintf.h"
 #include "base/string_util.h"
+#include "base/win/scoped_process_information.h"
 #include "base/win/windows_version.h"
 #include "content/common/debug_flags.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/process_type.h"
 #include "sandbox/src/sandbox.h"
 #include "ui/gfx/gl/gl_switches.h"
 
 static sandbox::BrokerServices* g_broker_services = NULL;
 
@@ skipping 383 matching lines @@
   // TODO(abarth): DCHECK(CalledOnValidThread());
   //               See <http://b/1287166>.
   DCHECK(broker_services);
   DCHECK(!g_broker_services);
   broker_services->Init();
   g_broker_services = broker_services;
 }
 
 base::ProcessHandle StartProcessWithAccess(CommandLine* cmd_line,
                                            const FilePath& exposed_dir) {
-  base::ProcessHandle process = 0;
   const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
   content::ProcessType type;
   std::string type_str = cmd_line->GetSwitchValueASCII(switches::kProcessType);
   if (type_str == switches::kRendererProcess) {
     type = content::PROCESS_TYPE_RENDERER;
   } else if (type_str == switches::kPluginProcess) {
     type = content::PROCESS_TYPE_PLUGIN;
   } else if (type_str == switches::kWorkerProcess) {
     type = content::PROCESS_TYPE_WORKER;
   } else if (type_str == switches::kNaClLoaderProcess) {
@@ skipping 58 matching lines @@
 
   bool child_needs_help =
       DebugFlags::ProcessDebugFlags(cmd_line, type, in_sandbox);
 
   // Prefetch hints on windows:
   // Using a different prefetch profile per process type will allow Windows
   // to create separate pretetch settings for browser, renderer etc.
   cmd_line->AppendArg(base::StringPrintf("/prefetch:%d", type));
 
   sandbox::ResultCode result;
-  PROCESS_INFORMATION target = {0};
+  base::win::ScopedProcessInformation target;
   sandbox::TargetPolicy* policy = g_broker_services->CreatePolicy();
 
 #if !defined(NACL_WIN64)  // We don't need this code on win nacl64.
   if (type == content::PROCESS_TYPE_PLUGIN &&
       !browser_command_line.HasSwitch(switches::kNoSandbox) &&
       content::GetContentClient()->SandboxPlugin(cmd_line, policy)) {
     in_sandbox = true;
   }
 #endif
 
   if (!in_sandbox) {
     policy->Release();
+    base::ProcessHandle process = 0;
     base::LaunchProcess(*cmd_line, base::LaunchOptions(), &process);
     return process;
   }
 
   if (type == content::PROCESS_TYPE_PLUGIN) {
     AddGenericDllEvictionPolicy(policy);
     AddPluginDllEvictionPolicy(policy);
   } else if (type == content::PROCESS_TYPE_GPU) {
     if (!AddPolicyForGPU(cmd_line, policy))
       return 0;
@@ skipping 35 matching lines @@
   if (!AddGenericPolicy(policy)) {
     NOTREACHED();
     return 0;
   }
 
   TRACE_EVENT_BEGIN_ETW("StartProcessWithAccess::LAUNCHPROCESS", 0, 0);
 
   result = g_broker_services->SpawnTarget(
       cmd_line->GetProgram().value().c_str(),
       cmd_line->GetCommandLineString().c_str(),
-      policy, &target);
+      policy, target.Receive());
   policy->Release();
 
   TRACE_EVENT_END_ETW("StartProcessWithAccess::LAUNCHPROCESS", 0, 0);
 
   if (sandbox::SBOX_ALL_OK != result) {
     DLOG(ERROR) << "Failed to launch process. Error: " << result;
     return 0;
   }
 
   // For Native Client sel_ldr processes on 32-bit Windows, reserve 1 GB of
   // address space to prevent later failure due to address space fragmentation
   // from .dll loading. The NaCl process will attempt to locate this space by
   // scanning the address space using VirtualQuery.
   // TODO(bbudge) Handle the --no-sandbox case.
   // http://code.google.com/p/nativeclient/issues/detail?id=2131
   if (type == content::PROCESS_TYPE_NACL_LOADER &&
       (base::win::OSInfo::GetInstance()->wow64_status() ==
           base::win::OSInfo::WOW64_DISABLED)) {
     const SIZE_T kOneGigabyte = 1 << 30;
-    void* nacl_mem = VirtualAllocEx(target.hProcess,
+    void* nacl_mem = VirtualAllocEx(target.process_handle(),
                                     NULL,
                                     kOneGigabyte,
                                     MEM_RESERVE,
                                     PAGE_NOACCESS);
     if (!nacl_mem) {
       DLOG(WARNING) << "Failed to reserve address space for Native Client";
     }
   }
 
-  ResumeThread(target.hThread);
-  CloseHandle(target.hThread);
-  process = target.hProcess;
+  ResumeThread(target.thread_handle());
 
   // Help the process a little. It can't start the debugger by itself if
   // the process is in a sandbox.
   if (child_needs_help)
-    base::debug::SpawnDebuggerOnProcess(target.dwProcessId);
+    base::debug::SpawnDebuggerOnProcess(target.process_id());
 
-  return process;
+  return target.TakeProcessHandle();
 }
 
 }  // namespace sandbox