mus: Implement Window Server Capture

components/mus/ws/event_dispatcher.cc

 // Copyright 2015 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/event_dispatcher.h"
 
 #include <set>
 
+#include "base/time/time.h"
 #include "cc/surfaces/surface_hittest.h"
 #include "components/mus/surfaces/surfaces_state.h"
 #include "components/mus/ws/event_dispatcher_delegate.h"
 #include "components/mus/ws/server_window.h"
 #include "components/mus/ws/server_window_delegate.h"
 #include "components/mus/ws/window_coordinate_conversions.h"
 #include "components/mus/ws/window_finder.h"
 #include "components/mus/ws/window_tree_host_impl.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "ui/gfx/geometry/point.h"
@@ skipping 131 matching lines @@
   mojom::KeyboardCode keyboard_code_;
   mojom::PointerKind pointer_kind_;
   gfx::RectF pointer_region_;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 EventDispatcher::EventDispatcher(EventDispatcherDelegate* delegate)
     : delegate_(delegate),
       root_(nullptr),
+      capture_window_(nullptr),
+      capture_window_in_nonclient_area_(false),
       mouse_button_down_(false),
       mouse_cursor_source_window_(nullptr) {}
 
 EventDispatcher::~EventDispatcher() {
   std::set<ServerWindow*> pointer_targets;
+  if (capture_window_) {
+    pointer_targets.insert(capture_window_);
+    capture_window_->RemoveObserver(this);
+    capture_window_ = nullptr;
+  }
   for (const auto& pair : pointer_targets_) {
     if (pair.second.window &&
         pointer_targets.insert(pair.second.window).second) {
       pair.second.window->RemoveObserver(this);
     }
   }
+  pointer_targets_.clear();
+}
+
+void EventDispatcher::SetCaptureWindow(ServerWindow* window,
+                                       bool in_nonclient_area) {
+  if (window == capture_window_)
+    return;
+
+  // Cancel implicit capture to all other windows.
+  bool observing_window = false;
+  std::set<ServerWindow*> unobserved_windows;
+  if (capture_window_) {
+    delegate_->OnLostCapture(capture_window_);
+    unobserved_windows.insert(capture_window_);
+    capture_window_->RemoveObserver(this);
+  }
+
+  for (const auto& pair : pointer_targets_) {
+    ServerWindow* target = pair.second.window;
+    if (!target)
+      continue;
+    if (target == window) {
+      observing_window = true;
+    } else if (unobserved_windows.insert(target).second) {

[sky, 2016/01/29 20:47:00]

Why do you only send the cancel once per window? If multiple pointer ids are
down shouldn't we send a cancel per id?

I think this code would be less error prone if you called StopTrackingPointer
for each item. That way you don't need unobserved_windows.

[jonross, 2016/02/01 18:52:22]

Good catch, I've updated this to send once cancel per window id. Updated the
tests to confirm this.

I am not using StopTrackingPointer here as it directly removes from the map.
I've cleaned this up, so that observing_window is no longer needed.

+      target->RemoveObserver(this);
+      mojom::EventPtr cancel_event = mojom::Event::New();
+      cancel_event->action = mojom::EventType::POINTER_CANCEL;
+      cancel_event->flags = mojom::kEventFlagNone;
+      cancel_event->time_stamp = base::TimeTicks::Now().ToInternalValue();
+      cancel_event->pointer_data = mojom::PointerData::New();
+      // TODO(jonross): Do we want to track previous location in PointerTarger

[sky, 2016/01/29 20:47:00]

PointerTarger->PointerTarget
And to your TODO, I think we should. I would be inclined to store the last
location in PointerTarget. But you can do that later.

[jonross, 2016/02/01 18:52:22]

Fixed the comment.

I agree with storing the last location in PointerTarget, I'll do that in a
followup

+      // for sending cancels?
+      cancel_event->pointer_data->location = mojom::LocationData::New();
+      cancel_event->pointer_data->pointer_id = pair.first;
+      DispatchToPointerTarget(pair.second, std::move(cancel_event));
+    }
+  }
+  pointer_targets_.clear();
+
+  capture_window_ = window;
+  capture_window_in_nonclient_area_ = in_nonclient_area;
+  // Begin tracking the capture window if it is not yet being observed.
+  if (window && !observing_window)
+    window->AddObserver(this);
 }
 
 void EventDispatcher::UpdateCursorProviderByLastKnownLocation() {
   if (!mouse_button_down_) {
     gfx::Point location = mouse_pointer_last_location_;
     mouse_cursor_source_window_ =
         FindDeepestVisibleWindowForEvents(root_, surface_id_, &location);
   }
 }
 
