Standardize usage of virtual/override/final in components/

components/invalidation/invalidation_logger_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/invalidation_logger.h"
 #include "components/invalidation/invalidation_logger_observer.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace invalidation {
 
 class InvalidationLoggerObserverTest : public InvalidationLoggerObserver {
  public:
   InvalidationLoggerObserverTest() { ResetStates(); }
 
   void ResetStates() {
     registration_change_received = false;
     state_received = false;
     update_id_received = false;
     debug_message_received = false;
     invalidation_received = false;
     detailed_status_received = false;
     update_id_replicated = std::map<std::string, syncer::ObjectIdCountMap>();
     registered_handlers = std::multiset<std::string>();
   }
 
-  virtual void OnRegistrationChange(const std::multiset<std::string>& handlers)
-      override {
+  void OnRegistrationChange(
+      const std::multiset<std::string>& handlers) override {
     registered_handlers = handlers;
     registration_change_received = true;
   }
 
-  virtual void OnStateChange(const syncer::InvalidatorState& new_state,
-                             const base::Time& last_change_timestamp)
-      override {
+  void OnStateChange(const syncer::InvalidatorState& new_state,
+                     const base::Time& last_change_timestamp) override {
     state_received = true;
   }
 
-  virtual void OnUpdateIds(const std::string& handler,
-                           const syncer::ObjectIdCountMap& details) override {
+  void OnUpdateIds(const std::string& handler,
+                   const syncer::ObjectIdCountMap& details) override {
     update_id_received = true;
     update_id_replicated[handler] = details;
   }
 
-  virtual void OnDebugMessage(const base::DictionaryValue& details) override {
+  void OnDebugMessage(const base::DictionaryValue& details) override {
     debug_message_received = true;
   }
 
-  virtual void OnInvalidation(
+  void OnInvalidation(
       const syncer::ObjectIdInvalidationMap& new_invalidations) override {
     invalidation_received = true;
   }
 
-  virtual void OnDetailedStatus(const base::DictionaryValue& details) override {
+  void OnDetailedStatus(const base::DictionaryValue& details) override {
     detailed_status_received = true;
   }
 
   bool registration_change_received;
   bool state_received;
   bool update_id_received;
   bool debug_message_received;
   bool invalidation_received;
   bool detailed_status_received;
   std::map<std::string, syncer::ObjectIdCountMap> update_id_replicated;
@@ skipping 212 matching lines @@
 
   observer_test.ResetStates();
   log.OnUnregistration(std::string("FakeHandler2"));
   test_multiset.erase("FakeHandler2");
   EXPECT_TRUE(observer_test.registration_change_received);
   EXPECT_EQ(observer_test.registered_handlers, test_multiset);
 
   log.UnregisterObserver(&observer_test);
 }
 }  // namespace invalidation