Sync ui/events to chromium @ https://codereview.chromium.org/1210203002

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"
@@ skipping 20 matching lines @@
 
   const std::vector<int>& handler_list() const { return handler_list_; }
 
   void Reset() {
     handler_list_.clear();
     valid_ = true;
   }
 
  private:
   // Overridden from EventTarget:
-  bool CanAcceptEvent(const ui::Event& event) override {
-    return true;
+  bool CanAcceptEvent(const ui::Event& event) override { return true; }
+
+  EventTarget* GetParentTarget() override { return parent_; }
+
+  scoped_ptr<EventTargetIterator> GetChildIterator() const override {
+    return nullptr;
   }
 
-  EventTarget* GetParentTarget() override {
-    return parent_;
-  }
-
-  scoped_ptr<EventTargetIterator> GetChildIterator() override {
-    return scoped_ptr<EventTargetIterator>();
-  }
-
-  EventTargeter* GetEventTargeter() override {
-    return NULL;
-  }
+  EventTargeter* GetEventTargeter() override { return NULL; }
 
   TestTarget* parent_;
   std::vector<int> handler_list_;
   bool valid_;
 
   DISALLOW_COPY_AND_ASSIGN(TestTarget);
 };
 
 class TestEventHandler : public EventHandler {
  public:
@@ skipping 104 matching lines @@
 // 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) {
   }
 
-  ~EventHandlerDestroyer() override {
-    CHECK(!to_destroy_);
-  }
+  ~EventHandlerDestroyer() override { CHECK(!to_destroy_); }
 
   void set_dispatcher_delegate(EventDispatcherDelegate* dispatcher_delegate) {
     dispatcher_delegate_ = dispatcher_delegate;
   }
 
  private:
   void ReceivedEvent(Event* event) override {
     TestEventHandler::ReceivedEvent(event);
     delete to_destroy_;
     to_destroy_ = NULL;
@@ skipping 55 matching lines @@
   child.AddPostTargetHandler(&h6);
 
   parent.AddPostTargetHandler(&h7);
   parent.AddPostTargetHandler(&h8);
 
   h5.set_expect_post_target(true);
   h6.set_expect_post_target(true);
   h7.set_expect_post_target(true);
   h8.set_expect_post_target(true);
 
-  MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4),
-                   gfx::Point(3, 4), 0, 0);
+  MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4),
+                   ui::EventTimeForNow(), 0, 0);
   Event::DispatcherApi event_mod(&mouse);
   dispatcher.ProcessEvent(&child, &mouse);
   EXPECT_FALSE(mouse.stopped_propagation());
   EXPECT_FALSE(mouse.handled());
 
   {
     int expected[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
     EXPECT_EQ(
         std::vector<int>(expected, expected + sizeof(expected) / sizeof(int)),
         child.handler_list());
@@ skipping 52 matching lines @@
   TestEventDispatcher dispatcher;
   TestTarget target;
 
   TestEventHandler handler(11);
 
   target.AddPreTargetHandler(&handler);
   target.AddPostTargetHandler(&handler);
   handler.set_expect_pre_target(true);
   handler.set_expect_post_target(true);
 
-  MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4),
-                   gfx::Point(3, 4), 0, 0);
+  MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4),
+                   ui::EventTimeForNow(), 0, 0);
   Event::DispatcherApi event_mod(&mouse);
   dispatcher.ProcessEvent(&target, &mouse);
   EXPECT_EQ(ER_UNHANDLED, mouse.result());
 
   int handlers[] = { 11, 11 };
   EXPECT_EQ(
       std::vector<int>(handlers, handlers + sizeof(handlers) / sizeof(int)),
       target.handler_list());
 }
 
@@ skipping 10 matching lines @@
     target.AddPreTargetHandler(&h1);
     target.AddPreTargetHandler(&handler);
     target.AddPreTargetHandler(&h2);
 
     h1.set_expect_pre_target(true);
     handler.set_expect_pre_target(true);
     // |h2| should not receive any events at all since |handler| will have
     // destroyed the dispatcher.
     h2.set_expect_pre_target(false);
 
