replace OVERRIDE and FINAL with override and final in net/

BUG=417463

Review URL: https://codereview.chromium.org/623213004

Cr-Commit-Position: refs/heads/master@{#298844}

23 files changed, 128 insertions, 128 deletions

diff --git a/net/disk_cache/backend_unittest.cc b/net/disk_cache/backend_unittest.cc
index 572691c..b3b80b4 100644
--- a/net/disk_cache/backend_unittest.cc
+++ b/net/disk_cache/backend_unittest.cc
@@ -1843,7 +1843,7 @@ class BadEntropyProvider : public base::FieldTrial::EntropyProvider {
   virtual ~BadEntropyProvider() {}
 
   virtual double GetEntropyForTrial(const std::string& trial_name,
-                                    uint32 randomization_seed) const OVERRIDE {
+                                    uint32 randomization_seed) const override {
     return 0.5;
   }
 };
diff --git a/net/disk_cache/blockfile/backend_impl.cc b/net/disk_cache/blockfile/backend_impl.cc
index 4082743..bcac374 100644
--- a/net/disk_cache/blockfile/backend_impl.cc
+++ b/net/disk_cache/blockfile/backend_impl.cc
@@ -1260,7 +1260,7 @@ class BackendImpl::IteratorImpl : public Backend::Iterator {
   }
 
   virtual int OpenNextEntry(Entry** next_entry,
-                            const net::CompletionCallback& callback) OVERRIDE {
+                            const net::CompletionCallback& callback) override {
     if (!background_queue_)
       return net::ERR_FAILED;
     background_queue_->OpenNextEntry(iterator_.get(), next_entry, callback);
diff --git a/net/disk_cache/blockfile/backend_impl.h b/net/disk_cache/blockfile/backend_impl.h
index 1abc66d..e81b928 100644
--- a/net/disk_cache/blockfile/backend_impl.h
+++ b/net/disk_cache/blockfile/backend_impl.h
@@ -259,20 +259,20 @@ class NET_EXPORT_PRIVATE BackendImpl : public Backend {
   void FlushIndex();
 
   // Backend implementation.
-  virtual net::CacheType GetCacheType() const OVERRIDE;
-  virtual int32 GetEntryCount() const OVERRIDE;
+  virtual net::CacheType GetCacheType() const override;
+  virtual int32 GetEntryCount() const override;
   virtual int OpenEntry(const std::string& key, Entry** entry,
-                        const CompletionCallback& callback) OVERRIDE;
+                        const CompletionCallback& callback) override;
   virtual int CreateEntry(const std::string& key, Entry** entry,
-                          const CompletionCallback& callback) OVERRIDE;
+                          const CompletionCallback& callback) override;
   virtual int DoomEntry(const std::string& key,
-                        const CompletionCallback& callback) OVERRIDE;
-  virtual int DoomAllEntries(const CompletionCallback& callback) OVERRIDE;
+                        const CompletionCallback& callback) override;
+  virtual int DoomAllEntries(const CompletionCallback& callback) override;
   virtual int DoomEntriesBetween(base::Time initial_time,
                                  base::Time end_time,
-                                 const CompletionCallback& callback) OVERRIDE;
+                                 const CompletionCallback& callback) override;
   virtual int DoomEntriesSince(base::Time initial_time,
-                               const CompletionCallback& callback) OVERRIDE;
+                               const CompletionCallback& callback) override;
   // NOTE: The blockfile Backend::Iterator::OpenNextEntry method does not modify
   // the last_used field of the entry, and therefore it does not impact the
   // eviction ranking of the entry. However, an enumeration will go through all
