replace OVERRIDE and FINAL with override and final in chrome/browser/[j-q]*

chrome/browser/policy/policy_browsertest.cc

 // Copyright (c) 2012 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 <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 471 matching lines @@
   }
 
   int output_mute_changed_count() const {
     return output_mute_changed_count_;
   }
 
   virtual ~TestAudioObserver() {}
 
  protected:
   // chromeos::CrasAudioHandler::AudioObserver overrides.
-  virtual void OnOutputMuteChanged() OVERRIDE {
+  virtual void OnOutputMuteChanged() override {
     ++output_mute_changed_count_;
   }
 
  private:
   int output_mute_changed_count_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAudioObserver);
 };
 #endif
 
 // This class waits until either a load stops or the WebContents is destroyed.
 class WebContentsLoadedOrDestroyedWatcher
     : public content::WebContentsObserver {
  public:
   explicit WebContentsLoadedOrDestroyedWatcher(
       content::WebContents* web_contents);
   virtual ~WebContentsLoadedOrDestroyedWatcher();
 
   // Waits until the WebContents's load is done or until it is destroyed.
   void Wait();
 
   // Overridden WebContentsObserver methods.
-  virtual void WebContentsDestroyed() OVERRIDE;
+  virtual void WebContentsDestroyed() override;
   virtual void DidStopLoading(
-      content::RenderViewHost* render_view_host) OVERRIDE;
+      content::RenderViewHost* render_view_host) override;
 
  private:
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentsLoadedOrDestroyedWatcher);
 };
 
 WebContentsLoadedOrDestroyedWatcher::WebContentsLoadedOrDestroyedWatcher(
     content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
@@ skipping 18 matching lines @@
 #if !defined(OS_MACOSX)
 
 // Observer used to wait for the creation of a new app window.
 class TestAddAppWindowObserver
     : public extensions::AppWindowRegistry::Observer {
  public:
   explicit TestAddAppWindowObserver(extensions::AppWindowRegistry* registry);
   virtual ~TestAddAppWindowObserver();
 
   // extensions::AppWindowRegistry::Observer:
-  virtual void OnAppWindowAdded(extensions::AppWindow* app_window) OVERRIDE;
+  virtual void OnAppWindowAdded(extensions::AppWindow* app_window) override;
 
   extensions::AppWindow* WaitForAppWindow();
 
  private:
   extensions::AppWindowRegistry* registry_;  // Not owned.
   extensions::AppWindow* window_;            // Not owned.
   base::RunLoop run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAddAppWindowObserver);
 };
@@ skipping 21 matching lines @@
 
 #endif
 
 }  // namespace
 
 class PolicyTest : public InProcessBrowserTest {
  protected:
   PolicyTest() {}
   virtual ~PolicyTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     test_extension_cache_.reset(new extensions::ExtensionCacheFake());
     InProcessBrowserTest::SetUp();
   }
 
-  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
+  virtual void SetUpInProcessBrowserTestFixture() override {
     CommandLine::ForCurrentProcess()->AppendSwitch("noerrdialogs");
     EXPECT_CALL(provider_, IsInitializationComplete(_))
         .WillRepeatedly(Return(true));
     BrowserPolicyConnector::SetPolicyProviderForTesting(&provider_);
   }
 
