Linux: make current InitializeSandbox() private.

content/common/sandbox_seccomp_bpf_linux.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 <asm/unistd.h>
 #include <dlfcn.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/audit.h>
 #include <linux/filter.h>
@@ skipping 20 matching lines @@
 // These are the only architectures supported for now.
 #if defined(__i386__) || defined(__x86_64__) || \
     (defined(__arm__) && (defined(__thumb__) || defined(__ARM_EABI__)))
 #define SECCOMP_BPF_SANDBOX
 #endif
 
 #if defined(SECCOMP_BPF_SANDBOX)
 #include "sandbox/linux/seccomp-bpf/sandbox_bpf.h"
 #include "sandbox/linux/services/linux_syscalls.h"
 
+using content::LinuxSandbox;
 using playground2::arch_seccomp_data;
 using playground2::ErrorCode;
 using playground2::Sandbox;
 using sandbox::BrokerProcess;
 
 namespace {
 
 void StartSandboxWithPolicy(Sandbox::EvaluateSyscall syscall_policy,
                             BrokerProcess* broker_process);
 
@@ skipping 1447 matching lines @@
         }
 
         dlopen(I965DrvVideoPath, RTLD_NOW|RTLD_GLOBAL|RTLD_NODELETE);
       }
     }
   }
 }
 
 Sandbox::EvaluateSyscall GetProcessSyscallPolicy(
     const CommandLine& command_line,
-    const std::string& process_type) {
-  if (process_type == switches::kGpuProcess) {
+    LinuxSandbox::SandboxConfig sandbox_config) {
+  if (sandbox_config == LinuxSandbox::SANDBOX_CONFIG_GPU) {
     // On Chrome OS, --enable-gpu-sandbox enables the more restrictive policy.
     // However, we don't yet enable the more restrictive GPU process policy
     // on ARM.
     if (IsArchitectureArm() ||
         (IsChromeOS() && !command_line.HasSwitch(switches::kEnableGpuSandbox)))
       return BlacklistDebugAndNumaPolicy;
     else
       return GpuProcessPolicy;
   }
 
-  if (process_type == switches::kPpapiPluginProcess) {
+  if (sandbox_config == LinuxSandbox::SANDBOX_CONFIG_PPAPI) {
     // TODO(jln): figure out what to do with non-Flash PPAPI
     // out-of-process plug-ins.
     return FlashProcessPolicy;
   }
 
-  if (process_type == switches::kRendererProcess ||
-      process_type == switches::kWorkerProcess) {
+  if (sandbox_config == LinuxSandbox::SANDBOX_CONFIG_RENDERER ||
+      sandbox_config == LinuxSandbox::SANDBOX_CONFIG_WORKER) {
     return RendererOrWorkerProcessPolicy;
   }
 
-  if (process_type == switches::kUtilityProcess) {
+  if (sandbox_config == LinuxSandbox::SANDBOX_CONFIG_UTILITY) {
     return BlacklistDebugAndNumaPolicy;
   }
 
   NOTREACHED();
   // This will be our default if we need one.
   return AllowAllPolicy;
 }
 
 // broker_process can be NULL if there is no need for one.
 void StartSandboxWithPolicy(Sandbox::EvaluateSyscall syscall_policy,
                             BrokerProcess* broker_process) {
   // Starting the sandbox is a one-way operation. The kernel doesn't allow
   // us to unload a sandbox policy after it has been started. Nonetheless,
   // in order to make the use of the "Sandbox" object easier, we allow for
   // the object to be destroyed after the sandbox has been started. Note that
   // doing so does not stop the sandbox.
   Sandbox sandbox;
   sandbox.SetSandboxPolicy(syscall_policy, broker_process);
   sandbox.StartSandbox();
 }
 
 // Initialize the seccomp-bpf sandbox.
 bool StartBpfSandbox(const CommandLine& command_line,
-                     const std::string& process_type) {
+                     LinuxSandbox::SandboxConfig sandbox_config) {
   Sandbox::EvaluateSyscall syscall_policy =
-      GetProcessSyscallPolicy(command_line, process_type);
+      GetProcessSyscallPolicy(command_line, sandbox_config);
 
   BrokerProcess* broker_process = NULL;
   // Warm up resources needed by the policy we're about to enable and
   // eventually start a broker process.
   WarmupPolicy(syscall_policy, &broker_process);
 
   StartSandboxWithPolicy(syscall_policy, broker_process);
 
   return true;
 }
 
 }  // namespace
 
 #endif  // SECCOMP_BPF_SANDBOX
 
 namespace content {
 
 // Is seccomp BPF globally enabled?
 bool SandboxSeccompBpf::IsSeccompBpfDesired() {
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (!command_line.HasSwitch(switches::kNoSandbox) &&
       !command_line.HasSwitch(switches::kDisableSeccompFilterSandbox)) {
     return true;
   } else {
     return false;
   }
 }
 
 bool SandboxSeccompBpf::ShouldEnableSeccompBpf(
-    const std::string& process_type) {
+    LinuxSandbox::SandboxConfig sandbox_config) {
 #if defined(SECCOMP_BPF_SANDBOX)
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
-  if (process_type == switches::kGpuProcess)
+  if (sandbox_config == LinuxSandbox::SANDBOX_CONFIG_GPU)
     return !command_line.HasSwitch(switches::kDisableGpuSandbox);
 
   return true;
 #endif  // SECCOMP_BPF_SANDBOX
   return false;
 }
 
 bool SandboxSeccompBpf::SupportsSandbox() {
 #if defined(SECCOMP_BPF_SANDBOX)
   // TODO(jln): pass the saved proc_fd_ from the LinuxSandbox singleton
   // here.
   Sandbox::SandboxStatus bpf_sandbox_status =
       Sandbox::SupportsSeccompSandbox(-1);
   // Kernel support is what we are interested in here. Other status
   // such as STATUS_UNAVAILABLE (has threads) still indicate kernel support.
   // We make this a negative check, since if there is a bug, we would rather
   // "fail closed" (expect a sandbox to be available and try to start it).
   if (bpf_sandbox_status != Sandbox::STATUS_UNSUPPORTED) {
     return true;
   }
 #endif
   return false;
 }
 
-bool SandboxSeccompBpf::StartSandbox(const std::string& process_type) {
+bool SandboxSeccompBpf::StartSandbox(
+    LinuxSandbox::SandboxConfig sandbox_config) {
 #if defined(SECCOMP_BPF_SANDBOX)
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
   if (IsSeccompBpfDesired() &&  // Global switches policy.
-      ShouldEnableSeccompBpf(process_type) &&  // Process-specific policy.
+      ShouldEnableSeccompBpf(sandbox_config) &&  // Process-specific policy.
       SupportsSandbox()) {
     // If the kernel supports the sandbox, and if the command line says we
     // should enable it, enable it or die.
-    bool started_sandbox = StartBpfSandbox(command_line, process_type);
+    bool started_sandbox = StartBpfSandbox(command_line, sandbox_config);
     CHECK(started_sandbox);
     return true;
   }
 #endif
   return false;
 }
 
 }  // namespace content