replace OVERRIDE and FINAL with override and 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 19 matching lines @@
 class GCMNetworkChannelDelegate;
 
 class SyncLogger : public invalidation::Logger {
  public:
   SyncLogger();
 
   virtual ~SyncLogger();
 
   // invalidation::Logger implementation.
   virtual void Log(LogLevel level, const char* file, int line,
-                   const char* format, ...) OVERRIDE;
+                   const char* format, ...) override;
 
   virtual void SetSystemResources(
-      invalidation::SystemResources* resources) OVERRIDE;
+      invalidation::SystemResources* resources) override;
 };
 
 class SyncInvalidationScheduler : public invalidation::Scheduler {
  public:
   SyncInvalidationScheduler();
 
   virtual ~SyncInvalidationScheduler();
 
   // Start and stop the scheduler.
   void Start();
   void Stop();
 
   // invalidation::Scheduler implementation.
   virtual void Schedule(invalidation::TimeDelta delay,
-                        invalidation::Closure* task) OVERRIDE;
+                        invalidation::Closure* task) override;
 
-  virtual bool IsRunningOnThread() const OVERRIDE;
+  virtual bool IsRunningOnThread() const override;
 
-  virtual invalidation::Time GetCurrentTime() const OVERRIDE;
+  virtual invalidation::Time GetCurrentTime() const override;
 
   virtual void SetSystemResources(
-      invalidation::SystemResources* resources) OVERRIDE;
+      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 22 matching lines @@
   };
 
   SyncNetworkChannel();
 
   virtual ~SyncNetworkChannel();
 
   // invalidation::NetworkChannel implementation.
   // SyncNetworkChannel doesn't implement SendMessage. It is responsibility of
   // subclass to implement it.
   virtual void SetMessageReceiver(
-      invalidation::MessageCallback* incoming_receiver) OVERRIDE;
+      invalidation::MessageCallback* incoming_receiver) override;
   virtual void AddNetworkStatusReceiver(
-      invalidation::NetworkStatusCallback* network_status_receiver) OVERRIDE;
+      invalidation::NetworkStatusCallback* network_status_receiver) override;
   virtual void SetSystemResources(
-      invalidation::SystemResources* resources) OVERRIDE;
+      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 56 matching lines @@
   SyncStorage(StateWriter* state_writer, invalidation::Scheduler* scheduler);
 
   virtual ~SyncStorage();
 
   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;
+                        invalidation::WriteKeyCallback* done) override;
 
   virtual void ReadKey(const std::string& key,
-                       invalidation::ReadKeyCallback* done) OVERRIDE;
+                       invalidation::ReadKeyCallback* done) override;
 
   virtual void DeleteKey(const std::string& key,
-                         invalidation::DeleteKeyCallback* done) OVERRIDE;
+                         invalidation::DeleteKeyCallback* done) override;
 
   virtual void ReadAllKeys(
-      invalidation::ReadAllKeysCallback* key_callback) OVERRIDE;
+      invalidation::ReadAllKeysCallback* key_callback) override;
 
   virtual void SetSystemResources(
-      invalidation::SystemResources* resources) OVERRIDE;
+      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();
 
   // invalidation::SystemResources implementation.
-  virtual void Start() OVERRIDE;
-  virtual void Stop() OVERRIDE;
-  virtual bool IsStarted() const OVERRIDE;
+  virtual void Start() override;
+  virtual void Stop() override;
+  virtual 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;
+  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;
 
  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_