Linux sandbox: cleanup sandbox-bpf naming.

sandbox/linux/seccomp-bpf/errorcode.h

 // 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.
 
 #ifndef SANDBOX_LINUX_SECCOMP_BPF_ERRORCODE_H__
 #define SANDBOX_LINUX_SECCOMP_BPF_ERRORCODE_H__
 
 #include "sandbox/linux/seccomp-bpf/linux_seccomp.h"
 #include "sandbox/linux/seccomp-bpf/trap.h"
 
-namespace playground2 {
+namespace sandbox {
 
 struct arch_seccomp_data;
 
 // This class holds all the possible values that can be returned by a sandbox
 // policy.
 // We can either wrap a symbolic ErrorCode (i.e. ERR_XXX enum values), an
 // errno value (in the range 0..4095), a pointer to a TrapFnc callback
 // handling a SECCOMP_RET_TRAP trap, or a complex constraint.
 // All of the commonly used values are stored in the "err_" field. So, code
 // that is using the ErrorCode class typically operates on a single 32bit
@@ skipping 17 matching lines @@
     ERR_MAX_ERRNO = 4095,
   };
 
   // While BPF filter programs always operate on 32bit quantities, the kernel
   // always sees system call arguments as 64bit values. This statement is true
   // no matter whether the host system is natively operating in 32bit or 64bit.
   // The BPF compiler hides the fact that BPF instructions cannot directly
   // access 64bit quantities. But policies are still advised to specify whether
   // a system call expects a 32bit or a 64bit quantity.
   enum ArgType {
-    // When passed as an argument to Sandbox::Cond(), TP_32BIT requests that
+    // When passed as an argument to SandboxBPF::Cond(), TP_32BIT requests that
     // the conditional test should operate on the 32bit part of the system call
     // argument.
     // On 64bit architectures, this verifies that user space did not pass
     // a 64bit value as an argument to the system call. If it did, that will be
     // interpreted as an attempt at breaking the sandbox and results in the
     // program getting terminated.
     // In other words, only perform a 32bit test, if you are sure this
     // particular system call would never legitimately take a 64bit
     // argument.
     // Implementation detail: TP_32BIT does two things. 1) it restricts the
     // conditional test to operating on the LSB only, and 2) it adds code to
     // the BPF filter program verifying that the MSB  the kernel received from
     // user space is either 0, or 0xFFFFFFFF; the latter is acceptable, iff bit
     // 31 was set in the system call argument. It deals with 32bit arguments
     // having been sign extended.
     TP_32BIT,
 
-    // When passed as an argument to Sandbox::Cond(), TP_64BIT requests that
+    // When passed as an argument to SandboxBPF::Cond(), TP_64BIT requests that
     // the conditional test should operate on the full 64bit argument. It is
     // generally harmless to perform a 64bit test on 32bit systems, as the
     // kernel will always see the top 32 bits of all arguments as zero'd out.
     // This approach has the desirable property that for tests of pointer
     // values, we can always use TP_64BIT no matter the host architecture.
     // But of course, that also means, it is possible to write conditional
     // policies that turn into no-ops on 32bit systems; this is by design.
     TP_64BIT,
   };
 
@@ skipping 63 matching lines @@
   const ErrorCode* failed() const { return failed_; }
 
   struct LessThan {
     bool operator()(const ErrorCode& a, const ErrorCode& b) const {
       return a.LessThan(b);
     }
   };
 
  private:
   friend class CodeGen;
-  friend class Sandbox;
+  friend class SandboxBPF;
   friend class Trap;
 
   // If we are wrapping a callback, we must assign a unique id. This id is
   // how the kernel tells us which one of our different SECCOMP_RET_TRAP
   // cases has been triggered.
   ErrorCode(Trap::TrapFnc fnc, const void* aux, bool safe, uint16_t id);
 
   // Some system calls require inspection of arguments. This constructor
   // allows us to specify additional constraints.
   ErrorCode(int argno,
@@ skipping 23 matching lines @@
       const ErrorCode* failed_;  //   or if it failed.
     };
   };
 
   // 32bit field used for all possible types of ErrorCode values. This is
   // the value that uniquely identifies any ErrorCode and it (typically) can
   // be emitted directly into a BPF filter program.
   uint32_t err_;
 };
 
-}  // namespace
+}  // namespace sandbox
 
 #endif  // SANDBOX_LINUX_SECCOMP_BPF_ERRORCODE_H__