replace 'virtual ... OVERRIDE' with '... override'

base/memory/discardable_memory_mac.cc

 // Copyright (c) 2013 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 "base/memory/discardable_memory.h"
 
 #include <mach/mach.h>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 38 matching lines @@
 
   bool Initialize() { return Lock() != DISCARDABLE_MEMORY_LOCK_STATUS_FAILED; }
 
   virtual ~DiscardableMemoryMac() {
     if (is_locked_)
       Unlock();
     g_shared_state.Pointer()->manager.Unregister(this);
   }
 
   // Overridden from DiscardableMemory:
-  virtual DiscardableMemoryLockStatus Lock() OVERRIDE {
+  DiscardableMemoryLockStatus Lock() override {
     DCHECK(!is_locked_);
 
     bool purged = false;
     if (!g_shared_state.Pointer()->manager.AcquireLock(this, &purged))
       return DISCARDABLE_MEMORY_LOCK_STATUS_FAILED;
 
     is_locked_ = true;
     return purged ? DISCARDABLE_MEMORY_LOCK_STATUS_PURGED
                   : DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS;
   }
 
-  virtual void Unlock() OVERRIDE {
+  void Unlock() override {
     DCHECK(is_locked_);
     g_shared_state.Pointer()->manager.ReleaseLock(this);
     is_locked_ = false;
   }
 
-  virtual void* Memory() const OVERRIDE {
+  void* Memory() const override {
     DCHECK(is_locked_);
     return reinterpret_cast<void*>(memory_.address());
   }
 
   // Overridden from internal::DiscardableMemoryManagerAllocation:
-  virtual bool AllocateAndAcquireLock() OVERRIDE {
+  bool AllocateAndAcquireLock() override {
     kern_return_t ret;
     bool persistent;
     if (!memory_.size()) {
       vm_address_t address = 0;
       ret = vm_allocate(
           mach_task_self(),
           &address,
           bytes_,
           VM_FLAGS_ANYWHERE | VM_FLAGS_PURGABLE | kDiscardableMemoryTag);
       MACH_CHECK(ret == KERN_SUCCESS, ret) << "vm_allocate";
@@ skipping 22 matching lines @@
                               memory_.address(),
                               VM_PURGABLE_SET_STATE,
                               &state);
     MACH_CHECK(ret == KERN_SUCCESS, ret) << "vm_purgable_control";
     if (state & VM_PURGABLE_EMPTY)
       persistent = false;
 
     return persistent;
   }
 
-  virtual void ReleaseLock() OVERRIDE {
+  void ReleaseLock() override {
     int state = VM_PURGABLE_VOLATILE | VM_VOLATILE_GROUP_DEFAULT;
     kern_return_t ret = vm_purgable_control(mach_task_self(),
                                             memory_.address(),
                                             VM_PURGABLE_SET_STATE,
                                             &state);
     MACH_CHECK(ret == KERN_SUCCESS, ret) << "vm_purgable_control";
 
 #if !defined(NDEBUG)
     ret = vm_protect(mach_task_self(),
                      memory_.address(),
                      memory_.size(),
                      FALSE,
                      VM_PROT_NONE);
     MACH_DCHECK(ret == KERN_SUCCESS, ret) << "vm_protect";
 #endif
   }
 
-  virtual void Purge() OVERRIDE {
-    memory_.reset();
-  }
+  void Purge() override { memory_.reset(); }
 
  private:
   mac::ScopedMachVM memory_;
   const size_t bytes_;
   bool is_locked_;
 
   DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryMac);
 };
 
 }  // namespace
@@ skipping 51 matching lines @@
 }
 
 // static
 void DiscardableMemory::PurgeForTesting() {
   int state = 0;
   vm_purgable_control(mach_task_self(), 0, VM_PURGABLE_PURGE_ALL, &state);
   internal::DiscardableMemoryEmulated::PurgeForTesting();
 }
 
 }  // namespace base