mus Window Server: implement event 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;
+
+  if (capture_window_) {
+    // Stop observing old capture window. |pointer_targets_| are cleared on
+    // intial setting of a capture window.
+    delegate_->OnServerWindowCaptureLost(capture_window_);
+    capture_window_->RemoveObserver(this);
+  } else {
+    // Cancel implicit capture to all other windows.
+    std::set<ServerWindow*> unobserved_windows;
+    for (const auto& pair : pointer_targets_) {
+      ServerWindow* target = pair.second.window;
+      if (!target)
+        continue;
+      if (unobserved_windows.insert(target).second)
+        target->RemoveObserver(this);
+      if (target == window)
+        continue;
+      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): Track previous location in PointerTarget 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();
+  }
+
+  // Begin tracking the capture window if it is not yet being observed.
+  if (window) {
+    window->AddObserver(this);
+    if (!capture_window_)
+      delegate_->SetNativeCapture();
+  } else {
+    delegate_->ReleaseNativeCapture();
+    if (!mouse_button_down_)
+      UpdateCursorProviderByLastKnownLocation();
+  }
+
+  capture_window_ = window;
+  capture_window_in_nonclient_area_ = in_nonclient_area;
 }
 
 void EventDispatcher::UpdateCursorProviderByLastKnownLocation() {
   if (!mouse_button_down_) {
     gfx::Point location = mouse_pointer_last_location_;
     mouse_cursor_source_window_ =
         FindDeepestVisibleWindowForEvents(root_, surface_id_, &location);
   }
 }
 
@@ skipping 49 matching lines @@
                                           std::move(event));
 }
 
 void EventDispatcher::ProcessPointerEvent(mojom::EventPtr event) {
   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);
 
+  // Release capture on pointer up. For mouse we only release if there are
+  // no buttons down.
+  const bool is_pointer_going_up =
+      (event->action == mojom::EventType::POINTER_UP ||
+       event->action == mojom::EventType::POINTER_CANCEL) &&
+      (event->pointer_data->kind != mojom::PointerKind::MOUSE ||
+       IsOnlyOneMouseButtonDown(event->flags));
+
+  // Update mouse down state upon events which change it.
+  if (is_mouse_event) {
+    if (event->action == mojom::EventType::POINTER_DOWN)
+      mouse_button_down_ = true;
+    else if (is_pointer_going_up)
+      mouse_button_down_ = false;
+  }
+
+  if (capture_window_) {
+    mouse_cursor_source_window_ = 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;
+  }
+
   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();
     UpdateTargetForPointer(*event);
     if (is_mouse_event)
       mouse_cursor_source_window_ = pointer_targets_[pointer_id].window;
 
     PointerTarget& pointer_target = pointer_targets_[pointer_id];
     if (pointer_target.is_pointer_down) {
-      if (is_mouse_event) {
-        mouse_button_down_ = true;
+      if (is_mouse_event)
         mouse_cursor_source_window_ = pointer_target.window;
+      if (!any_pointers_down) {
+        delegate_->SetFocusedWindowFromEventDispatcher(pointer_target.window);
+        delegate_->SetNativeCapture();
       }
-      if (!any_pointers_down)
-        delegate_->SetFocusedWindowFromEventDispatcher(pointer_target.window);
     }
   }
 
-  // Release capture on pointer up. For mouse we only release if there are
-  // no buttons down.
-  const bool is_pointer_going_up =
-      (event->action == mojom::EventType::POINTER_UP ||
-       event->action == mojom::EventType::POINTER_CANCEL) &&
-      (event->pointer_data->kind != mojom::PointerKind::MOUSE ||
-       IsOnlyOneMouseButtonDown(event->flags));
-
-  if (is_pointer_going_up && is_mouse_event) {
-    // When we release the mouse button, we want the cursor to be sourced from
-    // the window under the mouse pointer, even though we're sending the button
-    // up event to the window that had implicit capture. We have to set this
-    // before we perform dispatch because the Delegate is going to read this
-    // information from us.
-    mouse_button_down_ = false;
-    gfx::Point location(EventLocationToPoint(*event));
-    mouse_cursor_source_window_ =
-        FindDeepestVisibleWindowForEvents(root_, surface_id_, &location);
-  }
+  // When we release the mouse button, we want the cursor to be sourced from
+  // the window under the mouse pointer, even though we're sending the button
+  // up event to the window that had implicit capture. We have to set this
+  // before we perform dispatch because the Delegate is going to read this
+  // information from us.
+  if (is_pointer_going_up && is_mouse_event)
+    UpdateCursorProviderByLastKnownLocation();
 
   DispatchToPointerTarget(pointer_targets_[pointer_id], std::move(event));
 
   if (is_pointer_going_up) {
     if (is_mouse_event)
       pointer_targets_[pointer_id].is_pointer_down = false;
     else
       StopTrackingPointer(pointer_id);
+    if (!AreAnyPointersDown())
+      delegate_->ReleaseNativeCapture();
   }
 }
 
 void EventDispatcher::StartTrackingPointer(
     int32_t pointer_id,
     const PointerTarget& pointer_target) {
   DCHECK(!IsTrackingPointer(pointer_id));
   if (!IsObservingWindow(pointer_target.window))
     pointer_target.window->AddObserver(this);
   pointer_targets_[pointer_id] = pointer_target;
@@ skipping 77 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) {
+    capture_window_ = nullptr;
+    mouse_button_down_ = false;
+    // 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_->OnServerWindowCaptureLost(window);
+    delegate_->ReleaseNativeCapture();
+    UpdateCursorProviderByLastKnownLocation();
+    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