replace OVERRIDE and FINAL with override and final in extensions/

extensions/shell/browser/shell_desktop_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 "extensions/shell/browser/shell_desktop_controller.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 34 matching lines @@
 namespace {
 
 // A simple layout manager that makes each new window fill its parent.
 class FillLayout : public aura::LayoutManager {
  public:
   FillLayout() {}
   virtual ~FillLayout() {}
 
  private:
   // aura::LayoutManager:
-  virtual void OnWindowResized() OVERRIDE {}
+  virtual void OnWindowResized() override {}
 
-  virtual void OnWindowAddedToLayout(aura::Window* child) OVERRIDE {
+  virtual void OnWindowAddedToLayout(aura::Window* child) override {
     if (!child->parent())
       return;
 
     // Create a rect at 0,0 with the size of the parent.
     gfx::Size parent_size = child->parent()->bounds().size();
     child->SetBounds(gfx::Rect(parent_size));
   }
 
-  virtual void OnWillRemoveWindowFromLayout(aura::Window* child) OVERRIDE {}
+  virtual void OnWillRemoveWindowFromLayout(aura::Window* child) override {}
 
-  virtual void OnWindowRemovedFromLayout(aura::Window* child) OVERRIDE {}
+  virtual void OnWindowRemovedFromLayout(aura::Window* child) override {}
 
   virtual void OnChildWindowVisibilityChanged(aura::Window* child,
-                                              bool visible) OVERRIDE {}
+                                              bool visible) override {}
 
   virtual void SetChildBounds(aura::Window* child,
-                              const gfx::Rect& requested_bounds) OVERRIDE {
+                              const gfx::Rect& requested_bounds) override {
     SetChildBoundsDirect(child, requested_bounds);
   }
 
   DISALLOW_COPY_AND_ASSIGN(FillLayout);
 };
 
 // A class that bridges the gap between CursorManager and Aura. It borrows
 // heavily from AshNativeCursorManager.
 class ShellNativeCursorManager : public wm::NativeCursorManager {
  public:
   explicit ShellNativeCursorManager(aura::WindowTreeHost* host)
       : host_(host), image_cursors_(new ui::ImageCursors) {}
   virtual ~ShellNativeCursorManager() {}
 
   // 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.
 
   scoped_ptr<ui::ImageCursors> image_cursors_;
 
   DISALLOW_COPY_AND_ASSIGN(ShellNativeCursorManager);
 };
 
 class AppsFocusRules : public wm::BaseFocusRules {
  public:
   AppsFocusRules() {}
   virtual ~AppsFocusRules() {}
 
-  virtual bool SupportsChildActivation(aura::Window* window) const OVERRIDE {
+  virtual bool SupportsChildActivation(aura::Window* window) const override {
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AppsFocusRules);
 };
 
 }  // namespace
 
 ShellDesktopController::ShellDesktopController()
@@ skipping 180 matching lines @@
   if (displays.empty())
     return gfx::Size();
   const ui::DisplayMode* mode = displays[0].display->current_mode();
   return mode ? mode->size() : gfx::Size();
 #else
   return gfx::Size();
 #endif
 }
 
 }  // namespace extensions