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

services/ui/public/cpp/lib/window_tree_client.cc

Index: services/ui/public/cpp/lib/window_tree_client.cc
diff --git a/services/ui/public/cpp/lib/window_tree_client.cc b/services/ui/public/cpp/lib/window_tree_client.cc
index 1cfdf74f62889c6a754ac3cd1a9c368df6db0fd7..6696e67fc2fea8b1b253d50b1c20e6b6e6c987be 100644
--- a/services/ui/public/cpp/lib/window_tree_client.cc
+++ b/services/ui/public/cpp/lib/window_tree_client.cc
@@ -626,15 +626,17 @@ gfx::Point WindowTreeClient::GetCursorScreenPoint() {
                     static_cast<int16_t>(location & 0xFFFF));
 }
 
-void WindowTreeClient::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_);
-  }
+void WindowTreeClient::StartPointerWatcher(bool want_moves) {
+  DCHECK(!has_pointer_watcher_);

[sky, 2016/08/04 20:40:25]

I don't think this should be a DCHECK. I think clients should be able to call
start multiple times and this does the right thing. Is there a particular reason
you want the DCHECK?

[riajiang, 2016/08/04 21:22:06]

They can call AddPointerWatcher multiple times in WindowManagerConnection but we
only call StartPointerWatcher once for the first time they call
AddPointerWatcher right?

[sky, 2016/08/04 23:08:44]

You shouldn't assume this code is only ever used through
WindowManagerConnection. It looks like you have TODOs in WMC to handle corner
cases there. I would like WTC to do the right thing though.

[riajiang, 2016/08/05 17:36:02]

True makes sense. Is it correct that when clients call StartPointerWatcher
multiple times to replace the pointer watcher, we want to keep the new one?
Changed it to StopPointerWatcher for the old watcher first if there's an
existing pointer watcher.
Right now WMC only call StartPointerWatcher if it's the first time
AddPointerWatcher is called (so only one active pointer watcher at a time). The
TODO in WMC is for supporting multiple pointer watchers at the same time
(crbug.com/627146). 

+  has_pointer_watcher_ = true;
+  pointer_watcher_id_++;
+  tree_->StartPointerWatcher(want_moves, pointer_watcher_id_);
+}
+
+void WindowTreeClient::StopPointerWatcher() {
+  DCHECK(has_pointer_watcher_);
+  tree_->StopPointerWatcher();
+  has_pointer_watcher_ = false;
 }
 
 void WindowTreeClient::PerformWindowMove(
@@ -972,15 +974,16 @@ void WindowTreeClient::OnWindowSharedPropertyChanged(
 void WindowTreeClient::OnWindowInputEvent(uint32_t event_id,
                                           Id window_id,
                                           std::unique_ptr<ui::Event> event,
-                                          uint32_t event_observer_id) {
+                                          uint32_t pointer_watcher_id) {
   DCHECK(event);
   Window* window = GetWindowByServerId(window_id);  // May be null.
 
-  // Non-zero event_observer_id means it matched an event observer on the
+  // Non-zero pointer_watcher_id means it matched a pointer watcher on the
   // server.
-  if (event_observer_id != 0 && has_event_observer_ &&
-      event_observer_id == event_observer_id_)
-    delegate_->OnEventObserved(*event.get(), window);
+  if (pointer_watcher_id_ != 0 && has_pointer_watcher_ &&
+      pointer_watcher_id == pointer_watcher_id_ && event->IsPointerEvent()) {

[sky, 2016/08/04 20:40:25]

Shouldn't event->IsPointerEvent() be a DCHECK? When would it not be a pointer
event?

[riajiang, 2016/08/04 21:22:06]

Moved it to be a DCHECK inside this if.

+    delegate_->OnPointerEventObserved(*event->AsPointerEvent(), window);
+  }
 
   if (!window || !window->input_event_handler_) {
     tree_->OnWindowInputEventAck(event_id, mojom::EventResult::UNHANDLED);
@@ -1011,11 +1014,13 @@ void WindowTreeClient::OnWindowInputEvent(uint32_t event_id,
     ack_callback->Run(mojom::EventResult::UNHANDLED);
 }
 
-void WindowTreeClient::OnEventObserved(std::unique_ptr<ui::Event> event,
-                                       uint32_t event_observer_id) {
+void WindowTreeClient::OnPointerEventObserved(std::unique_ptr<ui::Event> event,
+                                              uint32_t pointer_watcher_id) {
   DCHECK(event);
-  if (has_event_observer_ && event_observer_id == event_observer_id_)
-    delegate_->OnEventObserved(*event.get(), nullptr /* target */);
+  DCHECK(event->IsPointerEvent());
+  if (has_pointer_watcher_ && pointer_watcher_id == pointer_watcher_id_)
+    delegate_->OnPointerEventObserved(*event->AsPointerEvent(),
+                                      nullptr /* target */);
 }
 
 void WindowTreeClient::OnWindowFocused(Id focused_window_id) {