mus: Change PointerWatcher to observe all pointer events, with moves optional.

services/ui/public/cpp/tests/window_tree_client_unittest.cc

Index: services/ui/public/cpp/tests/window_tree_client_unittest.cc
diff --git a/services/ui/public/cpp/tests/window_tree_client_unittest.cc b/services/ui/public/cpp/tests/window_tree_client_unittest.cc
index 5766f754a24bdfece1d6762111ca939c985b4d85..5f236920ffdf6a637a1339ad5a4aefea182764c7 100644
--- a/services/ui/public/cpp/tests/window_tree_client_unittest.cc
+++ b/services/ui/public/cpp/tests/window_tree_client_unittest.cc
@@ -52,19 +52,20 @@ class TestWindowTreeClientDelegate : public WindowTreeClientDelegate {
   TestWindowTreeClientDelegate() {}
   ~TestWindowTreeClientDelegate() override {}
 
-  ui::Event* last_event_observed() { return last_event_observed_.get(); }
+  ui::PointerEvent* last_event_observed() { return last_event_observed_.get(); }
 
   void Reset() { last_event_observed_.reset(); }
 
   // WindowTreeClientDelegate:
   void OnEmbed(Window* root) override {}
   void OnDidDestroyClient(WindowTreeClient* client) override {}
-  void OnEventObserved(const ui::Event& event, Window* target) override {
-    last_event_observed_ = ui::Event::Clone(event);
+  void OnPointerEventObserved(const ui::PointerEvent& event,
+                              Window* target) override {
+    last_event_observed_.reset(new ui::PointerEvent(event));
   }
 
  private:
-  std::unique_ptr<ui::Event> last_event_observed_;
+  std::unique_ptr<ui::PointerEvent> last_event_observed_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWindowTreeClientDelegate);
 };
@@ -95,8 +96,8 @@ class WindowTreeSetup {
                                         : *client()->GetRoots().begin();
   }
 
-  uint32_t GetEventObserverId() {
-    return WindowTreeClientPrivate(&tree_client_).event_observer_id();
+  uint32_t GetPointerWatcherId() {
+    return WindowTreeClientPrivate(&tree_client_).pointer_watcher_id();
   }
 
  private:
@@ -466,112 +467,108 @@ TEST_F(WindowTreeClientTest, InputEventBasic) {
   EXPECT_TRUE(setup.window_tree()->WasEventAcked(33));
 }
 
-// Tests event observers triggered by events that did not hit a target in this
+// Tests pointer watchers triggered by events that did not hit a target in this
 // window tree.
-TEST_F(WindowTreeClientTest, OnEventObserved) {
+TEST_F(WindowTreeClientTest, OnPointerEventObserved) {
   WindowTreeSetup setup;
   Window* root = setup.GetFirstRoot();
   ASSERT_TRUE(root);
 
-  // Set up an event observer.
-  mojom::EventMatcherPtr matcher = mojom::EventMatcher::New();
-  matcher->type_matcher = mojom::EventTypeMatcher::New();
-  matcher->type_matcher->type = ui::mojom::EventType::POINTER_DOWN;
-  setup.client()->SetEventObserver(std::move(matcher));
+  // Start a pointer watcher for all events excluding move events.
+  setup.client()->StartPointerWatcher(false /* want_moves */);
 
   // Simulate the server sending an observed event.
-  uint32_t event_observer_id = setup.GetEventObserverId();
-  std::unique_ptr<ui::Event> ui_event(
-      new ui::MouseEvent(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
-                         ui::EventTimeForNow(), ui::EF_CONTROL_DOWN, 0));
-  setup.window_tree_client()->OnEventObserved(ui::Event::Clone(*ui_event.get()),
-                                              event_observer_id);
+  uint32_t pointer_watcher_id = setup.GetPointerWatcherId();
+  std::unique_ptr<ui::PointerEvent> pointer_event_down(new ui::PointerEvent(
+      ui::ET_POINTER_DOWN, gfx::Point(), gfx::Point(), ui::EF_CONTROL_DOWN, 1,
+      ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH),
+      base::TimeTicks()));
+  setup.window_tree_client()->OnPointerEventObserved(
+      std::move(pointer_event_down), pointer_watcher_id);
 
   // Delegate sensed the event.
   ui::Event* last_event = setup.window_tree_delegate()->last_event_observed();
-  EXPECT_EQ(ui::ET_MOUSE_PRESSED, last_event->type());
+  EXPECT_EQ(ui::ET_POINTER_DOWN, last_event->type());
   EXPECT_EQ(ui::EF_CONTROL_DOWN, last_event->flags());
   setup.window_tree_delegate()->Reset();
 
-  // Clear the event observer.
-  setup.client()->SetEventObserver(nullptr);
+  // Stop the pointer watcher.
+  setup.client()->StopPointerWatcher();
 
   // Simulate another event from the server.
-  setup.window_tree_client()->OnEventObserved(ui::Event::Clone(*ui_event.get()),
-                                              event_observer_id);
+  std::unique_ptr<ui::PointerEvent> pointer_event_up(new ui::PointerEvent(
+      ui::ET_POINTER_UP, gfx::Point(), gfx::Point(), ui::EF_CONTROL_DOWN, 1,
+      ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH),
+      base::TimeTicks()));
+  setup.window_tree_client()->OnPointerEventObserved(
+      std::move(pointer_event_up), pointer_watcher_id);
 
   // No event was sensed.
   EXPECT_FALSE(setup.window_tree_delegate()->last_event_observed());
 }
 
