Replacing the OVERRIDE with override and FINAL with final in content/browser/[accessibility|battery…

content/browser/battery_status/battery_status_service_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 "content/browser/battery_status/battery_status_service.h"
 
 #include "base/bind.h"
 #include "base/run_loop.h"
 #include "content/browser/battery_status/battery_status_manager.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 
 namespace content {
 
 namespace {
 
 class FakeBatteryManager : public BatteryStatusManager {
  public:
   explicit FakeBatteryManager(
       const BatteryStatusService::BatteryUpdateCallback& callback)
       : callback_(callback), start_invoked_count_(0), stop_invoked_count_(0) {}
   virtual ~FakeBatteryManager() { }
 
   // Methods from Battery Status Manager
-  virtual bool StartListeningBatteryChange() OVERRIDE {
+  virtual bool StartListeningBatteryChange() override {
     start_invoked_count_++;
     return true;
   }
 
-  virtual void StopListeningBatteryChange() OVERRIDE {
+  virtual void StopListeningBatteryChange() override {
     stop_invoked_count_++;
   }
 
   void InvokeUpdateCallback(const blink::WebBatteryStatus& status) {
     callback_.Run(status);
   }
 
   int start_invoked_count() const { return start_invoked_count_; }
   int stop_invoked_count() const { return stop_invoked_count_; }
 
@@ skipping 12 matching lines @@
           battery_service_(0),
           battery_manager_(0),
           callback1_invoked_count_(0),
           callback2_invoked_count_(0) {
     }
     virtual ~BatteryStatusServiceTest() { }
 
  protected:
   typedef BatteryStatusService::BatteryUpdateSubscription BatterySubscription;
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     callback1_ = base::Bind(&BatteryStatusServiceTest::Callback1,
                             base::Unretained(this));
     callback2_ = base::Bind(&BatteryStatusServiceTest::Callback2,
                             base::Unretained(this));
     battery_service_ = BatteryStatusService::GetInstance();
     battery_manager_ = new FakeBatteryManager(
         battery_service_->GetUpdateCallbackForTesting());
     battery_service_->SetBatteryManagerForTesting(battery_manager_);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     base::RunLoop().RunUntilIdle();
     battery_service_->SetBatteryManagerForTesting(0);
   }
 
   FakeBatteryManager* battery_manager() {
     return battery_manager_;
   }
 
   scoped_ptr<BatterySubscription> AddCallback(
       const BatteryStatusService::BatteryUpdateCallback& callback) {
@@ skipping 98 matching lines @@
   subscription1.reset();
   battery_manager()->InvokeUpdateCallback(status);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, callback1_invoked_count());
   EXPECT_EQ(2, callback2_invoked_count());
 }
 
 }  // namespace
 
 }  // namespace content