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 55 matching lines @@
       (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 (!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);
 
+    mouse_button_down_ = true;

[sky, 2015/12/03 22:01:10]

This path is hit for both touch and mouse. Don't you only want to set these if
it's a mouse event?

[Elliot Glaysher, 2015/12/03 22:32:00]

Is it? In a previous comment you said this was only entered on first button
down, and that it was the other block that had to deal with touch.

Whatever. Put all access to mouse_cursor_source_window_ behind a variable that
checks POINTER_KIND_MOUSE.

+    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 &&
+      event->pointer_data &&
+      event->pointer_data->kind == mojom::PointerKind::POINTER_KIND_MOUSE) {
+    // 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