Standardize usage of virtual/override/final specifiers.

content/browser/web_contents/web_contents_view_aura.cc

 // Copyright (c) 2012 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 "content/browser/web_contents/web_contents_view_aura.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/metrics/histogram.h"
@@ skipping 126 matching lines @@
       std::vector<gfx::ImagePNGRep> image_reps;
       image_reps.push_back(gfx::ImagePNGRep(entry->screenshot(), 1.0f));
       image = gfx::Image(image_reps);
     }
     SetImage(image);
   }
 
   void stop_forwarding_events() { forward_events_ = false; }
 
  private:
-  virtual ~OverscrollWindowDelegate() {}
+  ~OverscrollWindowDelegate() override {}
 
   aura::Window* web_contents_window() {
     return web_contents_->GetView()->GetContentNativeView();
   }
 
   // Overridden from ui::EventHandler.
-  virtual void OnScrollEvent(ui::ScrollEvent* event) override {
+  void OnScrollEvent(ui::ScrollEvent* event) override {
     if (forward_events_ && web_contents_window())
       web_contents_window()->delegate()->OnScrollEvent(event);
   }
 
-  virtual void OnGestureEvent(ui::GestureEvent* event) override {
+  void OnGestureEvent(ui::GestureEvent* event) override {
     if (forward_events_ && web_contents_window())
       web_contents_window()->delegate()->OnGestureEvent(event);
   }
 
   WebContentsImpl* web_contents_;
 
   // The window is displayed both during the gesture, and after the gesture
   // while the navigation is in progress. During the gesture, it is necessary to
   // forward input events to the content page (e.g. when the overscroll window
   // slides under the cursor and starts receiving scroll events). However, once
   // the gesture is complete, and the window is being displayed as an overlay
   // window during navigation, events should not be forwarded anymore.
   bool forward_events_;
 
   DISALLOW_COPY_AND_ASSIGN(OverscrollWindowDelegate);
 };
 
 // Listens to all mouse drag events during a drag and drop and sends them to
 // the renderer.
 class WebDragSourceAura : public NotificationObserver {
  public:
   WebDragSourceAura(aura::Window* window, WebContentsImpl* contents)
       : window_(window),
         contents_(contents) {
     registrar_.Add(this,
                    NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
                    Source<WebContents>(contents));
   }
 
-  virtual ~WebDragSourceAura() {
-  }
+  ~WebDragSourceAura() override {}
 
   // NotificationObserver:
-  virtual void Observe(int type,
-      const NotificationSource& source,
-      const NotificationDetails& details) override {
+  void Observe(int type,
+               const NotificationSource& source,
+               const NotificationDetails& details) override {
     if (type != NOTIFICATION_WEB_CONTENTS_DISCONNECTED)
       return;
 
     // Cancel the drag if it is still in progress.
     aura::client::DragDropClient* dnd_client =
         aura::client::GetDragDropClient(window_->GetRootWindow());
     if (dnd_client && dnd_client->IsDragDropInProgress())
       dnd_client->DragCancel();
 
     window_ = NULL;
@@ skipping 266 matching lines @@
       : view_(view),
         host_window_(NULL) {
     view_->window_->AddObserver(this);
 
 #if defined(OS_WIN)
     if (view_->window_->GetRootWindow())
       view_->window_->GetRootWindow()->AddObserver(this);
 #endif
   }
 
-  virtual ~WindowObserver() {
+  ~WindowObserver() override {
     view_->window_->RemoveObserver(this);
     if (view_->window_->GetHost())
       view_->window_->GetHost()->RemoveObserver(this);
     if (host_window_)
       host_window_->RemoveObserver(this);
 #if defined(OS_WIN)
     if (host_window_) {
       const aura::Window::Windows& children = host_window_->children();
       for (size_t i = 0; i < children.size(); ++i)
         children[i]->RemoveObserver(this);
     }
 
     aura::Window* root_window = view_->window_->GetRootWindow();
     if (root_window) {
       root_window->RemoveObserver(this);
       const aura::Window::Windows& root_children = root_window->children();
       for (size_t i = 0; i < root_children.size(); ++i)
         root_children[i]->RemoveObserver(this);
     }
 #endif
   }
 
   // Overridden from aura::WindowObserver:
-  virtual void OnWindowHierarchyChanged(
+  void OnWindowHierarchyChanged(
       const aura::WindowObserver::HierarchyChangeParams& params) override {
     if (params.receiver != view_->window_.get() ||
         !params.target->Contains(view_->window_.get())) {
       return;
     }
 
     // Use the new parent's root window for calculating HiDPI subpixel offset.
     RenderWidgetHostViewAura* rwhv = ToRenderWidgetHostViewAura(
         view_->web_contents_->GetRenderWidgetHostView());
     if (rwhv)
@@ skipping 36 matching lines @@
   virtual void OnWindowVisibilityChanged(aura::Window* window,
                                          bool visible) override {
     if (window == view_->window_ ||
         window->parent() == host_window_ ||
         window->parent() == view_->window_->GetRootWindow()) {
       UpdateConstrainedWindows(NULL);
     }
   }
 #endif
 
-  virtual void OnWindowParentChanged(aura::Window* window,
-                                     aura::Window* parent) override {
+  void OnWindowParentChanged(aura::Window* window,
+                             aura::Window* parent) override {
     if (window != view_->window_)
       return;
 
     aura::Window* host_window =
         window->GetProperty(aura::client::kHostWindowKey);
     if (!host_window)
       host_window = parent;
 
     if (host_window_)
       host_window_->RemoveObserver(this);
@@ skipping 33 matching lines @@
         const aura::Window::Windows& children = host_window->children();
         for (size_t i = 0; i < children.size(); ++i) {
           if (!children[i]->Contains(view_->window_.get()))
             children[i]->AddObserver(this);
         }
       }
 #endif
     }
   }
 
-  virtual void OnWindowBoundsChanged(aura::Window* window,
-                                     const gfx::Rect& old_bounds,
-                                     const gfx::Rect& new_bounds) override {
+  void OnWindowBoundsChanged(aura::Window* window,
+                             const gfx::Rect& old_bounds,
+                             const gfx::Rect& new_bounds) override {
     if (window == host_window_ || window == view_->window_) {
       SendScreenRects();
       if (view_->touch_editable_)
         view_->touch_editable_->UpdateEditingController();
 #if defined(OS_WIN)
     } else {
       UpdateConstrainedWindows(NULL);
 #endif
     }
   }
 
-  virtual void OnWindowDestroying(aura::Window* window) override {
+  void OnWindowDestroying(aura::Window* window) override {
     if (window == host_window_) {
       host_window_->RemoveObserver(this);
       host_window_ = NULL;
     }
   }
 
-  virtual void OnWindowAddedToRootWindow(aura::Window* window) override {
+  void OnWindowAddedToRootWindow(aura::Window* window) override {
     if (window == view_->window_) {
       window->GetHost()->AddObserver(this);
 #if defined(OS_WIN)
       if (!window->GetRootWindow()->HasObserver(this))
         window->GetRootWindow()->AddObserver(this);
 #endif
     }
   }
 
-  virtual void OnWindowRemovingFromRootWindow(aura::Window* window,
-                                              aura::Window* new_root) override {
+  void OnWindowRemovingFromRootWindow(aura::Window* window,
+                                      aura::Window* new_root) override {
     if (window == view_->window_) {
       window->GetHost()->RemoveObserver(this);
 #if defined(OS_WIN)
       window->GetRootWindow()->RemoveObserver(this);
 
       const aura::Window::Windows& root_children =
           window->GetRootWindow()->children();
       for (size_t i = 0; i < root_children.size(); ++i) {
         if (root_children[i] != view_->window_ &&
             root_children[i] != host_window_) {
           root_children[i]->RemoveObserver(this);
         }
       }
 #endif
     }
   }
 
   // Overridden WindowTreeHostObserver:
-  virtual void OnHostMoved(const aura::WindowTreeHost* host,
-                           const gfx::Point& new_origin) override {
+  void OnHostMoved(const aura::WindowTreeHost* host,
+                   const gfx::Point& new_origin) override {
     TRACE_EVENT1("ui",
                  "WebContentsViewAura::WindowObserver::OnHostMoved",
                  "new_origin", new_origin.ToString());
 
     // This is for the desktop case (i.e. Aura desktop).
     SendScreenRects();
   }
 
  private:
   void SendScreenRects() {
@@ skipping 953 matching lines @@
   if (visible) {
     if (!web_contents_->should_normally_be_visible())
       web_contents_->WasShown();
   } else {
     if (web_contents_->should_normally_be_visible())
       web_contents_->WasHidden();
   }
 }
 
 }  // namespace content