-    MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4),
-                     gfx::Point(3, 4), 0, 0);
+    MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4),
+                     ui::EventTimeForNow(), 0, 0);
     EventDispatchDetails details = dispatcher->ProcessEvent(&target, &mouse);
     EXPECT_TRUE(details.dispatcher_destroyed);
     EXPECT_EQ(ER_CONSUMED, mouse.result());
     EXPECT_EQ(2U, target.handler_list().size());
     EXPECT_EQ(1, target.handler_list()[0]);
     EXPECT_EQ(5, target.handler_list()[1]);
   }
 
   // Test for non-cancelable event.
   {
@@ skipping 30 matching lines @@
     target.AddPostTargetHandler(&h1);
     target.AddPostTargetHandler(&handler);
     target.AddPostTargetHandler(&h2);
 
     h1.set_expect_post_target(true);
     handler.set_expect_post_target(true);
     // |h2| should not receive any events at all since |handler| will have
     // destroyed the dispatcher.
     h2.set_expect_post_target(false);
 
-    MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4),
-                     gfx::Point(3, 4), 0, 0);
+    MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4),
+                     ui::EventTimeForNow(), 0, 0);
     EventDispatchDetails details = dispatcher->ProcessEvent(&target, &mouse);
     EXPECT_TRUE(details.dispatcher_destroyed);
     EXPECT_EQ(ER_CONSUMED, mouse.result());
     EXPECT_EQ(2U, target.handler_list().size());
     EXPECT_EQ(1, target.handler_list()[0]);
     EXPECT_EQ(5, target.handler_list()[1]);
   }
 
   // Test for non-cancelable event.
   {
@@ skipping 32 matching lines @@
 
   target.AddPreTargetHandler(&h1);
   target.AddPreTargetHandler(&invalidate_handler);
   target.AddPreTargetHandler(&h3);
 
   h1.set_expect_pre_target(true);
   invalidate_handler.set_expect_pre_target(true);
   // |h3| should not receive events as the target will be invalidated.
   h3.set_expect_pre_target(false);
 
-  MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4), 0,
-                   0);
+  MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4),
+                   ui::EventTimeForNow(), 0, 0);
   EventDispatchDetails details = dispatcher.ProcessEvent(&target, &mouse);
   EXPECT_FALSE(details.dispatcher_destroyed);
   EXPECT_TRUE(details.target_destroyed);
   EXPECT_FALSE(target.valid());
   EXPECT_TRUE(mouse.stopped_propagation());
   EXPECT_EQ(2U, target.handler_list().size());
   EXPECT_EQ(1, target.handler_list()[0]);
   EXPECT_EQ(2, target.handler_list()[1]);
 
   // Test for non-cancelable event.
@@ skipping 21 matching lines @@
     target.AddPreTargetHandler(&h1);
     target.AddPreTargetHandler(&handle_destroyer);
     target.AddPreTargetHandler(h3);
 
     h1.set_expect_pre_target(true);
     handle_destroyer.set_expect_pre_target(true);
     // |h3| should not receive events since |handle_destroyer| will have
     // destroyed it.
     h3->set_expect_pre_target(false);
 
-    MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4), 0,
-                     0);
+    MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4),
+                     ui::EventTimeForNow(), 0, 0);
     EventDispatchDetails details = dispatcher.ProcessEvent(&target, &mouse);
     EXPECT_FALSE(details.dispatcher_destroyed);
     EXPECT_FALSE(details.target_destroyed);
     EXPECT_FALSE(mouse.stopped_propagation());
     EXPECT_EQ(2U, target.handler_list().size());
     EXPECT_EQ(1, target.handler_list()[0]);
     EXPECT_EQ(2, target.handler_list()[1]);
   }
 
   // Test for non-cancelable events.
@@ skipping 36 matching lines @@
     target.AddPreTargetHandler(&destroyer);
     target.AddPreTargetHandler(h3);
 
     h1.set_expect_pre_target(true);
     destroyer.set_expect_pre_target(true);
     destroyer.set_dispatcher_delegate(dispatcher);
     // |h3| should not receive events since |destroyer| will have destroyed
     // it.
     h3->set_expect_pre_target(false);
 
-    MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4), 0,
-                     0);
+    MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4),
+                     ui::EventTimeForNow(), 0, 0);
     EventDispatchDetails details = dispatcher->ProcessEvent(&target, &mouse);
     EXPECT_TRUE(details.dispatcher_destroyed);
     EXPECT_TRUE(mouse.stopped_propagation());
     EXPECT_EQ(2U, target.handler_list().size());
     EXPECT_EQ(1, target.handler_list()[0]);
     EXPECT_EQ(2, target.handler_list()[1]);
   }
 
   // Test for non-cancelable events.
   {
@@ skipping 17 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