replace OVERRIDE and FINAL with override and final in net/

net/disk_cache/simple/simple_index_unittest.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 <algorithm>
 #include <functional>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/hash.h"
 #include "base/logging.h"
@@ skipping 42 matching lines @@
  public:
   MockSimpleIndexFile()
       : SimpleIndexFile(NULL, NULL, net::DISK_CACHE, base::FilePath()),
         load_result_(NULL),
         load_index_entries_calls_(0),
         disk_writes_(0) {}
 
   virtual void LoadIndexEntries(
       base::Time cache_last_modified,
       const base::Closure& callback,
-      SimpleIndexLoadResult* out_load_result) OVERRIDE {
+      SimpleIndexLoadResult* out_load_result) override {
     load_callback_ = callback;
     load_result_ = out_load_result;
     ++load_index_entries_calls_;
   }
 
   virtual void WriteToDisk(const SimpleIndex::EntrySet& entry_set,
                            uint64 cache_size,
                            const base::TimeTicks& start,
-                           bool app_on_background) OVERRIDE {
+                           bool app_on_background) override {
     disk_writes_++;
     disk_write_entry_set_ = entry_set;
   }
 
   void GetAndResetDiskWriteEntrySet(SimpleIndex::EntrySet* entry_set) {
     entry_set->swap(disk_write_entry_set_);
   }
 
   const base::Closure& load_callback() const { return load_callback_; }
   SimpleIndexLoadResult* load_result() const { return load_result_; }
@@ skipping 12 matching lines @@
  protected:
   SimpleIndexTest()
       : hashes_(base::Bind(&HashesInitializer)),
         doom_entries_calls_(0) {}
 
   static uint64 HashesInitializer(size_t hash_index) {
     return disk_cache::simple_util::GetEntryHashKey(
         base::StringPrintf("key%d", static_cast<int>(hash_index)));
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     scoped_ptr<MockSimpleIndexFile> index_file(new MockSimpleIndexFile());
     index_file_ = index_file->AsWeakPtr();
     index_.reset(new SimpleIndex(NULL, this, net::DISK_CACHE,
                                  index_file.PassAs<SimpleIndexFile>()));
 
     index_->Initialize(base::Time());
   }
 
   void WaitForTimeChange() {
     const base::Time initial_time = base::Time::Now();
     do {
       base::PlatformThread::YieldCurrentThread();
     } while (base::Time::Now() -
              initial_time < base::TimeDelta::FromSeconds(1));
   }
 
   // From SimpleIndexDelegate:
   virtual void DoomEntries(std::vector<uint64>* entry_hashes,
-                           const net::CompletionCallback& callback) OVERRIDE {
+                           const net::CompletionCallback& callback) override {
     std::for_each(entry_hashes->begin(), entry_hashes->end(),
                   std::bind1st(std::mem_fun(&SimpleIndex::Remove),
                                index_.get()));
     last_doom_entry_hashes_ = *entry_hashes;
     ++doom_entries_calls_;
   }
 
   // Redirect to allow single "friend" declaration in base class.
   bool GetEntryForTesting(uint64 key, EntryMetadata* metadata) {
     SimpleIndex::EntrySet::iterator it = index_->entries_set_.find(key);
@@ skipping 484 matching lines @@
   WaitForTimeChange();
   EXPECT_EQ(expected_trigger, index()->write_to_disk_timer_.desired_run_time());
   index()->Insert(hashes_.at<2>());
   index()->UpdateEntrySize(hashes_.at<2>(), 40);
   EXPECT_TRUE(index()->write_to_disk_timer_.IsRunning());
   EXPECT_LT(expected_trigger, index()->write_to_disk_timer_.desired_run_time());
   index()->write_to_disk_timer_.Stop();
 }
 
 }  // namespace disk_cache