mus: Let clients set the cursor of their window.

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 "cc/surfaces/surface_hittest.h"
 #include "components/mus/surfaces/surfaces_state.h"
@@ skipping 121 matching lines @@
   mojom::EventType event_type_;
   mojom::EventFlags event_flags_;
   mojom::KeyboardCode keyboard_code_;
   mojom::PointerKind pointer_kind_;
   gfx::RectF pointer_region_;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 EventDispatcher::EventDispatcher(EventDispatcherDelegate* delegate)
-    : delegate_(delegate), root_(nullptr) {}
+    : delegate_(delegate),
+      root_(nullptr),
+      mouse_button_down_(false),
+      mouse_cursor_source_window_(nullptr) {}
 
 EventDispatcher::~EventDispatcher() {
   std::set<ServerWindow*> pointer_targets;
   for (const auto& pair : pointer_targets_) {
     if (pair.second.window &&
         pointer_targets.insert(pair.second.window).second) {
       pair.second.window->RemoveObserver(this);
     }
   }
 }
@@ skipping 43 matching lines @@
 }
 
 void EventDispatcher::ProcessKeyEvent(mojom::EventPtr event) {
   ServerWindow* focused_window =
       delegate_->GetFocusedWindowForEventDispatcher();
   if (focused_window)
     delegate_->DispatchInputEventToWindow(focused_window, false, event.Pass());
 }
 
 void EventDispatcher::ProcessPointerEvent(mojom::EventPtr event) {
+  bool is_mouse_event =
+      event->pointer_data &&
+      event->pointer_data->kind == mojom::PointerKind::POINTER_KIND_MOUSE;
+
   const int32_t pointer_id = event->pointer_data->pointer_id;
   if (event->action == mojom::EVENT_TYPE_WHEEL ||
       (event->action == mojom::EVENT_TYPE_POINTER_MOVE &&
        pointer_targets_.count(pointer_id) == 0)) {
     PointerTarget pointer_target;
     if (pointer_targets_.count(pointer_id) != 0) {
       pointer_target = pointer_targets_[pointer_id];
     } else {
       gfx::Point location(EventLocationToPoint(*event));
       pointer_target.window =
           FindDeepestVisibleWindowForEvents(root_, surface_id_, &location);
     }
+    if (is_mouse_event && !mouse_button_down_)
+      mouse_cursor_source_window_ = pointer_target.window;
     DispatchToPointerTarget(pointer_target, event.Pass());
     return;
   }
 
   // Pointer down implicitly captures.
   if (pointer_targets_.count(pointer_id) == 0) {
     DCHECK(event->action == mojom::EVENT_TYPE_POINTER_DOWN);
     const bool is_first_pointer_down = pointer_targets_.empty();
     gfx::Point location(EventLocationToPoint(*event));
     ServerWindow* target =
         FindDeepestVisibleWindowForEvents(root_, surface_id_, &location);
     DCHECK(target);
     if (!IsObservingWindow(target))
       target->AddObserver(this);
 
+    if (is_mouse_event) {
+      mouse_button_down_ = true;
+      mouse_cursor_source_window_ = target;
+    }
+
     pointer_targets_[pointer_id].window = target;
     pointer_targets_[pointer_id].in_nonclient_area =
         IsLocationInNonclientArea(target, location);
 
     if (is_first_pointer_down)
       delegate_->SetFocusedWindowFromEventDispatcher(target);
   }
 
   // Release capture on pointer up. For mouse we only release if there are
   // no buttons down.
   const bool should_reset_target =
       (event->action == mojom::EVENT_TYPE_POINTER_UP ||
        event->action == mojom::EVENT_TYPE_POINTER_CANCEL) &&
       (event->pointer_data->kind != mojom::POINTER_KIND_MOUSE ||
        IsOnlyOneMouseButtonDown(event->flags));
 
+  if (should_reset_target && 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);
+  }
+
   DispatchToPointerTarget(pointer_targets_[pointer_id], event.Pass());
 
   if (should_reset_target) {
     ServerWindow* target = pointer_targets_[pointer_id].window;
     pointer_targets_.erase(pointer_id);
     if (target && !IsObservingWindow(target))
       target->RemoveObserver(this);
   }
 }
 
@@ skipping 45 matching lines @@
                                                   ServerWindow* old_parent) {
   CancelPointerEventsToTarget(window);
 }
 
 void EventDispatcher::OnWindowVisibilityChanged(ServerWindow* window) {
   CancelPointerEventsToTarget(window);
 }
 
 void EventDispatcher::OnWindowDestroyed(ServerWindow* window) {
   CancelPointerEventsToTarget(window);
+
+  if (mouse_cursor_source_window_ == window)
+    mouse_cursor_source_window_ = nullptr;
 }
 
 }  // namespace ws
 }  // namespace mus