replace OVERRIDE and FINAL with override and final in chrome/browser/[a-i]*

chrome/browser/background/background_mode_manager_unittest.cc

 // Copyright (c) 2011 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/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/background/background_mode_manager.h"
 #include "chrome/browser/browser_shutdown.h"
@@ skipping 29 matching lines @@
  public:
   SimpleTestBackgroundModeManager(
       CommandLine* command_line, ProfileInfoCache* cache)
       : BackgroundModeManager(command_line, cache),
         have_status_tray_(false),
         launch_on_startup_(false),
         has_shown_balloon_(false) {
     ResumeBackgroundMode();
   }
 
-  virtual void EnableLaunchOnStartup(bool launch) OVERRIDE {
+  virtual void EnableLaunchOnStartup(bool launch) override {
     launch_on_startup_ = launch;
   }
 
   virtual void DisplayAppInstalledNotification(
-      const extensions::Extension* extension) OVERRIDE {
+      const extensions::Extension* extension) override {
     has_shown_balloon_ = true;
   }
-  virtual void CreateStatusTrayIcon() OVERRIDE { have_status_tray_ = true; }
-  virtual void RemoveStatusTrayIcon() OVERRIDE { have_status_tray_ = false; }
+  virtual void CreateStatusTrayIcon() override { have_status_tray_ = true; }
+  virtual void RemoveStatusTrayIcon() override { have_status_tray_ = false; }
 
   bool HaveStatusTray() const { return have_status_tray_; }
   bool IsLaunchOnStartup() const { return launch_on_startup_; }
   bool HasShownBalloon() const { return has_shown_balloon_; }
   void SetHasShownBalloon(bool value) { has_shown_balloon_ = value; }
 
  private:
   // Flags to track whether we are launching on startup/have a status tray.
   bool have_status_tray_;
   bool launch_on_startup_;
   bool has_shown_balloon_;
 
   DISALLOW_COPY_AND_ASSIGN(SimpleTestBackgroundModeManager);
 };
 
 class TestStatusIcon : public StatusIcon {
  public:
   TestStatusIcon() {}
-  virtual void SetImage(const gfx::ImageSkia& image) OVERRIDE {}
-  virtual void SetToolTip(const base::string16& tool_tip) OVERRIDE {}
+  virtual void SetImage(const gfx::ImageSkia& image) override {}
+  virtual void SetToolTip(const base::string16& tool_tip) override {}
   virtual void DisplayBalloon(const gfx::ImageSkia& icon,
                               const base::string16& title,
-                              const base::string16& contents) OVERRIDE {}
+                              const base::string16& contents) override {}
   virtual void UpdatePlatformContextMenu(
-      StatusIconMenuModel* menu) OVERRIDE {}
+      StatusIconMenuModel* menu) override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestStatusIcon);
 };
 
 } // namespace
 
 // More complex test helper that exposes APIs for fine grained control of
 // things like the number of background applications. This allows writing
 // smaller tests that don't have to install/uninstall extensions.
 class TestBackgroundModeManager : public SimpleTestBackgroundModeManager {
  public:
   TestBackgroundModeManager(
       CommandLine* command_line, ProfileInfoCache* cache, bool enabled)
       : SimpleTestBackgroundModeManager(command_line, cache),
         enabled_(enabled),
         app_count_(0),
         profile_app_count_(0) {
     ResumeBackgroundMode();
   }
 
-  virtual int GetBackgroundAppCount() const OVERRIDE { return app_count_; }
+  virtual int GetBackgroundAppCount() const override { return app_count_; }
   virtual int GetBackgroundAppCountForProfile(
-      Profile* const profile) const OVERRIDE {
+      Profile* const profile) const override {
     return profile_app_count_;
   }
   void SetBackgroundAppCount(int count) { app_count_ = count; }
   void SetBackgroundAppCountForProfile(int count) {
     profile_app_count_ = count;
   }
   void SetEnabled(bool enabled) {
     enabled_ = enabled;
     OnBackgroundModeEnabledPrefChanged();
   }
-  virtual bool IsBackgroundModePrefEnabled() const OVERRIDE { return enabled_; }
+  virtual bool IsBackgroundModePrefEnabled() const override { return enabled_; }
 
  private:
   bool enabled_;
   int app_count_;
   int profile_app_count_;
 
   DISALLOW_COPY_AND_ASSIGN(TestBackgroundModeManager);
 };
 
 namespace {
@@ skipping 18 matching lines @@
   EXPECT_FALSE(manager.HaveStatusTray());
   EXPECT_TRUE(manager.IsLaunchOnStartup());
 }
 
 } // namespace
 
 class BackgroundModeManagerTest : public testing::Test {
  public:
   BackgroundModeManagerTest() {}
   virtual ~BackgroundModeManagerTest() {}
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     command_line_.reset(new CommandLine(CommandLine::NO_PROGRAM));
     profile_manager_ = CreateTestingProfileManager();
     profile_ = profile_manager_->CreateTestingProfile("p1");
   }
   scoped_ptr<CommandLine> command_line_;
 
  protected:
   scoped_refptr<extensions::Extension> CreateExtension(
       extensions::Manifest::Location location,
       const std::string& data,
@@ skipping 28 matching lines @@
   }
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundModeManagerTest);
 };
 
 class BackgroundModeManagerWithExtensionsTest
     : public BackgroundModeManagerTest {
  public:
   BackgroundModeManagerWithExtensionsTest() {}
   virtual ~BackgroundModeManagerWithExtensionsTest() {}
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     BackgroundModeManagerTest::SetUp();
     // Aura clears notifications from the message center at shutdown.
     message_center::MessageCenter::Initialize();
 
     // BackgroundModeManager actually affects Chrome start/stop state,
     // tearing down our thread bundle before we've had chance to clean
     // everything up. Keeping Chrome alive prevents this.
     // We aren't interested in if the keep alive works correctly in this test.
     chrome::IncrementKeepAliveCount();
 
@@ skipping 659 matching lines @@
   // Installing an ephemeral app should not show the balloon.
   manager_->SetHasShownBalloon(false);
   AddEphemeralApp(ephemeral_app.get(), service);
   EXPECT_FALSE(manager_->HasShownBalloon());
 
   // Promoting the ephemeral app to a regular installed app should now show
   // the balloon.
   service->PromoteEphemeralApp(ephemeral_app.get(), false /*from sync*/);
   EXPECT_TRUE(manager_->HasShownBalloon());
 }