replace OVERRIDE and FINAL with override and final in ui/

ui/aura/window_unittest.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 "ui/aura/window.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 37 matching lines @@
 DECLARE_WINDOW_PROPERTY_TYPE(int)
 
 namespace aura {
 namespace test {
 
 class WindowTest : public AuraTestBase {
  public:
   WindowTest() : max_separation_(0) {
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     AuraTestBase::SetUp();
     // TODO: there needs to be an easier way to do this.
     max_separation_ = ui::GestureConfiguration::
         max_separation_for_gesture_touches_in_pixels();
     ui::GestureConfiguration::
         set_max_separation_for_gesture_touches_in_pixels(0);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     AuraTestBase::TearDown();
     ui::GestureConfiguration::
         set_max_separation_for_gesture_touches_in_pixels(max_separation_);
   }
 
  private:
   int max_separation_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTest);
 };
 
 namespace {
 
 // Used for verifying destruction methods are invoked.
 class DestroyTrackingDelegateImpl : public TestWindowDelegate {
  public:
   DestroyTrackingDelegateImpl()
       : destroying_count_(0),
         destroyed_count_(0),
         in_destroying_(false) {}
 
   void clear_destroying_count() { destroying_count_ = 0; }
   int destroying_count() const { return destroying_count_; }
 
   void clear_destroyed_count() { destroyed_count_ = 0; }
   int destroyed_count() const { return destroyed_count_; }
 
   bool in_destroying() const { return in_destroying_; }
 
-  virtual void OnWindowDestroying(Window* window) OVERRIDE {
+  virtual void OnWindowDestroying(Window* window) override {
     EXPECT_FALSE(in_destroying_);
     in_destroying_ = true;
     destroying_count_++;
   }
 
-  virtual void OnWindowDestroyed(Window* window) OVERRIDE {
+  virtual void OnWindowDestroyed(Window* window) override {
     EXPECT_TRUE(in_destroying_);
     in_destroying_ = false;
     destroyed_count_++;
   }
 
  private:
   int destroying_count_;
   int destroyed_count_;
   bool in_destroying_;
 
   DISALLOW_COPY_AND_ASSIGN(DestroyTrackingDelegateImpl);
 };
 
 // Used to verify that when OnWindowDestroying is invoked the parent is also
 // is in the process of being destroyed.
 class ChildWindowDelegateImpl : public DestroyTrackingDelegateImpl {
  public:
   explicit ChildWindowDelegateImpl(
       DestroyTrackingDelegateImpl* parent_delegate)
       : parent_delegate_(parent_delegate) {
   }
 
-  virtual void OnWindowDestroying(Window* window) OVERRIDE {
+  virtual void OnWindowDestroying(Window* window) override {
     EXPECT_TRUE(parent_delegate_->in_destroying());
     DestroyTrackingDelegateImpl::OnWindowDestroying(window);
   }
 
  private:
   DestroyTrackingDelegateImpl* parent_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(ChildWindowDelegateImpl);
 };
 
 // Used to verify that a Window is removed from its parent when
 // OnWindowDestroyed is called.
 class DestroyOrphanDelegate : public TestWindowDelegate {
  public:
   DestroyOrphanDelegate() : window_(NULL) {
   }
 
   void set_window(Window* window) { window_ = window; }
 
-  virtual void OnWindowDestroyed(Window* window) OVERRIDE {
+  virtual void OnWindowDestroyed(Window* window) override {
     EXPECT_FALSE(window_->parent());
   }
 
  private:
   Window* window_;
   DISALLOW_COPY_AND_ASSIGN(DestroyOrphanDelegate);
 };
 
 // Used in verifying mouse capture.
 class CaptureWindowDelegateImpl : public TestWindowDelegate {
@@ skipping 11 matching lines @@
   }
 
   int capture_changed_event_count() const {
     return capture_changed_event_count_;
   }
   int capture_lost_count() const { return capture_lost_count_; }
   int mouse_event_count() const { return mouse_event_count_; }
   int touch_event_count() const { return touch_event_count_; }
   int gesture_event_count() const { return gesture_event_count_; }
 
-  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) override {
     if (event->type() == ui::ET_MOUSE_CAPTURE_CHANGED)
       capture_changed_event_count_++;
     mouse_event_count_++;
   }
-  virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
+  virtual void OnTouchEvent(ui::TouchEvent* event) override {
     touch_event_count_++;
   }
-  virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
+  virtual void OnGestureEvent(ui::GestureEvent* event) override {
     gesture_event_count_++;
   }
-  virtual void OnCaptureLost() OVERRIDE {
+  virtual void OnCaptureLost() override {
     capture_lost_count_++;
   }
 
  private:
   int capture_changed_event_count_;
   int capture_lost_count_;
   int mouse_event_count_;
   int touch_event_count_;
   int gesture_event_count_;
 
   DISALLOW_COPY_AND_ASSIGN(CaptureWindowDelegateImpl);
 };
 
 // Keeps track of the location of the gesture.
 class GestureTrackPositionDelegate : public TestWindowDelegate {
  public:
   GestureTrackPositionDelegate() {}
 
-  virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
+  virtual void OnGestureEvent(ui::GestureEvent* event) override {
     position_ = event->location();
     event->StopPropagation();
   }
 
   const gfx::Point& position() const { return position_; }
 
  private:
   gfx::Point position_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureTrackPositionDelegate);
 };
 
 base::TimeDelta getTime() {
   return ui::EventTimeForNow();
 }
 
 class SelfEventHandlingWindowDelegate : public TestWindowDelegate {
  public:
   SelfEventHandlingWindowDelegate() {}
 
   virtual bool ShouldDescendIntoChildForEventHandling(
       Window* child,
-      const gfx::Point& location) OVERRIDE {
+      const gfx::Point& location) override {
     return false;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SelfEventHandlingWindowDelegate);
 };
 
 // The delegate deletes itself when the window is being destroyed.
 class DestroyWindowDelegate : public TestWindowDelegate {
  public:
   DestroyWindowDelegate() {}
 
  private:
   virtual ~DestroyWindowDelegate() {}
 
   // Overridden from WindowDelegate.
-  virtual void OnWindowDestroyed(Window* window) OVERRIDE {
+  virtual void OnWindowDestroyed(Window* window) override {
     delete this;
   }
 
   DISALLOW_COPY_AND_ASSIGN(DestroyWindowDelegate);
 };
 
 }  // namespace
 
 TEST_F(WindowTest, GetChildById) {
   scoped_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
@@ skipping 310 matching lines @@
   EXPECT_TRUE(w1->GetToplevelWindow() == NULL);
   EXPECT_EQ(w11.get(), w11->GetToplevelWindow());
   EXPECT_EQ(w11.get(), w111->GetToplevelWindow());
   EXPECT_EQ(w11.get(), w1111->GetToplevelWindow());
 }
 
 class AddedToRootWindowObserver : public WindowObserver {
  public:
   AddedToRootWindowObserver() : called_(false) {}
 
-  virtual void OnWindowAddedToRootWindow(Window* window) OVERRIDE {
+  virtual void OnWindowAddedToRootWindow(Window* window) override {
     called_ = true;
   }
 
   bool called() const { return called_; }
 
  private:
   bool called_;
 
   DISALLOW_COPY_AND_ASSIGN(AddedToRootWindowObserver);
 };
@@ skipping 490 matching lines @@
   // The |child| window is moved to the 0,0 in screen coordinates.
   // |GetBoundsInRootWindow()| should return 0,0.
   child->SetBounds(gfx::Rect(100, 100, 100, 100));
   EXPECT_EQ("0,0 100x100", child->GetBoundsInRootWindow().ToString());
 }
 
 class MouseEnterExitWindowDelegate : public TestWindowDelegate {
  public:
   MouseEnterExitWindowDelegate() : entered_(false), exited_(false) {}
 
-  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) override {
     switch (event->type()) {
       case ui::ET_MOUSE_ENTERED:
         EXPECT_TRUE(event->flags() & ui::EF_IS_SYNTHESIZED);
         entered_ = true;
         break;
       case ui::ET_MOUSE_EXITED:
         EXPECT_TRUE(event->flags() & ui::EF_IS_SYNTHESIZED);
         exited_ = true;
         break;
       default:
@@ skipping 264 matching lines @@
         hidden_(0) {
   }
 
   int shown() const { return shown_; }
   int hidden() const { return hidden_; }
   void Clear() {
     shown_ = 0;
     hidden_ = 0;
   }
 
-  virtual void OnWindowTargetVisibilityChanged(bool visible) OVERRIDE {
+  virtual void OnWindowTargetVisibilityChanged(bool visible) override {
     if (visible)
       shown_++;
     else
       hidden_++;
   }
 
  private:
   int shown_;
   int hidden_;
 
@@ skipping 328 matching lines @@
             transform_notifications_.begin();
         it != transform_notifications_.end();
         ++it) {
       base::StringAppendF(&result, "(%d,%d)", it->first, it->second);
     }
     transform_notifications_.clear();
     return result;
   }
 
  private:
-  virtual void OnWindowAdded(Window* new_window) OVERRIDE {
+  virtual void OnWindowAdded(Window* new_window) override {
     added_count_++;
   }
 
-  virtual void OnWillRemoveWindow(Window* window) OVERRIDE {
+  virtual void OnWillRemoveWindow(Window* window) override {
     removed_count_++;
   }
 
   virtual void OnWindowVisibilityChanged(Window* window,
-                                         bool visible) OVERRIDE {
+                                         bool visible) override {
     if (!visibility_info_) {
       visibility_info_.reset(new VisibilityInfo);
       visibility_info_->changed_count = 0;
     }
     visibility_info_->window_visible = window->IsVisible();
     visibility_info_->visible_param = visible;
     visibility_info_->changed_count++;
   }
 
-  virtual void OnWindowDestroyed(Window* window) OVERRIDE {
+  virtual void OnWindowDestroyed(Window* window) override {
     EXPECT_FALSE(window->parent());
     destroyed_count_++;
   }
 
   virtual void OnWindowPropertyChanged(Window* window,
                                        const void* key,
-                                       intptr_t old) OVERRIDE {
+                                       intptr_t old) override {
     property_key_ = key;
     old_property_value_ = old;
   }
 
   virtual void OnAncestorWindowTransformed(Window* source,
-                                           Window* window) OVERRIDE {
+                                           Window* window) override {
     transform_notifications_.push_back(
         std::make_pair(source->id(), window->id()));
   }
 
   int added_count_;
   int removed_count_;
   int destroyed_count_;
   scoped_ptr<VisibilityInfo> visibility_info_;
   const void* property_key_;
   intptr_t old_property_value_;
@@ skipping 269 matching lines @@
   }
   virtual ~TestVisibilityClient() {
   }
 
   void set_ignore_visibility_changes(bool ignore_visibility_changes) {
     ignore_visibility_changes_ = ignore_visibility_changes;
   }
 
   // Overridden from client::VisibilityClient:
   virtual void UpdateLayerVisibility(aura::Window* window,
-                                     bool visible) OVERRIDE {
+                                     bool visible) override {
     if (!ignore_visibility_changes_)
       window->layer()->SetVisible(visible);
   }
 
  private:
   bool ignore_visibility_changes_;
   DISALLOW_COPY_AND_ASSIGN(TestVisibilityClient);
 };
 
 TEST_F(WindowTest, VisibilityClientIsVisible) {
@@ skipping 115 matching lines @@
 
   int added_count() const { return added_count_; }
   int removed_count() const { return removed_count_; }
 
   void Clear() {
     added_count_ = 0;
     removed_count_ = 0;
   }
 
   // Overridden from WindowObserver:
-  virtual void OnWindowAddedToRootWindow(Window* window) OVERRIDE {
+  virtual void OnWindowAddedToRootWindow(Window* window) override {
     ++added_count_;
   }
   virtual void OnWindowRemovingFromRootWindow(Window* window,
-                                              Window* new_root) OVERRIDE {
+                                              Window* new_root) override {
     ++removed_count_;
   }
 
  private:
   int added_count_;
   int removed_count_;
 
   DISALLOW_COPY_AND_ASSIGN(RootWindowAttachmentObserver);
 };
 
@@ skipping 61 matching lines @@
   EXPECT_EQ(2, observer.added_count());
   EXPECT_EQ(2, observer.removed_count());
 }
 
 class BoundsChangedWindowObserver : public WindowObserver {
  public:
   BoundsChangedWindowObserver() : root_set_(false) {}
 
   virtual void OnWindowBoundsChanged(Window* window,
                                      const gfx::Rect& old_bounds,
-                                     const gfx::Rect& new_bounds) OVERRIDE {
+                                     const gfx::Rect& new_bounds) override {
     root_set_ = window->GetRootWindow() != NULL;
   }
 
   bool root_set() const { return root_set_; }
 
  private:
   bool root_set_;
 
   DISALLOW_COPY_AND_ASSIGN(BoundsChangedWindowObserver);
 };
@@ skipping 58 matching lines @@
 // Used By DeleteWindowFromOnWindowDestroyed. Destroys a Window from
 // OnWindowDestroyed().
 class OwningWindowDelegate : public TestWindowDelegate {
  public:
   OwningWindowDelegate() {}
 
   void SetOwnedWindow(Window* window) {
     owned_window_.reset(window);
   }
 
-  virtual void OnWindowDestroyed(Window* window) OVERRIDE {
+  virtual void OnWindowDestroyed(Window* window) override {
     owned_window_.reset(NULL);
   }
 
  private:
   scoped_ptr<Window> owned_window_;
 
   DISALLOW_COPY_AND_ASSIGN(OwningWindowDelegate);
 };
 
 }  // namespace
@@ skipping 25 matching lines @@
  public:
   BoundsChangeDelegate() : bounds_changed_(false) {}
 
   void clear_bounds_changed() { bounds_changed_ = false; }
   bool bounds_changed() const {
     return bounds_changed_;
   }
 
   // Window
   virtual void OnBoundsChanged(const gfx::Rect& old_bounds,
-                               const gfx::Rect& new_bounds) OVERRIDE {
+                               const gfx::Rect& new_bounds) override {
     bounds_changed_ = true;
   }
 
  private:
   // Was OnBoundsChanged() invoked?
   bool bounds_changed_;
 
   DISALLOW_COPY_AND_ASSIGN(BoundsChangeDelegate);
 };
 
@@ skipping 87 matching lines @@
   AddChildNotificationsObserver() : added_count_(0), removed_count_(0) {}
 
   std::string CountStringAndReset() {
     std::string result = base::IntToString(added_count_) + " " +
         base::IntToString(removed_count_);
     added_count_ = removed_count_ = 0;
     return result;
   }
 
   // WindowObserver overrides:
-  virtual void OnWindowAddedToRootWindow(Window* window) OVERRIDE {
+  virtual void OnWindowAddedToRootWindow(Window* window) override {
     added_count_++;
   }
   virtual void OnWindowRemovingFromRootWindow(Window* window,
-                                              Window* new_root) OVERRIDE {
+                                              Window* new_root) override {
     removed_count_++;
   }
 
  private:
   int added_count_;
   int removed_count_;
 
   DISALLOW_COPY_AND_ASSIGN(AddChildNotificationsObserver);
 };
 
@@ skipping 41 matching lines @@
     ParamsMatch(params_[index], params);
   }
 
   void Reset() {
     params_.clear();
   }
 
  private:
   // Overridden from WindowObserver:
   virtual void OnWindowHierarchyChanging(
-      const HierarchyChangeParams& params) OVERRIDE {
+      const HierarchyChangeParams& params) override {
     params_.push_back(params);
   }
   virtual void OnWindowHierarchyChanged(
-      const HierarchyChangeParams& params) OVERRIDE {
+      const HierarchyChangeParams& params) override {
     params_.push_back(params);
   }
 
   void ParamsMatch(const WindowObserver::HierarchyChangeParams& p1,
                    const WindowObserver::HierarchyChangeParams& p2) const {
     EXPECT_EQ(p1.phase, p2.phase);
     EXPECT_EQ(p1.target, p2.target);
     EXPECT_EQ(p1.new_parent, p2.new_parent);
     EXPECT_EQ(p1.old_parent, p2.old_parent);
     EXPECT_EQ(p1.receiver, p2.receiver);
@@ skipping 360 matching lines @@
   }
 
   const gfx::Vector2d& most_recent_paint_matrix_offset() const {
     return most_recent_paint_matrix_offset_;
   }
 
   void clear_paint_count() { paint_count_ = 0; }
   int paint_count() const { return paint_count_; }
 
   // TestWindowDelegate::
-  virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE {
+  virtual void OnPaint(gfx::Canvas* canvas) override {
     paint_count_++;
     canvas->GetClipBounds(&most_recent_paint_clip_bounds_);
     const SkMatrix& matrix = canvas->sk_canvas()->getTotalMatrix();
     most_recent_paint_matrix_offset_ = gfx::Vector2d(
         SkScalarFloorToInt(matrix.getTranslateX()),
         SkScalarFloorToInt(matrix.getTranslateY()));
   }
 
  private:
   int paint_count_;
@@ skipping 455 matching lines @@
   bool animation_aborted() const { return animation_aborted_; }
 
   void Reset() {
     animation_completed_ = false;
     animation_aborted_ = false;
   }
 
  private:
   // ui::LayerAnimationObserver:
   virtual void OnLayerAnimationEnded(
-      ui::LayerAnimationSequence* sequence) OVERRIDE {
+      ui::LayerAnimationSequence* sequence) override {
     animation_completed_ = true;
   }
 
   virtual void OnLayerAnimationAborted(
-      ui::LayerAnimationSequence* sequence) OVERRIDE {
+      ui::LayerAnimationSequence* sequence) override {
     animation_aborted_ = true;
   }
 
   virtual void OnLayerAnimationScheduled(
-      ui::LayerAnimationSequence* sequence) OVERRIDE {
+      ui::LayerAnimationSequence* sequence) override {
   }
 
   bool animation_completed_;
   bool animation_aborted_;
 
   DISALLOW_COPY_AND_ASSIGN(TestLayerAnimationObserver);
 };
 
 }
 
@@ skipping 41 matching lines @@
 
   EXPECT_TRUE(animator.get());
   EXPECT_FALSE(animator->is_animating());
   EXPECT_TRUE(observer.animation_completed());
   EXPECT_FALSE(observer.animation_aborted());
   animator->RemoveObserver(&observer);
 }
 
 }  // namespace test
 }  // namespace aura