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

chrome/browser/prefs/tracked/segregated_pref_store_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/tracked/segregated_pref_store.h"
 
 #include <set>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 24 matching lines @@
     bool invoked;
     PersistentPrefStore::PrefReadError read_error;
   };
 
   explicit MockReadErrorDelegate(Data* data) : data_(data) {
     DCHECK(data_);
     EXPECT_FALSE(data_->invoked);
   }
 
   // PersistentPrefStore::ReadErrorDelegate implementation
-  virtual void OnError(PersistentPrefStore::PrefReadError read_error) OVERRIDE {
+  virtual void OnError(PersistentPrefStore::PrefReadError read_error) override {
     EXPECT_FALSE(data_->invoked);
     data_->invoked = true;
     data_->read_error = read_error;
   }
 
  private:
   Data* data_;
 };
 
 }  // namespace
 
 class SegregatedPrefStoreTest : public testing::Test {
  public:
   SegregatedPrefStoreTest()
       : read_error_delegate_data_(false,
                                   PersistentPrefStore::PREF_READ_ERROR_NONE),
         read_error_delegate_(
             new MockReadErrorDelegate(&read_error_delegate_data_)) {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     selected_store_ = new TestingPrefStore;
     default_store_ = new TestingPrefStore;
 
     std::set<std::string> selected_pref_names;
     selected_pref_names.insert(kSelectedPref);
 
     segregated_store_ = new SegregatedPrefStore(
         default_store_,
         selected_store_,
         selected_pref_names);
 
     segregated_store_->AddObserver(&observer_);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     segregated_store_->RemoveObserver(&observer_);
   }
 
  protected:
   scoped_ptr<PersistentPrefStore::ReadErrorDelegate> GetReadErrorDelegate() {
     EXPECT_TRUE(read_error_delegate_);
     return read_error_delegate_
         .PassAs<PersistentPrefStore::ReadErrorDelegate>();
   }
 
@@ skipping 172 matching lines @@
   selected_store_->SetBlockAsyncRead(true);
   default_store_->SetBlockAsyncRead(true);
   EXPECT_FALSE(segregated_store_->IsInitializationComplete());
   segregated_store_->ReadPrefsAsync(NULL);
   EXPECT_FALSE(segregated_store_->IsInitializationComplete());
   selected_store_->SetBlockAsyncRead(false);
   EXPECT_FALSE(segregated_store_->IsInitializationComplete());
   default_store_->SetBlockAsyncRead(false);
   EXPECT_TRUE(segregated_store_->IsInitializationComplete());
 }