Linux sandbox: cleanup sandbox-bpf naming.

content/common/sandbox_linux.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 <dirent.h>
 #include <fcntl.h>
 #include <sys/resource.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
@@ skipping 90 matching lines @@
   __sanitizer_sandbox_on_notify(/*reserved*/NULL);
 #endif
 
 #if !defined(NDEBUG)
   // Open proc_fd_ only in Debug mode so that forgetting to close it doesn't
   // produce a sandbox escape in Release mode.
   proc_fd_ = open("/proc", O_DIRECTORY | O_RDONLY);
   CHECK_GE(proc_fd_, 0);
 #endif  // !defined(NDEBUG)
   // We "pre-warm" the code that detects supports for seccomp BPF.
-  if (SandboxSeccompBpf::IsSeccompBpfDesired()) {
-    if (!SandboxSeccompBpf::SupportsSandbox()) {
+  if (SandboxSeccompBPF::IsSeccompBPFDesired()) {
+    if (!SandboxSeccompBPF::SupportsSandbox()) {
       VLOG(1) << "Lacking support for seccomp-bpf sandbox.";
     } else {
       seccomp_bpf_supported_ = true;
     }
   }
   pre_initialized_ = true;
 }
 
 bool LinuxSandbox::InitializeSandbox() {
   bool seccomp_bpf_started = false;
@@ skipping 24 matching lines @@
   }
 
   DCHECK(!linux_sandbox->HasOpenDirectories()) <<
       "InitializeSandbox() called after unexpected directories have been " <<
       "opened. This breaks the security of the setuid sandbox.";
 
   // Attempt to limit the future size of the address space of the process.
   linux_sandbox->LimitAddressSpace(process_type);
 
   // First, try to enable seccomp-bpf.
-  seccomp_bpf_started = linux_sandbox->StartSeccompBpf(process_type);
+  seccomp_bpf_started = linux_sandbox->StartSeccompBPF(process_type);
 
   return seccomp_bpf_started;
 }
 
 int LinuxSandbox::GetStatus() const {
   CHECK(pre_initialized_);
   int sandbox_flags = 0;
   if (setuid_sandbox_client_->IsSandboxed()) {
     sandbox_flags |= kSandboxLinuxSUID;
     if (setuid_sandbox_client_->IsInNewPIDNamespace())
       sandbox_flags |= kSandboxLinuxPIDNS;
     if (setuid_sandbox_client_->IsInNewNETNamespace())
       sandbox_flags |= kSandboxLinuxNetNS;
   }
 
   if (seccomp_bpf_supported() &&
-      SandboxSeccompBpf::ShouldEnableSeccompBpf(switches::kRendererProcess)) {
+      SandboxSeccompBPF::ShouldEnableSeccompBPF(switches::kRendererProcess)) {
     // We report whether the sandbox will be activated when renderers go
     // through sandbox initialization.
-    sandbox_flags |= kSandboxLinuxSeccompBpf;
+    sandbox_flags |= kSandboxLinuxSeccompBPF;
   }
 
   return sandbox_flags;
 }
 
 // Threads are counted via /proc/self/task. This is a little hairy because of
 // PID namespaces and existing sandboxes, so "self" must really be used instead
 // of using the pid.
 bool LinuxSandbox::IsSingleThreaded() const {
   struct stat task_stat;
@@ skipping 29 matching lines @@
 
 bool LinuxSandbox::seccomp_bpf_started() const {
   return seccomp_bpf_started_;
 }
 
 sandbox::SetuidSandboxClient*
     LinuxSandbox::setuid_sandbox_client() const {
   return setuid_sandbox_client_.get();
 }
 
-// For seccomp-bpf, we use the SandboxSeccompBpf class.
-bool LinuxSandbox::StartSeccompBpf(const std::string& process_type) {
+// For seccomp-bpf, we use the SandboxSeccompBPF class.
+bool LinuxSandbox::StartSeccompBPF(const std::string& process_type) {
   CHECK(!seccomp_bpf_started_);
   if (!pre_initialized_)
     PreinitializeSandbox();
   if (seccomp_bpf_supported())
-    seccomp_bpf_started_ = SandboxSeccompBpf::StartSandbox(process_type);
+    seccomp_bpf_started_ = SandboxSeccompBPF::StartSandbox(process_type);
 
   if (seccomp_bpf_started_)
     LogSandboxStarted("seccomp-bpf");
 
   return seccomp_bpf_started_;
 }
 
 bool LinuxSandbox::seccomp_bpf_supported() const {
   CHECK(pre_initialized_);
   return seccomp_bpf_supported_;
@@ skipping 46 matching lines @@
 void LinuxSandbox::SealSandbox() {
   if (proc_fd_ >= 0) {
     int ret = IGNORE_EINTR(close(proc_fd_));
     CHECK_EQ(0, ret);
     proc_fd_ = -1;
   }
 }
 
 }  // namespace content