sandbox: Convert remaining legacy tests to use policy classes

sandbox/linux/seccomp-bpf/syscall_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/syscall.h"
 
 #include <asm/unistd.h>
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <sys/syscall.h>
@@ skipping 81 matching lines @@
 // SIGSYS trap handler that will be called on __NR_uname.
 intptr_t CopySyscallArgsToAux(const struct arch_seccomp_data& args, void* aux) {
   // |aux| is our BPF_AUX pointer.
   std::vector<uint64_t>* const seen_syscall_args =
       static_cast<std::vector<uint64_t>*>(aux);
   BPF_ASSERT(arraysize(args.args) == 6);
   seen_syscall_args->assign(args.args, args.args + arraysize(args.args));
   return -ENOMEM;
 }
 
-ErrorCode CopyAllArgsOnUnamePolicy(SandboxBPF* sandbox,
-                                   int sysno,
-                                   std::vector<uint64_t>* aux) {
-  if (!SandboxBPF::IsValidSyscallNumber(sysno)) {
-    return ErrorCode(ENOSYS);
+class CopyAllArgsOnUnamePolicy : public SandboxBPFPolicy {
+ public:
+  CopyAllArgsOnUnamePolicy(std::vector<uint64_t>* aux) : aux_(aux) {}

[jln (very slow on Chromium), 2014/09/23 18:42:06]

bit: explicit

[mdempsky, 2014/09/23 18:50:20]

Done.

+  virtual ~CopyAllArgsOnUnamePolicy() {}
+
+  virtual ErrorCode EvaluateSyscall(SandboxBPF* sandbox,
+                                    int sysno) const OVERRIDE {
+    DCHECK(SandboxBPF::IsValidSyscallNumber(sysno));
+    if (sysno == __NR_uname) {
+      return sandbox->Trap(CopySyscallArgsToAux, aux_);
+    } else {
+      return ErrorCode(ErrorCode::ERR_ALLOWED);
+    }
   }
-  if (sysno == __NR_uname) {
-    return sandbox->Trap(CopySyscallArgsToAux, aux);
-  } else {
-    return ErrorCode(ErrorCode::ERR_ALLOWED);
-  }
-}
+
+ private:
+  std::vector<uint64_t>* aux_;
+
+  DISALLOW_COPY_AND_ASSIGN(CopyAllArgsOnUnamePolicy);
+};
 
 // We are testing Syscall::Call() by making use of a BPF filter that
 // allows us
 // to inspect the system call arguments that the kernel saw.
 BPF_TEST(Syscall,
          SyntheticSixArgs,
          CopyAllArgsOnUnamePolicy,
          std::vector<uint64_t> /* (*BPF_AUX) */) {
   const int kExpectedValue = 42;
   // In this test we only pass integers to the kernel. We might want to make
@@ skipping 95 matching lines @@
 
   // Clean up
   EXPECT_EQ(0, Syscall::Call(__NR_munmap, addr2, 8192L));
   EXPECT_EQ(0, Syscall::Call(__NR_munmap, addr3, 4096L));
   EXPECT_EQ(0, IGNORE_EINTR(Syscall::Call(__NR_close, fd)));
 }
 
 }  // namespace
 
 }  // namespace sandbox