Standardize usage of virtual/override/final in chrome/browser/sync/

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 257 matching lines @@
   // Sync server URL for dev channel users
   static const char* kDevServerUrl;
 
   // Takes ownership of |factory| and |signin_wrapper|.
   ProfileSyncService(
       scoped_ptr<ProfileSyncComponentsFactory> factory,
       Profile* profile,
       scoped_ptr<SupervisedUserSigninManagerWrapper> signin_wrapper,
       ProfileOAuth2TokenService* oauth2_token_service,
       browser_sync::ProfileSyncServiceStartBehavior start_behavior);
-  virtual ~ProfileSyncService();
+  ~ProfileSyncService() override;
 
   // 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 void RemoveObserver(
-      ProfileSyncServiceBase::Observer* observer) override;
-  virtual bool HasObserver(
-      ProfileSyncServiceBase::Observer* observer) const override;
+  bool HasSyncSetupCompleted() const override;
+  bool SyncActive() const override;
+  syncer::ModelTypeSet GetActiveDataTypes() const override;
+  void AddObserver(ProfileSyncServiceBase::Observer* observer) override;
+  void RemoveObserver(ProfileSyncServiceBase::Observer* observer) override;
+  bool HasObserver(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 81 matching lines @@
   void GetDataTypeControllerStates(
     sync_driver::DataTypeController::StateMap* state_map) const;
 
   // Disables sync for user. Use ShowLoginDialog to enable.
   virtual void DisableForUser();
 
   // Disables sync for the user and prevents it from starting on next restart.
   virtual void StopSyncingPermanently();
 
   // SyncFrontend implementation.
-  virtual void OnBackendInitialized(
+  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;
-  virtual void OnDirectoryTypeCommitCounterUpdated(
+  void OnSyncCycleCompleted() override;
+  void OnProtocolEvent(const syncer::ProtocolEvent& event) override;
+  void OnDirectoryTypeCommitCounterUpdated(
       syncer::ModelType type,
       const syncer::CommitCounters& counters) override;
-  virtual void OnDirectoryTypeUpdateCounterUpdated(
+  void OnDirectoryTypeUpdateCounterUpdated(
       syncer::ModelType type,
       const syncer::UpdateCounters& counters) override;
-  virtual void OnDirectoryTypeStatusCounterUpdated(
+  void OnDirectoryTypeStatusCounterUpdated(
       syncer::ModelType type,
       const syncer::StatusCounters& counters) override;
-  virtual void OnConnectionStatusChange(
-      syncer::ConnectionStatus status) override;
-  virtual void OnPassphraseRequired(
+  void OnConnectionStatusChange(syncer::ConnectionStatus status) override;
+  void OnPassphraseRequired(
       syncer::PassphraseRequiredReason reason,
       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;
-  virtual void OnMigrationNeededForTypes(
-      syncer::ModelTypeSet types) override;
-  virtual void OnExperimentsChanged(
-      const syncer::Experiments& experiments) override;
-  virtual void OnActionableError(
-      const syncer::SyncProtocolError& error) override;
+  void OnPassphraseAccepted() override;
+  void OnEncryptedTypesChanged(syncer::ModelTypeSet encrypted_types,
+                               bool encrypt_everything) override;
+  void OnEncryptionComplete() override;
+  void OnMigrationNeededForTypes(syncer::ModelTypeSet types) override;
+  void OnExperimentsChanged(const syncer::Experiments& experiments) override;
+  void OnActionableError(const syncer::SyncProtocolError& error) override;
 
   // DataTypeManagerObserver implementation.
-  virtual void OnConfigureDone(
+  void OnConfigureDone(
       const sync_driver::DataTypeManager::ConfigureResult& result) override;
-  virtual void OnConfigureStart() override;
+  void OnConfigureStart() override;
 
   // DataTypeEncryptionHandler implementation.
-  virtual bool IsPassphraseRequired() const override;
-  virtual syncer::ModelTypeSet GetEncryptedDataTypes() const override;
+  bool IsPassphraseRequired() const override;
+  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;
-  virtual void GoogleSignedOut(const std::string& account_id,
-                               const std::string& username) override;
+  void GoogleSigninSucceeded(const std::string& account_id,
+                             const std::string& username,
+                             const std::string& password) override;
+  void GoogleSignedOut(const std::string& account_id,
+                       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 79 matching lines @@
   // Profile::IsSyncAccessible() is probably a better signal than this function.
   // This function can be called from any thread, and the implementation doesn't
   // 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;
+  void OnUnrecoverableError(const tracked_objects::Location& from_here,
+                            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;
+  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 105 matching lines @@
   // succeeded, and is waiting for initialization to complete. This is used by
   // the UI to differentiate between a new auth error (encountered as part of
   // the initialization process) and a pre-existing auth error that just hasn't
   // 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;
-  virtual void OnGetTokenFailure(
-      const OAuth2TokenService::Request* request,
-      const GoogleServiceAuthError& error) override;
+  void OnGetTokenSuccess(const OAuth2TokenService::Request* request,
+                         const std::string& access_token,
+                         const base::Time& expiration_time) override;
+  void OnGetTokenFailure(const OAuth2TokenService::Request* request,
+                         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;
+  void OnRefreshTokenAvailable(const std::string& account_id) override;
+  void OnRefreshTokenRevoked(const std::string& account_id) override;
+  void OnRefreshTokensLoaded() override;
 
   // KeyedService implementation.  This must be called exactly
   // once (before this object is destroyed).
-  virtual void Shutdown() override;
+  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 405 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_