C++11 override style change for athena

athena/home/home_card_impl.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/home/home_card_impl.h"
 
 #include <cmath>
 #include <limits>
 
 #include "athena/env/public/athena_env.h"
@@ skipping 53 matching lines @@
 }  // namespace
 
 // Makes sure the homecard is center-aligned horizontally and bottom-aligned
 // vertically.
 class HomeCardLayoutManager : public aura::LayoutManager {
  public:
   HomeCardLayoutManager()
       : home_card_(NULL),
         minimized_layer_(NULL) {}
 
-  virtual ~HomeCardLayoutManager() {}
+  ~HomeCardLayoutManager() override {}
 
   void Layout(bool animate, gfx::Tween::Type tween_type) {
     // |home_card| could be detached from the root window (e.g. when it is being
     // destroyed).
     if (!home_card_ || !home_card_->IsVisible() || !home_card_->GetRootWindow())
       return;
 
     scoped_ptr<ui::ScopedLayerAnimationSettings> settings;
     if (animate) {
       settings.reset(new ui::ScopedLayerAnimationSettings(
@@ skipping 12 matching lines @@
  private:
   void UpdateMinimizedHomeBounds() {
     gfx::Rect minimized_bounds = minimized_layer_->parent()->bounds();
     minimized_bounds.set_y(
         minimized_bounds.bottom() - kHomeCardMinimizedHeight);
     minimized_bounds.set_height(kHomeCardMinimizedHeight);
     minimized_layer_->SetBounds(minimized_bounds);
   }
 
   // aura::LayoutManager:
-  virtual void OnWindowResized() override {
+  void OnWindowResized() override {
     Layout(false, gfx::Tween::LINEAR);
     UpdateMinimizedHomeBounds();
   }
-  virtual void OnWindowAddedToLayout(aura::Window* child) override {
+  void OnWindowAddedToLayout(aura::Window* child) override {
     if (!home_card_) {
       home_card_ = child;
       Layout(false, gfx::Tween::LINEAR);
     }
   }
-  virtual void OnWillRemoveWindowFromLayout(aura::Window* child) override {
+  void OnWillRemoveWindowFromLayout(aura::Window* child) override {
     if (home_card_ == child)
       home_card_ = NULL;
   }
-  virtual void OnWindowRemovedFromLayout(aura::Window* child) override {
+  void OnWindowRemovedFromLayout(aura::Window* child) override {
   }
-  virtual void OnChildWindowVisibilityChanged(aura::Window* child,
+  void OnChildWindowVisibilityChanged(aura::Window* child,
                                               bool visible) override {
     if (home_card_ == child)
       Layout(false, gfx::Tween::LINEAR);
   }
-  virtual void SetChildBounds(aura::Window* child,
+  void SetChildBounds(aura::Window* child,
                               const gfx::Rect& requested_bounds) override {
     SetChildBoundsDirect(child, requested_bounds);
   }
 
   aura::Window* home_card_;
   ui::Layer* minimized_layer_;
 
   DISALLOW_COPY_AND_ASSIGN(HomeCardLayoutManager);
 };
 
 // The container view of home card contents of each state.
 class HomeCardView : public views::WidgetDelegateView,
                      public AthenaStartPageView::Observer {
  public:
   HomeCardView(app_list::AppListViewDelegate* view_delegate,
                aura::Window* container,
                HomeCardGestureManager::Delegate* gesture_delegate)
       : gesture_delegate_(gesture_delegate) {
     SetLayoutManager(new views::FillLayout());
     // Ideally AppListMainView should be used here and have AthenaStartPageView
     // as its child view, so that custom pages and apps grid are available in
     // the home card.
     // TODO(mukai): make it so after the detailed UI has been fixed.
     main_view_ = new AthenaStartPageView(view_delegate);
     main_view_->AddObserver(this);
     AddChildView(main_view_);
   }
 
-  virtual ~HomeCardView() { main_view_->RemoveObserver(this); }
+  ~HomeCardView() override { main_view_->RemoveObserver(this); }
 
   void SetStateProgress(HomeCard::State from_state,
                         HomeCard::State to_state,
                         float progress) {
     // TODO(mukai): not clear the focus, but simply close the virtual keyboard.
     GetFocusManager()->ClearFocus();
     if (from_state == HomeCard::VISIBLE_CENTERED)
       main_view_->SetLayoutState(1.0f - progress);
     else if (to_state == HomeCard::VISIBLE_CENTERED)
       main_view_->SetLayoutState(progress);
@@ skipping 10 matching lines @@
 
     main_view_->SetLayoutStateWithAnimation(
         (state == HomeCard::VISIBLE_CENTERED) ? 1.0f : 0.0f, tween_type);
   }
 
   void ClearGesture() {
     gesture_manager_.reset();
   }
 
   // views::View:
-  virtual void OnGestureEvent(ui::GestureEvent* event) override {
+  void OnGestureEvent(ui::GestureEvent* event) override {
     if (!gesture_manager_ &&
         event->type() == ui::ET_GESTURE_SCROLL_BEGIN) {
       gesture_manager_.reset(new HomeCardGestureManager(
           gesture_delegate_,
           GetWidget()->GetNativeWindow()->GetRootWindow()->bounds()));
     }
 
     if (gesture_manager_)
       gesture_manager_->ProcessGestureEvent(event);
   }
-  virtual bool OnMousePressed(const ui::MouseEvent& event) override {
+  bool OnMousePressed(const ui::MouseEvent& event) override {
     if (HomeCard::Get()->GetState() == HomeCard::VISIBLE_MINIMIZED &&
         event.IsLeftMouseButton() && event.GetClickCount() == 1) {
       athena::WindowManager::Get()->EnterOverview();
       return true;
     }
     return false;
   }
 
  private:
   void UpdateShadow(bool should_show) {
     wm::SetShadowType(
         GetWidget()->GetNativeWindow(),
         should_show ? wm::SHADOW_TYPE_RECTANGULAR : wm::SHADOW_TYPE_NONE);
   }
 
   // views::WidgetDelegate:
-  virtual views::View* GetContentsView() override {
+  views::View* GetContentsView() override {
     return this;
   }
 
   // AthenaStartPageView::Observer:
-  virtual void OnLayoutStateChanged(float new_state) override {
+  void OnLayoutStateChanged(float new_state) override {
     if (new_state == 1.0f)
       HomeCard::Get()->SetState(HomeCard::VISIBLE_CENTERED);
   }
 
   AthenaStartPageView* main_view_;
   scoped_ptr<HomeCardGestureManager> gesture_manager_;
   HomeCardGestureManager::Delegate* gesture_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(HomeCardView);
 };
@@ skipping 210 matching lines @@
   instance = NULL;
 }
 
 // static
 HomeCard* HomeCard::Get() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena