Standardize usage of virtual/override/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 39 matching lines @@
 
 class MockSimpleIndexFile : public SimpleIndexFile,
                             public base::SupportsWeakPtr<MockSimpleIndexFile> {
  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 {
+  void LoadIndexEntries(base::Time cache_last_modified,
+                        const base::Closure& callback,
+                        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 {
+  void WriteToDisk(const SimpleIndex::EntrySet& entry_set,
+                   uint64 cache_size,
+                   const base::TimeTicks& start,
+                   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 30 matching lines @@
 
   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 {
+  void DoomEntries(std::vector<uint64>* entry_hashes,
+                   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