Refactored ErrorCode into it's own class

sandbox/linux/seccomp-bpf/sandbox_bpf_unittest.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 "sandbox/linux/seccomp-bpf/sandbox_bpf.h"
 #include "sandbox/linux/seccomp-bpf/verifier.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using namespace playground2;
 
@@ skipping 48 matching lines @@
     ExitGroup(1);
   }
   Sandbox::setProcFd(proc_fd);
   Sandbox::setSandboxPolicy(evaluator, NULL);
   Sandbox::startSandbox();
 }
 
 void RunInSandbox(Sandbox::EvaluateSyscall evaluator,
                       void (*SandboxedCode)()) {
   // TODO(jln): Implement IsEqual for ErrorCode
-  // IsEqual(evaluator(__NR_exit_group), Sandbox::SB_ALLOWED) <<
+  // IsEqual(evaluator(__NR_exit_group), ErrorCode::ERR_ALLOWED) <<
   //    "You need to always allow exit_group() in your test policy";
   StartSandboxOrDie(evaluator);
   // TODO(jln): find a way to use the testing framework inside
   // SandboxedCode() or at the very least to surface errors
   SandboxedCode();
   // SandboxedCode() should have exited, this is a failure
   ExitGroup(1);
 }
 
 // evaluator should always allow ExitGroup
 // SandboxedCode should ExitGroup(kExpectedReturnValue) if and only if
 // things go as expected.
 void TryPolicyInProcess(Sandbox::EvaluateSyscall evaluator,
                         void (*SandboxedCode)()) {
   // TODO(jln) figure out a way to surface whether we're actually testing
   // something or not.
   if (Sandbox::supportsSeccompSandbox(-1) == Sandbox::STATUS_AVAILABLE) {
     EXPECT_EXIT(RunInSandbox(evaluator, SandboxedCode),
                 ::testing::ExitedWithCode(kExpectedReturnValue),
                 "");
   }
 }
 
 // A simple blacklist test
 
-Sandbox::ErrorCode BlacklistNanosleepPolicy(int sysno) {
+ErrorCode BlacklistNanosleepPolicy(int sysno) {
   if (sysno < static_cast<int>(MIN_SYSCALL) ||
       sysno > static_cast<int>(MAX_SYSCALL)) {
     // FIXME: we should really not have to do that in a trivial policy
     return ENOSYS;
   }
   switch (sysno) {
     case __NR_nanosleep:
       return EACCES;
     default:
-      return Sandbox::SB_ALLOWED;
+      return ErrorCode::ERR_ALLOWED;
   }
 }
 
 void NanosleepProcess(void) {
   const struct timespec ts = {0, 0};
   errno = 0;
   if(syscall(__NR_nanosleep, &ts, NULL) != -1 || errno != EACCES) {
     ExitGroup(1);
   }
   ExitGroup(kExpectedReturnValue);
 }
 
 TEST(SandboxBpf, ApplyBasicBlacklistPolicy) {
   TryPolicyInProcess(BlacklistNanosleepPolicy, NanosleepProcess);
 }
 
 // Now do a simple whitelist test
 
-Sandbox::ErrorCode WhitelistGetpidPolicy(int sysno) {
+ErrorCode WhitelistGetpidPolicy(int sysno) {
   switch (sysno) {
     case __NR_getpid:
     case __NR_exit_group:
-      return Sandbox::SB_ALLOWED;
+      return ErrorCode::ERR_ALLOWED;
     default:
       return ENOMEM;
   }
 }
 
 void GetpidProcess(void) {
   errno = 0;
   // getpid() should be allowed
   if (syscall(__NR_getpid) < 0 || errno)
     ExitGroup(1);
@@ skipping 15 matching lines @@
 static int BlacklistNanosleepPolicySigsysAuxData;
 
 intptr_t EnomemHandler(const struct arch_seccomp_data& args, void *aux) {
   // We also check that the auxiliary data is correct
   if (!aux)
     ExitGroup(1);
   *(static_cast<int*>(aux)) = kExpectedReturnValue;
   return -ENOMEM;
 }
 
-Sandbox::ErrorCode BlacklistNanosleepPolicySigsys(int sysno) {
+ErrorCode BlacklistNanosleepPolicySigsys(int sysno) {
   if (sysno < static_cast<int>(MIN_SYSCALL) ||
       sysno > static_cast<int>(MAX_SYSCALL)) {
     // FIXME: we should really not have to do that in a trivial policy
     return ENOSYS;
   }
   switch (sysno) {
     case __NR_nanosleep:
-      return Sandbox::ErrorCode(EnomemHandler,
+      return Sandbox::Trap(EnomemHandler,
                  static_cast<void *>(&BlacklistNanosleepPolicySigsysAuxData));
     default:
-      return Sandbox::SB_ALLOWED;
+      return ErrorCode::ERR_ALLOWED;
   }
 }
 
 void NanosleepProcessSigsys(void) {
   const struct timespec ts = {0, 0};
   errno = 0;
   // getpid() should work properly
   if (syscall(__NR_getpid) < 0)
     ExitGroup(1);
   // Our Auxiliary Data, should be reset by the signal handler
@@ skipping 20 matching lines @@
 // We try to make sure we exercise optimizations in the BPF compiler. We make
 // sure that the compiler can have an opportunity to coalesce syscalls with
 // contiguous numbers and we also make sure that disjoint sets can return the
 // same errno.
 int SysnoToRandomErrno(int sysno) {
   // Small contiguous sets of 3 system calls return an errno equal to the
   // index of that set + 1 (so that we never return a NUL errno).
   return ((sysno & ~3) >> 2) % 29 + 1;
 }
 
-Sandbox::ErrorCode SyntheticPolicy(int sysno) {
+ErrorCode SyntheticPolicy(int sysno) {
   if (sysno < static_cast<int>(MIN_SYSCALL) ||
       sysno > static_cast<int>(MAX_SYSCALL)) {
     // FIXME: we should really not have to do that in a trivial policy.
     return ENOSYS;
   }
   if (sysno == __NR_exit_group) {
     // exit_group() is special, we really need it to work.
-    return Sandbox::SB_ALLOWED;
+    return ErrorCode::ERR_ALLOWED;
   } else {
     return SysnoToRandomErrno(sysno);
   }
 }
 
 void SyntheticProcess(void) {
   // Ensure that that kExpectedReturnValue + syscallnumber + 1 does not int
   // overflow.
   if (std::numeric_limits<int>::max() - kExpectedReturnValue - 1 <
       static_cast<int>(MAX_SYSCALL)) {
@@ skipping 16 matching lines @@
     }
   }
   ExitGroup(kExpectedReturnValue);
 }
 
 TEST(SandboxBpf, SyntheticPolicy) {
   TryPolicyInProcess(SyntheticPolicy, SyntheticProcess);
 }
 
 } // namespace