Standardize usage of virtual/override/final specifiers.

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 <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 31 matching lines @@
 #include "ui/display/types/display_snapshot.h"
 #endif
 
 namespace extensions {
 namespace {
 
 // A simple layout manager that makes each new window fill its parent.
 class FillLayout : public aura::LayoutManager {
  public:
   FillLayout() {}
-  virtual ~FillLayout() {}
+  ~FillLayout() override {}
 
  private:
   // aura::LayoutManager:
-  virtual void OnWindowResized() override {}
+  void OnWindowResized() override {}
 
-  virtual void OnWindowAddedToLayout(aura::Window* child) override {
+  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 {}
+  void OnWillRemoveWindowFromLayout(aura::Window* child) override {}
 
-  virtual void OnWindowRemovedFromLayout(aura::Window* child) override {}
+  void OnWindowRemovedFromLayout(aura::Window* child) override {}
 
-  virtual void OnChildWindowVisibilityChanged(aura::Window* child,
-                                              bool visible) override {}
+  void OnChildWindowVisibilityChanged(aura::Window* child,
+                                      bool visible) override {}
 
-  virtual void SetChildBounds(aura::Window* child,
-                              const gfx::Rect& requested_bounds) override {
+  void SetChildBounds(aura::Window* child,
+                      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() {}
+  ~ShellNativeCursorManager() override {}
 
   // wm::NativeCursorManager overrides.
-  virtual void SetDisplay(const gfx::Display& display,
-                          wm::NativeCursorManagerDelegate* delegate) override {
+  void SetDisplay(const gfx::Display& display,
+                  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 {
+  void SetCursor(gfx::NativeCursor cursor,
+                 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 {
+  void SetVisibility(bool visible,
+                     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 {
+  void SetCursorSet(ui::CursorSetType cursor_set,
+                    wm::NativeCursorManagerDelegate* delegate) override {
     image_cursors_->SetCursorSet(cursor_set);
     delegate->CommitCursorSet(cursor_set);
     if (delegate->IsCursorVisible())
       SetCursor(delegate->GetCursor(), delegate);
   }
 
-  virtual void SetMouseEventsEnabled(
+  void SetMouseEventsEnabled(
       bool enabled,
       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() {}
+  ~AppsFocusRules() override {}
 
-  virtual bool SupportsChildActivation(aura::Window* window) const override {
+  bool SupportsChildActivation(aura::Window* window) const override {
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AppsFocusRules);
 };
 
 }  // namespace
 
 ShellDesktopController::ShellDesktopController()
@@ skipping 190 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