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

services/ui/public/cpp/lib/window_tree_client.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/public/cpp/window_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 608 matching lines @@
   // We raced initialization. Return (0, 0).
   if (!cursor_location_memory())
     return gfx::Point();
 
   base::subtle::Atomic32 location =
       base::subtle::NoBarrier_Load(cursor_location_memory());
   return gfx::Point(static_cast<int16_t>(location >> 16),
                     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(
     Window* window,
     ui::mojom::MoveLoopSource source,
     const gfx::Point& cursor_location,
     const base::Callback<void(bool)>& callback) {
   DCHECK(on_current_move_finished_.is_null());
   on_current_move_finished_ = callback;
 
@@ skipping 317 matching lines @@
   InFlightPropertyChange new_change(window, name, new_data);
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
 
   WindowPrivate(window).LocalSetSharedProperty(name, std::move(new_data));
 }
 
 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);
     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)));
@@ skipping 10 matching lines @@
     window->input_event_handler_->OnWindowInputEvent(window, *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 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) {
   Window* focused_window = GetWindowByServerId(focused_window_id);
   InFlightFocusChange new_change(this, focused_window);
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
 
   LocalSetFocus(focused_window);
 }
@@ skipping 221 matching lines @@
     Window* window,
     const gfx::Vector2d& offset,
     const gfx::Insets& hit_area) {
   if (window_manager_internal_client_) {
     window_manager_internal_client_->SetUnderlaySurfaceOffsetAndExtendedHitArea(
         server_id(window), offset.x(), offset.y(), hit_area);
   }
 }
 
 }  // namespace ui