@@ skipping 43 matching lines @@
 
 void EventDispatcher::ProcessKeyEvent(mojom::EventPtr event) {
   ServerWindow* focused_window =
       delegate_->GetFocusedWindowForEventDispatcher();
   if (focused_window)
     delegate_->DispatchInputEventToWindow(focused_window, false,
                                           std::move(event));
 }
 
 void EventDispatcher::ProcessPointerEvent(mojom::EventPtr event) {
+  if (capture_window_) {
+    PointerTarget pointer_target;
+    pointer_target.window = capture_window_;
+    pointer_target.in_nonclient_area = capture_window_in_nonclient_area_;
+    DispatchToPointerTarget(pointer_target, std::move(event));
+    return;

[sky, 2016/01/29 20:47:00]

The problem with an early return here is mouse_pointer_last_location and
mouse_cursor_source_window_ are not updated correctly.

[jonross, 2016/02/01 18:52:22]

I've moved this, and added logic for updating mouse_cursor_source_window_ and
mouse_button_down_.

This does ignore the window cursor updating on line 335. We will maintain the
captured window cursor until capture is released. CancelPointerEventsToTarget
will be updated to perform this.

+  }
+
   const bool is_mouse_event = event->pointer_data &&
                         event->pointer_data->kind == mojom::PointerKind::MOUSE;
 
   if (is_mouse_event)
     mouse_pointer_last_location_ = EventLocationToPoint(*event);
 
   const int32_t pointer_id = event->pointer_data->pointer_id;
   if (!IsTrackingPointer(pointer_id) ||
       !pointer_targets_[pointer_id].is_pointer_down) {
     const bool any_pointers_down = AreAnyPointersDown();
@@ skipping 129 matching lines @@
   transform.TransformPoint(&location);
   event->pointer_data->location->x = location.x();
   event->pointer_data->location->y = location.y();
   delegate_->DispatchInputEventToWindow(target.window, target.in_nonclient_area,
                                         std::move(event));
 }
 
 void EventDispatcher::CancelPointerEventsToTarget(ServerWindow* window) {
   window->RemoveObserver(this);
 
+  if (capture_window_ == window) {

[sky, 2016/01/29 20:47:00]

When this happens you may need to update the cursor. See 327-337.

[jonross, 2016/02/01 18:52:22]

Done.

+    capture_window_ = nullptr;
+    // A window only cares to be informed that it lost capture if it explicitly
+    // requested capture. A window can lose capture if another window gains
+    // explicit capture.
+    delegate_->OnLostCapture(window);
+    return;
+  }
+
   for (auto& pair : pointer_targets_) {
     if (pair.second.window == window)
       pair.second.window = nullptr;
   }
 }
 
 bool EventDispatcher::IsObservingWindow(ServerWindow* window) {
   for (const auto& pair : pointer_targets_) {
     if (pair.second.window == window)
       return true;
@@ skipping 25 matching lines @@
 
 void EventDispatcher::OnWindowDestroyed(ServerWindow* window) {
   CancelPointerEventsToTarget(window);
 
   if (mouse_cursor_source_window_ == window)
     mouse_cursor_source_window_ = nullptr;
 }
 
 }  // namespace ws
 }  // namespace mus