C++11 override style change for athena

athena/input/accelerator_manager_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/input/accelerator_manager_impl.h"
 
 #include "athena/input/public/input_manager.h"
 #include "athena/util/switches.h"
 #include "base/logging.h"
 #include "ui/aura/window.h"
@@ skipping 31 matching lines @@
 // wm::NestedAcceleratorController while accelerators in normal case are
 // handled by wm::AcceleratorFilter. These delegates act bridges in these
 // two different environment so that AcceleratorManagerImpl can handle
 // accelerators in an uniform way.
 
 class NestedAcceleratorDelegate : public wm::NestedAcceleratorDelegate {
  public:
   explicit NestedAcceleratorDelegate(
       AcceleratorManagerImpl* accelerator_manager)
       : accelerator_manager_(accelerator_manager) {}
-  virtual ~NestedAcceleratorDelegate() {}
+  ~NestedAcceleratorDelegate() override {}
 
  private:
   // wm::NestedAcceleratorDelegate:
-  virtual Result ProcessAccelerator(
+  Result ProcessAccelerator(
       const ui::Accelerator& accelerator) override {
     return accelerator_manager_->Process(accelerator) ? RESULT_PROCESSED
                                                       : RESULT_NOT_PROCESSED;
   }
 
   AcceleratorManagerImpl* accelerator_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(NestedAcceleratorDelegate);
 };
 
 class AcceleratorDelegate : public wm::AcceleratorDelegate {
  public:
   explicit AcceleratorDelegate(AcceleratorManagerImpl* accelerator_manager)
       : accelerator_manager_(accelerator_manager) {}
-  virtual ~AcceleratorDelegate() {}
+  ~AcceleratorDelegate() override {}
 
  private:
   // wm::AcceleratorDelegate:
-  virtual bool ProcessAccelerator(const ui::KeyEvent& event,
+  bool ProcessAccelerator(const ui::KeyEvent& event,
                                   const ui::Accelerator& accelerator,
                                   KeyType key_type) override {
     aura::Window* target = static_cast<aura::Window*>(event.target());
     if (!target->IsRootWindow() &&
         !accelerator_manager_->IsRegistered(accelerator, AF_RESERVED)) {
       // TODO(oshima): do the same when the active window is in fullscreen.
       return false;
     }
     return accelerator_manager_->Process(accelerator);
   }
 
   AcceleratorManagerImpl* accelerator_manager_;
   DISALLOW_COPY_AND_ASSIGN(AcceleratorDelegate);
 };
 
 class FocusManagerDelegate : public views::FocusManagerDelegate {
  public:
   explicit FocusManagerDelegate(AcceleratorManagerImpl* accelerator_manager)
       : accelerator_manager_(accelerator_manager) {}
-  virtual ~FocusManagerDelegate() {}
+  ~FocusManagerDelegate() override {}
 
-  virtual bool ProcessAccelerator(const ui::Accelerator& accelerator) override {
+  bool ProcessAccelerator(const ui::Accelerator& accelerator) override {
     return accelerator_manager_->Process(accelerator);
   }
 
-  virtual ui::AcceleratorTarget* GetCurrentTargetForAccelerator(
+  ui::AcceleratorTarget* GetCurrentTargetForAccelerator(
       const ui::Accelerator& accelerator) const override {
     return accelerator_manager_->IsRegistered(accelerator, AF_NONE)
                ? accelerator_manager_
                : NULL;
   }
 
  private:
   AcceleratorManagerImpl* accelerator_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(FocusManagerDelegate);
 };
 
 // Key strokes must be sent to web contents to give them a chance to
 // consume them unless they are reserved, and unhandled key events are
 // sent back to focus manager asynchronously. This installs the athena's
 // focus manager that handles athena shell's accelerators.
 class FocusManagerFactory : public views::FocusManagerFactory {
  public:
   explicit FocusManagerFactory(AcceleratorManagerImpl* accelerator_manager)
       : accelerator_manager_(accelerator_manager) {}
-  virtual ~FocusManagerFactory() {}
+  ~FocusManagerFactory() override {}
 
-  virtual views::FocusManager* CreateFocusManager(
+  views::FocusManager* CreateFocusManager(
       views::Widget* widget,
       bool desktop_widget) override {
     return new views::FocusManager(
         widget,
         desktop_widget ? NULL : new FocusManagerDelegate(accelerator_manager_));
   }
 
  private:
   AcceleratorManagerImpl* accelerator_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(FocusManagerFactory);
 };
 
 class UIAcceleratorManagerWrapper
     : public AcceleratorManagerImpl::AcceleratorWrapper {
  public:
   UIAcceleratorManagerWrapper()
       : ui_accelerator_manager_(new ui::AcceleratorManager) {}
-  virtual ~UIAcceleratorManagerWrapper() {}
+  ~UIAcceleratorManagerWrapper() override {}
 
   virtual void Register(const ui::Accelerator& accelerator,
                         ui::AcceleratorTarget* target) override {
     ui_accelerator_manager_->Register(
         accelerator, ui::AcceleratorManager::kNormalPriority, target);
   }
 
   virtual void Unregister(const ui::Accelerator& accelerator,
                           ui::AcceleratorTarget* target) override {
     ui_accelerator_manager_->Unregister(accelerator, target);
@@ skipping 11 matching lines @@
  private:
   scoped_ptr<ui::AcceleratorManager> ui_accelerator_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(UIAcceleratorManagerWrapper);
 };
 
 class FocusManagerWrapper : public AcceleratorManagerImpl::AcceleratorWrapper {
  public:
   explicit FocusManagerWrapper(views::FocusManager* focus_manager)
       : focus_manager_(focus_manager) {}
-  virtual ~FocusManagerWrapper() {}
+  ~FocusManagerWrapper() override {}
 
   virtual void Register(const ui::Accelerator& accelerator,
                         ui::AcceleratorTarget* target) override {
     return focus_manager_->RegisterAccelerator(
         accelerator, ui::AcceleratorManager::kNormalPriority, target);
   }
 
   virtual void Unregister(const ui::Accelerator& accelerator,
                           ui::AcceleratorTarget* target) override {
     focus_manager_->UnregisterAccelerator(accelerator, target);
@@ skipping 167 matching lines @@
   return InputManager::Get()->GetAcceleratorManager();
 }
 
 // static
 scoped_ptr<AcceleratorManager> AcceleratorManager::CreateForFocusManager(
     views::FocusManager* focus_manager) {
   return AcceleratorManagerImpl::CreateForFocusManager(focus_manager).Pass();
 }
 
 }  // namespace athena