mus: Add EventObserver to allow passively listening to UI events

components/mus/ws/window_tree_unittest.cc

 // Copyright 2014 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/ws/window_tree.h"
 
 #include <stdint.h>
 
 #include <string>
 #include <vector>
@@ skipping 71 matching lines @@
   return ui::PointerEvent(
       ui::MouseEvent(ui::ET_MOUSE_RELEASED, gfx::Point(x, y), gfx::Point(x, y),
                      ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON,
                      ui::EF_LEFT_MOUSE_BUTTON));
 }
 
 ServerWindow* GetCaptureWindow(Display* display) {
   return display->GetActiveWindowManagerState()->capture_window();
 }
 
+mojom::EventMatcherPtr CreateEventMatcher(mojom::EventType type) {
+  mojom::EventMatcherPtr matcher = mojom::EventMatcher::New();
+  matcher->type_matcher = mojom::EventTypeMatcher::New();
+  matcher->type_matcher->type = type;
+  return matcher;
+}
+
 }  // namespace
 
 // -----------------------------------------------------------------------------
 
 class WindowTreeTest : public testing::Test {
  public:
   WindowTreeTest()
       : wm_client_(nullptr),
         cursor_id_(0),
         platform_display_factory_(&cursor_id_),
@@ skipping 61 matching lines @@
   // testing::Test:
   void SetUp() override {
     PlatformDisplay::set_factory_for_testing(&platform_display_factory_);
     window_server_.reset(new WindowServer(&delegate_, surfaces_state_));
     PlatformDisplayInitParams display_init_params;
     display_init_params.surfaces_state = surfaces_state_;
     display_ = new Display(window_server_.get(), display_init_params);
     display_binding_ = new TestDisplayBinding(display_, window_server_.get());
     display_->Init(base::WrapUnique(display_binding_));
     wm_client_ = delegate_.last_client();
+    wm_client_->tracker()->changes()->clear();
   }
 
  protected:
   // TestWindowTreeClient that is used for the WM connection.
   TestWindowTreeClient* wm_client_;
   int32_t cursor_id_;
   TestPlatformDisplayFactory platform_display_factory_;
   TestWindowServerDelegate delegate_;
   // Owned by WindowServer.
   TestDisplayBinding* display_binding_;
@@ skipping 18 matching lines @@
   EXPECT_TRUE(wm_tree()->AddWindow(FirstRootId(wm_tree()), embed_window_id));
   display_->root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   mojom::WindowTreeClientPtr client;
   mojom::WindowTreeClientRequest client_request = GetProxy(&client);
   wm_client()->Bind(std::move(client_request));
   wm_tree()->Embed(embed_window_id, std::move(client));
   ServerWindow* embed_window = wm_tree()->GetWindowByClientId(embed_window_id);
   WindowTree* tree1 = window_server()->GetTreeWithRoot(embed_window);
   ASSERT_TRUE(tree1 != nullptr);
   ASSERT_NE(tree1, wm_tree());
+  WindowTreeTestApi(tree1).set_user_id(wm_tree()->user_id());
 
   embed_window->SetBounds(gfx::Rect(0, 0, 50, 50));
 
   const ClientWindowId child1_id(BuildClientWindowId(tree1, 1));
   EXPECT_TRUE(tree1->NewWindow(child1_id, ServerWindow::Properties()));
   ServerWindow* child1 = tree1->GetWindowByClientId(child1_id);
   ASSERT_TRUE(child1);
   EXPECT_TRUE(tree1->AddWindow(ClientWindowIdForWindow(tree1, embed_window),
                                child1_id));
   tree1->GetDisplay(embed_window)->AddActivationParent(embed_window);
@@ skipping 106 matching lines @@
   ASSERT_EQ(1u, wm_client()->tracker()->changes()->size());
   EXPECT_EQ("Focused id=2,1",
             ChangesToDescription1(*wm_client()->tracker()->changes())[0]);
   ASSERT_EQ(2u, embed_connection->tracker()->changes()->size());
   EXPECT_EQ("Focused id=2,1",
             ChangesToDescription1(*embed_connection->tracker()->changes())[0]);
   EXPECT_EQ("InputEvent window=2,1 event_action=4",
             ChangesToDescription1(*embed_connection->tracker()->changes())[1]);
 }
 
