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 <ostream>
 
 #include "sandbox/linux/seccomp-bpf/sandbox_bpf.h"
 #include "sandbox/linux/seccomp-bpf/verifier.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 60 matching lines @@
      Sandbox::STATUS_AVAILABLE) {
     ExitGroup(1);
   }
   Sandbox::setProcFd(proc_fd);
   Sandbox::setSandboxPolicy(evaluator, NULL);
   Sandbox::startSandbox();
 }
 
 void RunInSandbox(Sandbox::EvaluateSyscall evaluator,
                       void (*SandboxedCode)()) {
-  // TODO(markus): Implement IsEqual for ErrorCode
-  // IsEqual(evaluator(__NR_exit_group), Sandbox::SB_ALLOWED) <<
+  // TODO(jln): Implement IsEqual for ErrorCode
+  // 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
@@ skipping 10 matching lines @@
   } else {
     // The sandbox is not available. We should still try to exercise what we
     // can.
     // TODO(markus): (crbug.com/141545) let us call the compiler from here.
     Sandbox::setSandboxPolicy(evaluator, NULL);
   }
 }
 
 // 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;
+    return ErrorCode(ENOSYS);
   }
   switch (sysno) {
     case __NR_nanosleep:
-      return EACCES;
+      return ErrorCode(EACCES);
     default:
-      return Sandbox::SB_ALLOWED;
+      return ErrorCode(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(ErrorCode::ERR_ALLOWED);
     default:
-      return ENOMEM;
+      return ErrorCode(ENOMEM);
   }
 }
 
 void GetpidProcess(void) {
   errno = 0;
   // getpid() should be allowed
   if (syscall(__NR_getpid) < 0 || errno)
     ExitGroup(1);
   // getpgid() should be denied
   if (getpgid(0) != -1 || errno != ENOMEM)
@@ skipping 13 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;
+    return ErrorCode(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(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;
+    return ErrorCode(ENOSYS);
   }
 
   // TODO(jorgelo): remove this restriction once crbug.com/141694 is fixed.
 #if defined(__arm__)
   if (sysno > kArmPublicSysnoCeiling)
     return ENOSYS;
 #endif
 
   if (sysno == __NR_exit_group) {
     // exit_group() is special, we really need it to work.
-    return Sandbox::SB_ALLOWED;
+    return ErrorCode(ErrorCode::ERR_ALLOWED);
   } else {
-    return SysnoToRandomErrno(sysno);
+    return ErrorCode(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)) {
     ExitGroup(1);
   }
@@ skipping 22 matching lines @@
     }
   }
   ExitGroup(kExpectedReturnValue);
 }
 
 TEST(SandboxBpf, SyntheticPolicy) {
   TryPolicyInProcess(SyntheticPolicy, SyntheticProcess);
 }
 
 } // namespace