@@ -281,9 +281,9 @@ class NET_EXPORT_PRIVATE BackendImpl : public Backend {
   // the iterator (for example, deleting the entry) will invalidate the
   // iterator. Performing operations on an entry that modify the entry may
   // result in loops in the iteration, skipped entries or similar.
-  virtual scoped_ptr<Iterator> CreateIterator() OVERRIDE;
-  virtual void GetStats(StatsItems* stats) OVERRIDE;
-  virtual void OnExternalCacheHit(const std::string& key) OVERRIDE;
+  virtual scoped_ptr<Iterator> CreateIterator() override;
+  virtual void GetStats(StatsItems* stats) override;
+  virtual void OnExternalCacheHit(const std::string& key) override;
 
  private:
   typedef base::hash_map<CacheAddr, EntryImpl*> EntriesMap;
diff --git a/net/disk_cache/blockfile/backend_impl_v3.cc b/net/disk_cache/blockfile/backend_impl_v3.cc
index b44b195..09794d3 100644
--- a/net/disk_cache/blockfile/backend_impl_v3.cc
+++ b/net/disk_cache/blockfile/backend_impl_v3.cc
@@ -667,7 +667,7 @@ class BackendImplV3::IteratorImpl : public Backend::Iterator {
   }
 
   virtual int OpenNextEntry(Entry** next_entry,
-                            const net::CompletionCallback& callback) OVERRIDE {
+                            const net::CompletionCallback& callback) override {
     if (!background_queue_)
       return net::ERR_FAILED;
     background_queue_->OpenNextEntry(&data_, next_entry, callback);
@@ -1511,7 +1511,7 @@ int BackendImplV3::DoomEntriesSince(base::Time initial_time,
 class BackendImplV3::NotImplementedIterator : public Backend::Iterator {
  public:
   virtual int OpenNextEntry(disk_cache::Entry** next_entry,
-                            const net::CompletionCallback& callback) OVERRIDE {
+                            const net::CompletionCallback& callback) override {
     return net::ERR_NOT_IMPLEMENTED;
   }
 };
diff --git a/net/disk_cache/blockfile/backend_impl_v3.h b/net/disk_cache/blockfile/backend_impl_v3.h
index ca64997..6f4f882 100644
--- a/net/disk_cache/blockfile/backend_impl_v3.h
+++ b/net/disk_cache/blockfile/backend_impl_v3.h
@@ -172,23 +172,23 @@ class NET_EXPORT_PRIVATE BackendImplV3 : public Backend {
   int SelfCheck();
 
   // Backend implementation.
-  virtual net::CacheType GetCacheType() const OVERRIDE;
-  virtual int32 GetEntryCount() const OVERRIDE;
+  virtual net::CacheType GetCacheType() const override;
+  virtual int32 GetEntryCount() const override;
   virtual int OpenEntry(const std::string& key, Entry** entry,
-                        const CompletionCallback& callback) OVERRIDE;
+                        const CompletionCallback& callback) override;
   virtual int CreateEntry(const std::string& key, Entry** entry,
-                          const CompletionCallback& callback) OVERRIDE;
+                          const CompletionCallback& callback) override;
   virtual int DoomEntry(const std::string& key,
-                        const CompletionCallback& callback) OVERRIDE;
-  virtual int DoomAllEntries(const CompletionCallback& callback) OVERRIDE;
+                        const CompletionCallback& callback) override;
+  virtual int DoomAllEntries(const CompletionCallback& callback) override;
   virtual int DoomEntriesBetween(base::Time initial_time,
                                  base::Time end_time,
-                                 const CompletionCallback& callback) OVERRIDE;
+                                 const CompletionCallback& callback) override;
   virtual int DoomEntriesSince(base::Time initial_time,
-                               const CompletionCallback& callback) OVERRIDE;
-  virtual scoped_ptr<Iterator> CreateIterator() OVERRIDE;
-  virtual void GetStats(StatsItems* stats) OVERRIDE;
-  virtual void OnExternalCacheHit(const std::string& key) OVERRIDE;
+                               const CompletionCallback& callback) override;
+  virtual scoped_ptr<Iterator> CreateIterator() override;
+  virtual void GetStats(StatsItems* stats) override;
+  virtual void OnExternalCacheHit(const std::string& key) override;
 
  private:
   friend class EvictionV3;
diff --git a/net/disk_cache/blockfile/entry_impl.cc b/net/disk_cache/blockfile/entry_impl.cc
index 3c3b218..2b98470 100644
--- a/net/disk_cache/blockfile/entry_impl.cc
+++ b/net/disk_cache/blockfile/entry_impl.cc
@@ -46,7 +46,7 @@ class SyncCallback: public disk_cache::FileIOCallback {
   }
   virtual ~SyncCallback() {}
 
