Standardize usage of virtual/override/final specifiers.

ui/views/widget/widget_interactive_uitest.cc

 // Copyright (c) 2013 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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
@@ skipping 25 matching lines @@
 namespace views {
 namespace test {
 
 namespace {
 
 // A View that closes the Widget and exits the current message-loop when it
 // receives a mouse-release event.
 class ExitLoopOnRelease : public View {
  public:
   ExitLoopOnRelease() {}
-  virtual ~ExitLoopOnRelease() {}
+  ~ExitLoopOnRelease() override {}
 
  private:
   // Overridden from View:
-  virtual void OnMouseReleased(const ui::MouseEvent& event) override {
+  void OnMouseReleased(const ui::MouseEvent& event) override {
     GetWidget()->Close();
     base::MessageLoop::current()->QuitNow();
   }
 
   DISALLOW_COPY_AND_ASSIGN(ExitLoopOnRelease);
 };
 
 // A view that does a capture on ui::ET_GESTURE_TAP_DOWN events.
 class GestureCaptureView : public View {
  public:
   GestureCaptureView() {}
-  virtual ~GestureCaptureView() {}
+  ~GestureCaptureView() override {}
 
  private:
   // Overridden from View:
-  virtual void OnGestureEvent(ui::GestureEvent* event) override {
+  void OnGestureEvent(ui::GestureEvent* event) override {
     if (event->type() == ui::ET_GESTURE_TAP_DOWN) {
       GetWidget()->SetCapture(this);
       event->StopPropagation();
     }
   }
 
   DISALLOW_COPY_AND_ASSIGN(GestureCaptureView);
 };
 
 // A view that always processes all mouse events.
 class MouseView : public View {
  public:
   MouseView()
       : View(),
         entered_(0),
         exited_(0),
         pressed_(0) {
   }
-  virtual ~MouseView() {}
+  ~MouseView() override {}
 
-  virtual bool OnMousePressed(const ui::MouseEvent& event) override {
+  bool OnMousePressed(const ui::MouseEvent& event) override {
     pressed_++;
     return true;
   }
 
-  virtual void OnMouseEntered(const ui::MouseEvent& event) override {
-    entered_++;
-  }
+  void OnMouseEntered(const ui::MouseEvent& event) override { entered_++; }
 
-  virtual void OnMouseExited(const ui::MouseEvent& event) override {
-    exited_++;
-  }
+  void OnMouseExited(const ui::MouseEvent& event) override { exited_++; }
 
   // Return the number of OnMouseEntered calls and reset the counter.
   int EnteredCalls() {
     int i = entered_;
     entered_ = 0;
     return i;
   }
 
   // Return the number of OnMouseExited calls and reset the counter.
   int ExitedCalls() {
@@ skipping 11 matching lines @@
   int pressed_;
 
   DISALLOW_COPY_AND_ASSIGN(MouseView);
 };
 
 // A View that shows a different widget, sets capture on that widget, and
 // initiates a nested message-loop when it receives a mouse-press event.
 class NestedLoopCaptureView : public View {
  public:
   explicit NestedLoopCaptureView(Widget* widget) : widget_(widget) {}
-  virtual ~NestedLoopCaptureView() {}
+  ~NestedLoopCaptureView() override {}
 
  private:
   // Overridden from View:
-  virtual bool OnMousePressed(const ui::MouseEvent& event) override {
+  bool OnMousePressed(const ui::MouseEvent& event) override {
     // Start a nested loop.
     widget_->Show();
     widget_->SetCapture(widget_->GetContentsView());
     EXPECT_TRUE(widget_->HasCapture());
 
     base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
     base::MessageLoop::ScopedNestableTaskAllower allow(loop);
 
     base::RunLoop run_loop;
     run_loop.Run();
     return true;
   }
 
   Widget* widget_;
 
   DISALLOW_COPY_AND_ASSIGN(NestedLoopCaptureView);
 };
 
 }  // namespace
 
 class WidgetTestInteractive : public WidgetTest {
  public:
   WidgetTestInteractive() {}
-  virtual ~WidgetTestInteractive() {}
+  ~WidgetTestInteractive() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     gfx::GLSurface::InitializeOneOffForTests();
     ui::RegisterPathProvider();
     base::FilePath ui_test_pak_path;
     ASSERT_TRUE(PathService::Get(ui::UI_TEST_PAK, &ui_test_pak_path));
     ui::ResourceBundle::InitSharedInstanceWithPakPath(ui_test_pak_path);
     WidgetTest::SetUp();
   }
 
  protected:
   static void ShowQuickMenuImmediately(
@@ skipping 459 matching lines @@
   EXPECT_EQ(true, widget1.active());
   EXPECT_EQ(false, widget2.active());
 }
 #endif  // defined(OS_WIN)
 
 #if !defined(OS_CHROMEOS)
 // Provides functionality to create a window modal dialog.
 class ModalDialogDelegate : public DialogDelegateView {
  public:
   explicit ModalDialogDelegate(ui::ModalType type) : type_(type) {}
-  virtual ~ModalDialogDelegate() {}
+  ~ModalDialogDelegate() override {}
 
   // WidgetDelegate overrides.
-  virtual ui::ModalType GetModalType() const override {
-    return type_;
-  }
+  ui::ModalType GetModalType() const override { return type_; }
 
  private:
   ui::ModalType type_;
 
   DISALLOW_COPY_AND_ASSIGN(ModalDialogDelegate);
 };
 
 // Tests whether the focused window is set correctly when a modal window is
 // created and destroyed. When it is destroyed it should focus the owner window.
 TEST_F(WidgetTestInteractive, WindowModalWindowDestroyedActivationTest) {
@@ skipping 195 matching lines @@
   EXPECT_FALSE(widget1.IsActive());
   EXPECT_TRUE(widget2.IsActive());
 }
 
 namespace {
 
 // Used to veirfy OnMouseCaptureLost() has been invoked.
 class CaptureLostTrackingWidget : public Widget {
  public:
   CaptureLostTrackingWidget() : got_capture_lost_(false) {}
-  virtual ~CaptureLostTrackingWidget() {}
+  ~CaptureLostTrackingWidget() override {}
 
   bool GetAndClearGotCaptureLost() {
     bool value = got_capture_lost_;
     got_capture_lost_ = false;
     return value;
   }
 
   // Widget:
-  virtual void OnMouseCaptureLost() override {
+  void OnMouseCaptureLost() override {
     got_capture_lost_ = true;
     Widget::OnMouseCaptureLost();
   }
 
  private:
   bool got_capture_lost_;
 
   DISALLOW_COPY_AND_ASSIGN(CaptureLostTrackingWidget);
 };
 
 }  // namespace
 
 class WidgetCaptureTest : public ViewsTestBase {
  public:
   WidgetCaptureTest() {
   }
 
-  virtual ~WidgetCaptureTest() {
-  }
+  ~WidgetCaptureTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     gfx::GLSurface::InitializeOneOffForTests();
     ui::RegisterPathProvider();
     base::FilePath ui_test_pak_path;
     ASSERT_TRUE(PathService::Get(ui::UI_TEST_PAK, &ui_test_pak_path));
     ui::ResourceBundle::InitSharedInstanceWithPakPath(ui_test_pak_path);
     ViewsTestBase::SetUp();
   }
 
   // Verifies Widget::SetCapture() results in updating native capture along with
   // invoking the right Widget function.
@@ skipping 135 matching lines @@
 }
 #endif  // !defined(OS_CHROMEOS)
 
 namespace {
 
 // Widget observer which grabs capture when the widget is activated.
 class CaptureOnActivationObserver : public WidgetObserver {
  public:
   CaptureOnActivationObserver() {
   }
-  virtual ~CaptureOnActivationObserver() {
-  }
+  ~CaptureOnActivationObserver() override {}
 
   // WidgetObserver:
-  virtual void OnWidgetActivationChanged(Widget* widget, bool active) override {
+  void OnWidgetActivationChanged(Widget* widget, bool active) override {
     if (active)
       widget->SetCapture(NULL);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CaptureOnActivationObserver);
 };
 
 }  // namespace
 
@@ skipping 86 matching lines @@
   ui::EventDispatchDetails details = widget1.GetNativeWindow()->
       GetHost()->event_processor()->OnEventFromSource(&mouse_event);
   ASSERT_FALSE(details.dispatcher_destroyed);
   EXPECT_TRUE(widget1.GetAndClearGotMouseEvent());
   EXPECT_FALSE(widget2.GetAndClearGotMouseEvent());
 }
 #endif  // defined(OS_WIN)
 
 }  // namespace test
 }  // namespace views