Standardize usage of virtual/override/final in chrome/browser/

chrome/browser/web_resource/resource_request_allowed_notifier_unittest.cc

 // Copyright 2013 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 "base/prefs/testing_pref_service.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/web_resource/eula_accepted_notifier.h"
 #include "chrome/browser/web_resource/resource_request_allowed_notifier_test_util.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 12 matching lines @@
   // Simulates a change of the connection type to |type|. This will notify any
   // objects that are NetworkChangeNotifiers.
   void SimulateNetworkConnectionChange(
       net::NetworkChangeNotifier::ConnectionType type) {
     connection_type_to_return_ = type;
     net::NetworkChangeNotifier::NotifyObserversOfConnectionTypeChange();
     base::MessageLoop::current()->RunUntilIdle();
   }
 
  private:
-  virtual ConnectionType GetCurrentConnectionType() const override {
+  ConnectionType GetCurrentConnectionType() const override {
     return connection_type_to_return_;
   }
 
   // The currently simulated network connection type. If this is set to
   // CONNECTION_NONE, then NetworkChangeNotifier::IsOffline will return true.
   net::NetworkChangeNotifier::ConnectionType connection_type_to_return_;
 
   DISALLOW_COPY_AND_ASSIGN(TestNetworkChangeNotifier);
 };
 
 // EulaAcceptedNotifier test class that allows mocking the EULA accepted state
 // and issuing simulated notifications.
 class TestEulaAcceptedNotifier : public EulaAcceptedNotifier {
  public:
   TestEulaAcceptedNotifier()
       : EulaAcceptedNotifier(NULL),
         eula_accepted_(false) {
   }
-  virtual ~TestEulaAcceptedNotifier() {
-  }
+  ~TestEulaAcceptedNotifier() override {}
 
-  virtual bool IsEulaAccepted() override {
-    return eula_accepted_;
-  }
+  bool IsEulaAccepted() override { return eula_accepted_; }
 
   void SetEulaAcceptedForTesting(bool eula_accepted) {
     eula_accepted_ = eula_accepted;
   }
 
   void SimulateEulaAccepted() {
     NotifyObserver();
   }
 
  private:
@@ skipping 14 matching lines @@
       eula_notifier_(new TestEulaAcceptedNotifier),
       was_notified_(false) {
     resource_request_allowed_notifier_.InitWithEulaAcceptNotifier(
         this, scoped_ptr<EulaAcceptedNotifier>(eula_notifier_));
   }
   virtual ~ResourceRequestAllowedNotifierTest() { }
 
   bool was_notified() const { return was_notified_; }
 
   // ResourceRequestAllowedNotifier::Observer override:
-  virtual void OnResourceRequestsAllowed() override {
-    was_notified_ = true;
-  }
+  void OnResourceRequestsAllowed() override { was_notified_ = true; }
 
   // Network manipulation methods:
   void SetWaitingForNetwork(bool waiting) {
     resource_request_allowed_notifier_.SetWaitingForNetworkForTesting(waiting);
   }
 
   void SimulateNetworkConnectionChange(
       net::NetworkChangeNotifier::ConnectionType type) {
     network_notifier.SimulateNetworkConnectionChange(type);
   }
@@ skipping 184 matching lines @@
   // calling SimulateResourceRequest here.
   DisableEulaAndNetwork();
 
   SimulateNetworkConnectionChange(
       net::NetworkChangeNotifier::CONNECTION_WIFI);
   EXPECT_FALSE(was_notified());
 
   SimulateEulaAccepted();
   EXPECT_FALSE(was_notified());
 }