-  virtual void OnFileIOComplete(int bytes_copied) OVERRIDE;
+  virtual void OnFileIOComplete(int bytes_copied) override;
   void Discard();
 
  private:
diff --git a/net/disk_cache/blockfile/entry_impl.h b/net/disk_cache/blockfile/entry_impl.h
index c0b332b7..fea815dc 100644
--- a/net/disk_cache/blockfile/entry_impl.h
+++ b/net/disk_cache/blockfile/entry_impl.h
@@ -147,26 +147,26 @@ class NET_EXPORT_PRIVATE EntryImpl
   static int NumBlocksForEntry(int key_size);
 
   // Entry interface.
-  virtual void Doom() OVERRIDE;
-  virtual void Close() OVERRIDE;
-  virtual std::string GetKey() const OVERRIDE;
-  virtual base::Time GetLastUsed() const OVERRIDE;
-  virtual base::Time GetLastModified() const OVERRIDE;
-  virtual int32 GetDataSize(int index) const OVERRIDE;
+  virtual void Doom() override;
+  virtual void Close() override;
+  virtual std::string GetKey() const override;
+  virtual base::Time GetLastUsed() const override;
+  virtual base::Time GetLastModified() const override;
+  virtual int32 GetDataSize(int index) const override;
   virtual int ReadData(int index, int offset, IOBuffer* buf, int buf_len,
-                       const CompletionCallback& callback) OVERRIDE;
+                       const CompletionCallback& callback) override;
   virtual int WriteData(int index, int offset, IOBuffer* buf, int buf_len,
                         const CompletionCallback& callback,
-                        bool truncate) OVERRIDE;
+                        bool truncate) override;
   virtual int ReadSparseData(int64 offset, IOBuffer* buf, int buf_len,
-                             const CompletionCallback& callback) OVERRIDE;
+                             const CompletionCallback& callback) override;
   virtual int WriteSparseData(int64 offset, IOBuffer* buf, int buf_len,
-                              const CompletionCallback& callback) OVERRIDE;
+                              const CompletionCallback& callback) override;
   virtual int GetAvailableRange(int64 offset, int len, int64* start,
-                                const CompletionCallback& callback) OVERRIDE;
-  virtual bool CouldBeSparse() const OVERRIDE;
-  virtual void CancelSparseIO() OVERRIDE;
-  virtual int ReadyForSparseIO(const CompletionCallback& callback) OVERRIDE;
+                                const CompletionCallback& callback) override;
+  virtual bool CouldBeSparse() const override;
+  virtual void CancelSparseIO() override;
+  virtual int ReadyForSparseIO(const CompletionCallback& callback) override;
 
  private:
   enum {
diff --git a/net/disk_cache/blockfile/entry_impl_v3.h b/net/disk_cache/blockfile/entry_impl_v3.h
index 6be0c71..4215000 100644
--- a/net/disk_cache/blockfile/entry_impl_v3.h
+++ b/net/disk_cache/blockfile/entry_impl_v3.h
@@ -77,26 +77,26 @@ class NET_EXPORT_PRIVATE EntryImplV3
   const net::BoundNetLog& net_log() const;
 
   // Entry interface.
-  virtual void Doom() OVERRIDE;
-  virtual void Close() OVERRIDE;
-  virtual std::string GetKey() const OVERRIDE;
-  virtual base::Time GetLastUsed() const OVERRIDE;
-  virtual base::Time GetLastModified() const OVERRIDE;
-  virtual int32 GetDataSize(int index) const OVERRIDE;
+  virtual void Doom() override;
+  virtual void Close() override;
+  virtual std::string GetKey() const override;
+  virtual base::Time GetLastUsed() const override;
+  virtual base::Time GetLastModified() const override;
+  virtual int32 GetDataSize(int index) const override;
   virtual int ReadData(int index, int offset, IOBuffer* buf, int buf_len,
-                       const CompletionCallback& callback) OVERRIDE;
+                       const CompletionCallback& callback) override;
   virtual int WriteData(int index, int offset, IOBuffer* buf, int buf_len,
                         const CompletionCallback& callback,
-                        bool truncate) OVERRIDE;
+                        bool truncate) override;
   virtual int ReadSparseData(int64 offset, IOBuffer* buf, int buf_len,
-                             const CompletionCallback& callback) OVERRIDE;
+                             const CompletionCallback& callback) override;
   virtual int WriteSparseData(int64 offset, IOBuffer* buf, int buf_len,
-                              const CompletionCallback& callback) OVERRIDE;
+                              const CompletionCallback& callback) override;
   virtual int GetAvailableRange(int64 offset, int len, int64* start,
-                                const CompletionCallback& callback) OVERRIDE;
-  virtual bool CouldBeSparse() const OVERRIDE;
-  virtual void CancelSparseIO() OVERRIDE;
-  virtual int ReadyForSparseIO(const CompletionCallback& callback) OVERRIDE;
+                                const CompletionCallback& callback) override;
+  virtual bool CouldBeSparse() const override;
+  virtual void CancelSparseIO() override;
+  virtual int ReadyForSparseIO(const CompletionCallback& callback) override;
 
  private:
   enum {
diff --git a/net/disk_cache/blockfile/file_ios.cc b/net/disk_cache/blockfile/file_ios.cc
index 4659e75..ef0e2fa 100644
--- a/net/disk_cache/blockfile/file_ios.cc
+++ b/net/disk_cache/blockfile/file_ios.cc
@@ -80,7 +80,7 @@ class FileInFlightIO : public disk_cache::InFlightIO {
   // queued (because we are inside WaitForPendingIO), and false if said task is
   // the one performing the call.
   virtual void OnOperationComplete(disk_cache::BackgroundIO* operation,
-                                   bool cancel) OVERRIDE;
+                                   bool cancel) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FileInFlightIO);
diff --git a/net/disk_cache/blockfile/in_flight_backend_io.h b/net/disk_cache/blockfile/in_flight_backend_io.h
index 5d8e435..4b10405 100644
--- a/net/disk_cache/blockfile/in_flight_backend_io.h
+++ b/net/disk_cache/blockfile/in_flight_backend_io.h
@@ -205,7 +205,7 @@ class InFlightBackendIO : public InFlightIO {
 
  protected:
   virtual void OnOperationComplete(BackgroundIO* operation,
-                                   bool cancel) OVERRIDE;
+                                   bool cancel) override;
 
  private:
   void PostOperation(BackendIO* operation);
