replace OVERRIDE and FINAL with override and final in chrome/browser/[j-q]*

chrome/browser/prefs/tracked/pref_hash_filter_unittest.cc

 // Copyright 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 "chrome/browser/prefs/tracked/pref_hash_filter.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 136 matching lines @@
         stored_values_.find(path);
     if (value != stored_values_.end())
       return value->second;
     return std::make_pair(
                reinterpret_cast<void*>(0xBAD),
                static_cast<PrefHashFilter::PrefTrackingStrategy>(-1));
   }
 
   // PrefHashStore implementation.
   virtual scoped_ptr<PrefHashStoreTransaction> BeginTransaction(
-      scoped_ptr<HashStoreContents> storage) OVERRIDE;
+      scoped_ptr<HashStoreContents> storage) override;
 
  private:
   // A MockPrefHashStoreTransaction is handed to the caller on
   // MockPrefHashStore::BeginTransaction(). It then stores state in its
   // underlying MockPrefHashStore about calls it receives from that same caller
   // which can later be verified in tests.
   class MockPrefHashStoreTransaction : public PrefHashStoreTransaction {
    public:
     explicit MockPrefHashStoreTransaction(MockPrefHashStore* outer)
         : outer_(outer) {}
 
     virtual ~MockPrefHashStoreTransaction() {
       outer_->transaction_active_ = false;
       ++outer_->transactions_performed_;
     }
 
     // PrefHashStoreTransaction implementation.
     virtual PrefHashStoreTransaction::ValueState CheckValue(
-        const std::string& path, const base::Value* value) const OVERRIDE;
+        const std::string& path, const base::Value* value) const override;
     virtual void StoreHash(const std::string& path,
-                           const base::Value* new_value) OVERRIDE;
+                           const base::Value* new_value) override;
     virtual PrefHashStoreTransaction::ValueState CheckSplitValue(
         const std::string& path,
         const base::DictionaryValue* initial_split_value,
-        std::vector<std::string>* invalid_keys) const OVERRIDE;
+        std::vector<std::string>* invalid_keys) const override;
     virtual void StoreSplitHash(
         const std::string& path,
-        const base::DictionaryValue* split_value) OVERRIDE;
-    virtual bool HasHash(const std::string& path) const OVERRIDE;
+        const base::DictionaryValue* split_value) override;
+    virtual bool HasHash(const std::string& path) const override;
     virtual void ImportHash(const std::string& path,
-                            const base::Value* hash) OVERRIDE;
-    virtual void ClearHash(const std::string& path) OVERRIDE;
-    virtual bool IsSuperMACValid() const OVERRIDE;
-    virtual bool StampSuperMac() OVERRIDE;
+                            const base::Value* hash) override;
+    virtual void ClearHash(const std::string& path) override;
+    virtual bool IsSuperMACValid() const override;
+    virtual bool StampSuperMac() override;
 
    private:
     MockPrefHashStore* outer_;
 
     DISALLOW_COPY_AND_ASSIGN(MockPrefHashStoreTransaction);
   };
 
   // Records a call to this mock's CheckValue/CheckSplitValue methods.
   PrefHashStoreTransaction::ValueState RecordCheckValue(
       const std::string& path,
@@ skipping 160 matching lines @@
 }
 
 class PrefHashFilterTest
     : public testing::TestWithParam<PrefHashFilter::EnforcementLevel> {
  public:
   PrefHashFilterTest() : mock_pref_hash_store_(NULL),
                          pref_store_contents_(new base::DictionaryValue),
                          last_filter_on_load_modified_prefs_(false),
                          reset_recorded_(false) {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     base::StatisticsRecorder::Initialize();
     Reset();
   }
 
  protected:
   // Reset the PrefHashFilter instance.
   void Reset() {
     // Construct a PrefHashFilter and MockPrefHashStore for the test.
     InitializePrefHashFilter(GetConfiguration(GetParam()));
   }
@@ skipping 667 matching lines @@
               mock_pref_hash_store_->stored_value(kAtomicPref2).first);
 
     VerifyRecordedReset(false);
   }
 }
 
 INSTANTIATE_TEST_CASE_P(
     PrefHashFilterTestInstance, PrefHashFilterTest,
     testing::Values(PrefHashFilter::NO_ENFORCEMENT,
                     PrefHashFilter::ENFORCE_ON_LOAD));