Standardize usage of virtual/override/final in components/

components/invalidation/sync_system_resources_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/sync_system_resources.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 161 matching lines @@
   sync_system_resources_.storage()->WriteKey(
       std::string(), "state", mock_storage_callback.CreateCallback());
   message_loop_.RunUntilIdle();
   EXPECT_EQ(invalidation::Status(invalidation::Status::SUCCESS, std::string()),
             results);
 }
 
 class TestSyncNetworkChannel : public SyncNetworkChannel {
  public:
   TestSyncNetworkChannel() {}
-  virtual ~TestSyncNetworkChannel() {}
+  ~TestSyncNetworkChannel() override {}
 
   using SyncNetworkChannel::NotifyNetworkStatusChange;
   using SyncNetworkChannel::NotifyChannelStateChange;
   using SyncNetworkChannel::DeliverIncomingMessage;
 
-  virtual void SendMessage(const std::string& message) override {
-  }
+  void SendMessage(const std::string& message) override {}
 
-  virtual void UpdateCredentials(const std::string& email,
-      const std::string& token) override {
-  }
+  void UpdateCredentials(const std::string& email,
+                         const std::string& token) override {}
 
-  virtual int GetInvalidationClientType() override {
-    return 0;
-  }
+  int GetInvalidationClientType() override { return 0; }
 
-  virtual void RequestDetailedStatus(
+  void RequestDetailedStatus(
       base::Callback<void(const base::DictionaryValue&)> callback) override {
     base::DictionaryValue value;
     callback.Run(value);
   }
 };
 
 class SyncNetworkChannelTest
     : public testing::Test,
       public SyncNetworkChannel::Observer {
  protected:
   SyncNetworkChannelTest()
       : last_invalidator_state_(DEFAULT_INVALIDATION_ERROR),
         connected_(false) {
     network_channel_.AddObserver(this);
     network_channel_.AddNetworkStatusReceiver(
         invalidation::NewPermanentCallback(
             this, &SyncNetworkChannelTest::OnNetworkStatusChange));
   }
 
   virtual ~SyncNetworkChannelTest() {
     network_channel_.RemoveObserver(this);
   }
 
-  virtual void OnNetworkChannelStateChanged(
+  void OnNetworkChannelStateChanged(
       InvalidatorState invalidator_state) override {
     last_invalidator_state_ = invalidator_state;
   }
 
   void OnNetworkStatusChange(bool connected) {
     connected_ = connected;
   }
 
   TestSyncNetworkChannel network_channel_;
   InvalidatorState last_invalidator_state_;
@@ skipping 13 matching lines @@
 TEST_F(SyncNetworkChannelTest, NetworkStateChange) {
   EXPECT_FALSE(connected_);
   network_channel_.NotifyNetworkStatusChange(true);
   EXPECT_TRUE(connected_);
   network_channel_.NotifyNetworkStatusChange(false);
   EXPECT_FALSE(connected_);
 }
 
 }  // namespace
 }  // namespace syncer