C++11 override style change for athena

athena/wm/split_view_controller.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/split_view_controller.h"
 
 #include <cmath>
 
 #include "athena/screen/public/screen_manager.h"
 #include "athena/wm/public/window_list_provider.h"
@@ skipping 40 matching lines @@
   WINDOW_LEFT,
   // Activate |right_window_|.
   WINDOW_RIGHT
 };
 
 // Always returns the same target.
 class StaticViewTargeterDelegate : public views::ViewTargeterDelegate {
  public:
   explicit StaticViewTargeterDelegate(views::View* target) : target_(target) {}
 
-  virtual ~StaticViewTargeterDelegate() {}
+  ~StaticViewTargeterDelegate() override {}
 
  private:
   // views::ViewTargeterDelegate:
   virtual views::View* TargetForRect(views::View* root,
                                      const gfx::Rect& rect) override {
     return target_;
   }
 
   // Not owned.
   views::View* target_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticViewTargeterDelegate);
 };
 
 // Expands the effective target area of the window of the widget containing the
 // specified view. If the view is large enough to begin with, there should be
 // no change from the default targeting behavior.
 class PriorityWindowTargeter : public aura::WindowTargeter,
                                public aura::WindowObserver {
  public:
   explicit PriorityWindowTargeter(views::View* priority_view)
       : priority_view_(priority_view) {
     CHECK(priority_view->GetWidget());
     window_ = priority_view->GetWidget()->GetNativeWindow();
     CHECK(window_);
     window_->AddObserver(this);
   }
 
-  virtual ~PriorityWindowTargeter() {
-    window_->RemoveObserver(this);
-  }
+  ~PriorityWindowTargeter() override { window_->RemoveObserver(this); }
 
  private:
   // aura::WindowTargeter:
-  virtual ui::EventTarget* FindTargetForLocatedEvent(
-      ui::EventTarget* root,
-      ui::LocatedEvent* event) override {
+  ui::EventTarget* FindTargetForLocatedEvent(ui::EventTarget* root,
+                                             ui::LocatedEvent* event) override {
     if (!window_ || (event->type() != ui::ET_TOUCH_PRESSED))
       return WindowTargeter::FindTargetForLocatedEvent(root, event);
     CHECK_EQ(window_, priority_view_->GetWidget()->GetNativeWindow());
 
     // Bounds of the view in root window's coordinates.
     gfx::Rect view_bounds = priority_view_->GetBoundsInScreen();
     // If there is a transform on the window's layer - apply it.
     gfx::Transform window_transform = window_->layer()->transform();
     gfx::RectF transformed_bounds_f = view_bounds;
     window_transform.TransformRect(&transformed_bounds_f);
@@ skipping 14 matching lines @@
         gfx::UnionRects(transformed_bounds, extension_rect);
     if (extended_bounds.Contains(event->root_location())) {
       root->ConvertEventToTarget(window_, event);
       return window_;
     }
 
     return WindowTargeter::FindTargetForLocatedEvent(root, event);
   }
 
   // aura::WindowObserver:
-  virtual void OnWindowDestroying(aura::Window* window) override {
+  void OnWindowDestroying(aura::Window* window) override {
     DCHECK_EQ(window, window_);
     window_->RemoveObserver(this);
     window_ = nullptr;
   }
 
   // Minimum dimension of a target to be comfortably touchable.
   // The effective touch target area of |priority_window_| gets expanded so
   // that it's width and height is ayt least |kMinTouchDimension|.
   int const kMinTouchDimension = 26;
 
@@ skipping 490 matching lines @@
     ShowDivider();
 }
 
 void SplitViewController::OnSplitViewModeEnter() {
 }
 
 void SplitViewController::OnSplitViewModeExit() {
 }
 
 }  // namespace athena