+// Tests that a client can observe events outside its bounds.
+TEST_F(WindowTreeTest, SetEventObserver) {
+  // Create an embedded client.
+  TestWindowTreeClient* client = nullptr;
+  WindowTree* tree = nullptr;
+  ServerWindow* window = nullptr;
+  EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&client, &tree, &window));
+
+  // Create an event outside the bounds of the client.
+  ui::PointerEvent pointer_down = CreatePointerDownEvent(5, 5);
+
+  // Events are not observed before setting an observer.
+  DispatchEventAndAckImmediately(pointer_down);
+  ASSERT_EQ(0u, client->tracker()->changes()->size());
+
+  // Create an observer for pointer-down events.
+  WindowTreeTestApi(tree).SetEventObserver(
+      CreateEventMatcher(mojom::EventType::POINTER_DOWN), 111u);
+
+  // Pointer-down events are sent to the client.
+  DispatchEventAndAckImmediately(pointer_down);
+  ASSERT_EQ(1u, client->tracker()->changes()->size());
+  EXPECT_EQ("EventObserved event_action=4 event_observer_id=111",
+            ChangesToDescription1(*client->tracker()->changes())[0]);
+  client->tracker()->changes()->clear();
+
+  // Clearing the observer stops sending events to the client.
+  WindowTreeTestApi(tree).SetEventObserver(nullptr, 0u);
+  DispatchEventAndAckImmediately(pointer_down);
+  ASSERT_EQ(0u, client->tracker()->changes()->size());
+}
+
+// Tests that a client using an event observer does not receive events that
+// don't match the EventMatcher spec.
+TEST_F(WindowTreeTest, SetEventObserverNonMatching) {
+  // Create an embedded client.
+  TestWindowTreeClient* client = nullptr;
+  WindowTree* tree = nullptr;
+  ServerWindow* window = nullptr;
+  EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&client, &tree, &window));
+
+  // Create an observer for pointer-down events.
+  WindowTreeTestApi(tree).SetEventObserver(
+      CreateEventMatcher(mojom::EventType::POINTER_DOWN), 111u);
+
+  // Pointer-up events are not sent to the client, since they don't match.
+  DispatchEventAndAckImmediately(CreatePointerUpEvent(5, 5));
+  ASSERT_EQ(0u, client->tracker()->changes()->size());
+}
+
+// Tests that an event that both hits a client window and matches an event
+// observer is sent only once to the client.
+TEST_F(WindowTreeTest, SetEventObserverSendsOnce) {
+  // Create an embedded client.
+  TestWindowTreeClient* client = nullptr;
+  WindowTree* tree = nullptr;
+  ServerWindow* window = nullptr;
+  EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&client, &tree, &window));
+
+  // Create an observer for pointer-up events (which do not cause focus
+  // changes).
+  WindowTreeTestApi(tree).SetEventObserver(
+      CreateEventMatcher(mojom::EventType::POINTER_UP), 111u);
+
+  // Create an event inside the bounds of the client.
+  ui::PointerEvent pointer_up = CreatePointerUpEvent(25, 25);
+
+  // The event is dispatched once, with a flag set that it matched the event
+  // observer.
+  DispatchEventAndAckImmediately(pointer_up);
+  ASSERT_EQ(1u, client->tracker()->changes()->size());
+  EXPECT_EQ("InputEvent window=2,1 event_action=6 event_observer_id=111",
+            SingleChangeToDescription(*client->tracker()->changes()));
+}
+
+// Tests that events generated by user A are not observed by event observers for
+// user B.
+TEST_F(WindowTreeTest, SetEventObserverWrongUser) {
+  // Embed a window tree belonging to a different user.
+  TestWindowTreeBinding* other_binding;
+  WindowTree* other_tree = CreateNewTree("other_user", &other_binding);
+  other_binding->client()->tracker()->changes()->clear();
+
+  // Set event observers on both the wm tree and the other user's tree.
+  WindowTreeTestApi(wm_tree()).SetEventObserver(
+      CreateEventMatcher(mojom::EventType::POINTER_UP), 111u);
+  WindowTreeTestApi(other_tree)
+      .SetEventObserver(CreateEventMatcher(mojom::EventType::POINTER_UP), 222u);
+
+  // An event is observed by the wm tree, but not by the other user's tree.
+  DispatchEventAndAckImmediately(CreatePointerUpEvent(5, 5));
+  ASSERT_EQ(1u, wm_client()->tracker()->changes()->size());
+  EXPECT_EQ("InputEvent window=0,3 event_action=6 event_observer_id=111",
+            SingleChangeToDescription(*wm_client()->tracker()->changes()));
+  ASSERT_EQ(0u, other_binding->client()->tracker()->changes()->size());
+}
+
+// Tests that an event observer can receive events that have no target window.
+TEST_F(WindowTreeTest, SetEventObserverNoTarget) {
+  WindowTreeTestApi(wm_tree()).SetEventObserver(
+      CreateEventMatcher(mojom::EventType::KEY_RELEASED), 111u);
+  ui::KeyEvent key(ui::ET_KEY_RELEASED, ui::VKEY_A, ui::EF_NONE);
+  DispatchEventAndAckImmediately(key);
+  EXPECT_EQ("EventObserved event_action=2 event_observer_id=111",
+            SingleChangeToDescription(*wm_client()->tracker()->changes()));
+}
+
 TEST_F(WindowTreeTest, CursorChangesWhenMouseOverWindowAndWindowSetsCursor) {
   TestWindowTreeClient* embed_connection = nullptr;
   WindowTree* tree = nullptr;
   ServerWindow* window = nullptr;
   EXPECT_NO_FATAL_FAILURE(
       SetupEventTargeting(&embed_connection, &tree, &window));
 
   // Like in BasicInputEventTarget, we send a pointer down event to be
   // dispatched. This is only to place the mouse cursor over that window though.
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(21, 22));
@@ skipping 528 matching lines @@
   ASSERT_NE(new_opacity, unknown_window.opacity());
 
   EXPECT_FALSE(tree->SetWindowOpacity(
       ClientWindowId(WindowIdToTransportId(window_id)), new_opacity));
   EXPECT_NE(new_opacity, unknown_window.opacity());
 }
 
 }  // namespace test
 }  // namespace ws
 }  // namespace mus