Standardize usage of virtual/override/final specifiers.

ui/views/controls/button/menu_button_unittest.cc

 // Copyright 2014 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/views/controls/button/menu_button.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/views/controls/button/menu_button_listener.h"
 #include "ui/views/drag_controller.h"
 #include "ui/views/test/views_test_base.h"
 
 #if defined(USE_AURA)
 #include "ui/events/event.h"
 #include "ui/events/event_handler.h"
 #include "ui/wm/public/drag_drop_client.h"
 #endif
 
 using base::ASCIIToUTF16;
 
 namespace views {
 
 class MenuButtonTest : public ViewsTestBase {
  public:
   MenuButtonTest() : widget_(nullptr), button_(nullptr) {}
-  virtual ~MenuButtonTest() {}
+  ~MenuButtonTest() override {}
 
   void TearDown() override {
     if (widget_ && !widget_->IsClosed())
       widget_->Close();
 
     ViewsTestBase::TearDown();
   }
 
   Widget* widget() { return widget_; }
   MenuButton* button() { return button_; }
@@ skipping 43 matching lines @@
   Widget* widget_;
   MenuButton* button_;
 };
 
 class TestButtonListener : public ButtonListener {
  public:
   TestButtonListener()
       : last_sender_(nullptr),
         last_sender_state_(Button::STATE_NORMAL),
         last_event_type_(ui::ET_UNKNOWN) {}
-  virtual ~TestButtonListener() {}
+  ~TestButtonListener() override {}
 
   void ButtonPressed(Button* sender, const ui::Event& event) override {
     last_sender_ = sender;
     CustomButton* custom_button = CustomButton::AsCustomButton(sender);
     DCHECK(custom_button);
     last_sender_state_ = custom_button->state();
     last_event_type_ = event.type();
   }
 
   Button* last_sender() { return last_sender_; }
   Button::ButtonState last_sender_state() { return last_sender_state_; }
   ui::EventType last_event_type() { return last_event_type_; }
 
  private:
   Button* last_sender_;
   Button::ButtonState last_sender_state_;
   ui::EventType last_event_type_;
 
   DISALLOW_COPY_AND_ASSIGN(TestButtonListener);
 };
 
 class TestMenuButtonListener : public MenuButtonListener {
  public:
   TestMenuButtonListener()
       : last_source_(nullptr), last_source_state_(Button::STATE_NORMAL) {}
-  virtual ~TestMenuButtonListener() {}
+  ~TestMenuButtonListener() override {}
 
   void OnMenuButtonClicked(View* source, const gfx::Point& /*point*/) override {
     last_source_ = source;
     CustomButton* custom_button = CustomButton::AsCustomButton(source);
     DCHECK(custom_button);
     last_source_state_ = custom_button->state();
   }
 
   View* last_source() { return last_source_; }
   Button::ButtonState last_source_state() { return last_source_state_; }
 
  private:
   View* last_source_;
   Button::ButtonState last_source_state_;
 };
 
 // Basic implementation of a DragController, to test input behaviour for
 // MenuButtons that can be dragged.
 class TestDragController : public DragController {
  public:
   TestDragController() {}
-  virtual ~TestDragController() {}
+  ~TestDragController() override {}
 
   void WriteDragDataForView(View* sender,
                             const gfx::Point& press_pt,
                             ui::OSExchangeData* data) override {}
 
   int GetDragOperationsForView(View* sender, const gfx::Point& p) override {
     return ui::DragDropTypes::DRAG_MOVE;
   }
 
   bool CanStartDragForView(View* sender,
                            const gfx::Point& press_pt,
                            const gfx::Point& p) override {
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestDragController);
 };
 
 #if defined(USE_AURA)
 // Basic implementation of a DragDropClient, tracking the state of the drag
 // operation. While dragging addition mouse events are consumed, preventing the
 // target view from receiving them.
 class TestDragDropClient : public aura::client::DragDropClient,
                            public ui::EventHandler {
  public:
   TestDragDropClient();
-  virtual ~TestDragDropClient();
+  ~TestDragDropClient() override;
 
   // aura::client::DragDropClient:
   int StartDragAndDrop(const ui::OSExchangeData& data,
                        aura::Window* root_window,
                        aura::Window* source_window,
                        const gfx::Point& root_location,
                        int operation,
                        ui::DragDropTypes::DragEventSource source) override;
   void DragUpdate(aura::Window* target, const ui::LocatedEvent& event) override;
   void Drop(aura::Window* target, const ui::LocatedEvent& event) override;
@@ skipping 205 matching lines @@
 
   ui::test::EventGenerator generator(GetContext(), widget()->GetNativeWindow());
   generator.set_current_location(gfx::Point(10, 10));
   generator.DragMouseBy(10, 0);
   EXPECT_EQ(nullptr, menu_button_listener.last_source());
   EXPECT_EQ(Button::STATE_NORMAL, menu_button_listener.last_source_state());
 }
 #endif
 
 }  // namespace views