Remove more dependencies on sandbox/linux/seccomp-bpf

components/nacl/loader/sandbox_linux/nacl_bpf_sandbox_linux.cc

 // Copyright 2013 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 "components/nacl/loader/sandbox_linux/nacl_bpf_sandbox_linux.h"
 
 #include "build/build_config.h"
 
 #if defined(USE_SECCOMP_BPF)
 
 #include <errno.h>
 #include <signal.h>
 #include <sys/ptrace.h>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 
 #include "content/public/common/sandbox_init.h"
-#include "sandbox/linux/seccomp-bpf/sandbox_bpf.h"
-#include "sandbox/linux/seccomp-bpf/sandbox_bpf_policy.h"
+#include "sandbox/linux/bpf_dsl/bpf_dsl.h"
 #include "sandbox/linux/services/linux_syscalls.h"
 
 #endif  // defined(USE_SECCOMP_BPF)
 
 namespace nacl {
 
 #if defined(USE_SECCOMP_BPF)
 
 namespace {
 
-class NaClBPFSandboxPolicy : public sandbox::SandboxBPFPolicy {
+using sandbox::bpf_dsl::Allow;
+using sandbox::bpf_dsl::Error;
+using sandbox::bpf_dsl::ResultExpr;
+
+class NaClBPFSandboxPolicy : public sandbox::bpf_dsl::SandboxBPFDSLPolicy {
  public:
   NaClBPFSandboxPolicy()
       : baseline_policy_(content::GetBPFSandboxBaselinePolicy()) {}
   virtual ~NaClBPFSandboxPolicy() {}
 
-  virtual sandbox::ErrorCode EvaluateSyscall(
-      sandbox::SandboxBPF* sandbox_compiler,
-      int system_call_number) const OVERRIDE;
-  virtual sandbox::ErrorCode InvalidSyscall(
-      sandbox::SandboxBPF* sandbox_compiler) const OVERRIDE {
-    return baseline_policy_->InvalidSyscall(sandbox_compiler);
+  virtual ResultExpr EvaluateSyscall(int system_call_number) const OVERRIDE;
+  virtual ResultExpr InvalidSyscall() const OVERRIDE {
+    return baseline_policy_->InvalidSyscall();
   }
 
  private:
-  scoped_ptr<sandbox::SandboxBPFPolicy> baseline_policy_;
+  scoped_ptr<sandbox::bpf_dsl::SandboxBPFDSLPolicy> baseline_policy_;
+
   DISALLOW_COPY_AND_ASSIGN(NaClBPFSandboxPolicy);
 };
 
-sandbox::ErrorCode NaClBPFSandboxPolicy::EvaluateSyscall(
-    sandbox::SandboxBPF* sb, int sysno) const {
+ResultExpr NaClBPFSandboxPolicy::EvaluateSyscall(int sysno) const {
   DCHECK(baseline_policy_);
   switch (sysno) {
     // TODO(jln): NaCl's GDB debug stub uses the following socket system calls,
     // see if it can be restricted a bit.
 #if defined(__x86_64__) || defined(__arm__) || defined(__mips__)
     // transport_common.cc needs this.
     case __NR_accept:
     case __NR_setsockopt:
 #elif defined(__i386__)
     case __NR_socketcall:
@@ skipping 27 matching lines @@
     case __NR_sched_getaffinity:
     case __NR_sched_getparam:
     case __NR_sched_getscheduler:
     case __NR_sched_setscheduler:
     case __NR_sysinfo:
     // __NR_times needed as clock() is called by CommandBufferHelper, which is
     // used by NaCl applications that use Pepper's 3D interfaces.
     // See crbug.com/264856 for details.
     case __NR_times:
     case __NR_uname:
-      return sandbox::ErrorCode(sandbox::ErrorCode::ERR_ALLOWED);
+      return Allow();
     case __NR_ioctl:
     case __NR_ptrace:
-      return sandbox::ErrorCode(EPERM);
+      return Error(EPERM);
     default:
-      return baseline_policy_->EvaluateSyscall(sb, sysno);
+      return baseline_policy_->EvaluateSyscall(sysno);
   }
   NOTREACHED();
   // GCC wants this.
-  return sandbox::ErrorCode(EPERM);
+  return Error(EPERM);
 }
 
 void RunSandboxSanityChecks() {
   errno = 0;
   // Make a ptrace request with an invalid PID.
   long ptrace_ret = ptrace(PTRACE_PEEKUSER, -1 /* pid */, NULL, NULL);
   CHECK_EQ(-1, ptrace_ret);
   // Without the sandbox on, this ptrace call would ESRCH instead.
   CHECK_EQ(EPERM, errno);
 }
 
 }  // namespace
 
 #else
 
 #error "Seccomp-bpf disabled on supported architecture!"
 
 #endif  // defined(USE_SECCOMP_BPF)
 
 bool InitializeBPFSandbox() {
 #if defined(USE_SECCOMP_BPF)
   bool sandbox_is_initialized = content::InitializeSandbox(
-      scoped_ptr<sandbox::SandboxBPFPolicy>(new NaClBPFSandboxPolicy));
+      scoped_ptr<sandbox::bpf_dsl::SandboxBPFDSLPolicy>(
+          new NaClBPFSandboxPolicy));
   if (sandbox_is_initialized) {
     RunSandboxSanityChecks();
     return true;
   }
 #endif  // defined(USE_SECCOMP_BPF)
   return false;
 }
 
 }  // namespace nacl