replace OVERRIDE and FINAL with override and final in chrome/browser/[r-z]*

chrome/browser/sync/profile_sync_service.h

 // Copyright (c) 2012 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_SYNC_PROFILE_SYNC_SERVICE_H_
 #define CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_
 
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 266 matching lines @@
       browser_sync::ProfileSyncServiceStartBehavior start_behavior);
   virtual ~ProfileSyncService();
 
   // Initializes the object. This must be called at most once, and
   // immediately after an object of this class is constructed.
   void Initialize();
 
   virtual void SetSyncSetupCompleted();
 
   // ProfileSyncServiceBase implementation.
-  virtual bool HasSyncSetupCompleted() const OVERRIDE;
-  virtual bool SyncActive() const OVERRIDE;
-  virtual syncer::ModelTypeSet GetActiveDataTypes() const OVERRIDE;
-  virtual void AddObserver(ProfileSyncServiceBase::Observer* observer) OVERRIDE;
+  virtual bool HasSyncSetupCompleted() const override;
+  virtual bool SyncActive() const override;
+  virtual syncer::ModelTypeSet GetActiveDataTypes() const override;
+  virtual void AddObserver(ProfileSyncServiceBase::Observer* observer) override;
   virtual void RemoveObserver(
-      ProfileSyncServiceBase::Observer* observer) OVERRIDE;
+      ProfileSyncServiceBase::Observer* observer) override;
   virtual bool HasObserver(
-      ProfileSyncServiceBase::Observer* observer) const OVERRIDE;
+      ProfileSyncServiceBase::Observer* observer) const override;
 
   void AddProtocolEventObserver(browser_sync::ProtocolEventObserver* observer);
   void RemoveProtocolEventObserver(
       browser_sync::ProtocolEventObserver* observer);
 
   void AddTypeDebugInfoObserver(syncer::TypeDebugInfoObserver* observer);
   void RemoveTypeDebugInfoObserver(syncer::TypeDebugInfoObserver* observer);
 
   // Add a sync type preference provider. Each provider may only be added once.
   void AddPreferenceProvider(SyncTypePreferenceProvider* provider);
@@ skipping 86 matching lines @@
 
   // Disables sync for the user and prevents it from starting on next restart.
   virtual void StopSyncingPermanently();
 
   // SyncFrontend implementation.
   virtual void OnBackendInitialized(
       const syncer::WeakHandle<syncer::JsBackend>& js_backend,
       const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
           debug_info_listener,
       const std::string& cache_guid,
-      bool success) OVERRIDE;
-  virtual void OnSyncCycleCompleted() OVERRIDE;
-  virtual void OnProtocolEvent(const syncer::ProtocolEvent& event) OVERRIDE;
+      bool success) override;
+  virtual void OnSyncCycleCompleted() override;
+  virtual void OnProtocolEvent(const syncer::ProtocolEvent& event) override;
   virtual void OnDirectoryTypeCommitCounterUpdated(
       syncer::ModelType type,
-      const syncer::CommitCounters& counters) OVERRIDE;
+      const syncer::CommitCounters& counters) override;
   virtual void OnDirectoryTypeUpdateCounterUpdated(
       syncer::ModelType type,
-      const syncer::UpdateCounters& counters) OVERRIDE;
+      const syncer::UpdateCounters& counters) override;
   virtual void OnDirectoryTypeStatusCounterUpdated(
       syncer::ModelType type,
-      const syncer::StatusCounters& counters) OVERRIDE;
+      const syncer::StatusCounters& counters) override;
   virtual void OnConnectionStatusChange(
-      syncer::ConnectionStatus status) OVERRIDE;
+      syncer::ConnectionStatus status) override;
   virtual void OnPassphraseRequired(
       syncer::PassphraseRequiredReason reason,
-      const sync_pb::EncryptedData& pending_keys) OVERRIDE;
-  virtual void OnPassphraseAccepted() OVERRIDE;
+      const sync_pb::EncryptedData& pending_keys) override;
+  virtual void OnPassphraseAccepted() override;
   virtual void OnEncryptedTypesChanged(
       syncer::ModelTypeSet encrypted_types,
-      bool encrypt_everything) OVERRIDE;
-  virtual void OnEncryptionComplete() OVERRIDE;
+      bool encrypt_everything) override;
+  virtual void OnEncryptionComplete() override;
   virtual void OnMigrationNeededForTypes(
-      syncer::ModelTypeSet types) OVERRIDE;
+      syncer::ModelTypeSet types) override;
   virtual void OnExperimentsChanged(
-      const syncer::Experiments& experiments) OVERRIDE;
+      const syncer::Experiments& experiments) override;
   virtual void OnActionableError(
-      const syncer::SyncProtocolError& error) OVERRIDE;
+      const syncer::SyncProtocolError& error) override;
 
   // DataTypeManagerObserver implementation.
   virtual void OnConfigureDone(
-      const sync_driver::DataTypeManager::ConfigureResult& result) OVERRIDE;
-  virtual void OnConfigureStart() OVERRIDE;
+      const sync_driver::DataTypeManager::ConfigureResult& result) override;
+  virtual void OnConfigureStart() override;
 
   // DataTypeEncryptionHandler implementation.
