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

chrome/browser/ui/browser_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 <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
@@ skipping 145 matching lines @@
     ++result;
   return result;
 }
 
 class MockTabStripModelObserver : public TabStripModelObserver {
  public:
   MockTabStripModelObserver() : closing_count_(0) {}
 
   virtual void TabClosingAt(TabStripModel* tab_strip_model,
                             WebContents* contents,
-                            int index) OVERRIDE {
+                            int index) override {
     ++closing_count_;
   }
 
   int closing_count() const { return closing_count_; }
 
  private:
   int closing_count_;
 
   DISALLOW_COPY_AND_ASSIGN(MockTabStripModelObserver);
 };
 
 class InterstitialObserver : public content::WebContentsObserver {
  public:
   InterstitialObserver(content::WebContents* web_contents,
                        const base::Closure& attach_callback,
                        const base::Closure& detach_callback)
       : WebContentsObserver(web_contents),
         attach_callback_(attach_callback),
         detach_callback_(detach_callback) {
   }
 
-  virtual void DidAttachInterstitialPage() OVERRIDE {
+  virtual void DidAttachInterstitialPage() override {
     attach_callback_.Run();
   }
 
-  virtual void DidDetachInterstitialPage() OVERRIDE {
+  virtual void DidDetachInterstitialPage() override {
     detach_callback_.Run();
   }
 
  private:
   base::Closure attach_callback_;
   base::Closure detach_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(InterstitialObserver);
 };
 
 // Causes the browser to swap processes on a redirect to an HTTPS URL.
 class TransferHttpsRedirectsContentBrowserClient
     : public chrome::ChromeContentBrowserClient {
  public:
   virtual bool ShouldSwapProcessesForRedirect(
       content::ResourceContext* resource_context,
       const GURL& current_url,
-      const GURL& new_url) OVERRIDE {
+      const GURL& new_url) override {
     return new_url.SchemeIs(url::kHttpsScheme);
   }
 };
 
 // Used by CloseWithAppMenuOpen. Invokes CloseWindow on the supplied browser.
 void CloseWindowCallback(Browser* browser) {
   chrome::CloseWindow(browser);
 }
 
 // Used by CloseWithAppMenuOpen. Posts a CloseWindowCallback and shows the app
@@ skipping 16 matching lines @@
     interstitial_page_->Show();
   }
   virtual ~TestInterstitialPage() { }
   void Proceed() {
     interstitial_page_->Proceed();
   }
   void DontProceed() {
     interstitial_page_->DontProceed();
   }
 
-  virtual std::string GetHTMLContents() OVERRIDE {
+  virtual std::string GetHTMLContents() override {
     return "<h1>INTERSTITIAL</h1>";
   }
 
  private:
   InterstitialPage* interstitial_page_;  // Owns us.
 };
 
 class RenderViewSizeObserver : public content::WebContentsObserver {
  public:
   RenderViewSizeObserver(content::WebContents* web_contents,
@@ skipping 15 matching lines @@
       *wcv_commit_size = result->second.wcv_commit_size;
     }
   }
 
   void set_wcv_resize_insets(const gfx::Size& wcv_resize_insets) {
     wcv_resize_insets_ = wcv_resize_insets;
   }
 
   // Cache the size when RenderViewHost is first created.
   virtual void RenderViewCreated(
-      content::RenderViewHost* render_view_host) OVERRIDE {
+      content::RenderViewHost* render_view_host) override {
     render_view_sizes_[render_view_host].rwhv_create_size =
         render_view_host->GetView()->GetViewBounds().size();
   }
 
   // Enlarge WebContentsView by |wcv_resize_insets_| while the navigation entry
   // is pending.
   virtual void DidStartNavigationToPendingEntry(
       const GURL& url,
-      NavigationController::ReloadType reload_type) OVERRIDE {
+      NavigationController::ReloadType reload_type) override {
     if (wcv_resize_insets_.IsEmpty())
       return;
     // Resizing the main browser window by |wcv_resize_insets_| will
     // automatically resize the WebContentsView by the same amount.
     // Just resizing WebContentsView directly doesn't work on Linux, because the
     // next automatic layout of the browser window will resize WebContentsView
     // back to the previous size.  To make it consistent, resize main browser
     // window on all platforms.
     gfx::Rect bounds(browser_window_->GetBounds());
     gfx::Size size(bounds.size());
     size.Enlarge(wcv_resize_insets_.width(), wcv_resize_insets_.height());
     bounds.set_size(size);
     browser_window_->SetBounds(bounds);
     // Let the message loop run so that resize actually takes effect.
     content::RunAllPendingInMessageLoop();
   }
 
   // Cache the sizes of RenderWidgetHostView and WebContentsView when the
   // navigation entry is committed, which is before
   // WebContentsDelegate::DidNavigateMainFramePostCommit is called.
   virtual void NavigationEntryCommitted(
-      const content::LoadCommittedDetails& details) OVERRIDE {
+      const content::LoadCommittedDetails& details) override {
     content::RenderViewHost* rvh = web_contents()->GetRenderViewHost();
     render_view_sizes_[rvh].rwhv_commit_size =
         web_contents()->GetRenderWidgetHostView()->GetViewBounds().size();
     render_view_sizes_[rvh].wcv_commit_size =
         web_contents()->GetContainerBounds().size();
   }
 
  private:
   struct Sizes {
     gfx::Size rwhv_create_size;  // Size of RenderWidgetHostView when created.
@@ skipping 299 matching lines @@
 }
 
 class RedirectObserver : public content::WebContentsObserver {
  public:
   explicit RedirectObserver(content::WebContents* web_contents)
       : WebContentsObserver(web_contents) {
   }
 
   virtual void DidNavigateAnyFrame(
       const content::LoadCommittedDetails& details,
-      const content::FrameNavigateParams& params) OVERRIDE {
+      const content::FrameNavigateParams& params) override {
     params_ = params;
   }
 
-  virtual void WebContentsDestroyed() OVERRIDE {
+  virtual void WebContentsDestroyed() override {
     // Make sure we don't close the tab while the observer is in scope.
     // See http://crbug.com/314036.
     FAIL() << "WebContents closed during navigation (http://crbug.com/314036).";
   }
 
   const content::FrameNavigateParams& params() const {
     return params_;
   }
 
  private:
@@ skipping 191 matching lines @@
 }
 
 // BeforeUnloadAtQuitWithTwoWindows is a regression test for
 // http://crbug.com/11842. It opens two windows, one of which has a
 // beforeunload handler and attempts to exit cleanly.
 class BeforeUnloadAtQuitWithTwoWindows : public InProcessBrowserTest {
  public:
   // This test is for testing a specific shutdown behavior. This mimics what
   // happens in InProcessBrowserTest::RunTestOnMainThread and QuitBrowsers, but
   // ensures that it happens through the single IDC_EXIT of the test.
-  virtual void TearDownOnMainThread() OVERRIDE {
+  virtual void TearDownOnMainThread() override {
     // Cycle both the MessageLoop and the Cocoa runloop twice to flush out any
     // Chrome work that generates Cocoa work. Do this twice since there are two
     // Browsers that must be closed.
     CycleRunLoops();
     CycleRunLoops();
 
     // Run the application event loop to completion, which will cycle the
     // native MessagePump on all platforms.
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::MessageLoop::QuitClosure());
@@ skipping 1147 matching lines @@
   }
 }
 
 class MockWebContentsObserver : public WebContentsObserver {
  public:
   explicit MockWebContentsObserver(WebContents* web_contents)
       : WebContentsObserver(web_contents),
         got_user_gesture_(false) {
   }
 
-  virtual void DidGetUserGesture() OVERRIDE {
+  virtual void DidGetUserGesture() override {
     got_user_gesture_ = true;
   }
 
   bool got_user_gesture() const {
     return got_user_gesture_;
   }
 
   void set_got_user_gesture(bool got_it) {
     got_user_gesture_ = got_it;
   }
@@ skipping 158 matching lines @@
       browser()->tab_strip_model()->GetActiveWebContents(), expected_title);
   title_watcher.AlsoWaitForTitle(ASCIIToUTF16("Allowed"));
   ui_test_utils::NavigateToURL(browser(), url);
   ASSERT_EQ(expected_title, title_watcher.WaitAndGetTitle());
 }
 
 class KioskModeTest : public BrowserTest {
  public:
   KioskModeTest() {}
 
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     command_line->AppendSwitch(switches::kKioskMode);
   }
 };
 
 #if defined(OS_MACOSX) || (defined(OS_LINUX) && !defined(OS_CHROMEOS))
 // Mac: http://crbug.com/103912
 // Linux: http://crbug.com/163931
 #define MAYBE_EnableKioskModeTest DISABLED_EnableKioskModeTest
 #else
 #define MAYBE_EnableKioskModeTest EnableKioskModeTest
 #endif
 IN_PROC_BROWSER_TEST_F(KioskModeTest, MAYBE_EnableKioskModeTest) {
   // Check if browser is in fullscreen mode.
   ASSERT_TRUE(browser()->window()->IsFullscreen());
   ASSERT_FALSE(browser()->window()->IsFullscreenBubbleVisible());
 }
 
 #if defined(OS_WIN)
 // This test verifies that Chrome can be launched with a user-data-dir path
 // which contains non ASCII characters.
 class LaunchBrowserWithNonAsciiUserDatadir : public BrowserTest {
  public:
   LaunchBrowserWithNonAsciiUserDatadir() {}
 
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     base::FilePath tmp_profile = temp_dir_.path().AppendASCII("tmp_profile");
     tmp_profile = tmp_profile.Append(L"Test Chrome G\u00E9raldine");
 
     ASSERT_TRUE(base::CreateDirectory(tmp_profile));
     command_line->AppendSwitchPath(switches::kUserDataDir, tmp_profile);
   }
 
   base::ScopedTempDir temp_dir_;
 };
 
 IN_PROC_BROWSER_TEST_F(LaunchBrowserWithNonAsciiUserDatadir,
                        TestNonAsciiUserDataDir) {
   // Verify that the window is present.
   ASSERT_TRUE(browser());
 }
 #endif  // defined(OS_WIN)
 
 // Tests to ensure that the browser continues running in the background after
 // the last window closes.
 class RunInBackgroundTest : public BrowserTest {
  public:
   RunInBackgroundTest() {}
 
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     command_line->AppendSwitch(switches::kKeepAliveForTest);
   }
 };
 
 IN_PROC_BROWSER_TEST_F(RunInBackgroundTest, RunInBackgroundBasicTest) {
   // Close the browser window, then open a new one - the browser should keep
   // running.
   Profile* profile = browser()->profile();
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
   content::WindowedNotificationObserver observer(
       chrome::NOTIFICATION_BROWSER_CLOSED,
       content::Source<Browser>(browser()));
   chrome::CloseWindow(browser());
   observer.Wait();
   EXPECT_EQ(0u, chrome::GetTotalBrowserCount());
 
   ui_test_utils::BrowserAddedObserver browser_added_observer;
   chrome::NewEmptyWindow(profile, chrome::GetActiveDesktop());
   browser_added_observer.WaitForSingleNewBrowser();
 
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
 }
 
 // Tests to ensure that the browser continues running in the background after
 // the last window closes.
 class NoStartupWindowTest : public BrowserTest {
  public:
   NoStartupWindowTest() {}
 
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     command_line->AppendSwitch(switches::kNoStartupWindow);
     command_line->AppendSwitch(switches::kKeepAliveForTest);
   }
 };
 
 IN_PROC_BROWSER_TEST_F(NoStartupWindowTest, NoStartupWindowBasicTest) {
 #if defined(OS_WIN) && defined(USE_ASH)
   // kNoStartupWindow doesn't make sense in Metro+Ash.
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
     return;
@@ skipping 33 matching lines @@
   ASSERT_FALSE(session_service->processed_any_commands());
 }
 #endif  // !defined(OS_CHROMEOS)
 
 // This test needs to be placed outside the anonymous namespace because we
 // need to access private type of Browser.
 class AppModeTest : public BrowserTest {
  public:
   AppModeTest() {}
 
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+  virtual void SetUpCommandLine(CommandLine* command_line) override {
     GURL url = ui_test_utils::GetTestUrl(
        base::FilePath(), base::FilePath().AppendASCII("title1.html"));
     command_line->AppendSwitchASCII(switches::kApp, url.spec());
   }
 };
 
 IN_PROC_BROWSER_TEST_F(AppModeTest, EnableAppModeTest) {
 #if defined(OS_WIN) && defined(USE_ASH)
   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
@@ skipping 371 matching lines @@
 #endif
   EXPECT_EQ(exp_commit_size, rwhv_commit_size2);
   EXPECT_EQ(exp_commit_size, wcv_commit_size2);
   gfx::Size exp_final_size(initial_wcv_size);
   exp_final_size.Enlarge(wcv_resize_insets.width(),
                          wcv_resize_insets.height() + height_inset);
   EXPECT_EQ(exp_final_size,
             web_contents->GetRenderWidgetHostView()->GetViewBounds().size());
   EXPECT_EQ(exp_final_size, web_contents->GetContainerBounds().size());
 }