mus: Add PointerWatcher for passively observing mouse and touch events

components/mus/public/cpp/lib/window_tree_client_impl.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/public/cpp/lib/window_tree_client_impl.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 533 matching lines @@
   return focused_window_;
 }
 
 void WindowTreeClientImpl::ClearFocus() {
   if (!focused_window_)
     return;
 
   SetFocus(nullptr);
 }
 
+void WindowTreeClientImpl::SetEventObserver(mojom::EventMatcherPtr matcher) {
+  if (matcher.is_null()) {
+    has_event_observer_ = false;
+    tree_->SetEventObserver(nullptr, 0u);
+  } else {
+    has_event_observer_ = true;
+    event_observer_id_++;
+    tree_->SetEventObserver(std::move(matcher), event_observer_id_);
+  }
+}
+
 Window* WindowTreeClientImpl::NewWindow(
     const Window::SharedProperties* properties) {
   return NewWindowImpl(NewWindowType::CHILD, properties);
 }
 
 Window* WindowTreeClientImpl::NewTopLevelWindow(
     const Window::SharedProperties* properties) {
   Window* window = NewWindowImpl(NewWindowType::TOP_LEVEL, properties);
   // Assume newly created top level windows are drawn by default, otherwise
   // requests to focus will fail. We will get the real value in
@@ skipping 296 matching lines @@
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
 
   WindowPrivate(window).LocalSetSharedProperty(name, std::move(new_data));
 }
 
 void WindowTreeClientImpl::OnWindowInputEvent(uint32_t event_id,
                                               Id window_id,
                                               mojom::EventPtr event,
                                               uint32_t event_observer_id) {
-  // TODO(jamescook): If event_observer_id is non-zero, also route the event to
-  // PointerWatchers.
+  std::unique_ptr<ui::Event> ui_event = event.To<std::unique_ptr<ui::Event>>();
+
+  // Non-zero event_observer_id means it matched an event observer on the
+  // server.
+  if (event_observer_id != 0 && has_event_observer_ &&
+      event_observer_id == event_observer_id_)
+    delegate_->OnEventObserved(*ui_event);
 
   Window* window = GetWindowByServerId(window_id);
   if (!window || !window->input_event_handler_) {
     tree_->OnWindowInputEventAck(event_id, mojom::EventResult::UNHANDLED);
     return;
   }
 
   std::unique_ptr<base::Callback<void(mojom::EventResult)>> ack_callback(
       new base::Callback<void(mojom::EventResult)>(
           base::Bind(&mojom::WindowTree::OnWindowInputEventAck,
                      base::Unretained(tree_), event_id)));
   window->input_event_handler_->OnWindowInputEvent(
       window, *event.To<std::unique_ptr<ui::Event>>().get(), &ack_callback);
 
   // The handler did not take ownership of the callback, so we send the ack,
   // marking the event as not consumed.
   if (ack_callback)
     ack_callback->Run(mojom::EventResult::UNHANDLED);
 }
 
-void WindowTreeClientImpl::OnEventObserved(mojom::EventPtr event_in,
+void WindowTreeClientImpl::OnEventObserved(mojom::EventPtr event,
                                            uint32_t event_observer_id) {
-  // TODO(jamescook): Route the observed event to PointerWatchers.
+  if (has_event_observer_ && event_observer_id == event_observer_id_) {
+    std::unique_ptr<ui::Event> ui_event =
+        event.To<std::unique_ptr<ui::Event>>();
+    delegate_->OnEventObserved(*ui_event);
+  }
 }
 
 void WindowTreeClientImpl::OnWindowFocused(Id focused_window_id) {
   Window* focused_window = GetWindowByServerId(focused_window_id);
   InFlightFocusChange new_change(this, focused_window);
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
 
   LocalSetFocus(focused_window);
 }
@@ skipping 136 matching lines @@
 
 void WindowTreeClientImpl::SetUnderlaySurfaceOffsetAndExtendedHitArea(
     Window* window,
     const gfx::Vector2d& offset,
     const gfx::Insets& hit_area) {
   window_manager_internal_client_->SetUnderlaySurfaceOffsetAndExtendedHitArea(
       server_id(window), offset.x(), offset.y(), mojo::Insets::From(hit_area));
 }
 
 }  // namespace mus