-// Tests event observers triggered by events that hit this window tree.
-TEST_F(WindowTreeClientTest, OnWindowInputEventWithEventObserver) {
+// Tests pointer watchers triggered by events that hit this window tree.
+TEST_F(WindowTreeClientTest, OnWindowInputEventWithPointerWatcher) {
   WindowTreeSetup setup;
   Window* root = setup.GetFirstRoot();
   ASSERT_TRUE(root);
 
-  // Set up an event observer.
-  mojom::EventMatcherPtr matcher = mojom::EventMatcher::New();
-  matcher->type_matcher = mojom::EventTypeMatcher::New();
-  matcher->type_matcher->type = ui::mojom::EventType::POINTER_DOWN;
-  setup.client()->SetEventObserver(std::move(matcher));
+  // Start a pointer watcher for all events excluding move events.
+  setup.client()->StartPointerWatcher(false /* want_moves */);
 
   // Simulate the server dispatching an event that also matched the observer.
-  uint32_t event_observer_id = setup.GetEventObserverId();
-  std::unique_ptr<ui::Event> ui_event(
-      new ui::MouseEvent(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
-                         ui::EventTimeForNow(), ui::EF_CONTROL_DOWN, 0));
+  uint32_t pointer_watcher_id = setup.GetPointerWatcherId();
+  std::unique_ptr<ui::PointerEvent> pointer_event_down(new ui::PointerEvent(
+      ui::ET_POINTER_DOWN, gfx::Point(), gfx::Point(), ui::EF_CONTROL_DOWN, 1,
+      ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH),
+      base::TimeTicks()));
   setup.window_tree_client()->OnWindowInputEvent(
-      1, server_id(root), std::move(ui_event), event_observer_id);
+      1, server_id(root), std::move(pointer_event_down), pointer_watcher_id);
 
   // Delegate sensed the event.
   ui::Event* last_event = setup.window_tree_delegate()->last_event_observed();
-  EXPECT_EQ(ui::ET_MOUSE_PRESSED, last_event->type());
+  EXPECT_EQ(ui::ET_POINTER_DOWN, last_event->type());
   EXPECT_EQ(ui::EF_CONTROL_DOWN, last_event->flags());
 }
 
