Replace OVERRIDE and FINAL with override and final in content/browser/web_contents

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 133 matching lines @@
   void stop_forwarding_events() { forward_events_ = false; }
 
  private:
   virtual ~OverscrollWindowDelegate() {}
 
   aura::Window* web_contents_window() {
     return web_contents_->GetView()->GetContentNativeView();
   }
 
   // Overridden from ui::EventHandler.
-  virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE {
+  virtual 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 {
+  virtual 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
@@ skipping 15 matching lines @@
                    NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
                    Source<WebContents>(contents));
   }
 
   virtual ~WebDragSourceAura() {
   }
 
   // NotificationObserver:
   virtual void Observe(int type,
       const NotificationSource& source,
-      const NotificationDetails& details) OVERRIDE {
+      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 291 matching lines @@
       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(
-      const aura::WindowObserver::HierarchyChangeParams& params) OVERRIDE {
+      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)
       rwhv->SnapToPhysicalPixelBoundary();
   }
 
 #if defined(OS_WIN)
   // Constrained windows are added as children of the parent's parent's view
   // which may overlap with windowed NPAPI plugins. In that case, tell the RWHV
   // so that it can update the plugins' cutout rects accordingly.
   // Note: this is hard coding how Chrome layer adds its dialogs. Since NPAPI is
   // going to be deprecated in a year, this is ok for now. The test for this is
   // PrintPreviewTest.WindowedNPAPIPluginHidden.
-  virtual void OnWindowAdded(aura::Window* new_window) OVERRIDE {
+  virtual void OnWindowAdded(aura::Window* new_window) override {
     if (!new_window->Contains(view_->window_.get())) {
       // Skip the case when the parent moves to the root window.
       if (new_window != host_window_) {
         // Observe sibling windows of the WebContents, or children of the root
         // window.
         if (new_window->parent() == host_window_ ||
             new_window->parent() == view_->window_->GetRootWindow()) {
           new_window->AddObserver(this);
         }
       }
     }
 
     if (new_window->parent() == host_window_) {
       UpdateConstrainedWindows(NULL);
     }
   }
 
-  virtual void OnWillRemoveWindow(aura::Window* window) OVERRIDE {
+  virtual void OnWillRemoveWindow(aura::Window* window) override {
     if (window == view_->window_)
       return;
 
     window->RemoveObserver(this);
     UpdateConstrainedWindows(window);
   }
 
   virtual void OnWindowVisibilityChanged(aura::Window* window,
-                                         bool visible) OVERRIDE {
+                                         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 {
+                                     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 35 matching lines @@
           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 {
+                                     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 {
+  virtual void OnWindowDestroying(aura::Window* window) override {
     if (window == host_window_) {
       host_window_->RemoveObserver(this);
       host_window_ = NULL;
     }
   }
 
-  virtual void OnWindowAddedToRootWindow(aura::Window* window) OVERRIDE {
+  virtual 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 {
+                                              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 {
+                           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 947 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