replace OVERRIDE and FINAL with override and final in sandbox/

sandbox/linux/seccomp-bpf/sandbox_bpf.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/sandbox_bpf.h"
 
 // Some headers on Android are missing cdefs: crbug.com/172337.
 // (We can't use OS_ANDROID here since build_config.h is not included).
 #if defined(ANDROID)
 #include <sys/cdefs.h>
@@ skipping 84 matching lines @@
 }
 #endif  // !defined(NDEBUG)
 
 // We define a really simple sandbox policy. It is just good enough for us
 // to tell that the sandbox has actually been activated.
 class ProbePolicy : public SandboxBPFDSLPolicy {
  public:
   ProbePolicy() {}
   virtual ~ProbePolicy() {}
 
-  virtual ResultExpr EvaluateSyscall(int sysnum) const OVERRIDE {
+  virtual ResultExpr EvaluateSyscall(int sysnum) const override {
     switch (sysnum) {
       case __NR_getpid:
         // Return EPERM so that we can check that the filter actually ran.
         return Error(EPERM);
       case __NR_exit_group:
         // Allow exit() with a non-default return code.
         return Allow();
       default:
         // Make everything else fail in an easily recognizable way.
         return Error(EINVAL);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ProbePolicy);
 };
 
 void ProbeProcess(void) {
   if (syscall(__NR_getpid) < 0 && errno == EPERM) {
     syscall(__NR_exit_group, static_cast<intptr_t>(kExpectedExitCode));
   }
 }
 
 class AllowAllPolicy : public SandboxBPFDSLPolicy {
  public:
   AllowAllPolicy() {}
   virtual ~AllowAllPolicy() {}
 
-  virtual ResultExpr EvaluateSyscall(int sysnum) const OVERRIDE {
+  virtual ResultExpr EvaluateSyscall(int sysnum) const override {
     DCHECK(SandboxBPF::IsValidSyscallNumber(sysnum));
     return Allow();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AllowAllPolicy);
 };
 
 void TryVsyscallProcess(void) {
   time_t current_time;
@@ skipping 85 matching lines @@
 // TODO(markus): document the code inside better.
 class RedirectToUserSpacePolicyWrapper : public SandboxBPFPolicy {
  public:
   explicit RedirectToUserSpacePolicyWrapper(
       const SandboxBPFPolicy* wrapped_policy)
       : wrapped_policy_(wrapped_policy) {
     DCHECK(wrapped_policy_);
   }
 
   virtual ErrorCode EvaluateSyscall(SandboxBPF* sandbox_compiler,
-                                    int system_call_number) const OVERRIDE {
+                                    int system_call_number) const override {
     ErrorCode err =
         wrapped_policy_->EvaluateSyscall(sandbox_compiler, system_call_number);
     ChangeErrnoToTraps(&err, sandbox_compiler);
     return err;
   }
 
   virtual ErrorCode InvalidSyscall(
-      SandboxBPF* sandbox_compiler) const OVERRIDE {
+      SandboxBPF* sandbox_compiler) const override {
     return ReturnErrnoViaTrap(sandbox_compiler, ENOSYS);
   }
 
  private:
   ErrorCode ReturnErrnoViaTrap(SandboxBPF* sandbox_compiler, int err) const {
     return sandbox_compiler->Trap(ReturnErrno, reinterpret_cast<void*>(err));
   }
 
   // ChangeErrnoToTraps recursivly iterates through the ErrorCode
   // converting any ERRNO to a userspace trap
@@ skipping 884 matching lines @@
   }
 }
 
 ErrorCode SandboxBPF::Kill(const char* msg) {
   return Trap(BPFFailure, const_cast<char*>(msg));
 }
 
 SandboxBPF::SandboxStatus SandboxBPF::status_ = STATUS_UNKNOWN;
 
 }  // namespace sandbox