diff --git a/net/disk_cache/blockfile/index_table_v3_unittest.cc b/net/disk_cache/blockfile/index_table_v3_unittest.cc
index b7a93a2..7f68ee3 100644
--- a/net/disk_cache/blockfile/index_table_v3_unittest.cc
+++ b/net/disk_cache/blockfile/index_table_v3_unittest.cc
@@ -35,12 +35,12 @@ class MockIndexBackend : public disk_cache::IndexTableBackend {
   bool grow_called() const { return grow_called_; }
   int buffer_len() const { return buffer_len_; }
 
-  virtual void GrowIndex() OVERRIDE { grow_called_ = true; }
-  virtual void SaveIndex(net::IOBuffer* buffer, int buffer_len) OVERRIDE {
+  virtual void GrowIndex() override { grow_called_ = true; }
+  virtual void SaveIndex(net::IOBuffer* buffer, int buffer_len) override {
     buffer_len_ = buffer_len;
   }
-  virtual void DeleteCell(EntryCell cell) OVERRIDE {}
-  virtual void FixCell(EntryCell cell) OVERRIDE {}
+  virtual void DeleteCell(EntryCell cell) override {}
+  virtual void FixCell(EntryCell cell) override {}
 
  private:
   bool grow_called_;
diff --git a/net/disk_cache/blockfile/mapped_file_unittest.cc b/net/disk_cache/blockfile/mapped_file_unittest.cc
index 8b3a1d0..8093e9a1 100644
--- a/net/disk_cache/blockfile/mapped_file_unittest.cc
+++ b/net/disk_cache/blockfile/mapped_file_unittest.cc
@@ -23,7 +23,7 @@ class FileCallbackTest: public disk_cache::FileIOCallback {
   }
   virtual ~FileCallbackTest() {}
 
-  virtual void OnFileIOComplete(int bytes_copied) OVERRIDE;
+  virtual void OnFileIOComplete(int bytes_copied) override;
 
  private:
   int id_;
@@ -48,9 +48,9 @@ class TestFileBlock : public disk_cache::FileBlock {
   virtual ~TestFileBlock() {}
 
   // FileBlock interface.
-  virtual void* buffer() const OVERRIDE { return const_cast<char*>(buffer_); }
-  virtual size_t size() const OVERRIDE { return sizeof(buffer_); }
-  virtual int offset() const OVERRIDE { return 1024; }
+  virtual void* buffer() const override { return const_cast<char*>(buffer_); }
+  virtual size_t size() const override { return sizeof(buffer_); }
+  virtual int offset() const override { return 1024; }
 
  private:
   char buffer_[20];
diff --git a/net/disk_cache/blockfile/sparse_control.cc b/net/disk_cache/blockfile/sparse_control.cc
index e251d84..ddb57b6 100644
--- a/net/disk_cache/blockfile/sparse_control.cc
+++ b/net/disk_cache/blockfile/sparse_control.cc
@@ -56,7 +56,7 @@ class ChildrenDeleter
   ChildrenDeleter(disk_cache::BackendImpl* backend, const std::string& name)
       : backend_(backend->GetWeakPtr()), name_(name), signature_(0) {}
 
-  virtual void OnFileIOComplete(int bytes_copied) OVERRIDE;
+  virtual void OnFileIOComplete(int bytes_copied) override;
 
   // Two ways of deleting the children: if we have the children map, use Start()
   // directly, otherwise pass the data address to ReadData().
diff --git a/net/disk_cache/blockfile/sparse_control_v3.cc b/net/disk_cache/blockfile/sparse_control_v3.cc
index 66a60a2..cba0ed5 100644
--- a/net/disk_cache/blockfile/sparse_control_v3.cc
+++ b/net/disk_cache/blockfile/sparse_control_v3.cc
@@ -56,7 +56,7 @@ class ChildrenDeleter
   ChildrenDeleter(disk_cache::BackendImpl* backend, const std::string& name)
       : backend_(backend->GetWeakPtr()), name_(name), signature_(0) {}
 
-  virtual void OnFileIOComplete(int bytes_copied) OVERRIDE;
+  virtual void OnFileIOComplete(int bytes_copied) override;
 
   // Two ways of deleting the children: if we have the children map, use Start()
   // directly, otherwise pass the data address to ReadData().
diff --git a/net/disk_cache/disk_cache_test_base.h b/net/disk_cache/disk_cache_test_base.h
index 225d37f..ce36f92 100644
--- a/net/disk_cache/disk_cache_test_base.h
+++ b/net/disk_cache/disk_cache_test_base.h
@@ -46,7 +46,7 @@ class DiskCacheTest : public PlatformTest {
   // Deletes the contents of |cache_path_|.
   bool CleanupCacheDir();
 
-  virtual void TearDown() OVERRIDE;
+  virtual void TearDown() override;
 
   base::FilePath cache_path_;
 
@@ -154,7 +154,7 @@ class DiskCacheTestWithCache : public DiskCacheTest {
   void AddDelay();
 
   // DiskCacheTest:
-  virtual void TearDown() OVERRIDE;
+  virtual void TearDown() override;
 
   // cache_ will always have a valid object, regardless of how the cache was
   // initialized. The implementation pointers can be NULL.
diff --git a/net/disk_cache/entry_unittest.cc b/net/disk_cache/entry_unittest.cc
index afe93ac..a3a7747 100644
--- a/net/disk_cache/entry_unittest.cc
+++ b/net/disk_cache/entry_unittest.cc
@@ -2063,7 +2063,7 @@ class SparseTestCompletionCallback: public net::TestCompletionCallback {
   }
 
  private:
-  virtual void SetResult(int result) OVERRIDE {
+  virtual void SetResult(int result) override {
     cache_.reset();
     TestCompletionCallback::SetResult(result);
   }
diff --git a/net/disk_cache/memory/mem_backend_impl.cc b/net/disk_cache/memory/mem_backend_impl.cc
index 848ef98..3a90075 100644
--- a/net/disk_cache/memory/mem_backend_impl.cc
+++ b/net/disk_cache/memory/mem_backend_impl.cc
@@ -188,7 +188,7 @@ class MemBackendImpl::MemIterator : public Backend::Iterator {
   }
 
   virtual int OpenNextEntry(Entry** next_entry,
-                            const CompletionCallback& callback) OVERRIDE {
+                            const CompletionCallback& callback) override {
     if (!backend_)
       return net::ERR_FAILED;
 
diff --git a/net/disk_cache/memory/mem_backend_impl.h b/net/disk_cache/memory/mem_backend_impl.h
index 10946c5..46505ea 100644
--- a/net/disk_cache/memory/mem_backend_impl.h
+++ b/net/disk_cache/memory/mem_backend_impl.h
@@ -63,24 +63,24 @@ class NET_EXPORT_PRIVATE MemBackendImpl : public Backend {
   void RemoveFromRankingList(MemEntryImpl* entry);
 
   // Backend interface.
-  virtual net::CacheType GetCacheType() const OVERRIDE;
-  virtual int32 GetEntryCount() const OVERRIDE;
+  virtual net::CacheType GetCacheType() const override;
+  virtual int32 GetEntryCount() const override;
   virtual int OpenEntry(const std::string& key, Entry** entry,
-                        const CompletionCallback& callback) OVERRIDE;
+                        const CompletionCallback& callback) override;
   virtual int CreateEntry(const std::string& key, Entry** entry,
-                          const CompletionCallback& callback) OVERRIDE;
+                          const CompletionCallback& callback) override;
   virtual int DoomEntry(const std::string& key,
-                        const CompletionCallback& callback) OVERRIDE;
-  virtual int DoomAllEntries(const CompletionCallback& callback) OVERRIDE;
+                        const CompletionCallback& callback) override;
+  virtual int DoomAllEntries(const CompletionCallback& callback) override;
   virtual int DoomEntriesBetween(base::Time initial_time,
                                  base::Time end_time,
-                                 const CompletionCallback& callback) OVERRIDE;
+                                 const CompletionCallback& callback) override;
   virtual int DoomEntriesSince(base::Time initial_time,
-                               const CompletionCallback& callback) OVERRIDE;
-  virtual scoped_ptr<Iterator> CreateIterator() OVERRIDE;
+                               const CompletionCallback& callback) override;
+  virtual scoped_ptr<Iterator> CreateIterator() override;
   virtual void GetStats(
-      std::vector<std::pair<std::string, std::string> >* stats) OVERRIDE {}
-  virtual void OnExternalCacheHit(const std::string& key) OVERRIDE;
+      std::vector<std::pair<std::string, std::string> >* stats) override {}
+  virtual void OnExternalCacheHit(const std::string& key) override;
 
  private:
   class MemIterator;
diff --git a/net/disk_cache/memory/mem_entry_impl.h b/net/disk_cache/memory/mem_entry_impl.h
index aec8d22..d31e14a 100644
--- a/net/disk_cache/memory/mem_entry_impl.h
+++ b/net/disk_cache/memory/mem_entry_impl.h
@@ -87,26 +87,26 @@ class MemEntryImpl : public Entry {
   }
 
   // Entry interface.
-  virtual void Doom() OVERRIDE;
-  virtual void Close() OVERRIDE;
-  virtual std::string GetKey() const OVERRIDE;
-  virtual base::Time GetLastUsed() const OVERRIDE;
-  virtual base::Time GetLastModified() const OVERRIDE;
-  virtual int32 GetDataSize(int index) const OVERRIDE;
+  virtual void Doom() override;
+  virtual void Close() override;
+  virtual std::string GetKey() const override;
+  virtual base::Time GetLastUsed() const override;
+  virtual base::Time GetLastModified() const override;
+  virtual int32 GetDataSize(int index) const override;
   virtual int ReadData(int index, int offset, IOBuffer* buf, int buf_len,
-                       const CompletionCallback& callback) OVERRIDE;
+                       const CompletionCallback& callback) override;
   virtual int WriteData(int index, int offset, IOBuffer* buf, int buf_len,
                         const CompletionCallback& callback,
-                        bool truncate) OVERRIDE;
+                        bool truncate) override;
   virtual int ReadSparseData(int64 offset, IOBuffer* buf, int buf_len,
-                             const CompletionCallback& callback) OVERRIDE;
+                             const CompletionCallback& callback) override;
   virtual int WriteSparseData(int64 offset, IOBuffer* buf, int buf_len,
-                              const CompletionCallback& callback) OVERRIDE;
+                              const CompletionCallback& callback) override;
   virtual int GetAvailableRange(int64 offset, int len, int64* start,
-                                const CompletionCallback& callback) OVERRIDE;
-  virtual bool CouldBeSparse() const OVERRIDE;
-  virtual void CancelSparseIO() OVERRIDE {}
-  virtual int ReadyForSparseIO(const CompletionCallback& callback) OVERRIDE;
+                                const CompletionCallback& callback) override;
+  virtual bool CouldBeSparse() const override;
+  virtual void CancelSparseIO() override {}
+  virtual int ReadyForSparseIO(const CompletionCallback& callback) override;
 
  private:
   typedef base::hash_map<int, MemEntryImpl*> EntryMap;
