replace OVERRIDE and FINAL with override and final in ui/

ui/views/widget/widget_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 <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 69 matching lines @@
   int last_flags() const {
     return last_flags_;
   }
 
   void set_handle_mode(HandleMode handle_mode) {
     handle_mode_ = handle_mode;
   }
 
  protected:
   // Overridden from View:
-  virtual void OnMouseMoved(const ui::MouseEvent& event) OVERRIDE {
+  virtual void OnMouseMoved(const ui::MouseEvent& event) override {
     // MouseMove events are not re-dispatched from the RootView.
     ++event_count_[ui::ET_MOUSE_MOVED];
     last_flags_ = 0;
   }
 
   // Overridden from ui::EventHandler:
-  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
+  virtual void OnKeyEvent(ui::KeyEvent* event) override {
     RecordEvent(event);
   }
-  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) override {
     RecordEvent(event);
   }
-  virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE {
+  virtual void OnScrollEvent(ui::ScrollEvent* event) override {
     RecordEvent(event);
   }
-  virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
+  virtual void OnGestureEvent(ui::GestureEvent* event) override {
     RecordEvent(event);
   }
 
  private:
   void RecordEvent(ui::Event* event) {
     ++event_count_[event->type()];
     last_flags_ = event->flags();
     if (handle_mode_ == CONSUME_EVENTS)
       event->SetHandled();
   }
 
   std::map<ui::EventType, int> event_count_;
   int last_flags_;
   HandleMode handle_mode_;
 
   DISALLOW_COPY_AND_ASSIGN(EventCountView);
 };
 
 // A view that keeps track of the events it receives, and consumes all scroll
 // gesture events and ui::ET_SCROLL events.
 class ScrollableEventCountView : public EventCountView {
  public:
   ScrollableEventCountView() {}
   virtual ~ScrollableEventCountView() {}
 
  private:
   // Overridden from ui::EventHandler:
-  virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
+  virtual void OnGestureEvent(ui::GestureEvent* event) override {
     EventCountView::OnGestureEvent(event);
     switch (event->type()) {
       case ui::ET_GESTURE_SCROLL_BEGIN:
       case ui::ET_GESTURE_SCROLL_UPDATE:
       case ui::ET_GESTURE_SCROLL_END:
       case ui::ET_SCROLL_FLING_START:
         event->SetHandled();
         break;
       default:
         break;
     }
   }
 
-  virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE {
+  virtual void OnScrollEvent(ui::ScrollEvent* event) override {
     EventCountView::OnScrollEvent(event);
     if (event->type() == ui::ET_SCROLL)
       event->SetHandled();
   }
 
   DISALLOW_COPY_AND_ASSIGN(ScrollableEventCountView);
 };
 
 // A view that implements GetMinimumSize.
 class MinimumSizeFrameView : public NativeFrameView {
  public:
   explicit MinimumSizeFrameView(Widget* frame): NativeFrameView(frame) {}
   virtual ~MinimumSizeFrameView() {}
 
  private:
   // Overridden from View:
-  virtual gfx::Size GetMinimumSize() const OVERRIDE {
+  virtual gfx::Size GetMinimumSize() const override {
     return gfx::Size(300, 400);
   }
 
   DISALLOW_COPY_AND_ASSIGN(MinimumSizeFrameView);
 };
 
 // An event handler that simply keeps a count of the different types of events
 // it receives.
 class EventCountHandler : public ui::EventHandler {
  public:
   EventCountHandler() {}
   virtual ~EventCountHandler() {}
 
   int GetEventCount(ui::EventType type) {
     return event_count_[type];
   }
 
   void ResetCounts() {
     event_count_.clear();
   }
 
  protected:
   // Overridden from ui::EventHandler:
-  virtual void OnEvent(ui::Event* event) OVERRIDE {
+  virtual void OnEvent(ui::Event* event) override {
     RecordEvent(*event);
     ui::EventHandler::OnEvent(event);
   }
 
  private:
   void RecordEvent(const ui::Event& event) {
     ++event_count_[event.type()];
   }
 
   std::map<ui::EventType, int> event_count_;
 
   DISALLOW_COPY_AND_ASSIGN(EventCountHandler);
 };
 
 // Class that closes the widget (which ends up deleting it immediately) when the
 // appropriate event is received.
 class CloseWidgetView : public View {
  public:
   explicit CloseWidgetView(ui::EventType event_type)
       : event_type_(event_type) {
   }
 
   // ui::EventHandler override:
-  virtual void OnEvent(ui::Event* event) OVERRIDE {
+  virtual void OnEvent(ui::Event* event) override {
     if (event->type() == event_type_) {
       // Go through NativeWidgetPrivate to simulate what happens if the OS
       // deletes the NativeWindow out from under us.
       GetWidget()->native_widget_private()->CloseNow();
     } else {
       View::OnEvent(event);
       if (!event->IsTouchEvent())
         event->SetHandled();
     }
   }
@@ skipping 487 matching lines @@
         widget_closed_(NULL),
         widget_activated_(NULL),
         widget_shown_(NULL),
         widget_hidden_(NULL),
         widget_bounds_changed_(NULL) {
   }
 
   virtual ~WidgetObserverTest() {}
 
   // Overridden from WidgetObserver:
-  virtual void OnWidgetDestroying(Widget* widget) OVERRIDE {
+  virtual void OnWidgetDestroying(Widget* widget) override {
     if (active_ == widget)
       active_ = NULL;
     widget_closed_ = widget;
   }
 
   virtual void OnWidgetActivationChanged(Widget* widget,
-                                         bool active) OVERRIDE {
+                                         bool active) override {
     if (active) {
       if (widget_activated_)
         widget_activated_->Deactivate();
       widget_activated_ = widget;
       active_ = widget;
     } else {
       if (widget_activated_ == widget)
         widget_activated_ = NULL;
       widget_deactivated_ = widget;
     }
   }
 
   virtual void OnWidgetVisibilityChanged(Widget* widget,
-                                         bool visible) OVERRIDE {
+                                         bool visible) override {
     if (visible)
       widget_shown_ = widget;
     else
       widget_hidden_ = widget;
   }
 
   virtual void OnWidgetBoundsChanged(Widget* widget,
-                                     const gfx::Rect& new_bounds) OVERRIDE {
+                                     const gfx::Rect& new_bounds) override {
     widget_bounds_changed_ = widget;
   }
 
   void reset() {
     active_ = NULL;
     widget_closed_ = NULL;
     widget_activated_ = NULL;
     widget_deactivated_ = NULL;
     widget_shown_ = NULL;
     widget_hidden_ = NULL;
@@ skipping 294 matching lines @@
   EXPECT_TRUE(contents_view->HasFocus());
 }
 
 class TestBubbleDelegateView : public BubbleDelegateView {
  public:
   TestBubbleDelegateView(View* anchor)
       : BubbleDelegateView(anchor, BubbleBorder::NONE),
         reset_controls_called_(false) {}
   virtual ~TestBubbleDelegateView() {}
 
-  virtual bool ShouldShowCloseButton() const OVERRIDE {
+  virtual bool ShouldShowCloseButton() const override {
     reset_controls_called_ = true;
     return true;
   }
 
   mutable bool reset_controls_called_;
 };
 
 TEST_F(WidgetTest, BubbleControlsResetOnInit) {
   Widget* anchor = CreateTopLevelPlatformWidget();
   anchor->Show();
@@ skipping 37 matching lines @@
 class DesktopAuraTestValidPaintWidget : public views::Widget {
  public:
   DesktopAuraTestValidPaintWidget()
     : expect_paint_(true),
       received_paint_while_hidden_(false) {
   }
 
   virtual ~DesktopAuraTestValidPaintWidget() {
   }
 
-  virtual void Show() OVERRIDE {
+  virtual void Show() override {
     expect_paint_ = true;
     views::Widget::Show();
   }
 
-  virtual void Close() OVERRIDE {
+  virtual void Close() override {
     expect_paint_ = false;
     views::Widget::Close();
   }
 
   void Hide() {
     expect_paint_ = false;
     views::Widget::Hide();
   }
 
-  virtual void OnNativeWidgetPaint(gfx::Canvas* canvas) OVERRIDE {
+  virtual void OnNativeWidgetPaint(gfx::Canvas* canvas) override {
     EXPECT_TRUE(expect_paint_);
     if (!expect_paint_)
       received_paint_while_hidden_ = true;
     views::Widget::OnNativeWidgetPaint(canvas);
   }
 
   bool received_paint_while_hidden() const {
     return received_paint_while_hidden_;
   }
 
@@ skipping 395 matching lines @@
 class MousePressEventConsumer : public ui::EventHandler {
  public:
   explicit MousePressEventConsumer() {
   }
 
   virtual ~MousePressEventConsumer() {
   }
 
  private:
   // ui::EventHandler:
-  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) override {
     if (event->type() == ui::ET_MOUSE_PRESSED)
       event->SetHandled();
   }
 
   DISALLOW_COPY_AND_ASSIGN(MousePressEventConsumer);
 };
 
 }  // namespace
 
 // Test that mouse presses and mouse releases are dispatched normally when a
@@ skipping 24 matching lines @@
 // been invoked.
 class ClosingDelegate : public WidgetDelegate {
  public:
   ClosingDelegate() : count_(0), widget_(NULL) {}
 
   int count() const { return count_; }
 
   void set_widget(views::Widget* widget) { widget_ = widget; }
 
   // WidgetDelegate overrides:
-  virtual Widget* GetWidget() OVERRIDE { return widget_; }
-  virtual const Widget* GetWidget() const OVERRIDE { return widget_; }
-  virtual void WindowClosing() OVERRIDE {
+  virtual Widget* GetWidget() override { return widget_; }
+  virtual const Widget* GetWidget() const override { return widget_; }
+  virtual void WindowClosing() override {
     count_++;
   }
 
  private:
   int count_;
   views::Widget* widget_;
 
   DISALLOW_COPY_AND_ASSIGN(ClosingDelegate);
 };
 
@@ skipping 113 matching lines @@
 }
 
 // See description of RunGetNativeThemeFromDestructor() for details.
 class GetNativeThemeFromDestructorView : public WidgetDelegateView {
  public:
   GetNativeThemeFromDestructorView() {}
   virtual ~GetNativeThemeFromDestructorView() {
     VerifyNativeTheme();
   }
 
-  virtual View* GetContentsView() OVERRIDE {
+  virtual View* GetContentsView() override {
     return this;
   }
 
  private:
   void VerifyNativeTheme() {
     ASSERT_TRUE(GetNativeTheme() != NULL);
   }
 
   DISALLOW_COPY_AND_ASSIGN(GetNativeThemeFromDestructorView);
 };
@@ skipping 54 matching lines @@
 
 // An observer that registers that an animation has ended.
 class AnimationEndObserver : public ui::ImplicitAnimationObserver {
  public:
   AnimationEndObserver() : animation_completed_(false) {}
   virtual ~AnimationEndObserver() {}
 
   bool animation_completed() const { return animation_completed_; }
 
   // ui::ImplicitAnimationObserver:
-  virtual void OnImplicitAnimationsCompleted() OVERRIDE {
+  virtual void OnImplicitAnimationsCompleted() override {
     animation_completed_ = true;
   }
 
  private:
   bool animation_completed_;
 
   DISALLOW_COPY_AND_ASSIGN(AnimationEndObserver);
 };
 
 // An observer that registers the bounds of a widget on destruction.
 class WidgetBoundsObserver : public WidgetObserver {
  public:
   WidgetBoundsObserver() {}
   virtual ~WidgetBoundsObserver() {}
 
   gfx::Rect bounds() { return bounds_; }
 
   // WidgetObserver:
-  virtual void OnWidgetDestroying(Widget* widget) OVERRIDE {
+  virtual void OnWidgetDestroying(Widget* widget) override {
     bounds_ = widget->GetWindowBoundsInScreen();
   }
 
  private:
   gfx::Rect bounds_;
 
   DISALLOW_COPY_AND_ASSIGN(WidgetBoundsObserver);
 };
 
 // Verifies Close() results in destroying.
@@ skipping 50 matching lines @@
   EXPECT_TRUE(animation_observer.animation_completed());
   EXPECT_EQ(widget_observer.bounds(), bounds);
 }
 
 // A view that consumes mouse-pressed event and gesture-tap-down events.
 class RootViewTestView : public View {
  public:
   RootViewTestView(): View() {}
 
  private:
-  virtual bool OnMousePressed(const ui::MouseEvent& event) OVERRIDE {
+  virtual bool OnMousePressed(const ui::MouseEvent& event) override {
     return true;
   }
 
-  virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
+  virtual void OnGestureEvent(ui::GestureEvent* event) override {
     if (event->type() == ui::ET_GESTURE_TAP_DOWN)
       event->SetHandled();
   }
 };
 
 // Checks if RootView::*_handler_ fields are unset when widget is hidden.
 // Fails on chromium.webkit Windows bot, see crbug.com/264872.
 #if defined(OS_WIN)
 #define MAYBE_DisableTestRootViewHandlersWhenHidden\
     DISABLED_TestRootViewHandlersWhenHidden
@@ skipping 525 matching lines @@
 class GestureLocationView : public EventCountView {
  public:
   GestureLocationView() {}
   virtual ~GestureLocationView() {}
 
   void set_expected_location(gfx::Point expected_location) {
     expected_location_ = expected_location;
   }
 
   // EventCountView:
-  virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
+  virtual void OnGestureEvent(ui::GestureEvent* event) override {
     EventCountView::OnGestureEvent(event);
 
     // Verify that the location of |event| is in the local coordinate
     // space of |this|.
     EXPECT_EQ(expected_location_, event->location());
   }
 
  private:
   // The expected location of a gesture event dispatched to |this|.
   gfx::Point expected_location_;
@@ skipping 306 matching lines @@
 }
 
 #if !defined(OS_CHROMEOS)
 // Provides functionality to create a window modal dialog.
 class ModalDialogDelegate : public DialogDelegateView {
  public:
   ModalDialogDelegate() {}
   virtual ~ModalDialogDelegate() {}
 
   // WidgetDelegate overrides.
-  virtual ui::ModalType GetModalType() const OVERRIDE {
+  virtual ui::ModalType GetModalType() const override {
     return ui::MODAL_TYPE_WINDOW;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ModalDialogDelegate);
 };
 
 // This test verifies that whether mouse events when a modal dialog is
 // displayed are eaten or recieved by the dialog.
 TEST_F(WidgetTest, WindowMouseModalityTest) {
@@ skipping 108 matching lines @@
 // which can be set by an accessor.
 class ModalWindowTestWidgetDelegate : public WidgetDelegate {
  public:
   ModalWindowTestWidgetDelegate()
       : widget_(NULL),
         can_activate_(true) {}
 
   virtual ~ModalWindowTestWidgetDelegate() {}
 
   // Overridden from WidgetDelegate:
-  virtual void DeleteDelegate() OVERRIDE {
+  virtual void DeleteDelegate() override {
     delete this;
   }
-  virtual Widget* GetWidget() OVERRIDE {
+  virtual Widget* GetWidget() override {
     return widget_;
   }
-  virtual const Widget* GetWidget() const OVERRIDE {
+  virtual const Widget* GetWidget() const override {
     return widget_;
   }
-  virtual bool CanActivate() const OVERRIDE {
+  virtual bool CanActivate() const override {
     return can_activate_;
   }
-  virtual bool ShouldAdvanceFocusToTopLevelWidget() const OVERRIDE {
+  virtual bool ShouldAdvanceFocusToTopLevelWidget() const override {
     return true;
   }
 
   void set_can_activate(bool can_activate) {
     can_activate_ = can_activate;
   }
 
   void set_widget(Widget* widget) {
     widget_ = widget;
   }
@@ skipping 150 matching lines @@
 
 namespace {
 
 class FullscreenAwareFrame : public views::NonClientFrameView {
  public:
   explicit FullscreenAwareFrame(views::Widget* widget)
       : widget_(widget), fullscreen_layout_called_(false) {}
   virtual ~FullscreenAwareFrame() {}
 
   // views::NonClientFrameView overrides:
-  virtual gfx::Rect GetBoundsForClientView() const OVERRIDE {
+  virtual gfx::Rect GetBoundsForClientView() const override {
     return gfx::Rect();
   }
   virtual gfx::Rect GetWindowBoundsForClientBounds(
-      const gfx::Rect& client_bounds) const OVERRIDE {
+      const gfx::Rect& client_bounds) const override {
     return gfx::Rect();
   }
-  virtual int NonClientHitTest(const gfx::Point& point) OVERRIDE {
+  virtual int NonClientHitTest(const gfx::Point& point) override {
     return HTNOWHERE;
   }
   virtual void GetWindowMask(const gfx::Size& size,
-                             gfx::Path* window_mask) OVERRIDE {}
-  virtual void ResetWindowControls() OVERRIDE {}
-  virtual void UpdateWindowIcon() OVERRIDE {}
-  virtual void UpdateWindowTitle() OVERRIDE {}
-  virtual void SizeConstraintsChanged() OVERRIDE {}
+                             gfx::Path* window_mask) override {}
+  virtual void ResetWindowControls() override {}
+  virtual void UpdateWindowIcon() override {}
+  virtual void UpdateWindowTitle() override {}
+  virtual void SizeConstraintsChanged() override {}
 
   // views::View overrides:
-  virtual void Layout() OVERRIDE {
+  virtual void Layout() override {
     if (widget_->IsFullscreen())
       fullscreen_layout_called_ = true;
   }
 
   bool fullscreen_layout_called() const { return fullscreen_layout_called_; }
 
  private:
   views::Widget* widget_;
   bool fullscreen_layout_called_;
 
@@ skipping 23 matching lines @@
 
 #if !defined(OS_CHROMEOS)
 namespace {
 
 // Trivial WidgetObserverTest that invokes Widget::IsActive() from
 // OnWindowDestroying.
 class IsActiveFromDestroyObserver : public WidgetObserver {
  public:
   IsActiveFromDestroyObserver() {}
   virtual ~IsActiveFromDestroyObserver() {}
-  virtual void OnWidgetDestroying(Widget* widget) OVERRIDE {
+  virtual void OnWidgetDestroying(Widget* widget) override {
     widget->IsActive();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(IsActiveFromDestroyObserver);
 };
 
 }  // namespace
 
 // Verifies Widget::IsActive() invoked from
@@ skipping 185 matching lines @@
 
   EXPECT_EQ(test_rect, root_view->bounds());
   widget->ReorderNativeViews();
   EXPECT_EQ(test_rect, root_view->bounds());
 
   widget->CloseNow();
 }
 
 }  // namespace test
 }  // namespace views