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

services/ui/ws/window_tree.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 "services/ui/ws/window_tree.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 969 matching lines @@
 }
 
 void WindowTree::DispatchInputEventImpl(ServerWindow* target,
                                         const ui::Event& event) {
   GenerateEventAckId();
   WindowManagerDisplayRoot* display_root = GetWindowManagerDisplayRoot(target);
   DCHECK(display_root);
   event_source_wms_ = display_root->window_manager_state();
   // Should only get events from windows attached to a host.
   DCHECK(event_source_wms_);
-  bool matched_observer =
-      event_observer_matcher_ && event_observer_matcher_->MatchesEvent(event);
+  bool matched_pointer_watcher = EventMatchesPointerWatcher(event);
   client()->OnWindowInputEvent(
       event_ack_id_, ClientWindowIdForWindow(target).id,
-      ui::Event::Clone(event), matched_observer ? event_observer_id_ : 0);
+      ui::Event::Clone(event),
+      matched_pointer_watcher ? pointer_watcher_id_ : 0);
 }
 
-void WindowTree::SendToEventObserver(const ui::Event& event) {
-  if (event_observer_matcher_ && event_observer_matcher_->MatchesEvent(event))
-    client()->OnEventObserved(ui::Event::Clone(event), event_observer_id_);
+bool WindowTree::EventMatchesPointerWatcher(const ui::Event& event) {
+  if (!has_pointer_watcher_)
+    return false;
+  if (!event.IsPointerEvent())
+    return false;
+  if (!pointer_watcher_want_moves_ && (event.type() == ui::ET_POINTER_MOVED ||

[James Cook, 2016/08/02 21:19:51]

I think you can skip this if() now. The statement below is basically what we
want -- either pass everything or just pass DOWN/UP. I don't think
ET_POINTER_CANCELLED matters either way.

[riajiang, 2016/08/02 22:01:41]

True, done.

+                                       event.type() == ui::ET_POINTER_ENTERED ||
+                                       event.type() == ui::ET_POINTER_EXITED))
+    return false;
+  return pointer_watcher_want_moves_ || (event.type() == ui::ET_POINTER_DOWN ||
+                                         event.type() == ui::ET_POINTER_UP);
+}
+
+void WindowTree::SendToPointerWatcher(const ui::Event& event) {
+  if (EventMatchesPointerWatcher(event))
+    client()->OnPointerEventObserved(ui::Event::Clone(event),
+                                     pointer_watcher_id_);
 }
 
 void WindowTree::NewWindow(
     uint32_t change_id,
     Id transport_window_id,
     mojo::Map<mojo::String, mojo::Array<uint8_t>> transport_properties) {
   std::map<std::string, std::vector<uint8_t>> properties;
   if (!transport_properties.is_null()) {
     properties =
         transport_properties.To<std::map<std::string, std::vector<uint8_t>>>();
@@ skipping 145 matching lines @@
                   access_policy_->CanSetCapture(current_capture_window)) &&
                  window == current_capture_window;
   if (success) {
     Operation op(this, window_server_, OperationType::RELEASE_CAPTURE);
     success = display_root->window_manager_state()->SetCapture(
         nullptr, kInvalidClientId);
   }
   client()->OnChangeCompleted(change_id, success);
 }
 
-void WindowTree::SetEventObserver(mojom::EventMatcherPtr matcher,
-                                  uint32_t observer_id) {
-  if (matcher.is_null() || observer_id == 0) {
-    // Clear any existing event observer.
-    event_observer_matcher_.reset();
-    event_observer_id_ = 0;
+void WindowTree::StartPointerWatcher(bool want_moves,
+                                     uint32_t pointer_watcher_id) {
+  if (pointer_watcher_id == 0) {
+    StopPointerWatcher();
     return;
   }
+  has_pointer_watcher_ = true;
+  pointer_watcher_want_moves_ = want_moves;
+  pointer_watcher_id_ = pointer_watcher_id;
+}
 
-  // Do not allow key events to be observed, as a compromised app could register
-  // itself as an event observer and spy on keystrokes to another app.
-  if (!matcher->type_matcher && !matcher->pointer_kind_matcher) {
-    DVLOG(1) << "SetEventObserver must specify an event type.";
-    return;
-  }
-
-  const ui::mojom::EventType event_type_whitelist[] = {
-      ui::mojom::EventType::POINTER_CANCEL, ui::mojom::EventType::POINTER_DOWN,
-      ui::mojom::EventType::POINTER_MOVE,   ui::mojom::EventType::POINTER_UP,
-      ui::mojom::EventType::MOUSE_EXIT,     ui::mojom::EventType::WHEEL,
-  };
-
-  if (matcher->type_matcher) {
-    auto* iter =
-        std::find(std::begin(event_type_whitelist),
-                  std::end(event_type_whitelist), matcher->type_matcher->type);
-    if (iter == std::end(event_type_whitelist)) {
-      DVLOG(1) << "SetEventObserver event type not allowed";
-      return;
-    }
-  }
-  if (matcher->pointer_kind_matcher) {
-    ui::mojom::PointerKind pointer_kind =
-        matcher->pointer_kind_matcher->pointer_kind;
-    if (pointer_kind != ui::mojom::PointerKind::MOUSE &&
-        pointer_kind != ui::mojom::PointerKind::TOUCH &&
-        pointer_kind != ui::mojom::PointerKind::PEN) {
-      DVLOG(1) << "SetEventObserver pointer kind not allowed";
-      return;
-    }
-  }
-
-  event_observer_matcher_.reset(new EventMatcher(*matcher));
-  event_observer_id_ = observer_id;
+void WindowTree::StopPointerWatcher() {
+  has_pointer_watcher_ = false;
+  pointer_watcher_want_moves_ = false;
+  pointer_watcher_id_ = 0;
 }
 
 void WindowTree::SetWindowBounds(uint32_t change_id,
                                  Id window_id,
                                  const gfx::Rect& bounds) {
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
   if (window && ShouldRouteToWindowManager(window)) {
     const uint32_t wm_change_id =
         window_server_->GenerateWindowManagerChangeId(this, change_id);
     // |window_id| may be a client id, use the id from the window to ensure
@@ skipping 451 matching lines @@
 }
 
 bool WindowTree::IsWindowRootOfAnotherTreeForAccessPolicy(
     const ServerWindow* window) const {
   WindowTree* tree = window_server_->GetTreeWithRoot(window);
   return tree && tree != this;
 }
 
 }  // namespace ws
 }  // namespace ui