diff --git a/net/disk_cache/simple/simple_backend_impl.cc b/net/disk_cache/simple/simple_backend_impl.cc
index b0cbd52..32b074a 100644
--- a/net/disk_cache/simple/simple_backend_impl.cc
+++ b/net/disk_cache/simple/simple_backend_impl.cc
@@ -467,7 +467,7 @@ int SimpleBackendImpl::DoomEntriesSince(
   return DoomEntriesBetween(initial_time, Time(), callback);
 }
 
-class SimpleBackendImpl::SimpleIterator FINAL : public Iterator {
+class SimpleBackendImpl::SimpleIterator final : public Iterator {
  public:
   explicit SimpleIterator(base::WeakPtr<SimpleBackendImpl> backend)
       : backend_(backend),
@@ -476,7 +476,7 @@ class SimpleBackendImpl::SimpleIterator FINAL : public Iterator {
 
   // From Backend::Iterator:
   virtual int OpenNextEntry(Entry** next_entry,
-                            const CompletionCallback& callback) OVERRIDE {
+                            const CompletionCallback& callback) override {
     CompletionCallback open_next_entry_impl =
         base::Bind(&SimpleIterator::OpenNextEntryImpl,
                    weak_factory_.GetWeakPtr(), next_entry, callback);
diff --git a/net/disk_cache/simple/simple_backend_impl.h b/net/disk_cache/simple/simple_backend_impl.h
index 48c422f..e5a50da 100644
--- a/net/disk_cache/simple/simple_backend_impl.h
+++ b/net/disk_cache/simple/simple_backend_impl.h
@@ -85,27 +85,27 @@ class NET_EXPORT_PRIVATE SimpleBackendImpl : public Backend,
 
   // SimpleIndexDelegate:
   virtual void DoomEntries(std::vector<uint64>* entry_hashes,
-                           const CompletionCallback& callback) OVERRIDE;
+                           const CompletionCallback& callback) override;
 
   // Backend:
-  virtual net::CacheType GetCacheType() const OVERRIDE;
-  virtual int32 GetEntryCount() const OVERRIDE;
+  virtual net::CacheType GetCacheType() const override;
+  virtual int32 GetEntryCount() const override;
   virtual int OpenEntry(const std::string& key, Entry** entry,
-                        const CompletionCallback& callback) OVERRIDE;
+                        const CompletionCallback& callback) override;
   virtual int CreateEntry(const std::string& key, Entry** entry,
-                          const CompletionCallback& callback) OVERRIDE;
+                          const CompletionCallback& callback) override;
   virtual int DoomEntry(const std::string& key,
-                        const CompletionCallback& callback) OVERRIDE;
-  virtual int DoomAllEntries(const CompletionCallback& callback) OVERRIDE;
+                        const CompletionCallback& callback) override;
+  virtual int DoomAllEntries(const CompletionCallback& callback) override;
   virtual int DoomEntriesBetween(base::Time initial_time,
                                  base::Time end_time,
-                                 const CompletionCallback& callback) OVERRIDE;
+                                 const CompletionCallback& callback) override;
   virtual int DoomEntriesSince(base::Time initial_time,
-                               const CompletionCallback& callback) OVERRIDE;
-  virtual scoped_ptr<Iterator> CreateIterator() OVERRIDE;
+                               const CompletionCallback& callback) override;
+  virtual scoped_ptr<Iterator> CreateIterator() override;
   virtual void GetStats(
-      std::vector<std::pair<std::string, std::string> >* stats) OVERRIDE;
-  virtual void OnExternalCacheHit(const std::string& key) OVERRIDE;
+      std::vector<std::pair<std::string, std::string> >* stats) override;
+  virtual void OnExternalCacheHit(const std::string& key) override;
 
  private:
   class SimpleIterator;
