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

ui/events/event_processor_unittest.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 <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
 #include "ui/events/event_targeter.h"
 #include "ui/events/test/events_test_utils.h"
 #include "ui/events/test/test_event_handler.h"
 #include "ui/events/test/test_event_processor.h"
 #include "ui/events/test/test_event_target.h"
 
 typedef std::vector<std::string> HandlerSequenceRecorder;
 
 namespace ui {
 namespace test {
 
 class EventProcessorTest : public testing::Test {
  public:
   EventProcessorTest() {}
-  virtual ~EventProcessorTest() {}
+  ~EventProcessorTest() override {}
 
   // testing::Test:
-  virtual void SetUp() override {
+  void SetUp() override {
     processor_.SetRoot(scoped_ptr<EventTarget>(new TestEventTarget()));
     processor_.Reset();
     root()->SetEventTargeter(make_scoped_ptr(new EventTargeter()));
   }
 
   TestEventTarget* root() {
     return static_cast<TestEventTarget*>(processor_.GetRootTarget());
   }
 
   TestEventProcessor* processor() {
@@ skipping 34 matching lines @@
   virtual bool SubtreeShouldBeExploredForEvent(
       EventTarget* target, const LocatedEvent& event) override {
     T* t = static_cast<T*>(target);
     return (t->bounds().Contains(event.location()));
   }
 };
 
 class BoundsTestTarget : public TestEventTarget {
  public:
   BoundsTestTarget() {}
-  virtual ~BoundsTestTarget() {}
+  ~BoundsTestTarget() override {}
 
   void set_bounds(gfx::Rect rect) { bounds_ = rect; }
   gfx::Rect bounds() const { return bounds_; }
 
   static void ConvertPointToTarget(BoundsTestTarget* source,
                                    BoundsTestTarget* target,
                                    gfx::Point* location) {
     gfx::Vector2d vector;
     if (source->Contains(target)) {
       for (; target && target != source;
            target = static_cast<BoundsTestTarget*>(target->parent())) {
         vector += target->bounds().OffsetFromOrigin();
       }
       *location -= vector;
     } else if (target->Contains(source)) {
       for (; source && source != target;
            source = static_cast<BoundsTestTarget*>(source->parent())) {
         vector += source->bounds().OffsetFromOrigin();
       }
       *location += vector;
     } else {
       NOTREACHED();
     }
   }
 
  private:
   // EventTarget:
-  virtual void ConvertEventToTarget(EventTarget* target,
-                                    LocatedEvent* event) override {
+  void ConvertEventToTarget(EventTarget* target,
+                            LocatedEvent* event) override {
     event->ConvertLocationToTarget(this,
                                    static_cast<BoundsTestTarget*>(target));
   }
 
   gfx::Rect bounds_;
 
   DISALLOW_COPY_AND_ASSIGN(BoundsTestTarget);
 };
 
 TEST_F(EventProcessorTest, Bounds) {
@@ skipping 54 matching lines @@
 
 // ReDispatchEventHandler is used to receive mouse events and forward them
 // to a specified EventProcessor. Verifies that the event has the correct
 // target and phase both before and after the nested event processing. Also
 // verifies that the location of the event remains the same after it has
 // been processed by the second EventProcessor.
 class ReDispatchEventHandler : public TestEventHandler {
  public:
   ReDispatchEventHandler(EventProcessor* processor, EventTarget* target)
       : processor_(processor), expected_target_(target) {}
-  virtual ~ReDispatchEventHandler() {}
+  ~ReDispatchEventHandler() override {}
 
   // TestEventHandler:
-  virtual void OnMouseEvent(MouseEvent* event) override {
+  void OnMouseEvent(MouseEvent* event) override {
     TestEventHandler::OnMouseEvent(event);
 
     EXPECT_EQ(expected_target_, event->target());
     EXPECT_EQ(EP_TARGET, event->phase());
 
     gfx::Point location(event->location());
     EventDispatchDetails details = processor_->OnEventFromSource(event);
     EXPECT_FALSE(details.dispatcher_destroyed);
     EXPECT_FALSE(details.target_destroyed);
 
@@ skipping 116 matching lines @@
   EXPECT_FALSE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_TRUE(mouse2.handled());
   EXPECT_EQ(1, processor()->num_times_processing_started());
   EXPECT_EQ(1, processor()->num_times_processing_finished());
 }
 
 class IgnoreEventTargeter : public EventTargeter {
  public:
   IgnoreEventTargeter() {}
-  virtual ~IgnoreEventTargeter() {}
+  ~IgnoreEventTargeter() override {}
 
  private:
   // EventTargeter:
-  virtual bool SubtreeShouldBeExploredForEvent(
+  bool SubtreeShouldBeExploredForEvent(
       EventTarget* target, const LocatedEvent& event) override {
     return false;
   }
 };
 
 // Verifies that the EventTargeter installed on an EventTarget can dictate
 // whether the target itself can process an event.
 TEST_F(EventProcessorTest, TargeterChecksOwningEventTarget) {
   scoped_ptr<TestEventTarget> child(new TestEventTarget());
   root()->AddChild(child.Pass());
@@ skipping 17 matching lines @@
 }
 
 // An EventTargeter which is used to allow a bubbling behaviour in event
 // dispatch: if an event is not handled after being dispatched to its
 // initial target, the event is dispatched to the next-best target as
 // specified by FindNextBestTarget().
 class BubblingEventTargeter : public EventTargeter {
  public:
   explicit BubblingEventTargeter(TestEventTarget* initial_target)
     : initial_target_(initial_target) {}
-  virtual ~BubblingEventTargeter() {}
+  ~BubblingEventTargeter() override {}
 
  private:
   // EventTargeter:
-  virtual EventTarget* FindTargetForEvent(EventTarget* root,
+  EventTarget* FindTargetForEvent(EventTarget* root,
                                           Event* event) override {
     return initial_target_;
   }
 
-  virtual EventTarget* FindNextBestTarget(EventTarget* previous_target,
+  EventTarget* FindNextBestTarget(EventTarget* previous_target,
                                           Event* event) override {
     return previous_target->GetParentTarget();
   }
 
   TestEventTarget* initial_target_;
 
   DISALLOW_COPY_AND_ASSIGN(BubblingEventTargeter);
 };
 
 // Tests that unhandled events are correctly dispatched to the next-best
@@ skipping 129 matching lines @@
   DispatchEvent(&mouse);
 
   std::string expected[] = { "PreR", "PreC", "PreG", "G", "PostG", "PostC",
       "PostR", "PreR", "PreC", "C", "PostC", "PostR", "PreR", "R", "PostR" };
   EXPECT_EQ(std::vector<std::string>(
       expected, expected + arraysize(expected)), recorder);
 }
 
 }  // namespace test
 }  // namespace ui