mus: Let clients set the cursor of their window.

components/mus/ws/window_tree_host_impl.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/window_tree_host_impl.h"
 
 #include "base/debug/debugger.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/mus/common/types.h"
+#include "components/mus/public/interfaces/input_event_constants.mojom.h"
 #include "components/mus/ws/connection_manager.h"
 #include "components/mus/ws/display_manager.h"
 #include "components/mus/ws/focus_controller.h"
 #include "components/mus/ws/window_tree_host_delegate.h"
 #include "components/mus/ws/window_tree_impl.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 
 namespace mus {
 namespace ws {
@@ skipping 16 matching lines @@
     const scoped_refptr<GpuState>& gpu_state,
     const scoped_refptr<SurfacesState>& surfaces_state,
     mojom::WindowManagerPtr window_manager)
     : delegate_(nullptr),
       connection_manager_(connection_manager),
       client_(client.Pass()),
       event_dispatcher_(this),
       display_manager_(
           DisplayManager::Create(app_impl, gpu_state, surfaces_state)),
       window_manager_(window_manager.Pass()),
-      tree_awaiting_input_ack_(nullptr) {
+      tree_awaiting_input_ack_(nullptr),
+      last_cursor_(0) {
   display_manager_->Init(this);
   if (client_) {
     client_.set_connection_error_handler(base::Bind(
         &WindowTreeHostImpl::OnClientClosed, base::Unretained(this)));
   }
 }
 
 WindowTreeHostImpl::~WindowTreeHostImpl() {
   DestroyFocusController();
   for (ServerWindow* window : windows_needing_frame_destruction_)
@@ skipping 67 matching lines @@
   display_manager_->UpdateTextInputState(state);
 }
 
 void WindowTreeHostImpl::SetImeVisibility(ServerWindow* window, bool visible) {
   // Do not need to show or hide IME for unfocused window.
   if (focus_controller_->GetFocusedWindow() != window)
     return;
   display_manager_->SetImeVisibility(visible);
 }
 
+void WindowTreeHostImpl::OnCursorUpdated(ServerWindow* window) {
+  if (window == event_dispatcher_.last_targeted_window())

[sky, 2015/12/01 21:48:01]

Doesn't this need to be more sophisticated? What if the last event target is no
longer under the mouse?

[Elliot Glaysher, 2015/12/02 20:01:32]

So I might just be wrong about this, but in event_dispatcher.cc, we appear to
track implicit captures in EventDispatcher::ProcessPointerEvent() before it
passes to DispatchToPointerTarget, which actually sets this targeted window.

Is this insufficient?

[sky, 2015/12/02 21:19:41]

You are correct. We currently only have implicit capture.
There are a couple of cases that come to mind:
. press mouse, move mouse over another window. last_targeted_window is now the
wrong window, right?
. press and release mouse, z-order of windows changes, last_targeted_window is
now the wrong window.

+    UpdateNativeCursor(window->cursor());
+}
+
 void WindowTreeHostImpl::SetSize(mojo::SizePtr size) {
   display_manager_->SetViewportSize(size.To<gfx::Size>());
 }
 
 void WindowTreeHostImpl::SetTitle(const mojo::String& title) {
   display_manager_->SetTitle(title.To<base::string16>());
 }
 
 void WindowTreeHostImpl::AddAccelerator(uint32_t id,
                                         mojom::EventMatcherPtr event_matcher) {
@@ skipping 60 matching lines @@
 }
 
 void WindowTreeHostImpl::DispatchNextEventFromQueue() {
   if (event_queue_.empty())
     return;
   mojom::EventPtr next_event = event_queue_.front().Pass();
   event_queue_.pop();
   event_dispatcher_.OnEvent(next_event.Pass());
 }
 
+void WindowTreeHostImpl::UpdateNativeCursor(int32_t cursor_id) {
+  if (cursor_id != last_cursor_) {
+    display_manager_->SetCursorById(cursor_id);
+    last_cursor_ = cursor_id;
+  }
+}
+
 ServerWindow* WindowTreeHostImpl::GetRootWindow() {
   return root_.get();
 }
 
 void WindowTreeHostImpl::OnEvent(mojom::EventPtr event) {
   // If this is still waiting for an ack from a previously sent event, then
   // queue up the event to be dispatched once the ack is received.
   if (event_ack_timer_.IsRunning()) {
     // TODO(sad): Coalesce if possible.
     event_queue_.push(event.Pass());
@@ skipping 129 matching lines @@
 }
 
 ServerWindow* WindowTreeHostImpl::GetFocusedWindowForEventDispatcher() {
   return GetFocusedWindow();
 }
 
 void WindowTreeHostImpl::DispatchInputEventToWindow(ServerWindow* target,
                                                     bool in_nonclient_area,
                                                     mojom::EventPtr event) {
   DCHECK(!event_ack_timer_.IsRunning());
+  if (event->action == mojom::EventType::EVENT_TYPE_POINTER_CANCEL ||
+      event->action == mojom::EventType::EVENT_TYPE_POINTER_DOWN ||
+      event->action == mojom::EventType::EVENT_TYPE_POINTER_MOVE ||
+      event->action == mojom::EventType::EVENT_TYPE_POINTER_UP) {
+    UpdateNativeCursor(target->cursor());
+  }
+
   // If the event is in the non-client area the event goes to the owner of
   // the window. Otherwise if the window is an embed root, forward to the
   // embedded window.
   WindowTreeImpl* connection =
       in_nonclient_area
           ? connection_manager_->GetConnection(target->id().connection_id)
           : connection_manager_->GetConnectionWithRoot(target->id());
   if (!connection) {
     DCHECK(!in_nonclient_area);
     connection = connection_manager_->GetConnection(target->id().connection_id);
   }
   tree_awaiting_input_ack_ = connection;
   connection->DispatchInputEvent(target, event.Pass());
 
   // TOOD(sad): Adjust this delay, possibly make this dynamic.
   const base::TimeDelta max_delay = base::debug::BeingDebugged()
                                         ? base::TimeDelta::FromDays(1)
                                         : GetDefaultAckTimerDelay();
   event_ack_timer_.Start(FROM_HERE, max_delay, this,
                          &WindowTreeHostImpl::OnEventAckTimeout);
 }
 
 void WindowTreeHostImpl::OnWindowDestroyed(ServerWindow* window) {
   windows_needing_frame_destruction_.erase(window);
   window->RemoveObserver(this);
 }
 
 }  // namespace ws
 }  // namespace mus