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

chrome/browser/apps/app_browsertest.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 "apps/launcher.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/prefs/pref_service.h"
@@ skipping 62 matching lines @@
       : RenderViewContextMenu(render_frame_host, params) {}
 
   bool HasCommandWithId(int command_id) {
     return menu_model_.GetIndexOfCommandId(command_id) != -1;
   }
 
  protected:
   // RenderViewContextMenu implementation.
   virtual bool GetAcceleratorForCommandId(
       int command_id,
-      ui::Accelerator* accelerator) OVERRIDE {
+      ui::Accelerator* accelerator) override {
     return false;
   }
 };
 
 // This class keeps track of tabs as they are added to the browser. It will be
 // "done" (i.e. won't block on Wait()) once |observations| tabs have been added.
 class TabsAddedNotificationObserver
     : public content::WindowedNotificationObserver {
  public:
   explicit TabsAddedNotificationObserver(size_t observations)
       : content::WindowedNotificationObserver(
             chrome::NOTIFICATION_TAB_ADDED,
             content::NotificationService::AllSources()),
         observations_(observations) {
   }
 
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE {
+                       const content::NotificationDetails& details) override {
     observed_tabs_.push_back(
         content::Details<WebContents>(details).ptr());
     if (observed_tabs_.size() == observations_)
       content::WindowedNotificationObserver::Observe(type, source, details);
   }
 
   const std::vector<content::WebContents*>& tabs() { return observed_tabs_; }
 
  private:
   size_t observations_;
@@ skipping 10 matching lines @@
         total_page_count_(1),
         rendered_page_count_(0) {
     PrintPreviewUI::SetDelegateForTesting(this);
   }
 
   ~ScopedPreviewTestingDelegate() {
     PrintPreviewUI::SetDelegateForTesting(NULL);
   }
 
   // PrintPreviewUI::TestingDelegate implementation.
-  virtual bool IsAutoCancelEnabled() OVERRIDE {
+  virtual bool IsAutoCancelEnabled() override {
     return auto_cancel_;
   }
 
   // PrintPreviewUI::TestingDelegate implementation.
-  virtual void DidGetPreviewPageCount(int page_count) OVERRIDE {
+  virtual void DidGetPreviewPageCount(int page_count) override {
     total_page_count_ = page_count;
   }
 
   // PrintPreviewUI::TestingDelegate implementation.
   virtual void DidRenderPreviewPage(content::WebContents* preview_dialog)
-      OVERRIDE {
+      override {
     dialog_size_ = preview_dialog->GetContainerBounds().size();
     ++rendered_page_count_;
     CHECK(rendered_page_count_ <= total_page_count_);
     if (waiting_runner_.get() && rendered_page_count_ == total_page_count_) {
       waiting_runner_->Quit();
     }
   }
 
   void WaitUntilPreviewIsReady() {
     CHECK(!waiting_runner_.get());
@@ skipping 789 matching lines @@
         content::NotificationService::AllSources());
   }
 
   bool seen() const {
     return seen_;
   };
 
   // NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE {
+                       const content::NotificationDetails& details) override {
     EXPECT_FALSE(seen_);
     seen_ = true;
   }
 
  private:
   bool seen_;
   content::NotificationRegistrar registrar_;
 };
 
 }  // namespace
@@ skipping 207 matching lines @@
   GetFirstAppWindow()->GetBaseWindow()->Close();
 }
 #endif  // ENABLE_FULL_PRINTING
 
 
 #if defined(OS_CHROMEOS)
 
 class PlatformAppIncognitoBrowserTest : public PlatformAppBrowserTest,
                                         public AppWindowRegistry::Observer {
  public:
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     // Tell chromeos to launch in Guest mode, aka incognito.
     command_line->AppendSwitch(switches::kIncognito);
     PlatformAppBrowserTest::SetUpCommandLine(command_line);
   }
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     // Make sure the file manager actually gets loaded.
     ComponentLoader::EnableBackgroundExtensionsForTesting();
     PlatformAppBrowserTest::SetUp();
   }
 
   // AppWindowRegistry::Observer implementation.
-  virtual void OnAppWindowAdded(AppWindow* app_window) OVERRIDE {
+  virtual void OnAppWindowAdded(AppWindow* app_window) override {
     opener_app_ids_.insert(app_window->extension_id());
   }
 
  protected:
   // A set of ids of apps we've seen open a app window.
   std::set<std::string> opener_app_ids_;
 };
 
 IN_PROC_BROWSER_TEST_F(PlatformAppIncognitoBrowserTest, IncognitoComponentApp) {
   // Get the file manager app.
@@ skipping 26 matching lines @@
 }
 
 class RestartDeviceTest : public PlatformAppBrowserTest {
  public:
   RestartDeviceTest()
       : power_manager_client_(NULL),
         mock_user_manager_(NULL) {}
   virtual ~RestartDeviceTest() {}
 
   // PlatformAppBrowserTest overrides
-  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
+  virtual void SetUpInProcessBrowserTestFixture() override {
     PlatformAppBrowserTest::SetUpInProcessBrowserTestFixture();
 
     power_manager_client_ = new chromeos::FakePowerManagerClient;
     chromeos::DBusThreadManager::GetSetterForTesting()->SetPowerManagerClient(
         scoped_ptr<chromeos::PowerManagerClient>(power_manager_client_));
   }
 
-  virtual void SetUpOnMainThread() OVERRIDE {
+  virtual void SetUpOnMainThread() override {
     PlatformAppBrowserTest::SetUpOnMainThread();
 
     mock_user_manager_ = new chromeos::MockUserManager;
     user_manager_enabler_.reset(
         new chromeos::ScopedUserManagerEnabler(mock_user_manager_));
 
     EXPECT_CALL(*mock_user_manager_, IsUserLoggedIn())
         .WillRepeatedly(testing::Return(true));
     EXPECT_CALL(*mock_user_manager_, IsLoggedInAsKioskApp())
         .WillRepeatedly(testing::Return(true));
   }
 
-  virtual void TearDownOnMainThread() OVERRIDE {
+  virtual void TearDownOnMainThread() override {
     user_manager_enabler_.reset();
     PlatformAppBrowserTest::TearDownOnMainThread();
   }
 
-  virtual void TearDownInProcessBrowserTestFixture() OVERRIDE {
+  virtual void TearDownInProcessBrowserTestFixture() override {
     PlatformAppBrowserTest::TearDownInProcessBrowserTestFixture();
   }
 
   int num_request_restart_calls() const {
     return power_manager_client_->num_request_restart_calls();
   }
 
  private:
   chromeos::FakePowerManagerClient* power_manager_client_;
   chromeos::MockUserManager* mock_user_manager_;
@@ skipping 49 matching lines @@
         LoadAndLaunchPlatformApp("reinstall_data_cleanup", "Launched");
     ASSERT_TRUE(extension);
     ASSERT_EQ(extension_id, extension->id());
 
     ResultCatcher result_catcher;
     EXPECT_TRUE(result_catcher.GetNextResult());
   }
 }
 
 }  // namespace extensions