replace OVERRIDE and FINAL with override and final in ash/

ash/wm/workspace/workspace_layout_manager_unittest.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 "ash/wm/workspace/workspace_layout_manager.h"
 
 #include <string>
 
 #include "ash/display/display_layout.h"
 #include "ash/display/display_manager.h"
@@ skipping 33 matching lines @@
 class MaximizeDelegateView : public views::WidgetDelegateView {
  public:
   explicit MaximizeDelegateView(const gfx::Rect& initial_bounds)
       : initial_bounds_(initial_bounds) {
   }
   virtual ~MaximizeDelegateView() {}
 
   virtual bool GetSavedWindowPlacement(
       const views::Widget* widget,
       gfx::Rect* bounds,
-      ui::WindowShowState* show_state) const OVERRIDE {
+      ui::WindowShowState* show_state) const override {
     *bounds = initial_bounds_;
     *show_state = ui::SHOW_STATE_MAXIMIZED;
     return true;
   }
 
  private:
   const gfx::Rect initial_bounds_;
 
   DISALLOW_COPY_AND_ASSIGN(MaximizeDelegateView);
 };
 
 class TestShellObserver : public ShellObserver {
  public:
   TestShellObserver() : call_count_(0),
                         is_fullscreen_(false) {
     Shell::GetInstance()->AddShellObserver(this);
   }
 
   virtual ~TestShellObserver() {
     Shell::GetInstance()->RemoveShellObserver(this);
   }
 
   virtual void OnFullscreenStateChanged(bool is_fullscreen,
-                                        aura::Window* root_window) OVERRIDE {
+                                        aura::Window* root_window) override {
     call_count_++;
     is_fullscreen_ = is_fullscreen;
   }
 
   int call_count() const {
     return call_count_;
   }
 
   bool is_fullscreen() const {
     return is_fullscreen_;
@@ skipping 219 matching lines @@
 // sees the window was maximized it changes the bounds of a secondary
 // window. The secondary window mirrors the status window.
 class DontClobberRestoreBoundsWindowObserver : public aura::WindowObserver {
  public:
   DontClobberRestoreBoundsWindowObserver() : window_(NULL) {}
 
   void set_window(aura::Window* window) { window_ = window; }
 
   virtual void OnWindowPropertyChanged(aura::Window* window,
                                        const void* key,
-                                       intptr_t old) OVERRIDE {
+                                       intptr_t old) override {
     if (!window_)
       return;
 
     if (wm::GetWindowState(window)->IsMaximized()) {
       aura::Window* w = window_;
       window_ = NULL;
 
       gfx::Rect shelf_bounds(Shell::GetPrimaryRootWindowController()->
                              GetShelfLayoutManager()->GetIdealBounds());
       const gfx::Rect& window_bounds(w->bounds());
@@ skipping 243 matching lines @@
  public:
   FocusDelegate()
       : window_(NULL),
         show_state_(ui::SHOW_STATE_END) {
   }
   virtual ~FocusDelegate() {}
 
   void set_window(aura::Window* window) { window_ = window; }
 
   // aura::test::TestWindowDelegate overrides:
-  virtual void OnWindowTargetVisibilityChanged(bool visible) OVERRIDE {
+  virtual void OnWindowTargetVisibilityChanged(bool visible) override {
     if (window_) {
       if (visible)
         window_->Focus();
       show_state_ = window_->GetProperty(aura::client::kShowStateKey);
     }
   }
 
   ui::WindowShowState GetShowStateAndReset() {
     ui::WindowShowState ret = show_state_;
     show_state_ = ui::SHOW_STATE_END;
@@ skipping 190 matching lines @@
 
 // Following tests are written to test the backdrop functionality.
 
 namespace {
 
 class WorkspaceLayoutManagerBackdropTest : public test::AshTestBase {
  public:
   WorkspaceLayoutManagerBackdropTest() {}
   virtual ~WorkspaceLayoutManagerBackdropTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     test::AshTestBase::SetUp();
     UpdateDisplay("800x600");
     default_container_ = Shell::GetContainer(Shell::GetPrimaryRootWindow(),
                                              kShellWindowId_DefaultContainer);
   }
 
   aura::Window* CreateTestWindow(const gfx::Rect& bounds) {
     aura::Window* window = CreateTestWindowInShellWithBounds(bounds);
     return window;
   }
@@ skipping 167 matching lines @@
 
   EXPECT_GT(default_container()->children()[0]->bounds().height(),
             reduced_bounds.height());
 }
 
 class WorkspaceLayoutManagerKeyboardTest : public test::AshTestBase {
  public:
   WorkspaceLayoutManagerKeyboardTest() {}
   virtual ~WorkspaceLayoutManagerKeyboardTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     test::AshTestBase::SetUp();
     UpdateDisplay("800x600");
     aura::Window* default_container = Shell::GetContainer(
         Shell::GetPrimaryRootWindow(), kShellWindowId_DefaultContainer);
     layout_manager_ = static_cast<WorkspaceLayoutManager*>(
         default_container->layout_manager());
   }
 
   aura::Window* CreateTestWindow(const gfx::Rect& bounds) {
     return CreateTestWindowInShellWithBounds(bounds);
@@ skipping 51 matching lines @@
   WorkspaceLayoutManager* layout_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(WorkspaceLayoutManagerKeyboardTest);
 };
 
 class FakeTextInputClient : public ui::DummyTextInputClient {
  public:
   explicit FakeTextInputClient(gfx::NativeWindow window) : window_(window) {}
   virtual ~FakeTextInputClient() {}
 
-  virtual gfx::NativeWindow GetAttachedWindow() const OVERRIDE {
+  virtual gfx::NativeWindow GetAttachedWindow() const override {
     return window_;
   }
 
  private:
   gfx::NativeWindow window_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeTextInputClient);
 };
 
 // Tests that when a child window gains focus the top level window containing it
@@ skipping 87 matching lines @@
                       occluded_window_bounds.width(),
                       occluded_window_bounds.height()).ToString(),
             window->bounds().ToString());
   HideKeyboard();
   EXPECT_EQ(occluded_window_bounds.ToString(), window->bounds().ToString());
 
   Blur(&text_input_client);
 }
 
 }  // namespace ash