-  virtual void SetUpOnMainThread() OVERRIDE {
+  virtual void SetUpOnMainThread() override {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(chrome_browser_net::SetUrlRequestMocksEnabled, true));
   }
 
   // Makes URLRequestMockHTTPJobs serve data from content::DIR_TEST_DATA
   // instead of chrome::DIR_TEST_DATA.
   void ServeContentTestData() {
     base::FilePath root_http;
     PathService::Get(content::DIR_TEST_DATA, &root_http);
@@ skipping 15 matching lines @@
                  new base::FundamentalValue(!enabled),
                  NULL);
     UpdateProviderPolicy(policies);
   }
 
 #if defined(OS_CHROMEOS)
   class QuitMessageLoopAfterScreenshot : public ScreenshotTakerObserver {
    public:
     virtual void OnScreenshotCompleted(
         ScreenshotTakerObserver::Result screenshot_result,
-        const base::FilePath& screenshot_path) OVERRIDE {
+        const base::FilePath& screenshot_path) override {
       BrowserThread::PostTaskAndReply(BrowserThread::IO,
                                       FROM_HERE,
                                       base::Bind(base::DoNothing),
                                       base::MessageLoop::QuitClosure());
     }
 
     virtual ~QuitMessageLoopAfterScreenshot() {}
   };
 
   void TestScreenshotFile(bool enabled) {
@@ skipping 107 matching lines @@
 
 #if defined(OS_WIN)
 // This policy only exists on Windows.
 
 // Sets the locale policy before the browser is started.
 class LocalePolicyTest : public PolicyTest {
  public:
   LocalePolicyTest() {}
   virtual ~LocalePolicyTest() {}
 
-  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
+  virtual void SetUpInProcessBrowserTestFixture() override {
     PolicyTest::SetUpInProcessBrowserTestFixture();
     PolicyMap policies;
     policies.Set(key::kApplicationLocaleValue,
                  POLICY_LEVEL_MANDATORY,
                  POLICY_SCOPE_USER,
                  new base::StringValue("fr"),
                  NULL);
     provider_.UpdateChromePolicy(policies);
     // The "en-US" ResourceBundle is always loaded before this step for tests,
     // but in this test we want the browser to load the bundle as it
@@ skipping 1883 matching lines @@
 // and stores the expected startup URLs in |expected_urls_|.
 class RestoreOnStartupPolicyTest
     : public PolicyTest,
       public testing::WithParamInterface<
           void (RestoreOnStartupPolicyTest::*)(void)> {
  public:
   RestoreOnStartupPolicyTest() {}
   virtual ~RestoreOnStartupPolicyTest() {}
 
 #if defined(OS_CHROMEOS)
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     // TODO(nkostylev): Investigate if we can remove this switch.
     command_line->AppendSwitch(switches::kCreateBrowserOnStartupForTests);
     PolicyTest::SetUpCommandLine(command_line);
   }
 #endif
 
-  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
+  virtual void SetUpInProcessBrowserTestFixture() override {
     PolicyTest::SetUpInProcessBrowserTestFixture();
     // Set early policies now, before the browser is created.
     (this->*(GetParam()))();
 
     // Remove the non-switch arguments, so that session restore kicks in for
     // these tests.
     CommandLine* command_line = CommandLine::ForCurrentProcess();
     CommandLine::StringVector argv = command_line->argv();
     argv.erase(std::remove_if(++argv.begin(), argv.end(), IsNonSwitchArgument),
                argv.end());
     command_line->InitFromArgv(argv);
     ASSERT_TRUE(std::equal(argv.begin(), argv.end(),
                            command_line->argv().begin()));
   }
 
-  virtual void SetUpOnMainThread() OVERRIDE {
+  virtual void SetUpOnMainThread() override {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(
             RedirectHostsToTestData, kRestoredURLs, arraysize(kRestoredURLs)));
   }
 
   void HomepageIsNotNTP() {
     // Verifies that policy can set the startup pages to the homepage, when
     // the homepage is not the NTP.
@@ skipping 127 matching lines @@
                     &RestoreOnStartupPolicyTest::NTP,
                     &RestoreOnStartupPolicyTest::Last));
 
 // Similar to PolicyTest but sets a couple of policies before the browser is
 // started.
 class PolicyStatisticsCollectorTest : public PolicyTest {
  public:
   PolicyStatisticsCollectorTest() {}
   virtual ~PolicyStatisticsCollectorTest() {}
 
-  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
+  virtual void SetUpInProcessBrowserTestFixture() override {
     PolicyTest::SetUpInProcessBrowserTestFixture();
     PolicyMap policies;
     policies.Set(key::kShowHomeButton,
                  POLICY_LEVEL_MANDATORY,
                  POLICY_SCOPE_USER,
                  new base::FundamentalValue(true),
                  NULL);
     policies.Set(key::kBookmarkBarEnabled,
                  POLICY_LEVEL_MANDATORY,
                  POLICY_SCOPE_USER,
@@ skipping 269 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(MediaStreamDevicesControllerBrowserTestInstance,
                         MediaStreamDevicesControllerBrowserTest,
                         testing::Bool());
 
 #if !defined(OS_CHROMEOS)
 // Similar to PolicyTest but sets the proper policy before the browser is
 // started.
 class PolicyVariationsServiceTest : public PolicyTest {
  public:
-  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
+  virtual void SetUpInProcessBrowserTestFixture() override {
     PolicyTest::SetUpInProcessBrowserTestFixture();
     PolicyMap policies;
     policies.Set(key::kVariationsRestrictParameter,
                  POLICY_LEVEL_MANDATORY,
                  POLICY_SCOPE_USER,
                  new base::StringValue("restricted"),
                  NULL);
     provider_.UpdateChromePolicy(policies);
   }
 };
@@ skipping 82 matching lines @@
   EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
       browser2->tab_strip_model()->GetActiveWebContents(),
       "domAutomationController.send(window.showModalDialog !== undefined);",
       &result));
   EXPECT_TRUE(result);
 }
 
 #endif  // !defined(CHROME_OS)
 
 }  // namespace policy