Chromium roll (https://codereview.chromium.org/976353002)

ui/events/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/events/event_dispatcher.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
 #include "ui/events/event_dispatcher.h"
 #include "ui/events/event_target.h"
 #include "ui/events/event_target_iterator.h"
 #include "ui/events/event_utils.h"
 
 namespace ui {
 
 namespace {
 
 class TestTarget : public EventTarget {
  public:
   TestTarget() : parent_(NULL), valid_(true) {}
-  virtual ~TestTarget() {}
+  ~TestTarget() override {}
 
   void set_parent(TestTarget* parent) { parent_ = parent; }
 
   bool valid() const { return valid_; }
   void set_valid(bool valid) { valid_ = valid; }
 
   void AddHandlerId(int id) {
     handler_list_.push_back(id);
   }
 
   const std::vector<int>& handler_list() const { return handler_list_; }
 
   void Reset() {
     handler_list_.clear();
     valid_ = true;
   }
 
  private:
   // Overridden from EventTarget:
-  virtual bool CanAcceptEvent(const ui::Event& event) override {
+  bool CanAcceptEvent(const ui::Event& event) override {
     return true;
   }
 
-  virtual EventTarget* GetParentTarget() override {
+  EventTarget* GetParentTarget() override {
     return parent_;
   }
 
-  virtual scoped_ptr<EventTargetIterator> GetChildIterator() override {
+  scoped_ptr<EventTargetIterator> GetChildIterator() override {
     return scoped_ptr<EventTargetIterator>();
   }
 
-  virtual EventTargeter* GetEventTargeter() override {
+  EventTargeter* GetEventTargeter() override {
     return NULL;
   }
 
   TestTarget* parent_;
   std::vector<int> handler_list_;
   bool valid_;
 
   DISALLOW_COPY_AND_ASSIGN(TestTarget);
 };
 
 class TestEventHandler : public EventHandler {
  public:
   TestEventHandler(int id)
       : id_(id),
         event_result_(ER_UNHANDLED),
         expect_pre_target_(false),
         expect_post_target_(false),
         received_pre_target_(false) {
   }
 
-  virtual ~TestEventHandler() {}
+  ~TestEventHandler() override {}
 
   virtual void ReceivedEvent(Event* event) {
     static_cast<TestTarget*>(event->target())->AddHandlerId(id_);
     if (event->phase() == ui::EP_POSTTARGET) {
       EXPECT_TRUE(expect_post_target_);
       if (expect_pre_target_)
         EXPECT_TRUE(received_pre_target_);
     } else if (event->phase() == ui::EP_PRETARGET) {
       EXPECT_TRUE(expect_pre_target_);
       received_pre_target_ = true;
     } else {
       NOTREACHED();
     }
   }
 
   void set_event_result(EventResult result) { event_result_ = result; }
 
   void set_expect_pre_target(bool expect) { expect_pre_target_ = expect; }
   void set_expect_post_target(bool expect) { expect_post_target_ = expect; }
 
  private:
   // Overridden from EventHandler:
-  virtual void OnEvent(Event* event) override {
+  void OnEvent(Event* event) override {
     ui::EventHandler::OnEvent(event);
     ReceivedEvent(event);
     SetStatusOnEvent(event);
   }
 
   void SetStatusOnEvent(Event* event) {
     if (event_result_ & ui::ER_CONSUMED)
       event->StopPropagation();
     if (event_result_ & ui::ER_HANDLED)
       event->SetHandled();
   }
 
   int id_;
   EventResult event_result_;
   bool expect_pre_target_;
   bool expect_post_target_;
   bool received_pre_target_;
 
   DISALLOW_COPY_AND_ASSIGN(TestEventHandler);
 };
 
 class NonCancelableEvent : public Event {
  public:
   NonCancelableEvent()
       : Event(ui::ET_CANCEL_MODE, ui::EventTimeForNow(), 0) {
     set_cancelable(false);
   }
 
-  virtual ~NonCancelableEvent() {}
+  ~NonCancelableEvent() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NonCancelableEvent);
 };
 
 // Destroys the dispatcher-delegate when it receives any event.
 class EventHandlerDestroyDispatcherDelegate : public TestEventHandler {
  public:
   EventHandlerDestroyDispatcherDelegate(EventDispatcherDelegate* delegate,
                                         int id)
       : TestEventHandler(id),
         dispatcher_delegate_(delegate) {
   }
 
-  virtual ~EventHandlerDestroyDispatcherDelegate() {}
+  ~EventHandlerDestroyDispatcherDelegate() override {}
 
  private:
-  virtual void ReceivedEvent(Event* event) override {
+  void ReceivedEvent(Event* event) override {
     TestEventHandler::ReceivedEvent(event);
     delete dispatcher_delegate_;
   }
 
   EventDispatcherDelegate* dispatcher_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(EventHandlerDestroyDispatcherDelegate);
 };
 
 // Invalidates the target when it receives any event.
 class InvalidateTargetEventHandler : public TestEventHandler {
  public:
   explicit InvalidateTargetEventHandler(int id) : TestEventHandler(id) {}
-  virtual ~InvalidateTargetEventHandler() {}
+  ~InvalidateTargetEventHandler() override {}
 
  private:
-  virtual void ReceivedEvent(Event* event) override {
+  void ReceivedEvent(Event* event) override {
    TestEventHandler::ReceivedEvent(event);
    TestTarget* target = static_cast<TestTarget*>(event->target());
    target->set_valid(false);
   }
 
   DISALLOW_COPY_AND_ASSIGN(InvalidateTargetEventHandler);
 };
 
 // Destroys a second event handler when this handler gets an event.
 // Optionally also destroys the dispatcher.
 class EventHandlerDestroyer : public TestEventHandler {
  public:
   EventHandlerDestroyer(int id, EventHandler* destroy)
       : TestEventHandler(id),
         to_destroy_(destroy),
         dispatcher_delegate_(NULL) {
   }
 
-  virtual ~EventHandlerDestroyer() {
+  ~EventHandlerDestroyer() override {
     CHECK(!to_destroy_);
   }
 
   void set_dispatcher_delegate(EventDispatcherDelegate* dispatcher_delegate) {
     dispatcher_delegate_ = dispatcher_delegate;
   }
 
  private:
-  virtual void ReceivedEvent(Event* event) override {
+  void ReceivedEvent(Event* event) override {
     TestEventHandler::ReceivedEvent(event);
     delete to_destroy_;
     to_destroy_ = NULL;
 
     if (dispatcher_delegate_) {
       delete dispatcher_delegate_;
       dispatcher_delegate_ = NULL;
     }
   }
 
   EventHandler* to_destroy_;
   EventDispatcherDelegate* dispatcher_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(EventHandlerDestroyer);
 };
 
 class TestEventDispatcher : public EventDispatcherDelegate {
  public:
   TestEventDispatcher() {}
 
-  virtual ~TestEventDispatcher() {}
+  ~TestEventDispatcher() override {}
 
   EventDispatchDetails ProcessEvent(EventTarget* target, Event* event) {
     return DispatchEvent(target, event);
   }
 
  private:
   // Overridden from EventDispatcherDelegate:
-  virtual bool CanDispatchToTarget(EventTarget* target) override {
+  bool CanDispatchToTarget(EventTarget* target) override {
     TestTarget* test_target = static_cast<TestTarget*>(target);
     return test_target->valid();
   }
 
   DISALLOW_COPY_AND_ASSIGN(TestEventDispatcher);
 };
 
 }  // namespace
 
 TEST(EventDispatcherTest, EventDispatchOrder) {
@@ skipping 371 matching lines @@
     NonCancelableEvent event;
     EventDispatchDetails details = dispatcher->ProcessEvent(&target, &event);
     EXPECT_TRUE(details.dispatcher_destroyed);
     EXPECT_EQ(2U, target.handler_list().size());
     EXPECT_EQ(1, target.handler_list()[0]);
     EXPECT_EQ(2, target.handler_list()[1]);
   }
 }
 
 }  // namespace ui