replace OVERRIDE and FINAL with override and final in net/

net/disk_cache/simple/simple_backend_impl.h

 // 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.
 
 #ifndef NET_DISK_CACHE_SIMPLE_SIMPLE_BACKEND_IMPL_H_
 #define NET_DISK_CACHE_SIMPLE_SIMPLE_BACKEND_IMPL_H_
 
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 67 matching lines @@
   // run new operations for this |entry_hash| until the Doom is completed.
   void OnDoomStart(uint64 entry_hash);
 
   // The entry for |entry_hash| has been successfully doomed, we can now allow
   // operations on this entry, and we can run any operations enqueued while the
   // doom completed.
   void OnDoomComplete(uint64 entry_hash);
 
   // 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;
   friend class SimpleIterator;
 
   typedef base::hash_map<uint64, SimpleEntryImpl*> EntryMap;
 
   typedef base::Callback<void(base::Time mtime, uint64 max_size, int result)>
       InitializeIndexCallback;
 
@@ skipping 82 matching lines @@
   // is complete. The base::Closure map target is used to store deferred
   // operations to be run at the completion of the Doom.
   base::hash_map<uint64, std::vector<base::Closure> > entries_pending_doom_;
 
   net::NetLog* const net_log_;
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_BACKEND_IMPL_H_