Standardize usage of virtual/override/final specifiers.

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 49 matching lines @@
   // event sequence, such as a drag.
   enum HandleMode {
     PROPAGATE_EVENTS,
     CONSUME_EVENTS
   };
 
   EventCountView()
       : last_flags_(0),
         handle_mode_(PROPAGATE_EVENTS) {}
 
-  virtual ~EventCountView() {}
+  ~EventCountView() override {}
 
   int GetEventCount(ui::EventType type) {
     return event_count_[type];
   }
 
   void ResetCounts() {
     event_count_.clear();
   }
 
   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 {
+  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 {
-    RecordEvent(event);
-  }
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
-    RecordEvent(event);
-  }
-  virtual void OnScrollEvent(ui::ScrollEvent* event) override {
-    RecordEvent(event);
-  }
-  virtual void OnGestureEvent(ui::GestureEvent* event) override {
-    RecordEvent(event);
-  }
+  void OnKeyEvent(ui::KeyEvent* event) override { RecordEvent(event); }
+  void OnMouseEvent(ui::MouseEvent* event) override { RecordEvent(event); }
+  void OnScrollEvent(ui::ScrollEvent* event) override { RecordEvent(event); }
+  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() {}
+  ~ScrollableEventCountView() override {}
 
  private:
   // Overridden from ui::EventHandler:
