replace OVERRIDE and FINAL with override and final in athena/

athena/wm/window_overview_mode.cc

 // Copyright 2014 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 "athena/wm/window_overview_mode.h"
 
 #include <algorithm>
 #include <functional>
 #include <vector>
 
@@ skipping 162 matching lines @@
 
 // Always returns the same target.
 class StaticWindowTargeter : public aura::WindowTargeter {
  public:
   explicit StaticWindowTargeter(aura::Window* target) : target_(target) {}
   virtual ~StaticWindowTargeter() {}
 
  private:
   // aura::WindowTargeter:
   virtual ui::EventTarget* FindTargetForEvent(ui::EventTarget* root,
-                                              ui::Event* event) OVERRIDE {
+                                              ui::Event* event) override {
     return target_;
   }
 
   virtual ui::EventTarget* FindTargetForLocatedEvent(
       ui::EventTarget* root,
-      ui::LocatedEvent* event) OVERRIDE {
+      ui::LocatedEvent* event) override {
     return target_;
   }
 
   aura::Window* target_;
   DISALLOW_COPY_AND_ASSIGN(StaticWindowTargeter);
 };
 
 class WindowOverviewModeImpl : public WindowOverviewMode,
                                public ui::EventHandler,
                                public ui::CompositorAnimationObserver,
@@ skipping 408 matching lines @@
             split_view_controller_->left_window(),
             split_view_controller_->right_window(),
             window);
       } else {
         delegate_->OnSelectWindow(window);
       }
     }
   }
 
   // ui::EventHandler:
-  virtual void OnMouseEvent(ui::MouseEvent* mouse) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* mouse) override {
     if (mouse->type() == ui::ET_MOUSE_PRESSED) {
       aura::Window* select = SelectWindowAt(mouse);
       if (select) {
         mouse->SetHandled();
         SelectWindow(select);
       }
     } else if (mouse->type() == ui::ET_MOUSEWHEEL) {
       DoScroll(static_cast<ui::MouseWheelEvent*>(mouse)->y_offset());
     }
   }
 
-  virtual void OnScrollEvent(ui::ScrollEvent* scroll) OVERRIDE {
+  virtual void OnScrollEvent(ui::ScrollEvent* scroll) override {
     if (scroll->type() == ui::ET_SCROLL)
       DoScroll(scroll->y_offset());
   }
 
-  virtual void OnGestureEvent(ui::GestureEvent* gesture) OVERRIDE {
+  virtual void OnGestureEvent(ui::GestureEvent* gesture) override {
     if (gesture->type() == ui::ET_GESTURE_TAP) {
       aura::Window* select = SelectWindowAt(gesture);
       if (select) {
         gesture->SetHandled();
         SelectWindow(select);
       }
     } else if (gesture->type() == ui::ET_GESTURE_SCROLL_BEGIN) {
       if (std::abs(gesture->details().scroll_x_hint()) >
           std::abs(gesture->details().scroll_y_hint()) * 2) {
         dragged_start_location_ = gesture->location();
@@ skipping 41 matching lines @@
       if (fling_) {
         fling_.reset();
         RemoveAnimationObserver();
         gesture->SetHandled();
       }
       dragged_window_ = NULL;
     }
   }
 
   // ui::CompositorAnimationObserver:
-  virtual void OnAnimationStep(base::TimeTicks timestamp) OVERRIDE {
+  virtual void OnAnimationStep(base::TimeTicks timestamp) override {
     CHECK(fling_);
     if (fling_->start_timestamp() > timestamp)
       return;
     gfx::Vector2dF scroll = fling_->GetScrollAmountAtTime(timestamp);
     if (scroll.IsZero()) {
       fling_.reset();
       RemoveAnimationObserver();
     } else {
       DoScroll(scroll.y());
     }
   }
 
   // WindowListProviderObserver:
-  virtual void OnWindowStackingChanged() OVERRIDE {
+  virtual void OnWindowStackingChanged() override {
     // Recompute the states of all windows. There isn't enough information at
     // this point to do anything more clever.
     ComputeTerminalStatesForAllWindows();
     SetInitialWindowStates();
   }
 
   virtual void OnWindowRemoved(aura::Window* removed_window,
-                               int index) OVERRIDE {
+                               int index) override {
     const aura::Window::Windows& windows =
         window_list_provider_->GetWindowList();
     if (windows.empty())
       return;
     CHECK_LE(index, static_cast<int>(windows.size()));
     if (index == 0) {
       // The back-most window has been removed. Move all the remaining windows
       // one step backwards.
       for (int i = windows.size() - 1; i > 0; --i) {
         UpdateTerminalStateForWindowAtIndex(
@@ skipping 46 matching lines @@
     aura::Window* container,
     WindowListProvider* window_list_provider,
     SplitViewController* split_view_controller,
     WindowOverviewModeDelegate* delegate) {
   return scoped_ptr<WindowOverviewMode>(
       new WindowOverviewModeImpl(container, window_list_provider,
                                  split_view_controller, delegate));
 }
 
 }  // namespace athena