-  virtual bool IsPassphraseRequired() const OVERRIDE;
-  virtual syncer::ModelTypeSet GetEncryptedDataTypes() const OVERRIDE;
+  virtual bool IsPassphraseRequired() const override;
+  virtual syncer::ModelTypeSet GetEncryptedDataTypes() const override;
 
   // SigninManagerBase::Observer implementation.
   virtual void GoogleSigninSucceeded(const std::string& account_id,
                                      const std::string& username,
-                                     const std::string& password) OVERRIDE;
+                                     const std::string& password) override;
   virtual void GoogleSignedOut(const std::string& account_id,
-                               const std::string& username) OVERRIDE;
+                               const std::string& username) override;
 
   // Called when a user chooses which data types to sync as part of the sync
   // setup wizard.  |sync_everything| represents whether they chose the
   // "keep everything synced" option; if true, |chosen_types| will be ignored
   // and all data types will be synced.  |sync_everything| means "sync all
   // current and future data types."
   virtual void OnUserChoseDatatypes(bool sync_everything,
       syncer::ModelTypeSet chosen_types);
 
   // Get the sync status code.
@@ skipping 81 matching lines @@
   // assume it's running on the UI thread.
   static bool IsSyncEnabled();
 
   // Returns whether sync is managed, i.e. controlled by configuration
   // management. If so, the user is not allowed to configure sync.
   virtual bool IsManaged() const;
 
   // syncer::UnrecoverableErrorHandler implementation.
   virtual void OnUnrecoverableError(
       const tracked_objects::Location& from_here,
-      const std::string& message) OVERRIDE;
+      const std::string& message) override;
 
   // Called to re-enable a type disabled by DisableDatatype(..). Note, this does
   // not change the preferred state of a datatype, and is not persisted across
   // restarts.
   void ReenableDatatype(syncer::ModelType type);
 
   // The functions below (until ActivateDataType()) should only be
   // called if backend_initialized() is true.
 
   // TODO(akalin): This is called mostly by ModelAssociators and
@@ skipping 37 matching lines @@
   // This function is used by about_sync_util.cc to help populate the about:sync
   // page.  It returns a ListValue rather than a DictionaryValue in part to make
   // it easier to iterate over its elements when constructing that page.
   base::Value* GetTypeStatusMap() const;
 
   // Overridden by tests.
   // TODO(zea): Remove these and have the dtc's call directly into the SBH.
   virtual void DeactivateDataType(syncer::ModelType type);
 
   // SyncPrefObserver implementation.
-  virtual void OnSyncManagedPrefChange(bool is_sync_managed) OVERRIDE;
+  virtual void OnSyncManagedPrefChange(bool is_sync_managed) override;
 
   // Changes which data types we're going to be syncing to |preferred_types|.
   // If it is running, the DataTypeManager will be instructed to reconfigure
   // the sync backend so that exactly these datatypes are actively synced.  See
   // class comment for more on what it means for a datatype to be Preferred.
   virtual void ChangePreferredDataTypes(
       syncer::ModelTypeSet preferred_types);
 
   // Returns the set of types which are preferred for enabling. This is a
   // superset of the active types (see GetActiveDataTypes()).
@@ skipping 108 matching lines @@
   // been cleared yet. Virtual for testing purposes.
   virtual bool waiting_for_auth() const;
 
   // The set of currently enabled sync experiments.
   const syncer::Experiments& current_experiments() const;
 
   // OAuth2TokenService::Consumer implementation.
   virtual void OnGetTokenSuccess(
       const OAuth2TokenService::Request* request,
       const std::string& access_token,
-      const base::Time& expiration_time) OVERRIDE;
+      const base::Time& expiration_time) override;
   virtual void OnGetTokenFailure(
       const OAuth2TokenService::Request* request,
-      const GoogleServiceAuthError& error) OVERRIDE;
+      const GoogleServiceAuthError& error) override;
 
   // OAuth2TokenService::Observer implementation.
-  virtual void OnRefreshTokenAvailable(const std::string& account_id) OVERRIDE;
-  virtual void OnRefreshTokenRevoked(const std::string& account_id) OVERRIDE;
-  virtual void OnRefreshTokensLoaded() OVERRIDE;
+  virtual void OnRefreshTokenAvailable(const std::string& account_id) override;
+  virtual void OnRefreshTokenRevoked(const std::string& account_id) override;
+  virtual void OnRefreshTokensLoaded() override;
 
   // KeyedService implementation.  This must be called exactly
   // once (before this object is destroyed).
-  virtual void Shutdown() OVERRIDE;
+  virtual void Shutdown() override;
 
   // Called when a datatype (SyncableService) has a need for sync to start
   // ASAP, presumably because a local change event has occurred but we're
   // still in deferred start mode, meaning the SyncableService hasn't been
   // told to MergeDataAndStartSyncing yet.
   void OnDataTypeRequestsSyncStartup(syncer::ModelType type);
 
   // Return sync token status.
   SyncTokenStatus GetSyncTokenStatus() const;
 
@@ skipping 404 matching lines @@
   BrowsingDataRemover::Observer* browsing_data_remover_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileSyncService);
 };
 
 bool ShouldShowActionOnUI(
     const syncer::SyncProtocolError& error);
 
 
 #endif  // CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_