replace OVERRIDE and FINAL with override and final in athena/

athena/env/athena_env_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/env/public/athena_env.h"
 
 #include <vector>
 
 #include "athena/util/fill_layout_manager.h"
 #include "base/sys_info.h"
@@ skipping 38 matching lines @@
     screen_for_shutdown = new ScreenForShutdown(screen->GetPrimaryDisplay());
     gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE,
                                    screen_for_shutdown);
   }
 
  private:
   explicit ScreenForShutdown(const gfx::Display& primary_display)
       : primary_display_(primary_display) {}
 
   // gfx::Screen overrides:
-  virtual bool IsDIPEnabled() OVERRIDE { return true; }
-  virtual gfx::Point GetCursorScreenPoint() OVERRIDE { return gfx::Point(); }
-  virtual gfx::NativeWindow GetWindowUnderCursor() OVERRIDE { return NULL; }
+  virtual bool IsDIPEnabled() override { return true; }
+  virtual gfx::Point GetCursorScreenPoint() override { return gfx::Point(); }
+  virtual gfx::NativeWindow GetWindowUnderCursor() override { return NULL; }
   virtual gfx::NativeWindow GetWindowAtScreenPoint(
-      const gfx::Point& point) OVERRIDE {
+      const gfx::Point& point) override {
     return NULL;
   }