-// Tests that replacing an event observer with a new one results in only new
-// events being observed.
-TEST_F(WindowTreeClientTest, EventObserverReplaced) {
+// Tests that replacing a pointer watcher with a new one that has different
+// |want_moves| values results in only new events being observed.
+TEST_F(WindowTreeClientTest, PointerWatcherReplaced) {
   WindowTreeSetup setup;
   Window* root = setup.GetFirstRoot();
   ASSERT_TRUE(root);
 
-  // Set up an event observer.
-  mojom::EventMatcherPtr matcher1 = mojom::EventMatcher::New();
-  matcher1->type_matcher = mojom::EventTypeMatcher::New();
-  matcher1->type_matcher->type = ui::mojom::EventType::POINTER_DOWN;
-  setup.client()->SetEventObserver(std::move(matcher1));
-  uint32_t event_observer_id1 = setup.GetEventObserverId();
-
-  // Replace it with a second observer.
-  mojom::EventMatcherPtr matcher2 = mojom::EventMatcher::New();
-  matcher2->type_matcher = mojom::EventTypeMatcher::New();
-  matcher2->type_matcher->type = ui::mojom::EventType::POINTER_UP;
-  setup.client()->SetEventObserver(std::move(matcher2));
-  uint32_t event_observer_id2 = setup.GetEventObserverId();
-
-  // Simulate the server sending an observed event that matched the old observer
-  // (e.g. that was in-flight when the observer was replaced).
-  std::unique_ptr<ui::Event> pressed_event(
-      new ui::MouseEvent(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
-                         ui::EventTimeForNow(), ui::EF_NONE, 0));
-  setup.window_tree_client()->OnEventObserved(std::move(pressed_event),
-                                              event_observer_id1);
+  // Start a pointer watcher for all events excluding move events.
+  setup.client()->StartPointerWatcher(false /* want_moves */);
+  uint32_t pointer_watcher_id1 = setup.GetPointerWatcherId();
+
+  // Replace it with a second watcher that also watches for move events.
+  setup.client()->StartPointerWatcher(true /* want_moves */);
+  uint32_t pointer_watcher_id2 = setup.GetPointerWatcherId();
 
-  // The event was not sensed, because it does not match the current observer.
+  // Simulate the server sending an observed event that matched the old watcher
+  // (e.g. that was in-flight when the observer was replaced).
+  std::unique_ptr<ui::PointerEvent> pointer_event_down(new ui::PointerEvent(
+      ui::ET_POINTER_DOWN, gfx::Point(), gfx::Point(), ui::EF_CONTROL_DOWN, 1,
+      ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH),
+      base::TimeTicks()));
+  setup.window_tree_client()->OnPointerEventObserved(
+      std::move(pointer_event_down), pointer_watcher_id1);
+
+  // The event was not sensed, because it does not match the current watcher.
   EXPECT_FALSE(setup.window_tree_delegate()->last_event_observed());
 
-  // Simulate another event that matches the new observer.
-  std::unique_ptr<ui::Event> released_event(
-      new ui::MouseEvent(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(),
-                         ui::EventTimeForNow(), ui::EF_CONTROL_DOWN, 0));
-  setup.window_tree_client()->OnEventObserved(std::move(released_event),
-                                              event_observer_id2);
+  // Simulate another event that matches the new watcher.
+  std::unique_ptr<ui::PointerEvent> pointer_event_move(new ui::PointerEvent(
+      ui::ET_POINTER_MOVED, gfx::Point(), gfx::Point(), ui::EF_CONTROL_DOWN, 1,
+      ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH),
+      base::TimeTicks()));
+  setup.window_tree_client()->OnPointerEventObserved(
+      std::move(pointer_event_move), pointer_watcher_id2);
 
   // The delegate sensed the event.
   ui::Event* last_event = setup.window_tree_delegate()->last_event_observed();
-  EXPECT_EQ(ui::ET_MOUSE_RELEASED, last_event->type());
+  EXPECT_EQ(ui::ET_POINTER_MOVED, last_event->type());
   EXPECT_EQ(ui::EF_CONTROL_DOWN, last_event->flags());
 }