Standardize usage of virtual/override/final specifiers.

ui/aura/window_event_dispatcher_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_event_dispatcher.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/run_loop.h"
@@ skipping 27 matching lines @@
 namespace {
 
 // A delegate that always returns a non-client component for hit tests.
 class NonClientDelegate : public test::TestWindowDelegate {
  public:
   NonClientDelegate()
       : non_client_count_(0),
         mouse_event_count_(0),
         mouse_event_flags_(0x0) {
   }
-  virtual ~NonClientDelegate() {}
+  ~NonClientDelegate() override {}
 
   int non_client_count() const { return non_client_count_; }
   gfx::Point non_client_location() const { return non_client_location_; }
   int mouse_event_count() const { return mouse_event_count_; }
   gfx::Point mouse_event_location() const { return mouse_event_location_; }
   int mouse_event_flags() const { return mouse_event_flags_; }
 
-  virtual int GetNonClientComponent(const gfx::Point& location) const override {
+  int GetNonClientComponent(const gfx::Point& location) const override {
     NonClientDelegate* self = const_cast<NonClientDelegate*>(this);
     self->non_client_count_++;
     self->non_client_location_ = location;
     return HTTOPLEFT;
   }
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
+  void OnMouseEvent(ui::MouseEvent* event) override {
     mouse_event_count_++;
     mouse_event_location_ = event->location();
     mouse_event_flags_ = event->flags();
     event->SetHandled();
   }
 
  private:
   int non_client_count_;
   gfx::Point non_client_location_;
   int mouse_event_count_;
   gfx::Point mouse_event_location_;
   int mouse_event_flags_;
 
   DISALLOW_COPY_AND_ASSIGN(NonClientDelegate);
 };
 
 // A simple event handler that consumes key events.
 class ConsumeKeyHandler : public ui::test::TestEventHandler {
  public:
   ConsumeKeyHandler() {}
-  virtual ~ConsumeKeyHandler() {}
+  ~ConsumeKeyHandler() override {}
 
   // Overridden from ui::EventHandler:
-  virtual void OnKeyEvent(ui::KeyEvent* event) override {
+  void OnKeyEvent(ui::KeyEvent* event) override {
     ui::test::TestEventHandler::OnKeyEvent(event);
     event->StopPropagation();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ConsumeKeyHandler);
 };
 
 bool IsFocusedWindow(aura::Window* window) {
   return client::GetFocusClient(window)->GetFocusedWindow() == window;
@@ skipping 137 matching lines @@
       : root_window_(root_window),
         lock_(false) {
     client::SetEventClient(root_window_, this);
     Window* lock_window =
         test::CreateTestWindowWithBounds(root_window_->bounds(), root_window_);
     lock_window->set_id(kLockWindowId);
     Window* non_lock_window =
         test::CreateTestWindowWithBounds(root_window_->bounds(), root_window_);
     non_lock_window->set_id(kNonLockWindowId);
   }
-  virtual ~TestEventClient() {
-    client::SetEventClient(root_window_, NULL);
-  }
+  ~TestEventClient() override { client::SetEventClient(root_window_, NULL); }
 
   // Starts/stops locking. Locking prevents windows other than those inside
   // the lock container from receiving events, getting focus etc.
   void Lock() {
     lock_ = true;
   }
   void Unlock() {
     lock_ = false;
   }
 
   Window* GetLockWindow() {
     return const_cast<Window*>(
         static_cast<const TestEventClient*>(this)->GetLockWindow());
   }
   const Window* GetLockWindow() const {
     return root_window_->GetChildById(kLockWindowId);
   }
   Window* GetNonLockWindow() {
     return root_window_->GetChildById(kNonLockWindowId);
   }
 
  private:
   // Overridden from client::EventClient:
-  virtual bool CanProcessEventsWithinSubtree(
-      const Window* window) const override {
+  bool CanProcessEventsWithinSubtree(const Window* window) const override {
     return lock_ ?
         window->Contains(GetLockWindow()) || GetLockWindow()->Contains(window) :
         true;
   }
 
-  virtual ui::EventTarget* GetToplevelEventTarget() override {
-    return NULL;
-  }
+  ui::EventTarget* GetToplevelEventTarget() override { return NULL; }
 
   Window* root_window_;
   bool lock_;
 
   DISALLOW_COPY_AND_ASSIGN(TestEventClient);
 };
 
 }  // namespace
 
 TEST_F(WindowEventDispatcherTest, CanProcessEventsWithinSubtree) {
@@ skipping 189 matching lines @@
 
   void Reset() {
     events_.clear();
     mouse_locations_.clear();
     touch_locations_.clear();
     gesture_locations_.clear();
     mouse_event_flags_.clear();
   }
 
   // ui::EventHandler overrides:
-  virtual void OnEvent(ui::Event* event) override {
+  void OnEvent(ui::Event* event) override {
     ui::EventHandler::OnEvent(event);
     events_.push_back(event->type());
     if (wait_until_event_ == event->type() && run_loop_) {
       run_loop_->Quit();
       wait_until_event_ = ui::ET_UNKNOWN;
     }
   }
 
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
+  void OnMouseEvent(ui::MouseEvent* event) override {
     mouse_locations_.push_back(event->location());
     mouse_event_flags_.push_back(event->flags());
   }
 
-  virtual void OnTouchEvent(ui::TouchEvent* event) override {
+  void OnTouchEvent(ui::TouchEvent* event) override {
     touch_locations_.push_back(event->location());
   }
 
-  virtual void OnGestureEvent(ui::GestureEvent* event) override {
+  void OnGestureEvent(ui::GestureEvent* event) override {
     gesture_locations_.push_back(event->location());
   }
 
   bool HasReceivedEvent(ui::EventType type) {
     return std::find(events_.begin(), events_.end(), type) != events_.end();
   }
 
  private:
   scoped_ptr<base::RunLoop> run_loop_;
   ui::EventType wait_until_event_;
@@ skipping 309 matching lines @@
 
 // This event handler requests the dispatcher to start holding pointer-move
 // events when it receives the first scroll-update gesture.
 class HoldPointerOnScrollHandler : public ui::test::TestEventHandler {
  public:
   HoldPointerOnScrollHandler(WindowEventDispatcher* dispatcher,
                              EventFilterRecorder* filter)
       : dispatcher_(dispatcher),
         filter_(filter),
         holding_moves_(false) {}
-  virtual ~HoldPointerOnScrollHandler() {}
+  ~HoldPointerOnScrollHandler() override {}
 
  private:
   // ui::test::TestEventHandler:
-  virtual void OnGestureEvent(ui::GestureEvent* gesture) override {
+  void OnGestureEvent(ui::GestureEvent* gesture) override {
     if (!holding_moves_ && gesture->type() == ui::ET_GESTURE_SCROLL_UPDATE) {
       holding_moves_ = true;
       dispatcher_->HoldPointerMoves();
       filter_->Reset();
     } else if (gesture->type() == ui::ET_GESTURE_SCROLL_END) {
       dispatcher_->ReleasePointerMoves();
       holding_moves_ = false;
     }
   }
 
@@ skipping 274 matching lines @@
   int translated_y = mouse_exit_location.y() - window_origin.y();
   gfx::Point translated_point(translated_x, translated_y);
   EXPECT_EQ(recorder.mouse_location(0).ToString(), translated_point.ToString());
   root_window()->RemovePreTargetHandler(&recorder);
 }
 
 class DeletingEventFilter : public ui::EventHandler {
  public:
   DeletingEventFilter()
       : delete_during_pre_handle_(false) {}
-  virtual ~DeletingEventFilter() {}
+  ~DeletingEventFilter() override {}
 
   void Reset(bool delete_during_pre_handle) {
     delete_during_pre_handle_ = delete_during_pre_handle;
   }
 
  private:
   // Overridden from ui::EventHandler:
-  virtual void OnKeyEvent(ui::KeyEvent* event) override {
+  void OnKeyEvent(ui::KeyEvent* event) override {
     if (delete_during_pre_handle_)
       delete event->target();
   }
 
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
+  void OnMouseEvent(ui::MouseEvent* event) override {
     if (delete_during_pre_handle_)
       delete event->target();
   }
 
   bool delete_during_pre_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(DeletingEventFilter);
 };
 
 class DeletingWindowDelegate : public test::TestWindowDelegate {
  public:
   DeletingWindowDelegate()
       : window_(NULL),
         delete_during_handle_(false),
         got_event_(false) {}
-  virtual ~DeletingWindowDelegate() {}
+  ~DeletingWindowDelegate() override {}
 
   void Reset(Window* window, bool delete_during_handle) {
     window_ = window;
     delete_during_handle_ = delete_during_handle;
     got_event_ = false;
   }
   bool got_event() const { return got_event_; }
 
  private:
   // Overridden from WindowDelegate:
-  virtual void OnKeyEvent(ui::KeyEvent* event) override {
+  void OnKeyEvent(ui::KeyEvent* event) override {
     if (delete_during_handle_)
       delete window_;
     got_event_ = true;
   }
 
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
+  void OnMouseEvent(ui::MouseEvent* event) override {
     if (delete_during_handle_)
       delete window_;
     got_event_ = true;
   }
 
   Window* window_;
   bool delete_during_handle_;
   bool got_event_;
 
   DISALLOW_COPY_AND_ASSIGN(DeletingWindowDelegate);
@@ skipping 39 matching lines @@
   EXPECT_FALSE(d11.got_event());
 }
 
 namespace {
 
 // A window delegate that detaches the parent of the target's parent window when
 // it receives a tap event.
 class DetachesParentOnTapDelegate : public test::TestWindowDelegate {
  public:
   DetachesParentOnTapDelegate() {}
-  virtual ~DetachesParentOnTapDelegate() {}
+  ~DetachesParentOnTapDelegate() override {}
 
  private:
-  virtual void OnGestureEvent(ui::GestureEvent* event) override {
+  void OnGestureEvent(ui::GestureEvent* event) override {
     if (event->type() == ui::ET_GESTURE_TAP_DOWN) {
       event->SetHandled();
       return;
     }
 
     if (event->type() == ui::ET_GESTURE_TAP) {
       Window* parent = static_cast<Window*>(event->target())->parent();
       parent->parent()->RemoveChild(parent);
       event->SetHandled();
     }
@@ skipping 19 matching lines @@
 namespace {
 
 // A window delegate that processes nested gestures on tap.
 class NestedGestureDelegate : public test::TestWindowDelegate {
  public:
   NestedGestureDelegate(ui::test::EventGenerator* generator,
                         const gfx::Point tap_location)
       : generator_(generator),
         tap_location_(tap_location),
         gesture_end_count_(0) {}
-  virtual ~NestedGestureDelegate() {}
+  ~NestedGestureDelegate() override {}
 
   int gesture_end_count() const { return gesture_end_count_; }
 
  private:
-  virtual void OnGestureEvent(ui::GestureEvent* event) override {
+  void OnGestureEvent(ui::GestureEvent* event) override {
     switch (event->type()) {
       case ui::ET_GESTURE_TAP_DOWN:
         event->SetHandled();
         break;
       case ui::ET_GESTURE_TAP:
         if (generator_)
           generator_->GestureTapAt(tap_location_);
         event->SetHandled();
         break;
       case ui::ET_GESTURE_END:
@@ skipping 63 matching lines @@
 // events after that.
 class RepostGestureEventRecorder : public EventFilterRecorder {
  public:
   RepostGestureEventRecorder(aura::Window* repost_source,
                              aura::Window* repost_target)
       : repost_source_(repost_source),
         repost_target_(repost_target),
         reposted_(false),
         done_cleanup_(false) {}
 
-  virtual ~RepostGestureEventRecorder() {}
+  ~RepostGestureEventRecorder() override {}
 
-  virtual void OnTouchEvent(ui::TouchEvent* event) override {
+  void OnTouchEvent(ui::TouchEvent* event) override {
     if (reposted_ && event->type() == ui::ET_TOUCH_PRESSED) {
       done_cleanup_ = true;
       Reset();
     }
     EventFilterRecorder::OnTouchEvent(event);
   }
 
-  virtual void OnGestureEvent(ui::GestureEvent* event) override {
+  void OnGestureEvent(ui::GestureEvent* event) override {
     EXPECT_EQ(done_cleanup_ ? repost_target_ : repost_source_, event->target());
     if (event->type() == ui::ET_GESTURE_TAP_DOWN) {
       if (!reposted_) {
         EXPECT_NE(repost_target_, event->target());
         reposted_ = true;
         repost_target_->GetHost()->dispatcher()->RepostEvent(*event);
         // Ensure that the reposted gesture event above goes to the
         // repost_target_;
         repost_source_->GetRootWindow()->RemoveChild(repost_source_);
         return;
       }
     }
     EventFilterRecorder::OnGestureEvent(event);
   }
 
   // Ignore mouse events as they don't fire at all times. This causes
   // the GestureRepostEventOrder test to fail randomly.
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {}
+  void OnMouseEvent(ui::MouseEvent* event) override {}
 
  private:
   aura::Window* repost_source_;
   aura::Window* repost_target_;
   // set to true if we reposted the ET_GESTURE_TAP_DOWN event.
   bool reposted_;
   // set true if we're done cleaning up after hiding repost_source_;
   bool done_cleanup_;
   DISALLOW_COPY_AND_ASSIGN(RepostGestureEventRecorder);
 };
@@ skipping 53 matching lines @@
   EXPECT_EQ(1, tap_down_count);
 
   EXPECT_EQ(kExpectedTargetEvents,
             EventTypesToString(repost_event_recorder.events()));
   root_window()->RemovePreTargetHandler(&repost_event_recorder);
 }
 
 class OnMouseExitDeletingEventFilter : public EventFilterRecorder {
  public:
   OnMouseExitDeletingEventFilter() : window_to_delete_(NULL) {}
-  virtual ~OnMouseExitDeletingEventFilter() {}
+  ~OnMouseExitDeletingEventFilter() override {}
 
   void set_window_to_delete(Window* window_to_delete) {
     window_to_delete_ = window_to_delete;
   }
 
  private:
   // Overridden from ui::EventHandler:
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
+  void OnMouseEvent(ui::MouseEvent* event) override {
     EventFilterRecorder::OnMouseEvent(event);
     if (window_to_delete_) {
       delete window_to_delete_;
       window_to_delete_ = NULL;
     }
   }
 
   Window* window_to_delete_;
 
   DISALLOW_COPY_AND_ASSIGN(OnMouseExitDeletingEventFilter);
@@ skipping 45 matching lines @@
 // RootWindow at such time.
 class ValidRootDuringDestructionWindowObserver : public aura::WindowObserver {
  public:
   ValidRootDuringDestructionWindowObserver(bool* got_destroying,
                                            bool* has_valid_root)
       : got_destroying_(got_destroying),
         has_valid_root_(has_valid_root) {
   }
 
   // WindowObserver:
-  virtual void OnWindowDestroying(aura::Window* window) override {
+  void OnWindowDestroying(aura::Window* window) override {
     *got_destroying_ = true;
     *has_valid_root_ = (window->GetRootWindow() != NULL);
   }
 
  private:
   bool* got_destroying_;
   bool* has_valid_root_;
 
   DISALLOW_COPY_AND_ASSIGN(ValidRootDuringDestructionWindowObserver);
 };
@@ skipping 19 matching lines @@
 }
 
 namespace {
 
 // See description above DontResetHeldEvent for details.
 class DontResetHeldEventWindowDelegate : public test::TestWindowDelegate {
  public:
   explicit DontResetHeldEventWindowDelegate(aura::Window* root)
       : root_(root),
         mouse_event_count_(0) {}
-  virtual ~DontResetHeldEventWindowDelegate() {}
+  ~DontResetHeldEventWindowDelegate() override {}
 
   int mouse_event_count() const { return mouse_event_count_; }
 
   // TestWindowDelegate:
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
+  void OnMouseEvent(ui::MouseEvent* event) override {
     if ((event->flags() & ui::EF_SHIFT_DOWN) != 0 &&
         mouse_event_count_++ == 0) {
       ui::MouseEvent mouse_event(ui::ET_MOUSE_PRESSED,
                                  gfx::Point(10, 10), gfx::Point(10, 10),
                                  ui::EF_SHIFT_DOWN, 0);
       root_->GetHost()->dispatcher()->RepostEvent(mouse_event);
     }
   }
 
  private:
@@ skipping 34 matching lines @@
 
 // See description above DeleteHostFromHeldMouseEvent for details.
 class DeleteHostFromHeldMouseEventDelegate
     : public test::TestWindowDelegate {
  public:
   explicit DeleteHostFromHeldMouseEventDelegate(WindowTreeHost* host)
       : host_(host),
         got_mouse_event_(false),
         got_destroy_(false) {
   }
-  virtual ~DeleteHostFromHeldMouseEventDelegate() {}
+  ~DeleteHostFromHeldMouseEventDelegate() override {}
 
   bool got_mouse_event() const { return got_mouse_event_; }
   bool got_destroy() const { return got_destroy_; }
 
   // TestWindowDelegate:
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
+  void OnMouseEvent(ui::MouseEvent* event) override {
     if ((event->flags() & ui::EF_SHIFT_DOWN) != 0) {
       got_mouse_event_ = true;
       delete host_;
     }
   }
-  virtual void OnWindowDestroyed(Window* window) override {
-    got_destroy_ = true;
-  }
+  void OnWindowDestroyed(Window* window) override { got_destroy_ = true; }
 
  private:
   WindowTreeHost* host_;
   bool got_mouse_event_;
   bool got_destroy_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteHostFromHeldMouseEventDelegate);
 };
 
 }  // namespace
@@ skipping 130 matching lines @@
   EXPECT_TRUE(recorder2.events().empty());
 }
 
 namespace {
 
 // This class creates and manages a window which is destroyed as soon as
 // capture is lost. This is the case for the drag and drop capture window.
 class CaptureWindowTracker : public test::TestWindowDelegate {
  public:
   CaptureWindowTracker() {}
-  virtual ~CaptureWindowTracker() {}
+  ~CaptureWindowTracker() override {}
 
   void CreateCaptureWindow(aura::Window* root_window) {
     capture_window_.reset(test::CreateTestWindowWithDelegate(
         this, -1234, gfx::Rect(20, 20, 20, 20), root_window));
     capture_window_->SetCapture();
   }
 
   void reset() {
     capture_window_.reset();
   }
 
-  virtual void OnCaptureLost() override {
-    capture_window_.reset();
-  }
+  void OnCaptureLost() override { capture_window_.reset(); }
 
-  virtual void OnWindowDestroyed(Window* window) override {
+  void OnWindowDestroyed(Window* window) override {
     TestWindowDelegate::OnWindowDestroyed(window);
     capture_window_.reset();
   }
 
   aura::Window* capture_window() { return capture_window_.get(); }
 
  private:
   scoped_ptr<aura::Window> capture_window_;
 
   DISALLOW_COPY_AND_ASSIGN(CaptureWindowTracker);
@@ skipping 13 matching lines @@
 TEST_F(WindowEventDispatcherTest, CaptureWindowDestroyed) {
   CaptureWindowTracker capture_window_tracker;
   capture_window_tracker.CreateCaptureWindow(root_window());
   capture_window_tracker.reset();
   EXPECT_EQ(NULL, capture_window_tracker.capture_window());
 }
 
 class ExitMessageLoopOnMousePress : public ui::test::TestEventHandler {
  public:
   ExitMessageLoopOnMousePress() {}
-  virtual ~ExitMessageLoopOnMousePress() {}
+  ~ExitMessageLoopOnMousePress() override {}
 
  protected:
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
+  void OnMouseEvent(ui::MouseEvent* event) override {
     ui::test::TestEventHandler::OnMouseEvent(event);
     if (event->type() == ui::ET_MOUSE_PRESSED)
       base::MessageLoopForUI::current()->Quit();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ExitMessageLoopOnMousePress);
 };
 
 class WindowEventDispatcherTestWithMessageLoop
     : public WindowEventDispatcherTest {
  public:
   WindowEventDispatcherTestWithMessageLoop() {}
-  virtual ~WindowEventDispatcherTestWithMessageLoop() {}
+  ~WindowEventDispatcherTestWithMessageLoop() override {}
 
   void RunTest() {
     // Reset any event the window may have received when bringing up the window
     // (e.g. mouse-move events if the mouse cursor is over the window).
     handler_.Reset();
 
     // Start a nested message-loop, post an event to be dispatched, and then
     // terminate the message-loop. When the message-loop unwinds and gets back,
     // the reposted event should not have fired.
     scoped_ptr<ui::MouseEvent> mouse(new ui::MouseEvent(ui::ET_MOUSE_PRESSED,
@@ skipping 15 matching lines @@
 
     // Let the current message-loop run. The event-handler will terminate the
     // message-loop when it receives the reposted event.
   }
 
   base::MessageLoop* message_loop() {
     return base::MessageLoopForUI::current();
   }
 
  protected:
-  virtual void SetUp() override {
+  void SetUp() override {
     WindowEventDispatcherTest::SetUp();
     window_.reset(CreateNormalWindow(1, root_window(), NULL));
     window_->AddPreTargetHandler(&handler_);
   }
 
-  virtual void TearDown() override {
+  void TearDown() override {
     window_.reset();
     WindowEventDispatcherTest::TearDown();
   }
 
  private:
   // Used to avoid a copying |event| when binding to a closure.
   static void RepostEventHelper(WindowEventDispatcher* dispatcher,
                                 scoped_ptr<ui::MouseEvent> event) {
     dispatcher->RepostEvent(*event);
   }
@@ skipping 11 matching lines @@
   message_loop()->PostTask(
       FROM_HERE, base::Bind(
           &WindowEventDispatcherTestWithMessageLoop::RunTest,
           base::Unretained(this)));
   message_loop()->Run();
 }
 
 class WindowEventDispatcherTestInHighDPI : public WindowEventDispatcherTest {
  public:
   WindowEventDispatcherTestInHighDPI() {}
-  virtual ~WindowEventDispatcherTestInHighDPI() {}
+  ~WindowEventDispatcherTestInHighDPI() override {}
 
  protected:
-  virtual void SetUp() override {
+  void SetUp() override {
     WindowEventDispatcherTest::SetUp();
     test_screen()->SetDeviceScaleFactor(2.f);
   }
 };
 
 TEST_F(WindowEventDispatcherTestInHighDPI, EventLocationTransform) {
   test::TestWindowDelegate delegate;
   scoped_ptr<aura::Window> child(test::CreateTestWindowWithDelegate(&delegate,
       1234, gfx::Rect(20, 20, 100, 100), root_window()));
   child->Show();
@@ skipping 55 matching lines @@
   ASSERT_EQ(2u, recorder.touch_locations().size());
   EXPECT_EQ(gfx::Point(-40, 10).ToString(),
             recorder.touch_locations()[0].ToString());
   EXPECT_EQ(gfx::Point(-40, 10).ToString(),
             recorder.touch_locations()[1].ToString());
 }
 
 class SelfDestructDelegate : public test::TestWindowDelegate {
  public:
   SelfDestructDelegate() {}
-  virtual ~SelfDestructDelegate() {}
+  ~SelfDestructDelegate() override {}
 
-  virtual void OnMouseEvent(ui::MouseEvent* event) override {
-    window_.reset();
-  }
+  void OnMouseEvent(ui::MouseEvent* event) override { window_.reset(); }
 
   void set_window(scoped_ptr<aura::Window> window) {
     window_ = window.Pass();
   }
   bool has_window() const { return !!window_.get(); }
 
  private:
   scoped_ptr<aura::Window> window_;
   DISALLOW_COPY_AND_ASSIGN(SelfDestructDelegate);
 };
@@ skipping 48 matching lines @@
 
   client::CaptureDelegate* capture_delegate = host()->dispatcher();
   capture_delegate->UpdateCapture(window_first_raw, window_second.get());
   EXPECT_FALSE(delegate.has_window());
 }
 
 class StaticFocusClient : public client::FocusClient {
  public:
   explicit StaticFocusClient(Window* focused)
       : focused_(focused) {}
-  virtual ~StaticFocusClient() {}
+  ~StaticFocusClient() override {}
 
  private:
   // client::FocusClient:
-  virtual void AddObserver(client::FocusChangeObserver* observer) override {}
-  virtual void RemoveObserver(client::FocusChangeObserver* observer) override {}
-  virtual void FocusWindow(Window* window) override {}
-  virtual void ResetFocusWithinActiveWindow(Window* window) override {}
-  virtual Window* GetFocusedWindow() override { return focused_; }
+  void AddObserver(client::FocusChangeObserver* observer) override {}
+  void RemoveObserver(client::FocusChangeObserver* observer) override {}
+  void FocusWindow(Window* window) override {}
+  void ResetFocusWithinActiveWindow(Window* window) override {}
+  Window* GetFocusedWindow() override { return focused_; }
 
   Window* focused_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticFocusClient);
 };
 
 // Tests that host-cancel-mode event can be dispatched to a dispatcher safely
 // when the focused window does not live in the dispatcher's tree.
 TEST_F(WindowEventDispatcherTest, HostCancelModeWithFocusedWindowOutside) {
   test::TestWindowDelegate delegate;
   scoped_ptr<Window> focused(CreateTestWindowWithDelegate(&delegate, 123,
       gfx::Rect(20, 30, 100, 50), NULL));
   StaticFocusClient focus_client(focused.get());
   client::SetFocusClient(root_window(), &focus_client);
   EXPECT_FALSE(root_window()->Contains(focused.get()));
   EXPECT_EQ(focused.get(),
             client::GetFocusClient(root_window())->GetFocusedWindow());
   host()->dispatcher()->DispatchCancelModeEvent();
   EXPECT_EQ(focused.get(),
             client::GetFocusClient(root_window())->GetFocusedWindow());
 }
 
 // Dispatches a mouse-move event to |target| when it receives a mouse-move
 // event.
 class DispatchEventHandler : public ui::EventHandler {
  public:
   explicit DispatchEventHandler(Window* target)
       : target_(target),
         dispatched_(false) {}
-  virtual ~DispatchEventHandler() {}
+  ~DispatchEventHandler() override {}
 
   bool dispatched() const { return dispatched_; }
  private:
   // ui::EventHandler:
-  virtual void OnMouseEvent(ui::MouseEvent* mouse) override {
+  void OnMouseEvent(ui::MouseEvent* mouse) override {
     if (mouse->type() == ui::ET_MOUSE_MOVED) {
       ui::MouseEvent move(ui::ET_MOUSE_MOVED, target_->bounds().CenterPoint(),
           target_->bounds().CenterPoint(), ui::EF_NONE, ui::EF_NONE);
       ui::EventDispatchDetails details =
           target_->GetHost()->dispatcher()->OnEventFromSource(&move);
       ASSERT_FALSE(details.dispatcher_destroyed);
       EXPECT_FALSE(details.target_destroyed);
       EXPECT_EQ(target_, move.target());
       dispatched_ = true;
     }
     ui::EventHandler::OnMouseEvent(mouse);
   }
 
   Window* target_;
   bool dispatched_;
 
   DISALLOW_COPY_AND_ASSIGN(DispatchEventHandler);
 };
 
 // Moves |window| to |root_window| when it receives a mouse-move event.
 class MoveWindowHandler : public ui::EventHandler {
  public:
   MoveWindowHandler(Window* window, Window* root_window)
       : window_to_move_(window),
         root_window_to_move_to_(root_window) {}
-  virtual ~MoveWindowHandler() {}
+  ~MoveWindowHandler() override {}
 
  private:
   // ui::EventHandler:
-  virtual void OnMouseEvent(ui::MouseEvent* mouse) override {
+  void OnMouseEvent(ui::MouseEvent* mouse) override {
     if (mouse->type() == ui::ET_MOUSE_MOVED) {
       root_window_to_move_to_->AddChild(window_to_move_);
     }
     ui::EventHandler::OnMouseEvent(mouse);
   }
 
   Window* window_to_move_;
   Window* root_window_to_move_to_;
 
   DISALLOW_COPY_AND_ASSIGN(MoveWindowHandler);
@@ skipping 41 matching lines @@
   EXPECT_TRUE(dispatch_event.dispatched());
   EXPECT_EQ(second_root, first->GetRootWindow());
 
   first->RemovePreTargetHandler(&dispatch_event);
   second->RemovePreTargetHandler(&move_window);
 }
 
 class AlwaysMouseDownInputStateLookup : public InputStateLookup {
  public:
   AlwaysMouseDownInputStateLookup() {}
-  virtual ~AlwaysMouseDownInputStateLookup() {}
+  ~AlwaysMouseDownInputStateLookup() override {}
 
  private:
   // InputStateLookup:
-  virtual bool IsMouseButtonDown() const override { return true; }
+  bool IsMouseButtonDown() const override { return true; }
 
   DISALLOW_COPY_AND_ASSIGN(AlwaysMouseDownInputStateLookup);
 };
 
 TEST_F(WindowEventDispatcherTest,
        CursorVisibilityChangedWhileCaptureWindowInAnotherDispatcher) {
   test::EventCountDelegate delegate;
   scoped_ptr<Window> window(CreateTestWindowWithDelegate(&delegate, 123,
       gfx::Rect(20, 10, 10, 20), root_window()));
   window->Show();
@@ skipping 76 matching lines @@
 
 class AsyncWindowDelegate : public test::TestWindowDelegate {
  public:
   AsyncWindowDelegate(WindowEventDispatcher* dispatcher)
       : dispatcher_(dispatcher) {}
 
   void set_window(Window* window) {
     window_ = window;
   }
  private:
-  virtual void OnTouchEvent(ui::TouchEvent* event) override {
+  void OnTouchEvent(ui::TouchEvent* event) override {
     // Convert touch event back to root window coordinates.
     event->ConvertLocationToTarget(window_, window_->GetRootWindow());
     dispatcher_->ProcessedTouchEvent(event, window_, ui::ER_UNHANDLED);
     event->StopPropagation();
   }
 
   WindowEventDispatcher* dispatcher_;
   Window* window_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncWindowDelegate);
@@ skipping 27 matching lines @@
   ASSERT_EQ(1u, recorder.touch_locations().size());
   EXPECT_EQ(gfx::Point(kX - kWindowOffset, kY - kWindowOffset).ToString(),
             recorder.touch_locations()[0].ToString());
 
   ASSERT_EQ(2u, recorder.gesture_locations().size());
   EXPECT_EQ(gfx::Point(kX - kWindowOffset, kY - kWindowOffset).ToString(),
             recorder.gesture_locations()[0].ToString());
 }
 
 }  // namespace aura