Standardize usage of virtual/override/final in components/

components/invalidation/registration_manager_unittest.cc

 // 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.
 
 #include "components/invalidation/registration_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <cstddef>
 #include <deque>
@@ skipping 10 matching lines @@
 namespace {
 
 // Fake registration manager that lets you override jitter.
 class FakeRegistrationManager : public RegistrationManager {
  public:
   explicit FakeRegistrationManager(
       invalidation::InvalidationClient* invalidation_client)
       : RegistrationManager(invalidation_client),
         jitter_(0.0) {}
 
-  virtual ~FakeRegistrationManager() {}
+  ~FakeRegistrationManager() override {}
 
   void SetJitter(double jitter) {
     jitter_ = jitter;
   }
 
  protected:
-  virtual double GetJitter() override {
-    return jitter_;
-  }
+  double GetJitter() override { return jitter_; }
 
  private:
   double jitter_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeRegistrationManager);
 };
 
 // Fake invalidation client that just stores the currently-registered
 // object IDs.
 class FakeInvalidationClient : public invalidation::InvalidationClient {
  public:
   FakeInvalidationClient() {}
 
-  virtual ~FakeInvalidationClient() {}
+  ~FakeInvalidationClient() override {}
 
   void LoseRegistration(const invalidation::ObjectId& oid) {
     EXPECT_TRUE(ContainsKey(registered_ids_, oid));
     registered_ids_.erase(oid);
   }
 
   void LoseAllRegistrations() {
     registered_ids_.clear();
   }
 
   // invalidation::InvalidationClient implementation.
 
-  virtual void Start() override {}
-  virtual void Stop() override {}
-  virtual void Acknowledge(const invalidation::AckHandle& handle) override {}
+  void Start() override {}
+  void Stop() override {}
+  void Acknowledge(const invalidation::AckHandle& handle) override {}
 
-  virtual void Register(const invalidation::ObjectId& oid) override {
+  void Register(const invalidation::ObjectId& oid) override {
     EXPECT_FALSE(ContainsKey(registered_ids_, oid));
     registered_ids_.insert(oid);
   }
 
-  virtual void Register(
-      const std::vector<invalidation::ObjectId>& oids) override {
+  void Register(const std::vector<invalidation::ObjectId>& oids) override {
     // Unused for now.
   }
 
-  virtual void Unregister(const invalidation::ObjectId& oid) override {
+  void Unregister(const invalidation::ObjectId& oid) override {
     EXPECT_TRUE(ContainsKey(registered_ids_, oid));
     registered_ids_.erase(oid);
   }
 
-  virtual void Unregister(
-      const std::vector<invalidation::ObjectId>& oids) override {
+  void Unregister(const std::vector<invalidation::ObjectId>& oids) override {
     // Unused for now.
   }
 
   const ObjectIdSet& GetRegisteredIdsForTest() const {
     return registered_ids_;
   }
 
  private:
   ObjectIdSet registered_ids_;
 
@@ skipping 326 matching lines @@
       fake_registration_manager_.GetPendingRegistrationsForTest());
 
   fake_registration_manager_.MarkAllRegistrationsLost();
   ExpectPendingRegistrations(
       enabled_ids, 0.0,
       fake_registration_manager_.GetPendingRegistrationsForTest());
 }
 
 }  // namespace
 }  // namespace syncer