replace OVERRIDE and FINAL with override and final in sandbox/

sandbox/linux/bpf_dsl/bpf_dsl.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/bpf_dsl/bpf_dsl.h"
 
 #include <errno.h>
 
 #include <limits>
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "sandbox/linux/seccomp-bpf/errorcode.h"
 #include "sandbox/linux/seccomp-bpf/sandbox_bpf.h"
 
 namespace sandbox {
 namespace bpf_dsl {
 namespace {
 
 class AllowResultExprImpl : public internal::ResultExprImpl {
  public:
   AllowResultExprImpl() {}
 
-  virtual ErrorCode Compile(SandboxBPF* sb) const OVERRIDE {
+  virtual ErrorCode Compile(SandboxBPF* sb) const override {
     return ErrorCode(ErrorCode::ERR_ALLOWED);
   }
 
  private:
   virtual ~AllowResultExprImpl() {}
 
   DISALLOW_COPY_AND_ASSIGN(AllowResultExprImpl);
 };
 
 class ErrorResultExprImpl : public internal::ResultExprImpl {
  public:
   explicit ErrorResultExprImpl(int err) : err_(err) {
     CHECK(err_ >= ErrorCode::ERR_MIN_ERRNO && err_ <= ErrorCode::ERR_MAX_ERRNO);
   }
 
-  virtual ErrorCode Compile(SandboxBPF* sb) const OVERRIDE {
+  virtual ErrorCode Compile(SandboxBPF* sb) const override {
     return ErrorCode(err_);
   }
 
  private:
   virtual ~ErrorResultExprImpl() {}
 
   int err_;
 
   DISALLOW_COPY_AND_ASSIGN(ErrorResultExprImpl);
 };
 
 class KillResultExprImpl : public internal::ResultExprImpl {
  public:
   explicit KillResultExprImpl(const char* msg) : msg_(msg) { DCHECK(msg_); }
 
-  virtual ErrorCode Compile(SandboxBPF* sb) const OVERRIDE {
+  virtual ErrorCode Compile(SandboxBPF* sb) const override {
     return sb->Kill(msg_);
   }
 
  private:
   virtual ~KillResultExprImpl() {}
 
   const char* msg_;
 
   DISALLOW_COPY_AND_ASSIGN(KillResultExprImpl);
 };
 
 class TraceResultExprImpl : public internal::ResultExprImpl {
  public:
   TraceResultExprImpl(uint16_t aux) : aux_(aux) {}
 
-  virtual ErrorCode Compile(SandboxBPF* sb) const OVERRIDE {
+  virtual ErrorCode Compile(SandboxBPF* sb) const override {
     return ErrorCode(ErrorCode::ERR_TRACE + aux_);
   }
 
  private:
   virtual ~TraceResultExprImpl() {}
 
   uint16_t aux_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceResultExprImpl);
 };
 
 class TrapResultExprImpl : public internal::ResultExprImpl {
  public:
   TrapResultExprImpl(Trap::TrapFnc func, const void* arg)
       : func_(func), arg_(arg) {
     DCHECK(func_);
   }
 
-  virtual ErrorCode Compile(SandboxBPF* sb) const OVERRIDE {
+  virtual ErrorCode Compile(SandboxBPF* sb) const override {
     return sb->Trap(func_, arg_);
   }
 
  private:
   virtual ~TrapResultExprImpl() {}
 
   Trap::TrapFnc func_;
   const void* arg_;
 
   DISALLOW_COPY_AND_ASSIGN(TrapResultExprImpl);
 };
 
 class UnsafeTrapResultExprImpl : public internal::ResultExprImpl {
  public:
   UnsafeTrapResultExprImpl(Trap::TrapFnc func, const void* arg)
       : func_(func), arg_(arg) {
     DCHECK(func_);
   }
 
-  virtual ErrorCode Compile(SandboxBPF* sb) const OVERRIDE {
+  virtual ErrorCode Compile(SandboxBPF* sb) const override {
     return sb->UnsafeTrap(func_, arg_);
   }
 
  private:
   virtual ~UnsafeTrapResultExprImpl() {}
 
   Trap::TrapFnc func_;
   const void* arg_;
 
   DISALLOW_COPY_AND_ASSIGN(UnsafeTrapResultExprImpl);
 };
 
 class IfThenResultExprImpl : public internal::ResultExprImpl {
  public:
   IfThenResultExprImpl(const BoolExpr& cond,
                        const ResultExpr& then_result,
                        const ResultExpr& else_result)
       : cond_(cond), then_result_(then_result), else_result_(else_result) {}
 
-  virtual ErrorCode Compile(SandboxBPF* sb) const OVERRIDE {
+  virtual ErrorCode Compile(SandboxBPF* sb) const override {
     return cond_->Compile(
         sb, then_result_->Compile(sb), else_result_->Compile(sb));
   }
 
  private:
   virtual ~IfThenResultExprImpl() {}
 
   BoolExpr cond_;
   ResultExpr then_result_;
   ResultExpr else_result_;
 
   DISALLOW_COPY_AND_ASSIGN(IfThenResultExprImpl);
 };
 
 class ConstBoolExprImpl : public internal::BoolExprImpl {
  public:
   ConstBoolExprImpl(bool value) : value_(value) {}
 
   virtual ErrorCode Compile(SandboxBPF* sb,
                             ErrorCode true_ec,
-                            ErrorCode false_ec) const OVERRIDE {
+                            ErrorCode false_ec) const override {
     return value_ ? true_ec : false_ec;
   }
 
  private:
   virtual ~ConstBoolExprImpl() {}
 
   bool value_;
 
   DISALLOW_COPY_AND_ASSIGN(ConstBoolExprImpl);
 };
 
 class PrimitiveBoolExprImpl : public internal::BoolExprImpl {
  public:
   PrimitiveBoolExprImpl(int argno,
                         ErrorCode::ArgType is_32bit,
                         uint64_t mask,
                         uint64_t value)
       : argno_(argno), is_32bit_(is_32bit), mask_(mask), value_(value) {}
 
   virtual ErrorCode Compile(SandboxBPF* sb,
                             ErrorCode true_ec,
-                            ErrorCode false_ec) const OVERRIDE {
+                            ErrorCode false_ec) const override {
     return sb->CondMaskedEqual(
         argno_, is_32bit_, mask_, value_, true_ec, false_ec);
   }
 
  private:
   virtual ~PrimitiveBoolExprImpl() {}
 
   int argno_;
   ErrorCode::ArgType is_32bit_;
   uint64_t mask_;
   uint64_t value_;
 
   DISALLOW_COPY_AND_ASSIGN(PrimitiveBoolExprImpl);
 };
 
 class NegateBoolExprImpl : public internal::BoolExprImpl {
  public:
   explicit NegateBoolExprImpl(const BoolExpr& cond) : cond_(cond) {}
 
   virtual ErrorCode Compile(SandboxBPF* sb,
                             ErrorCode true_ec,
-                            ErrorCode false_ec) const OVERRIDE {
+                            ErrorCode false_ec) const override {
     return cond_->Compile(sb, false_ec, true_ec);
   }
 
  private:
   virtual ~NegateBoolExprImpl() {}
 
   BoolExpr cond_;
 
   DISALLOW_COPY_AND_ASSIGN(NegateBoolExprImpl);
 };
 
 class AndBoolExprImpl : public internal::BoolExprImpl {
  public:
   AndBoolExprImpl(const BoolExpr& lhs, const BoolExpr& rhs)
       : lhs_(lhs), rhs_(rhs) {}
 
   virtual ErrorCode Compile(SandboxBPF* sb,
                             ErrorCode true_ec,
-                            ErrorCode false_ec) const OVERRIDE {
+                            ErrorCode false_ec) const override {
     return lhs_->Compile(sb, rhs_->Compile(sb, true_ec, false_ec), false_ec);
   }
 
  private:
   virtual ~AndBoolExprImpl() {}
 
   BoolExpr lhs_;
   BoolExpr rhs_;
 
   DISALLOW_COPY_AND_ASSIGN(AndBoolExprImpl);
 };
 
 class OrBoolExprImpl : public internal::BoolExprImpl {
  public:
   OrBoolExprImpl(const BoolExpr& lhs, const BoolExpr& rhs)
       : lhs_(lhs), rhs_(rhs) {}
 
   virtual ErrorCode Compile(SandboxBPF* sb,
                             ErrorCode true_ec,
-                            ErrorCode false_ec) const OVERRIDE {
+                            ErrorCode false_ec) const override {
     return lhs_->Compile(sb, true_ec, rhs_->Compile(sb, true_ec, false_ec));
   }
 
  private:
   virtual ~OrBoolExprImpl() {}
 
   BoolExpr lhs_;
   BoolExpr rhs_;
 
   DISALLOW_COPY_AND_ASSIGN(OrBoolExprImpl);
@@ skipping 129 matching lines @@
 ErrorCode SandboxBPFDSLPolicy::InvalidSyscall(SandboxBPF* sb) const {
   return InvalidSyscall()->Compile(sb);
 }
 
 ResultExpr SandboxBPFDSLPolicy::Trap(Trap::TrapFnc trap_func, const void* aux) {
   return bpf_dsl::Trap(trap_func, aux);
 }
 
 }  // namespace bpf_dsl
 }  // namespace sandbox