diff --git a/net/disk_cache/simple/simple_entry_impl.h b/net/disk_cache/simple/simple_entry_impl.h
index 2dfb757..7c11b96 100644
--- a/net/disk_cache/simple/simple_entry_impl.h
+++ b/net/disk_cache/simple/simple_entry_impl.h
@@ -80,38 +80,38 @@ class NET_EXPORT_PRIVATE SimpleEntryImpl : public Entry,
   void SetKey(const std::string& key);
 
   // From Entry:
-  virtual void Doom() OVERRIDE;
-  virtual void Close() OVERRIDE;
-  virtual std::string GetKey() const OVERRIDE;
-  virtual base::Time GetLastUsed() const OVERRIDE;
-  virtual base::Time GetLastModified() const OVERRIDE;
-  virtual int32 GetDataSize(int index) const OVERRIDE;
+  virtual void Doom() override;
+  virtual void Close() override;
+  virtual std::string GetKey() const override;
+  virtual base::Time GetLastUsed() const override;
+  virtual base::Time GetLastModified() const override;
+  virtual int32 GetDataSize(int index) const override;
   virtual int ReadData(int stream_index,
                        int offset,
                        net::IOBuffer* buf,
                        int buf_len,
-                       const CompletionCallback& callback) OVERRIDE;
+                       const CompletionCallback& callback) override;
   virtual int WriteData(int stream_index,
                         int offset,
                         net::IOBuffer* buf,
                         int buf_len,
                         const CompletionCallback& callback,
-                        bool truncate) OVERRIDE;
+                        bool truncate) override;
   virtual int ReadSparseData(int64 offset,
                              net::IOBuffer* buf,
                              int buf_len,
-                             const CompletionCallback& callback) OVERRIDE;
+                             const CompletionCallback& callback) override;
   virtual int WriteSparseData(int64 offset,
                               net::IOBuffer* buf,
                               int buf_len,
-                              const CompletionCallback& callback) OVERRIDE;
+                              const CompletionCallback& callback) override;
   virtual int GetAvailableRange(int64 offset,
                                 int len,
                                 int64* start,
-                                const CompletionCallback& callback) OVERRIDE;
-  virtual bool CouldBeSparse() const OVERRIDE;
-  virtual void CancelSparseIO() OVERRIDE;
-  virtual int ReadyForSparseIO(const CompletionCallback& callback) OVERRIDE;
+                                const CompletionCallback& callback) override;
+  virtual bool CouldBeSparse() const override;
+  virtual void CancelSparseIO() override;
+  virtual int ReadyForSparseIO(const CompletionCallback& callback) override;
 
  private:
   class ScopedOperationRunner;
diff --git a/net/disk_cache/simple/simple_index_unittest.cc b/net/disk_cache/simple/simple_index_unittest.cc
index 0afbaa2..0bb10d3 100644
--- a/net/disk_cache/simple/simple_index_unittest.cc
+++ b/net/disk_cache/simple/simple_index_unittest.cc
@@ -60,7 +60,7 @@ class MockSimpleIndexFile : public SimpleIndexFile,
   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_;
@@ -69,7 +69,7 @@ class MockSimpleIndexFile : public SimpleIndexFile,
   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;
   }
@@ -102,7 +102,7 @@ class SimpleIndexTest  : public testing::Test, public SimpleIndexDelegate {
         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,
@@ -121,7 +121,7 @@ class SimpleIndexTest  : public testing::Test, public SimpleIndexDelegate {
 
   // 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()));