C++11 override style change for 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 <complex>
 #include <vector>
 
 #include "athena/wm/overview_toolbar.h"
@@ skipping 243 matching lines @@
 
   WindowOverviewState* target_state =
       target_window->GetProperty(kWindowOverviewState);
   setter.SetWindowProgress(target_state->progress);
 }
 
 // Always returns the same target.
 class StaticWindowTargeter : public aura::WindowTargeter {
  public:
   explicit StaticWindowTargeter(aura::Window* target) : target_(target) {}
-  virtual ~StaticWindowTargeter() {}
+  ~StaticWindowTargeter() override {}
 
  private:
   // aura::WindowTargeter:
-  virtual ui::EventTarget* FindTargetForEvent(ui::EventTarget* root,
+  ui::EventTarget* FindTargetForEvent(ui::EventTarget* root,
                                               ui::Event* event) override {
     return target_;
   }
 
-  virtual ui::EventTarget* FindTargetForLocatedEvent(
+  ui::EventTarget* FindTargetForLocatedEvent(
       ui::EventTarget* root,
       ui::LocatedEvent* event) override {
     return target_;
   }
 
   aura::Window* target_;
   DISALLOW_COPY_AND_ASSIGN(StaticWindowTargeter);
 };
 
 class WindowOverviewModeImpl : public WindowOverviewMode,
@@ skipping 18 matching lines @@
     container_->set_target_handler(this);
 
     // Prepare the desired transforms for all the windows, and set the initial
     // state on the windows.
     ComputeTerminalStatesForAllWindows();
     SetInitialWindowStates();
 
     window_list_provider_->AddObserver(this);
   }
 
-  virtual ~WindowOverviewModeImpl() {
+  ~WindowOverviewModeImpl() override {
     window_list_provider_->RemoveObserver(this);
     container_->set_target_handler(container_->delegate());
     RemoveAnimationObserver();
     const aura::Window::Windows& windows =
         window_list_provider_->GetWindowList();
     if (windows.empty())
       return;
     for (aura::Window* window : windows)
       RestoreWindowState(window, split_view_controller_);
   }
@@ skipping 367 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 {
+  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 {
+  void OnScrollEvent(ui::ScrollEvent* scroll) override {
     if (scroll->type() == ui::ET_SCROLL)
       DoScroll(scroll->y_offset());
   }
 
-  virtual void OnGestureEvent(ui::GestureEvent* gesture) override {
+  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 {
+  void OnAnimationStep(base::TimeTicks timestamp) override {
     CHECK(fling_);
     gfx::Vector2dF delta;
     bool fling_active = fling_->ComputeScrollDeltaAtTime(timestamp, &delta);
 
     if (!delta.IsZero())
       DoScroll(delta.y());
 
     if (!fling_active) {
       fling_.reset();
       RemoveAnimationObserver();
     }
   }
 
   // WindowListProviderObserver:
-  virtual void OnWindowStackingChanged() override {
+  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,
+  void OnWindowRemoved(aura::Window* removed_window,
                                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) {
@@ skipping 47 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