Get rid of SandboxedProcessLauncherDelegate::PreSandbox.

content/common/sandbox_win.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_win.h"
 
 #include <string>
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
@@ skipping 643 matching lines @@
   DCHECK(target_services);
   DCHECK(!g_target_services);
   sandbox::ResultCode result = target_services->Init();
   g_target_services = target_services;
   return sandbox::SBOX_ALL_OK == result;
 }
 
 base::Process StartSandboxedProcess(
     SandboxedProcessLauncherDelegate* delegate,
     base::CommandLine* cmd_line) {
+  DCHECK(delegate);
   const base::CommandLine& browser_command_line =
       *base::CommandLine::ForCurrentProcess();
   std::string type_str = cmd_line->GetSwitchValueASCII(switches::kProcessType);
 
   TRACE_EVENT1("startup", "StartProcessWithAccess", "type", type_str);
 
   // Propagate the --allow-no-job flag if present.
   if (browser_command_line.HasSwitch(switches::kAllowNoSandboxJob) &&
       !cmd_line->HasSwitch(switches::kAllowNoSandboxJob)) {
     cmd_line->AppendSwitch(switches::kAllowNoSandboxJob);
   }
 
   ProcessDebugFlags(cmd_line);
 
   // 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", base::Hash(type_str)));
 
-  if ((delegate && !delegate->ShouldSandbox()) ||
+  if ((!delegate->ShouldSandbox()) ||
       browser_command_line.HasSwitch(switches::kNoSandbox) ||
       cmd_line->HasSwitch(switches::kNoSandbox)) {
     base::Process process =
         base::LaunchProcess(*cmd_line, base::LaunchOptions());
     // TODO(rvargas) crbug.com/417532: Don't share a raw handle.
     g_broker_services->AddTargetPeer(process.Handle());
     return process.Pass();
   }
 
   sandbox::TargetPolicy* policy = g_broker_services->CreatePolicy();
@@ skipping 16 matching lines @@
 #endif
 
   mitigations = sandbox::MITIGATION_STRICT_HANDLE_CHECKS |
                 sandbox::MITIGATION_DLL_SEARCH_ORDER;
 
   if (policy->SetDelayedProcessMitigations(mitigations) != sandbox::SBOX_ALL_OK)
     return base::Process();
 
   SetJobLevel(*cmd_line, sandbox::JOB_LOCKDOWN, 0, policy);
 
-  bool disable_default_policy = false;
-  base::FilePath exposed_dir;
-  if (delegate)
-    delegate->PreSandbox(&disable_default_policy, &exposed_dir);
-
-  if (!disable_default_policy && !AddPolicyForSandboxedProcess(policy))
-    return base::Process();
+  if (!delegate->DisableDefaultPolicy()) {
+    if (!AddPolicyForSandboxedProcess(policy)) {
+      return base::Process();
+    }
+  }
 
 #if !defined(NACL_WIN64)
   if (type_str == switches::kRendererProcess ||
       type_str == switches::kPpapiPluginProcess) {
     if (gfx::win::ShouldUseDirectWrite()) {
       AddDirectory(base::DIR_WINDOWS_FONTS,
                   NULL,
                   true,
                   sandbox::TargetPolicy::FILES_ALLOW_READONLY,
                   policy);
@@ skipping 17 matching lines @@
   }
 #endif
 
   if (type_str != switches::kRendererProcess) {
     // Hack for Google Desktop crash. Trick GD into not injecting its DLL into
     // this subprocess. See
     // http://code.google.com/p/chromium/issues/detail?id=25580
     cmd_line->AppendSwitchASCII("ignored", " --type=renderer ");
   }
 
-  sandbox::ResultCode result;
-  if (!exposed_dir.empty()) {
-    result = policy->AddRule(sandbox::TargetPolicy::SUBSYS_FILES,
-                             sandbox::TargetPolicy::FILES_ALLOW_ANY,
-                             exposed_dir.value().c_str());
-    if (result != sandbox::SBOX_ALL_OK)
-      return base::Process();
-
-    base::FilePath exposed_files = exposed_dir.AppendASCII("*");
-    result = policy->AddRule(sandbox::TargetPolicy::SUBSYS_FILES,
-                             sandbox::TargetPolicy::FILES_ALLOW_ANY,
-                             exposed_files.value().c_str());
-    if (result != sandbox::SBOX_ALL_OK)
-      return base::Process();
-  }
-
   if (!AddGenericPolicy(policy)) {
     NOTREACHED();
     return base::Process();
   }
 
   // Allow the renderer and gpu processes to access the log file.
   if (type_str == switches::kRendererProcess ||
       type_str == switches::kGpuProcess) {
     if (logging::IsLoggingToFileEnabled()) {
       DCHECK(base::FilePath(logging::GetLogFileFullPath()).IsAbsolute());
       policy->AddRule(sandbox::TargetPolicy::SUBSYS_FILES,
                       sandbox::TargetPolicy::FILES_ALLOW_ANY,
                       logging::GetLogFileFullPath().c_str());
     }
   }
 
 #if !defined(OFFICIAL_BUILD)
   // If stdout/stderr point to a Windows console, these calls will
   // have no effect.
   policy->SetStdoutHandle(GetStdHandle(STD_OUTPUT_HANDLE));
   policy->SetStderrHandle(GetStdHandle(STD_ERROR_HANDLE));
 #endif
 
-  if (delegate) {
-    bool success = true;
-    delegate->PreSpawnTarget(policy, &success);
-    if (!success)
-      return base::Process();
+  if (!delegate->PreSpawnTarget(policy)) {
+    return base::Process();
   }
 
   TRACE_EVENT_BEGIN0("startup", "StartProcessWithAccess::LAUNCHPROCESS");
 
   PROCESS_INFORMATION temp_process_info = {};
-  result = g_broker_services->SpawnTarget(
+  sandbox::ResultCode result = g_broker_services->SpawnTarget(
       cmd_line->GetProgram().value().c_str(),
       cmd_line->GetCommandLineString().c_str(), policy, &temp_process_info);
   DWORD last_error = ::GetLastError();
   base::win::ScopedProcessInformation target(temp_process_info);
 
   TRACE_EVENT_END0("startup", "StartProcessWithAccess::LAUNCHPROCESS");
 
   if (sandbox::SBOX_ALL_OK != result) {
     if (result == sandbox::SBOX_ERROR_GENERIC)
       DPLOG(ERROR) << "Failed to launch process";
     else if (result == sandbox::SBOX_ERROR_CREATE_PROCESS) {
       // TODO(shrikant): Remove this special case handling after determining
       // cause for lowbox/createprocess errors.
       sandbox::PolicyBase* policy_base =
           static_cast<sandbox::PolicyBase*>(policy);
       UMA_HISTOGRAM_SPARSE_SLOWLY(policy_base->GetLowBoxSid() ?
                                       "Process.Sandbox.Lowbox.Launch.Error" :
                                       "Process.Sandbox.Launch.Error",
                                   last_error);
     } else
       DLOG(ERROR) << "Failed to launch process. Error: " << result;
 
-    policy->Release();
     return base::Process();
   }
-  policy->Release();
 
-  if (delegate)
-    delegate->PostSpawnTarget(target.process_handle());
+  delegate->PostSpawnTarget(target.process_handle());
 
   CHECK(ResumeThread(target.thread_handle()) != -1);
   return base::Process(target.TakeProcessHandle());
 }
 
 bool BrokerDuplicateHandle(HANDLE source_handle,
                            DWORD target_process_id,
                            HANDLE* target_handle,
                            DWORD desired_access,
                            DWORD options) {
   // If our process is the target just duplicate the handle.
   if (::GetCurrentProcessId() == target_process_id) {
     return !!::DuplicateHandle(::GetCurrentProcess(), source_handle,
                                ::GetCurrentProcess(), target_handle,
                                desired_access, FALSE, options);
-
   }
 
   // Try the broker next
   if (g_target_services &&
       g_target_services->DuplicateHandle(source_handle, target_process_id,
                                          target_handle, desired_access,
                                          options) == sandbox::SBOX_ALL_OK) {
     return true;
   }
 
   // Finally, see if we already have access to the process.
   base::win::ScopedHandle target_process;
   target_process.Set(::OpenProcess(PROCESS_DUP_HANDLE, FALSE,
                                     target_process_id));
   if (target_process.IsValid()) {
     return !!::DuplicateHandle(::GetCurrentProcess(), source_handle,
                                 target_process.Get(), target_handle,
                                 desired_access, FALSE, options);
   }
 
   return false;
 }
 
 bool BrokerAddTargetPeer(HANDLE peer_process) {
   return g_broker_services->AddTargetPeer(peer_process) == sandbox::SBOX_ALL_OK;
 }
 
 }  // namespace content