-  virtual void OnGestureEvent(ui::GestureEvent* event) override {
+  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 {
+  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() {}
+  ~MinimumSizeFrameView() override {}
 
  private:
   // Overridden from View:
-  virtual gfx::Size GetMinimumSize() const override {
-    return gfx::Size(300, 400);
-  }
+  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() {}
+  ~EventCountHandler() override {}
 
   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 {
+  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 {
+  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 90 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // Widget ownership tests.
 //
 // Tests various permutations of Widget ownership specified in the
 // InitParams::Ownership param.
 
 // A WidgetTest that supplies a toplevel widget for NativeWidget to parent to.
 class WidgetOwnershipTest : public WidgetTest {
  public:
   WidgetOwnershipTest() {}
-  virtual ~WidgetOwnershipTest() {}
+  ~WidgetOwnershipTest() override {}
 
-  virtual void SetUp() {
+  void SetUp() override {
     WidgetTest::SetUp();
     desktop_widget_ = CreateTopLevelPlatformWidget();
   }
 
-  virtual void TearDown() {
+  void TearDown() override {
     desktop_widget_->CloseNow();
     WidgetTest::TearDown();
   }
 
  private:
   Widget* desktop_widget_;
 
   DISALLOW_COPY_AND_ASSIGN(WidgetOwnershipTest);
 };
 
 // A bag of state to monitor destructions.
 struct OwnershipTestState {
   OwnershipTestState() : widget_deleted(false), native_widget_deleted(false) {}
 
   bool widget_deleted;
   bool native_widget_deleted;
 };
 
 // A platform NativeWidget subclass that updates a bag of state when it is
 // destroyed.
 class OwnershipTestNativeWidget : public PlatformNativeWidget {
  public:
   OwnershipTestNativeWidget(internal::NativeWidgetDelegate* delegate,
                             OwnershipTestState* state)
       : PlatformNativeWidget(delegate),
         state_(state) {
   }
-  virtual ~OwnershipTestNativeWidget() {
+  ~OwnershipTestNativeWidget() override {
     state_->native_widget_deleted = true;
   }
 
  private:
   OwnershipTestState* state_;
 
   DISALLOW_COPY_AND_ASSIGN(OwnershipTestNativeWidget);
 };
 
 // A views NativeWidget subclass that updates a bag of state when it is
 // destroyed.
 class OwnershipTestNativeWidgetAura : public NativeWidgetCapture {
  public:
   OwnershipTestNativeWidgetAura(internal::NativeWidgetDelegate* delegate,
                                 OwnershipTestState* state)
       : NativeWidgetCapture(delegate),
         state_(state) {
   }
-  virtual ~OwnershipTestNativeWidgetAura() {
+  ~OwnershipTestNativeWidgetAura() override {
     state_->native_widget_deleted = true;
   }
 
  private:
   OwnershipTestState* state_;
 
   DISALLOW_COPY_AND_ASSIGN(OwnershipTestNativeWidgetAura);
 };
 
 // A Widget subclass that updates a bag of state when it is destroyed.
 class OwnershipTestWidget : public Widget {
  public:
   explicit OwnershipTestWidget(OwnershipTestState* state) : state_(state) {}
-  virtual ~OwnershipTestWidget() {
-    state_->widget_deleted = true;
-  }
+  ~OwnershipTestWidget() override { state_->widget_deleted = true; }
 
  private:
   OwnershipTestState* state_;
 
   DISALLOW_COPY_AND_ASSIGN(OwnershipTestWidget);
 };
 
 // Widget owns its NativeWidget, part 1: NativeWidget is a platform-native
 // widget.
 TEST_F(WidgetOwnershipTest, Ownership_WidgetOwnsPlatformNativeWidget) {
@@ skipping 207 matching lines @@
   EXPECT_TRUE(state.native_widget_deleted);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Test to verify using various Widget methods doesn't crash when the underlying
 // NativeView is destroyed.
 //
 class WidgetWithDestroyedNativeViewTest : public ViewsTestBase {
  public:
   WidgetWithDestroyedNativeViewTest() {}
-  virtual ~WidgetWithDestroyedNativeViewTest() {}
+  ~WidgetWithDestroyedNativeViewTest() override {}
 
   void InvokeWidgetMethods(Widget* widget) {
     widget->GetNativeView();
     widget->GetNativeWindow();
     ui::Accelerator accelerator;
     widget->GetAccelerator(0, &accelerator);
     widget->GetTopLevelWidget();
     widget->GetWindowBoundsInScreen();
     widget->GetClientAreaBoundsInScreen();
     widget->SetBounds(gfx::Rect(0, 0, 100, 80));
@@ skipping 75 matching lines @@
  public:
   WidgetObserverTest()
       : active_(NULL),
         widget_closed_(NULL),
         widget_activated_(NULL),
         widget_shown_(NULL),
         widget_hidden_(NULL),
         widget_bounds_changed_(NULL) {
   }
 
-  virtual ~WidgetObserverTest() {}
+  ~WidgetObserverTest() override {}
 
   // Overridden from WidgetObserver:
-  virtual void OnWidgetDestroying(Widget* widget) override {
+  void OnWidgetDestroying(Widget* widget) override {
     if (active_ == widget)
       active_ = NULL;
     widget_closed_ = widget;
   }
 
-  virtual void OnWidgetActivationChanged(Widget* widget,
-                                         bool active) override {
+  void OnWidgetActivationChanged(Widget* widget, 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 {
+  void OnWidgetVisibilityChanged(Widget* widget, bool visible) override {
     if (visible)
       widget_shown_ = widget;
     else
       widget_hidden_ = widget;
   }
 
-  virtual void OnWidgetBoundsChanged(Widget* widget,
-                                     const gfx::Rect& new_bounds) override {
+  void OnWidgetBoundsChanged(Widget* widget,
+                             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 304 matching lines @@
 
   // Closing the bubble should result in focus going back to the contents view.
   EXPECT_TRUE(contents_view->HasFocus());
 }
 
 class TestBubbleDelegateView : public BubbleDelegateView {
  public:
   TestBubbleDelegateView(View* anchor)
       : BubbleDelegateView(anchor, BubbleBorder::NONE),
         reset_controls_called_(false) {}
-  virtual ~TestBubbleDelegateView() {}
+  ~TestBubbleDelegateView() override {}
 
-  virtual bool ShouldShowCloseButton() const override {
+  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 34 matching lines @@
 // This class validates whether paints are received for a visible Widget.
 // To achieve this it overrides the Show and Close methods on the Widget class
 // and sets state whether subsequent paints are expected.
 class DesktopAuraTestValidPaintWidget : public views::Widget {
  public:
   DesktopAuraTestValidPaintWidget()
     : received_paint_(false),
       expect_paint_(true),
       received_paint_while_hidden_(false) {}
 
-  virtual ~DesktopAuraTestValidPaintWidget() {}
+  ~DesktopAuraTestValidPaintWidget() override {}
 
   void InitForTest(Widget::InitParams create_params);
 
-  virtual void Show() override {
+  void Show() override {
     expect_paint_ = true;
     views::Widget::Show();
   }
 
-  virtual void Close() override {
+  void Close() override {
     expect_paint_ = false;
     views::Widget::Close();
   }
 
   void Hide() {
     expect_paint_ = false;
     views::Widget::Hide();
   }
 
-  virtual void OnNativeWidgetPaint(gfx::Canvas* canvas) override {
+  void OnNativeWidgetPaint(gfx::Canvas* canvas) override {
     received_paint_ = true;
     EXPECT_TRUE(expect_paint_);
     if (!expect_paint_)
       received_paint_while_hidden_ = true;
     views::Widget::OnNativeWidgetPaint(canvas);
   }
 
   bool ReadReceivedPaintAndReset() {
     bool result = received_paint_;
     received_paint_ = false;
@@ skipping 400 matching lines @@
 }
 
 namespace {
 
 // ui::EventHandler which handles all mouse press events.
 class MousePressEventConsumer : public ui::EventHandler {
  public:
   explicit MousePressEventConsumer() {
   }
 
-  virtual ~MousePressEventConsumer() {
-  }
+  ~MousePressEventConsumer() override {}
 
  private:
   // ui::EventHandler:
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
+  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 {
-    count_++;
-  }
+  Widget* GetWidget() override { return widget_; }
+  const Widget* GetWidget() const override { return widget_; }
+  void WindowClosing() override { count_++; }
 
  private:
   int count_;
   views::Widget* widget_;
 
   DISALLOW_COPY_AND_ASSIGN(ClosingDelegate);
 };
 
 // Verifies WindowClosing() is invoked correctly on the delegate when a Widget
 // is closed.
@@ skipping 107 matching lines @@
   generator.GestureTapAt(widget->GetWindowBoundsInScreen().CenterPoint());
   EXPECT_FALSE(deletion_observer.IsWidgetAlive());
 
   // Yay we did not crash!
 }
 
 // See description of RunGetNativeThemeFromDestructor() for details.
 class GetNativeThemeFromDestructorView : public WidgetDelegateView {
  public:
   GetNativeThemeFromDestructorView() {}
-  virtual ~GetNativeThemeFromDestructorView() {
-    VerifyNativeTheme();
-  }
+  ~GetNativeThemeFromDestructorView() override { VerifyNativeTheme(); }
 
-  virtual View* GetContentsView() override {
-    return this;
-  }
+  View* GetContentsView() override { return this; }
 
  private:
   void VerifyNativeTheme() {
     ASSERT_TRUE(GetNativeTheme() != NULL);
   }
 
   DISALLOW_COPY_AND_ASSIGN(GetNativeThemeFromDestructorView);
 };
 
 // Verifies GetNativeTheme() from the destructor of a WidgetDelegateView doesn't
@@ skipping 27 matching lines @@
 }
 
 // Used by HideCloseDestroy. Allows setting a boolean when the widget is
 // destroyed.
 class CloseDestroysWidget : public Widget {
  public:
   explicit CloseDestroysWidget(bool* destroyed)
       : destroyed_(destroyed) {
   }
 
-  virtual ~CloseDestroysWidget() {
+  ~CloseDestroysWidget() override {
     if (destroyed_) {
       *destroyed_ = true;
       base::MessageLoop::current()->QuitNow();
     }
   }
 
   void Detach() { destroyed_ = NULL; }
 
  private:
   // If non-null set to true from destructor.
   bool* destroyed_;
 
   DISALLOW_COPY_AND_ASSIGN(CloseDestroysWidget);
 };
 
 // An observer that registers that an animation has ended.
 class AnimationEndObserver : public ui::ImplicitAnimationObserver {
  public:
   AnimationEndObserver() : animation_completed_(false) {}
-  virtual ~AnimationEndObserver() {}
+  ~AnimationEndObserver() override {}
 
   bool animation_completed() const { return animation_completed_; }
 
   // ui::ImplicitAnimationObserver:
-  virtual void OnImplicitAnimationsCompleted() override {
-    animation_completed_ = true;
-  }
+  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() {}
+  ~WidgetBoundsObserver() override {}
 
   gfx::Rect bounds() { return bounds_; }
 
   // WidgetObserver:
-  virtual void OnWidgetDestroying(Widget* widget) override {
+  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 {
-    return true;
-  }
+  bool OnMousePressed(const ui::MouseEvent& event) override { return true; }
 
-  virtual void OnGestureEvent(ui::GestureEvent* event) override {
+  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 518 matching lines @@
   widget->Close();
 }
 
 // A class used in WidgetTest.GestureEventLocationWhileBubbling to verify
 // that when a gesture event bubbles up a View hierarchy, the location
 // of a gesture event seen by each View is in the local coordinate space
 // of that View.
 class GestureLocationView : public EventCountView {
  public:
   GestureLocationView() {}
-  virtual ~GestureLocationView() {}
+  ~GestureLocationView() override {}
 
   void set_expected_location(gfx::Point expected_location) {
     expected_location_ = expected_location;
   }
 
   // EventCountView:
-  virtual void OnGestureEvent(ui::GestureEvent* event) override {
+  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 217 matching lines @@
 // Used by DestroyChildWidgetsInOrder. On destruction adds the supplied name to
 // a vector.
 class DestroyedTrackingView : public View {
  public:
   DestroyedTrackingView(const std::string& name,
                         std::vector<std::string>* add_to)
       : name_(name),
         add_to_(add_to) {
   }
 
-  virtual ~DestroyedTrackingView() {
-    add_to_->push_back(name_);
-  }
+  ~DestroyedTrackingView() override { add_to_->push_back(name_); }
 
  private:
   const std::string name_;
   std::vector<std::string>* add_to_;
 
   DISALLOW_COPY_AND_ASSIGN(DestroyedTrackingView);
 };
 
 class WidgetChildDestructionTest : public WidgetTest {
  public:
@@ skipping 63 matching lines @@
 // See description of RunDestroyChildWidgetsTest().
 TEST_F(WidgetChildDestructionTest, DestroyChildWidgetsInOrder) {
   RunDestroyChildWidgetsTest(false, false);
 }
 
 #if !defined(OS_CHROMEOS)
 // Provides functionality to create a window modal dialog.
 class ModalDialogDelegate : public DialogDelegateView {
  public:
   ModalDialogDelegate() {}
-  virtual ~ModalDialogDelegate() {}
+  ~ModalDialogDelegate() override {}
 
   // WidgetDelegate overrides.
-  virtual ui::ModalType GetModalType() const override {
-    return ui::MODAL_TYPE_WINDOW;
-  }
+  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) {
   // Create a top level widget.
   Widget top_level_widget;
@@ skipping 286 matching lines @@
   widget2.CloseNow();
 }
 #endif  // !defined(OS_CHROMEOS)
 
 namespace {
 
 class FullscreenAwareFrame : public views::NonClientFrameView {
  public:
   explicit FullscreenAwareFrame(views::Widget* widget)
       : widget_(widget), fullscreen_layout_called_(false) {}
-  virtual ~FullscreenAwareFrame() {}
+  ~FullscreenAwareFrame() override {}
 
   // views::NonClientFrameView overrides:
-  virtual gfx::Rect GetBoundsForClientView() const override {
-    return gfx::Rect();
-  }
-  virtual gfx::Rect GetWindowBoundsForClientBounds(
+  gfx::Rect GetBoundsForClientView() const override { return gfx::Rect(); }
+  gfx::Rect GetWindowBoundsForClientBounds(
       const gfx::Rect& client_bounds) const override {
     return gfx::Rect();
   }
-  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 {}
+  int NonClientHitTest(const gfx::Point& point) override { return HTNOWHERE; }
+  void GetWindowMask(const gfx::Size& size, gfx::Path* window_mask) override {}
+  void ResetWindowControls() override {}
+  void UpdateWindowIcon() override {}
+  void UpdateWindowTitle() override {}
+  void SizeConstraintsChanged() override {}
 
   // views::View overrides:
-  virtual void Layout() override {
+  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 22 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 {
-    widget->IsActive();
-  }
+  ~IsActiveFromDestroyObserver() override {}
+  void OnWidgetDestroying(Widget* widget) override { widget->IsActive(); }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(IsActiveFromDestroyObserver);
 };
 
 }  // namespace
 
 // Verifies Widget::IsActive() invoked from
 // WidgetObserver::OnWidgetDestroying() in a child widget doesn't crash.
 TEST_F(WidgetTest, IsActiveFromDestroy) {
@@ skipping 183 matching lines @@
 
   EXPECT_EQ(test_rect, root_view->bounds());
   widget->ReorderNativeViews();
   EXPECT_EQ(test_rect, root_view->bounds());
 
   widget->CloseNow();
 }
 
 }  // namespace test
 }  // namespace views