replace OVERRIDE and FINAL with override and final in chrome/browser/[r-z]*

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 {
+  virtual 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() {
   }
 
-  virtual bool IsEulaAccepted() OVERRIDE {
+  virtual bool IsEulaAccepted() override {
     return eula_accepted_;
   }
 
   void SetEulaAcceptedForTesting(bool eula_accepted) {
     eula_accepted_ = eula_accepted;
   }
 
   void SimulateEulaAccepted() {
     NotifyObserver();
   }
@@ skipping 16 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 {
+  virtual 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) {
@@ skipping 23 matching lines @@
   // Used in tests involving the EULA. Disables both the EULA accepted state
   // and the network.
   void DisableEulaAndNetwork() {
     SetWaitingForNetwork(true);
     SimulateNetworkConnectionChange(
         net::NetworkChangeNotifier::CONNECTION_NONE);
     SetWaitingForEula(true);
     SetNeedsEulaAcceptance(true);
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     // Assume the test service has already requested permission, as all tests
     // just test that criteria changes notify the server.
     // Set default EULA state to done (not waiting and EULA accepted) to
     // simplify non-ChromeOS tests.
     SetWaitingForEula(false);
     SetNeedsEulaAcceptance(false);
   }
 
  private:
   base::MessageLoopForUI message_loop;
@@ skipping 142 matching lines @@
   // calling SimulateResourceRequest here.
   DisableEulaAndNetwork();
 
   SimulateNetworkConnectionChange(
       net::NetworkChangeNotifier::CONNECTION_WIFI);
   EXPECT_FALSE(was_notified());
 
   SimulateEulaAccepted();
   EXPECT_FALSE(was_notified());
 }