sandbox: Convert remaining legacy tests to use policy classes

sandbox/linux/seccomp-bpf/bpf_tests_unittest.cc

 // Copyright 2014 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/bpf_tests.h"
 
 #include <errno.h>
 #include <sys/ptrace.h>
 #include <sys/syscall.h>
 #include <sys/types.h>
@@ skipping 15 matching lines @@
  public:
   static const int kMagicValue = 42;
   FourtyTwo() : value_(kMagicValue) {}
   int value() { return value_; }
 
  private:
   int value_;
   DISALLOW_COPY_AND_ASSIGN(FourtyTwo);
 };
 
-ErrorCode EmptyPolicyTakesClass(SandboxBPF* sandbox,
-                                int sysno,
-                                FourtyTwo* fourty_two) {
-  // |aux| should point to an instance of FourtyTwo.
-  BPF_ASSERT(fourty_two);
-  BPF_ASSERT(FourtyTwo::kMagicValue == fourty_two->value());
-  if (!SandboxBPF::IsValidSyscallNumber(sysno)) {
-    return ErrorCode(ENOSYS);
-  } else {
+class EmptyClassTakingPolicy : public SandboxBPFPolicy {
+ public:
+  explicit EmptyClassTakingPolicy(FourtyTwo* fourty_two) {
+    BPF_ASSERT(fourty_two);
+    BPF_ASSERT(FourtyTwo::kMagicValue == fourty_two->value());
+  }
+  virtual ~EmptyClassTakingPolicy() {}
+
+  virtual ErrorCode EvaluateSyscall(SandboxBPF* sandbox,
+                                    int sysno) const OVERRIDE {
+    DCHECK(SandboxBPF::IsValidSyscallNumber(sysno));
     return ErrorCode(ErrorCode::ERR_ALLOWED);
   }
-}
+};
 
 BPF_TEST(BPFTest,
          BPFAUXPointsToClass,
-         EmptyPolicyTakesClass,
+         EmptyClassTakingPolicy,
          FourtyTwo /* *BPF_AUX */) {
   // BPF_AUX should point to an instance of FourtyTwo.
   BPF_ASSERT(BPF_AUX);
   BPF_ASSERT(FourtyTwo::kMagicValue == BPF_AUX->value());
 }
 
 void DummyTestFunction(FourtyTwo *fourty_two) {
 }
 
 TEST(BPFTest, BPFTesterCompatibilityDelegateLeakTest) {
   // Don't do anything, simply gives dynamic tools an opportunity to detect
   // leaks.
   {
-    BPFTesterCompatibilityDelegate<FourtyTwo> simple_delegate(
-        DummyTestFunction, EmptyPolicyTakesClass);
+    BPFTesterCompatibilityDelegate<EmptyClassTakingPolicy, FourtyTwo>
+        simple_delegate(DummyTestFunction);
   }
   {
     // Test polymorphism.
     scoped_ptr<BPFTesterDelegate> simple_delegate(
-        new BPFTesterCompatibilityDelegate<FourtyTwo>(DummyTestFunction,
-                                                      EmptyPolicyTakesClass));
+        new BPFTesterCompatibilityDelegate<EmptyClassTakingPolicy, FourtyTwo>(
+            DummyTestFunction));
   }
 }
 
 class EnosysPtracePolicy : public SandboxBPFPolicy {
  public:
   EnosysPtracePolicy() {
     my_pid_ = syscall(__NR_getpid);
   }
   virtual ~EnosysPtracePolicy() {
     // Policies should be able to bind with the process on which they are
@@ skipping 57 matching lines @@
                  BPFDeathTestWithInlineTest,
                  DEATH_MESSAGE(kHelloMessage),
                  EnosysPtracePolicy) {
   LOG(ERROR) << kHelloMessage;
   _exit(1);
 }
 
 }  // namespace
 
 }  // namespace sandbox