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

chrome/browser/prefs/tracked/segregated_pref_store.h

 // 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.
 
 #ifndef CHROME_BROWSER_PREFS_TRACKED_SEGREGATED_PREF_STORE_H_
 #define CHROME_BROWSER_PREFS_TRACKED_SEGREGATED_PREF_STORE_H_
 
 #include <set>
 #include <string>
 
@@ skipping 26 matching lines @@
   // be migrated back to |default_pref_store| upon access via a non-const
   // method.
   // |on_initialization| will be invoked when both stores have been initialized,
   // before observers of the SegregatedPrefStore store are notified.
   SegregatedPrefStore(
       const scoped_refptr<PersistentPrefStore>& default_pref_store,
       const scoped_refptr<PersistentPrefStore>& selected_pref_store,
       const std::set<std::string>& selected_pref_names);
 
   // PrefStore implementation
-  virtual void AddObserver(Observer* observer) OVERRIDE;
-  virtual void RemoveObserver(Observer* observer) OVERRIDE;
-  virtual bool HasObservers() const OVERRIDE;
-  virtual bool IsInitializationComplete() const OVERRIDE;
+  virtual void AddObserver(Observer* observer) override;
+  virtual void RemoveObserver(Observer* observer) override;
+  virtual bool HasObservers() const override;
+  virtual bool IsInitializationComplete() const override;
   virtual bool GetValue(const std::string& key,
-                        const base::Value** result) const OVERRIDE;
+                        const base::Value** result) const override;
 
   // WriteablePrefStore implementation
-  virtual void SetValue(const std::string& key, base::Value* value) OVERRIDE;
-  virtual void RemoveValue(const std::string& key) OVERRIDE;
+  virtual void SetValue(const std::string& key, base::Value* value) override;
+  virtual void RemoveValue(const std::string& key) override;
 
   // PersistentPrefStore implementation
   virtual bool GetMutableValue(const std::string& key,
-                               base::Value** result) OVERRIDE;
-  virtual void ReportValueChanged(const std::string& key) OVERRIDE;
+                               base::Value** result) override;
+  virtual void ReportValueChanged(const std::string& key) override;
   virtual void SetValueSilently(const std::string& key,
-                                base::Value* value) OVERRIDE;
-  virtual bool ReadOnly() const OVERRIDE;
-  virtual PrefReadError GetReadError() const OVERRIDE;
-  virtual PrefReadError ReadPrefs() OVERRIDE;
-  virtual void ReadPrefsAsync(ReadErrorDelegate* error_delegate) OVERRIDE;
-  virtual void CommitPendingWrite() OVERRIDE;
+                                base::Value* value) override;
+  virtual bool ReadOnly() const override;
+  virtual PrefReadError GetReadError() const override;
+  virtual PrefReadError ReadPrefs() override;
+  virtual void ReadPrefsAsync(ReadErrorDelegate* error_delegate) override;
+  virtual void CommitPendingWrite() override;
 
  private:
   // Aggregates events from the underlying stores and synthesizes external
   // events via |on_initialization|, |read_error_delegate_|, and |observers_|.
   class AggregatingObserver : public PrefStore::Observer {
    public:
     explicit AggregatingObserver(SegregatedPrefStore* outer);
 
     // PrefStore::Observer implementation
-    virtual void OnPrefValueChanged(const std::string& key) OVERRIDE;
-    virtual void OnInitializationCompleted(bool succeeded) OVERRIDE;
+    virtual void OnPrefValueChanged(const std::string& key) override;
+    virtual void OnInitializationCompleted(bool succeeded) override;
 
    private:
     SegregatedPrefStore* outer_;
     int failed_sub_initializations_;
     int successful_sub_initializations_;
 
     DISALLOW_COPY_AND_ASSIGN(AggregatingObserver);
   };
 
   virtual ~SegregatedPrefStore();
 
   // Returns |selected_pref_store| if |key| is selected and |default_pref_store|
   // otherwise.
   PersistentPrefStore* StoreForKey(const std::string& key);
   const PersistentPrefStore* StoreForKey(const std::string& key) const;
 
   scoped_refptr<PersistentPrefStore> default_pref_store_;
   scoped_refptr<PersistentPrefStore> selected_pref_store_;
   std::set<std::string> selected_preference_names_;
 
   scoped_ptr<PersistentPrefStore::ReadErrorDelegate> read_error_delegate_;
   ObserverList<PrefStore::Observer, true> observers_;
   AggregatingObserver aggregating_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(SegregatedPrefStore);
 };
 
 #endif  // CHROME_BROWSER_PREFS_TRACKED_SEGREGATED_PREF_STORE_H_