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

chrome/browser/prefs/profile_pref_store_manager_unittest.cc

 // Copyright 2014 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/profile_pref_store_manager.h"
 
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/files/file_enumerator.h"
@@ skipping 33 matching lines @@
 };
 
 // Observes changes to the PrefStore and verifies that only registered prefs are
 // written.
 class RegistryVerifier : public PrefStore::Observer {
  public:
   explicit RegistryVerifier(PrefRegistry* pref_registry)
       : pref_registry_(pref_registry) {}
 
   // PrefStore::Observer implementation
-  virtual void OnPrefValueChanged(const std::string& key) OVERRIDE {
+  virtual void OnPrefValueChanged(const std::string& key) override {
     EXPECT_TRUE(pref_registry_->end() !=
                 std::find_if(pref_registry_->begin(),
                              pref_registry_->end(),
                              FirstEqualsPredicate(key)))
         << "Unregistered key " << key << " was changed.";
   }
 
-  virtual void OnInitializationCompleted(bool succeeded) OVERRIDE {}
+  virtual void OnInitializationCompleted(bool succeeded) override {}
 
  private:
   scoped_refptr<PrefRegistry> pref_registry_;
 };
 
 const char kUnprotectedPref[] = "unprotected_pref";
 const char kTrackedAtomic[] = "tracked_atomic";
 const char kProtectedAtomic[] = "protected_atomic";
 
 const char kFoobar[] = "FOOBAR";
@@ skipping 15 matching lines @@
 class ProfilePrefStoreManagerTest : public testing::Test {
  public:
   ProfilePrefStoreManagerTest()
       : configuration_(kConfiguration,
                        kConfiguration + arraysize(kConfiguration)),
         profile_pref_registry_(new user_prefs::PrefRegistrySyncable),
         registry_verifier_(profile_pref_registry_.get()),
         seed_("seed"),
         reset_recorded_(false) {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     ProfilePrefStoreManager::RegisterPrefs(local_state_.registry());
     ProfilePrefStoreManager::RegisterProfilePrefs(profile_pref_registry_.get());
     for (const PrefHashFilter::TrackedPreferenceMetadata* it = kConfiguration;
          it != kConfiguration + arraysize(kConfiguration);
          ++it) {
       if (it->strategy == PrefHashFilter::TRACKING_STRATEGY_ATOMIC) {
         profile_pref_registry_->RegisterStringPref(
             it->name,
             std::string(),
             user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
@@ skipping 24 matching lines @@
 
   void ReloadConfiguration() {
     manager_.reset(new ProfilePrefStoreManager(profile_dir_.path(),
                                                configuration_,
                                                kReportingIdCount,
                                                seed_,
                                                "device_id",
                                                &local_state_));
   }
 
-  virtual void TearDown() OVERRIDE { DestroyPrefStore(); }
+  virtual void TearDown() override { DestroyPrefStore(); }
 
  protected:
   // Verifies whether a reset was reported via the RecordReset() hook. Also
   // verifies that GetResetTime() was set (or not) accordingly.
   void VerifyResetRecorded(bool reset_expected) {
     EXPECT_EQ(reset_expected, reset_recorded_);
 
     base::PrefServiceFactory pref_service_factory;
     pref_service_factory.set_user_prefs(pref_store_);
 
@@ skipping 424 matching lines @@
   LoadExistingPrefs();
   ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
 
   // Trigger the logic that migrates it back to the unprotected preferences
   // file.
   pref_store_->SetValue(kProtectedAtomic, new base::StringValue(kGoodbyeWorld));
   LoadExistingPrefs();
   ExpectStringValueEquals(kProtectedAtomic, kGoodbyeWorld);
   VerifyResetRecorded(false);
 }