replace OVERRIDE and FINAL with override and final in athena/

athena/screen/screen_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/screen/public/screen_manager.h"
 
 #include "athena/input/public/accelerator_manager.h"
 #include "athena/screen/screen_accelerator_handler.h"
 #include "athena/util/container_priorities.h"
 #include "athena/util/fill_layout_manager.h"
@@ skipping 37 matching lines @@
     container = container->parent();
   return container;
 }
 
 class AthenaFocusRules : public wm::BaseFocusRules {
  public:
   AthenaFocusRules() {}
   virtual ~AthenaFocusRules() {}
 
   // wm::BaseFocusRules:
-  virtual bool SupportsChildActivation(aura::Window* window) const OVERRIDE {
+  virtual bool SupportsChildActivation(aura::Window* window) const override {
     ScreenManager::ContainerParams* params =
         window->GetProperty(kContainerParamsKey);
     return params && params->can_activate_children;
   }
-  virtual bool CanActivateWindow(aura::Window* window) const OVERRIDE {
+  virtual bool CanActivateWindow(aura::Window* window) const override {
     // Check if containers of higher z-order than |window| have 'grab_inputs'
     // fields.
     if (window) {
       const aura::Window::Windows& containers =
           window->GetRootWindow()->children();
       aura::Window::Windows::const_iterator iter =
           std::find(containers.begin(), containers.end(), GetContainer(window));
       DCHECK(iter != containers.end());
       for (++iter; iter != containers.end(); ++iter) {
         if (GrabsInput(*iter))
@@ skipping 11 matching lines @@
  public:
   explicit AthenaWindowTreeClient(aura::Window* container)
       : container_(container) {}
 
  private:
   virtual ~AthenaWindowTreeClient() {}
 
   // aura::client::WindowTreeClient:
   virtual aura::Window* GetDefaultParent(aura::Window* context,
                                          aura::Window* window,
-                                         const gfx::Rect& bounds) OVERRIDE {
+                                         const gfx::Rect& bounds) override {
     aura::Window* transient_parent = wm::GetTransientParent(window);
     if (transient_parent)
       return GetContainer(transient_parent);
     return container_;
   }
 
   aura::Window* container_;
 
   DISALLOW_COPY_AND_ASSIGN(AthenaWindowTreeClient);
 };
 
 class AthenaScreenPositionClient : public aura::client::ScreenPositionClient {
  public:
   AthenaScreenPositionClient() {
   }
   virtual ~AthenaScreenPositionClient() {
   }
 
  private:
   // aura::client::ScreenPositionClient:
   virtual void ConvertPointToScreen(const aura::Window* window,
-                                    gfx::Point* point) OVERRIDE {
+                                    gfx::Point* point) override {
     const aura::Window* root = window->GetRootWindow();
     aura::Window::ConvertPointToTarget(window, root, point);
   }
 
   virtual void ConvertPointFromScreen(const aura::Window* window,
-                                      gfx::Point* point) OVERRIDE {
+                                      gfx::Point* point) override {
     const aura::Window* root = window->GetRootWindow();
     aura::Window::ConvertPointToTarget(root, window, point);
   }
 
   virtual void ConvertHostPointToScreen(aura::Window* window,
-                                        gfx::Point* point) OVERRIDE {
+                                        gfx::Point* point) override {
     // TODO(oshima): Implement this when adding multiple display support.
     NOTREACHED();
   }
 
   virtual void SetBounds(aura::Window* window,
                          const gfx::Rect& bounds,
-                         const gfx::Display& display) OVERRIDE {
+                         const gfx::Display& display) override {
     window->SetBounds(bounds);
   }
 
   DISALLOW_COPY_AND_ASSIGN(AthenaScreenPositionClient);
 };
 
 class AthenaEventTargeter : public aura::WindowTargeter,
                             public aura::WindowObserver {
  public:
   explicit AthenaEventTargeter(aura::Window* container)
       : container_(container) {
     container_->AddObserver(this);
   }
 
   virtual ~AthenaEventTargeter() {
     // Removed before the container is removed.
     if (container_)
       container_->RemoveObserver(this);
   }
 
  private:
   // aura::WindowTargeter:
   virtual bool SubtreeCanAcceptEvent(
       ui::EventTarget* target,
-      const ui::LocatedEvent& event) const OVERRIDE {
+      const ui::LocatedEvent& event) const override {
     aura::Window* window = static_cast<aura::Window*>(target);
     const aura::Window::Windows& containers =
         container_->GetRootWindow()->children();
     aura::Window::Windows::const_iterator iter =
         std::find(containers.begin(), containers.end(), container_);
     DCHECK(iter != containers.end());
     for (; iter != containers.end(); ++iter) {
       if ((*iter)->Contains(window))
         return true;
     }
     return false;
   }
 
   // aura::WindowObserver:
-  virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
+  virtual void OnWindowDestroying(aura::Window* window) override {
     aura::Window* root_window = container_->GetRootWindow();
     DCHECK_EQ(window, container_);
     DCHECK_EQ(
         this, static_cast<ui::EventTarget*>(root_window)->GetEventTargeter());
 
     container_->RemoveObserver(this);
     container_ = NULL;
 
     // This will remove myself.
     root_window->SetEventTargeter(scoped_ptr<ui::EventTargeter>());
   }
 
   aura::Window* container_;
 
   DISALLOW_COPY_AND_ASSIGN(AthenaEventTargeter);
 };
 
 class ScreenManagerImpl : public ScreenManager {
  public:
   explicit ScreenManagerImpl(aura::Window* root_window);
   virtual ~ScreenManagerImpl();
 
   void Init();
 
  private:
   // ScreenManager:
   virtual aura::Window* CreateDefaultContainer(
-      const ContainerParams& params) OVERRIDE;
-  virtual aura::Window* CreateContainer(const ContainerParams& params) OVERRIDE;
-  virtual aura::Window* GetContext() OVERRIDE { return root_window_; }
-  virtual void SetRotation(gfx::Display::Rotation rotation) OVERRIDE;
-  virtual void SetRotationLocked(bool rotation_locked) OVERRIDE;
+      const ContainerParams& params) override;
+  virtual aura::Window* CreateContainer(const ContainerParams& params) override;
+  virtual aura::Window* GetContext() override { return root_window_; }
+  virtual void SetRotation(gfx::Display::Rotation rotation) override;
+  virtual void SetRotationLocked(bool rotation_locked) override;
 
   // Not owned.
   aura::Window* root_window_;
 
   scoped_ptr<aura::client::FocusClient> focus_client_;
   scoped_ptr<aura::client::WindowTreeClient> window_tree_client_;
   scoped_ptr<AcceleratorHandler> accelerator_handler_;
   scoped_ptr< ::wm::ScopedCaptureClient> capture_client_;
   scoped_ptr<aura::client::ScreenPositionClient> screen_position_client_;
 
@@ skipping 166 matching lines @@
 }
 
 // static
 void ScreenManager::Shutdown() {
   DCHECK(instance);
   delete instance;
   DCHECK(!instance);
 }
 
 }  // namespace athena