-  virtual int GetNumDisplays() const OVERRIDE { return 1; }
-  virtual std::vector<gfx::Display> GetAllDisplays() const OVERRIDE {
+  virtual int GetNumDisplays() const override { return 1; }
+  virtual std::vector<gfx::Display> GetAllDisplays() const override {
     std::vector<gfx::Display> displays(1, primary_display_);
     return displays;
   }
   virtual gfx::Display GetDisplayNearestWindow(
-      gfx::NativeView view) const OVERRIDE {
+      gfx::NativeView view) const override {
     return primary_display_;
   }
   virtual gfx::Display GetDisplayNearestPoint(
-      const gfx::Point& point) const OVERRIDE {
+      const gfx::Point& point) const override {
     return primary_display_;
   }
   virtual gfx::Display GetDisplayMatching(
-      const gfx::Rect& match_rect) const OVERRIDE {
+      const gfx::Rect& match_rect) const override {
     return primary_display_;
   }
-  virtual gfx::Display GetPrimaryDisplay() const OVERRIDE {
+  virtual gfx::Display GetPrimaryDisplay() const override {
     return primary_display_;
   }
-  virtual void AddObserver(gfx::DisplayObserver* observer) OVERRIDE {
+  virtual void AddObserver(gfx::DisplayObserver* observer) override {
     NOTREACHED() << "Observer should not be added during shutdown";
   }
-  virtual void RemoveObserver(gfx::DisplayObserver* observer) OVERRIDE {}
+  virtual void RemoveObserver(gfx::DisplayObserver* observer) override {}
 
   const gfx::Display primary_display_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenForShutdown);
 };
 
 // A class that bridges the gap between CursorManager and Aura. It borrows
 // heavily from AshNativeCursorManager.
 class AthenaNativeCursorManager : public wm::NativeCursorManager {
  public:
   explicit AthenaNativeCursorManager(aura::WindowTreeHost* host)
       : host_(host), image_cursors_(new ui::ImageCursors) {}
   virtual ~AthenaNativeCursorManager() {}
 
   // wm::NativeCursorManager overrides.
   virtual void SetDisplay(const gfx::Display& display,
-                          wm::NativeCursorManagerDelegate* delegate) OVERRIDE {
+                          wm::NativeCursorManagerDelegate* delegate) override {
     if (image_cursors_->SetDisplay(display, display.device_scale_factor()))
       SetCursor(delegate->GetCursor(), delegate);
   }
 
   virtual void SetCursor(gfx::NativeCursor cursor,
-                         wm::NativeCursorManagerDelegate* delegate) OVERRIDE {
+                         wm::NativeCursorManagerDelegate* delegate) override {
     image_cursors_->SetPlatformCursor(&cursor);
     cursor.set_device_scale_factor(image_cursors_->GetScale());
     delegate->CommitCursor(cursor);
 
     if (delegate->IsCursorVisible())
       ApplyCursor(cursor);
   }
 
   virtual void SetVisibility(
       bool visible,
-      wm::NativeCursorManagerDelegate* delegate) OVERRIDE {
+      wm::NativeCursorManagerDelegate* delegate) override {
     delegate->CommitVisibility(visible);
 
     if (visible) {
       SetCursor(delegate->GetCursor(), delegate);
     } else {
       gfx::NativeCursor invisible_cursor(ui::kCursorNone);
       image_cursors_->SetPlatformCursor(&invisible_cursor);
       ApplyCursor(invisible_cursor);
     }
   }
 
   virtual void SetCursorSet(
       ui::CursorSetType cursor_set,
-      wm::NativeCursorManagerDelegate* delegate) OVERRIDE {
+      wm::NativeCursorManagerDelegate* delegate) override {
     image_cursors_->SetCursorSet(cursor_set);
     delegate->CommitCursorSet(cursor_set);
     if (delegate->IsCursorVisible())
       SetCursor(delegate->GetCursor(), delegate);
   }
 
   virtual void SetMouseEventsEnabled(
       bool enabled,
-      wm::NativeCursorManagerDelegate* delegate) OVERRIDE {
+      wm::NativeCursorManagerDelegate* delegate) override {
     delegate->CommitMouseEventsEnabled(enabled);
     SetVisibility(delegate->IsCursorVisible(), delegate);
   }
 
  private:
   // Sets |cursor| as the active cursor within Aura.
   void ApplyCursor(gfx::NativeCursor cursor) { host_->SetCursor(cursor); }
 
   aura::WindowTreeHost* host_;  // Not owned.
 
@@ skipping 96 matching lines @@
  private:
   struct Finder {
     explicit Finder(const base::Closure& c) : closure(c) {}
     bool operator()(const base::Closure& other) {
       return closure.Equals(other);
     }
     base::Closure closure;
   };
 
   // AthenaEnv:
-  virtual aura::WindowTreeHost* GetHost() OVERRIDE { return host_.get(); }
+  virtual aura::WindowTreeHost* GetHost() override { return host_.get(); }
 
-  virtual void SetDisplayWorkAreaInsets(const gfx::Insets& insets) OVERRIDE {
+  virtual void SetDisplayWorkAreaInsets(const gfx::Insets& insets) override {
     screen_->SetWorkAreaInsets(insets);
   }
 
-  virtual void AddTerminatingCallback(const base::Closure& closure) OVERRIDE {
+  virtual void AddTerminatingCallback(const base::Closure& closure) override {
     if (closure.is_null())
       return;
     DCHECK(terminating_callbacks_.end() ==
            std::find_if(terminating_callbacks_.begin(),
                         terminating_callbacks_.end(),
                         Finder(closure)));
     terminating_callbacks_.push_back(closure);
   }
 
   virtual void RemoveTerminatingCallback(
-      const base::Closure& closure) OVERRIDE {
+      const base::Closure& closure) override {
     std::vector<base::Closure>::iterator iter =
         std::find_if(terminating_callbacks_.begin(),
                      terminating_callbacks_.end(),
                      Finder(closure));
     if (iter != terminating_callbacks_.end())
       terminating_callbacks_.erase(iter);
   }
 
-  virtual void OnTerminating() OVERRIDE {
+  virtual void OnTerminating() override {
     for (std::vector<base::Closure>::iterator iter =
              terminating_callbacks_.begin();
          iter != terminating_callbacks_.end();
          ++iter) {
       iter->Run();
     }
   }
 
   // ui::DisplayConfigurator::Observer:
   virtual void OnDisplayModeChanged(const std::vector<
-      ui::DisplayConfigurator::DisplayState>& displays) OVERRIDE {
+      ui::DisplayConfigurator::DisplayState>& displays) override {
     gfx::Size size = GetPrimaryDisplaySize();
     if (!size.IsEmpty())
       host_->UpdateRootWindowSize(size);
   }
 
   // aura::WindowTreeHostObserver:
-  virtual void OnHostCloseRequested(const aura::WindowTreeHost* host) OVERRIDE {
+  virtual void OnHostCloseRequested(const aura::WindowTreeHost* host) override {
     base::MessageLoopForUI::current()->PostTask(
         FROM_HERE, base::MessageLoop::QuitClosure());
   }
 
   gfx::Size GetPrimaryDisplaySize() const {
     const std::vector<ui::DisplayConfigurator::DisplayState>& displays =
         display_configurator_->cached_displays();
     if (displays.empty())
       return gfx::Size();
     const ui::DisplayMode* mode = displays[0].display->current_mode();
@@ skipping 31 matching lines @@
 
 // static
 
 // static
 void AthenaEnv::Shutdown() {
   DCHECK(instance);
   delete instance;
 }
 
 }  // namespace athena