Standardize usage of virtual/override/final in components/

components/invalidation/sync_system_resources.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.
 //
 // Simple system resources class that uses the current message loop
 // for scheduling.  Assumes the current message loop is already
 // running.
 
 #ifndef COMPONENTS_INVALIDATION_SYNC_SYSTEM_RESOURCES_H_
 #define COMPONENTS_INVALIDATION_SYNC_SYSTEM_RESOURCES_H_
@@ skipping 15 matching lines @@
 #include "jingle/notifier/base/notifier_options.h"
 
 namespace syncer {
 
 class GCMNetworkChannelDelegate;
 
 class SyncLogger : public invalidation::Logger {
  public:
   SyncLogger();
 
-  virtual ~SyncLogger();
+  ~SyncLogger() override;
 
   // invalidation::Logger implementation.
-  virtual void Log(LogLevel level, const char* file, int line,
-                   const char* format, ...) override;
+  void Log(LogLevel level,
+           const char* file,
+           int line,
+           const char* format,
+           ...) override;
 
-  virtual void SetSystemResources(
-      invalidation::SystemResources* resources) override;
+  void SetSystemResources(invalidation::SystemResources* resources) override;
 };
 
 class SyncInvalidationScheduler : public invalidation::Scheduler {
  public:
   SyncInvalidationScheduler();
 
-  virtual ~SyncInvalidationScheduler();
+  ~SyncInvalidationScheduler() override;
 
   // Start and stop the scheduler.
   void Start();
   void Stop();
 
   // invalidation::Scheduler implementation.
-  virtual void Schedule(invalidation::TimeDelta delay,
-                        invalidation::Closure* task) override;
+  void Schedule(invalidation::TimeDelta delay,
+                invalidation::Closure* task) override;
 
-  virtual bool IsRunningOnThread() const override;
+  bool IsRunningOnThread() const override;
 
-  virtual invalidation::Time GetCurrentTime() const override;
+  invalidation::Time GetCurrentTime() const override;
 
-  virtual void SetSystemResources(
-      invalidation::SystemResources* resources) override;
+  void SetSystemResources(invalidation::SystemResources* resources) override;
 
  private:
   // Runs the task, deletes it, and removes it from |posted_tasks_|.
   void RunPostedTask(invalidation::Closure* task);
 
   // Holds all posted tasks that have not yet been run.
   std::set<invalidation::Closure*> posted_tasks_;
 
   const base::MessageLoop* created_on_loop_;
   bool is_started_;
@@ skipping 16 matching lines @@
     // Called when network channel state changes. Possible states are:
     //  - INVALIDATIONS_ENABLED : connection is established and working
     //  - TRANSIENT_INVALIDATION_ERROR : no network, connection lost, etc.
     //  - INVALIDATION_CREDENTIALS_REJECTED : Issues with auth token
     virtual void OnNetworkChannelStateChanged(
         InvalidatorState invalidator_state) = 0;
   };
 
   SyncNetworkChannel();
 
-  virtual ~SyncNetworkChannel();
+  ~SyncNetworkChannel() override;
 
   // invalidation::NetworkChannel implementation.
   // SyncNetworkChannel doesn't implement SendMessage. It is responsibility of
   // subclass to implement it.
-  virtual void SetMessageReceiver(
+  void SetMessageReceiver(
       invalidation::MessageCallback* incoming_receiver) override;
-  virtual void AddNetworkStatusReceiver(
+  void AddNetworkStatusReceiver(
       invalidation::NetworkStatusCallback* network_status_receiver) override;
-  virtual void SetSystemResources(
-      invalidation::SystemResources* resources) override;
+  void SetSystemResources(invalidation::SystemResources* resources) override;
 
   // Subclass should implement UpdateCredentials to pass new token to channel
   // library.
   virtual void UpdateCredentials(const std::string& email,
       const std::string& token) = 0;
 
   // Return value from GetInvalidationClientType will be passed to
   // invalidation::CreateInvalidationClient. Subclass should return one of the
   // values from ipc::invalidation::ClientType enum from types.proto.
   virtual int GetInvalidationClientType() = 0;
@@ skipping 48 matching lines @@
 
   int received_messages_count_;
 
   ObserverList<Observer> observers_;
 };
 
 class SyncStorage : public invalidation::Storage {
  public:
   SyncStorage(StateWriter* state_writer, invalidation::Scheduler* scheduler);
 
-  virtual ~SyncStorage();
+  ~SyncStorage() override;
 
   void SetInitialState(const std::string& value) {
     cached_state_ = value;
   }
 
   // invalidation::Storage implementation.
-  virtual void WriteKey(const std::string& key, const std::string& value,
-                        invalidation::WriteKeyCallback* done) override;
+  void WriteKey(const std::string& key,
+                const std::string& value,
+                invalidation::WriteKeyCallback* done) override;
 
-  virtual void ReadKey(const std::string& key,
-                       invalidation::ReadKeyCallback* done) override;
+  void ReadKey(const std::string& key,
+               invalidation::ReadKeyCallback* done) override;
 
-  virtual void DeleteKey(const std::string& key,
-                         invalidation::DeleteKeyCallback* done) override;
+  void DeleteKey(const std::string& key,
+                 invalidation::DeleteKeyCallback* done) override;
 
-  virtual void ReadAllKeys(
-      invalidation::ReadAllKeysCallback* key_callback) override;
+  void ReadAllKeys(invalidation::ReadAllKeysCallback* key_callback) override;
 
-  virtual void SetSystemResources(
-      invalidation::SystemResources* resources) override;
+  void SetSystemResources(invalidation::SystemResources* resources) override;
 
  private:
   // Runs the given storage callback with SUCCESS status and deletes it.
   void RunAndDeleteWriteKeyCallback(
       invalidation::WriteKeyCallback* callback);
 
   // Runs the given callback with the given value and deletes it.
   void RunAndDeleteReadKeyCallback(
       invalidation::ReadKeyCallback* callback, const std::string& value);
 
   StateWriter* state_writer_;
   invalidation::Scheduler* scheduler_;
   std::string cached_state_;
 };
 
 class INVALIDATION_EXPORT_PRIVATE SyncSystemResources
     : public NON_EXPORTED_BASE(invalidation::SystemResources) {
  public:
   SyncSystemResources(SyncNetworkChannel* sync_network_channel,
                       StateWriter* state_writer);
 
-  virtual ~SyncSystemResources();
+  ~SyncSystemResources() override;
 
   // invalidation::SystemResources implementation.
-  virtual void Start() override;
-  virtual void Stop() override;
-  virtual bool IsStarted() const override;
+  void Start() override;
+  void Stop() override;
+  bool IsStarted() const override;
   virtual void set_platform(const std::string& platform);
-  virtual std::string platform() const override;
-  virtual SyncLogger* logger() override;
-  virtual SyncStorage* storage() override;
-  virtual SyncNetworkChannel* network() override;
-  virtual SyncInvalidationScheduler* internal_scheduler() override;
-  virtual SyncInvalidationScheduler* listener_scheduler() override;
+  std::string platform() const override;
+  SyncLogger* logger() override;
+  SyncStorage* storage() override;
+  SyncNetworkChannel* network() override;
+  SyncInvalidationScheduler* internal_scheduler() override;
+  SyncInvalidationScheduler* listener_scheduler() override;
 
  private:
   bool is_started_;
   std::string platform_;
   scoped_ptr<SyncLogger> logger_;
   scoped_ptr<SyncInvalidationScheduler> internal_scheduler_;
   scoped_ptr<SyncInvalidationScheduler> listener_scheduler_;
   scoped_ptr<SyncStorage> storage_;
   // sync_network_channel_ is owned by SyncInvalidationListener.
   SyncNetworkChannel* sync_network_channel_;
 };
 
 }  // namespace syncer
 
 #endif  // COMPONENTS_INVALIDATION_SYNC_SYSTEM_RESOURCES_H_