mus: Add PointerWatcher for passively observing mouse and touch events

components/mus/public/cpp/tests/window_tree_client_impl_unittest.cc

 // Copyright 2015 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 "components/mus/public/cpp/lib/window_tree_client_impl.h"
 
 #include <stdint.h>
 
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 35 matching lines @@
   transport_value.resize(bytes.size());
   memcpy(&transport_value.front(), &(bytes.front()), bytes.size());
   return transport_value;
 }
 
 class TestWindowTreeDelegate : public WindowTreeDelegate {
  public:
   TestWindowTreeDelegate() {}
   ~TestWindowTreeDelegate() override {}
 
+  ui::Event* last_event_observed() { return last_event_observed_.get(); }
+
+  void Reset() { last_event_observed_.reset(); }
+
   // WindowTreeDelegate:
   void OnEmbed(Window* root) override {}
   void OnConnectionLost(WindowTreeConnection* connection) override {}
+  void OnEventObserved(const ui::Event& event) override {
+    last_event_observed_ = ui::Event::Clone(event);
+  }
 
  private:
+  std::unique_ptr<ui::Event> last_event_observed_;
+
   DISALLOW_COPY_AND_ASSIGN(TestWindowTreeDelegate);
 };
 
 class WindowTreeClientImplPrivate {
  public:
   WindowTreeClientImplPrivate(WindowTreeClientImpl* tree_client_impl)
       : tree_client_impl_(tree_client_impl) {}
   ~WindowTreeClientImplPrivate() {}
 
   void Init(mojom::WindowTree* window_tree) {
     mojom::WindowDataPtr root_data(mojom::WindowData::New());
     root_data->parent_id = 0;
     root_data->window_id = 1;
     root_data->bounds = mojo::Rect::From(gfx::Rect());
     root_data->properties.SetToEmpty();
     root_data->visible = true;
     root_data->viewport_metrics = mojom::ViewportMetrics::New();
     root_data->viewport_metrics->size_in_pixels =
         mojo::Size::From(gfx::Size(1000, 1000));
     root_data->viewport_metrics->device_pixel_ratio = 1;
     tree_client_impl_->OnEmbedImpl(window_tree, 1, std::move(root_data), 0,
                                    true);
   }
 
+  uint32_t event_observer_id() { return tree_client_impl_->event_observer_id_; }
+
  private:
   WindowTreeClientImpl* tree_client_impl_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTreeClientImplPrivate);
 };
 
 class WindowTreeSetup {
  public:
   WindowTreeSetup() : tree_client_(&window_tree_delegate_, nullptr, nullptr) {
     WindowTreeClientImplPrivate(&tree_client_).Init(&window_tree_);
     window_tree_.GetAndClearChangeId(nullptr);
   }
 
   WindowTreeConnection* window_tree_connection() {
     return static_cast<WindowTreeConnection*>(&tree_client_);
   }
 
   mojom::WindowTreeClient* window_tree_client() {
     return static_cast<mojom::WindowTreeClient*>(&tree_client_);
   }
 
   TestWindowTree* window_tree() { return &window_tree_; }
 
+  TestWindowTreeDelegate* window_tree_delegate() {
+    return &window_tree_delegate_;
+  }
+
   Window* GetFirstRoot() {
     return window_tree_connection()->GetRoots().empty()
                ? nullptr
                : *window_tree_connection()->GetRoots().begin();
   }
 
+  uint32_t GetEventObserverId() {
+    return WindowTreeClientImplPrivate(&tree_client_).event_observer_id();
+  }
+
  private:
   TestWindowTree window_tree_;
   TestWindowTreeDelegate window_tree_delegate_;
   WindowTreeClientImpl tree_client_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTreeSetup);
 };
 
 class TestInputEventHandler : public InputEventHandler {
  public:
@@ skipping 334 matching lines @@
   Window* root = setup.GetFirstRoot();
   ASSERT_TRUE(root);
 
   TestInputEventHandler event_handler;
   root->set_input_event_handler(&event_handler);
 
   std::unique_ptr<ui::Event> ui_event(
       new ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::Point(), gfx::Point(),
                          ui::EventTimeForNow(), ui::EF_NONE, 0));
   setup.window_tree_client()->OnWindowInputEvent(
-      1, server_id(root), mojom::Event::From(*ui_event.get()), false);
+      1, server_id(root), mojom::Event::From(*ui_event.get()), 0);
   EXPECT_TRUE(event_handler.received_event());
   EXPECT_TRUE(setup.window_tree()->WasEventAcked(1));
   event_handler.Reset();
 
   event_handler.set_should_manually_ack();
   setup.window_tree_client()->OnWindowInputEvent(
-      33, server_id(root), mojom::Event::From(*ui_event.get()), false);
+      33, server_id(root), mojom::Event::From(*ui_event.get()), 0);
   EXPECT_TRUE(event_handler.received_event());
   EXPECT_FALSE(setup.window_tree()->WasEventAcked(33));
 
   event_handler.AckEvent();
   EXPECT_TRUE(setup.window_tree()->WasEventAcked(33));
 }
 
+// Tests event observers triggered by events that did not hit a target in this
+// window tree.
+TEST_F(WindowTreeClientImplTest, OnEventObserved) {
+  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 = mojom::EventType::POINTER_DOWN;
+  setup.window_tree_connection()->SetEventObserver(std::move(matcher));
+
+  // 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(
+      mojom::Event::From(*ui_event.get()), event_observer_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::EF_CONTROL_DOWN, last_event->flags());
+  setup.window_tree_delegate()->Reset();
+
+  // Clear the event observer.
+  setup.window_tree_connection()->SetEventObserver(nullptr);
+
+  // Simulate another event from the server.
+  setup.window_tree_client()->OnEventObserved(
+      mojom::Event::From(*ui_event.get()), event_observer_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(WindowTreeClientImplTest, OnWindowInputEventWithEventObserver) {
+  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 = mojom::EventType::POINTER_DOWN;
+  setup.window_tree_connection()->SetEventObserver(std::move(matcher));
+
+  // 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));
+  setup.window_tree_client()->OnWindowInputEvent(
+      1, server_id(root), mojom::Event::From(*ui_event.get()),
+      event_observer_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::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(WindowTreeClientImplTest, EventObserverReplaced) {
+  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 = mojom::EventType::POINTER_DOWN;
+  setup.window_tree_connection()->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 = mojom::EventType::POINTER_UP;
+  setup.window_tree_connection()->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(
+      mojom::Event::From(*pressed_event.get()), event_observer_id1);
+
+  // The event was not sensed, because it does not match the current observer.
+  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(
+      mojom::Event::From(*released_event.get()), event_observer_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::EF_CONTROL_DOWN, last_event->flags());
+}
+
 // Verifies focus is reverted if the server replied that the change failed.
 TEST_F(WindowTreeClientImplTest, SetFocusFailed) {
   WindowTreeSetup setup;
   Window* root = setup.GetFirstRoot();
   ASSERT_TRUE(root);
   root->SetVisible(true);
   Window* child = setup.window_tree_connection()->NewWindow();
   child->SetVisible(true);
   root->AddChild(child);
   Window* original_focus = setup.window_tree_connection()->GetFocusedWindow();
@@ skipping 428 matching lines @@
 
   setup.window_tree_client()->OnChangeCompleted(change_id2, false);
   EXPECT_FALSE(child->HasCapture());
   EXPECT_TRUE(root->HasCapture());
 
   setup.window_tree_client()->OnLostCapture(server_id(root));
   EXPECT_FALSE(root->HasCapture());
 }
 
 }  // namespace mus