exo: Implement lazy cursor changes.

components/exo/pointer.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/exo/pointer.h"
 
 #include "ash/display/display_info.h"
 #include "ash/display/display_manager.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
@@ skipping 28 matching lines @@
       surface_(nullptr),
       focus_(nullptr),
       cursor_scale_(1.0f) {
   ash::Shell::GetInstance()->AddPreTargetHandler(this);
 }
 
 Pointer::~Pointer() {
   delegate_->OnPointerDestroying(this);
   if (surface_)
     surface_->RemoveSurfaceObserver(this);
-  if (focus_)
+  if (focus_) {
     focus_->RemoveSurfaceObserver(this);
+    focus_->UnregisterCursorProvider(this);
+  }
   if (widget_)
     widget_->CloseNow();
   ash::Shell::GetInstance()->RemovePreTargetHandler(this);
 }
 
 void Pointer::SetCursor(Surface* surface, const gfx::Point& hotspot) {
   // Early out if the pointer doesn't have a surface in focus.
   if (!focus_)
     return;
 
@@ skipping 18 matching lines @@
     }
   }
 
   // Update hotspot and show cursor surface if not already visible.
   hotspot_ = hotspot;
   if (surface_) {
     surface_->SetBounds(gfx::Rect(gfx::Point() - hotspot_.OffsetFromOrigin(),
                                   surface_->layer()->size()));
     if (!surface_->IsVisible())
       surface_->Show();
+
+    // Show widget now that cursor has been defined.
+    if (!widget_->IsVisible())
+      widget_->Show();
   }
+
+  // Register pointer as cursor provider now that the cursor for |focus_| has
+  // been defined.
+  focus_->RegisterCursorProvider(this);
+
+  // Update cursor in case the registration of pointer as cursor provider
+  // caused the cursor to change.
+  aura::client::CursorClient* cursor_client =
+      aura::client::GetCursorClient(focus_->GetRootWindow());
+  if (cursor_client)
+    cursor_client->SetCursor(focus_->GetCursor(gfx::ToFlooredPoint(location_)));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ui::EventHandler overrides:
 
 void Pointer::OnMouseEvent(ui::MouseEvent* event) {
   Surface* target = GetEffectiveTargetForEvent(event);
 
   // If target is different than the current pointer focus then we need to
   // generate enter and leave events.
   if (target != focus_) {
     // First generate a leave event if we currently have a target in focus.
     if (focus_) {
       delegate_->OnPointerLeave(focus_);
       focus_->RemoveSurfaceObserver(this);
+      // Require SetCursor() to be called and cursor to be re-defined in
+      // response to each OnPointerEnter() call.
+      focus_->UnregisterCursorProvider(this);
       focus_ = nullptr;
     }
     // Second generate an enter event if focus moved to a new target.
     if (target) {
       delegate_->OnPointerEnter(target, event->location_f(),
                                 event->button_flags());
       location_ = event->location_f();
       focus_ = target;
       focus_->AddSurfaceObserver(this);
     }
@@ skipping 82 matching lines @@
     float ui_scale = ash::Shell::GetInstance()
                          ->display_manager()
                          ->GetDisplayInfo(display.id())
                          .GetEffectiveUIScale();
     if (ui_scale != cursor_scale_) {
       gfx::Transform transform;
       transform.Scale(ui_scale, ui_scale);
       widget_->GetNativeWindow()->SetTransform(transform);
       cursor_scale_ = ui_scale;
     }
-
-    if (!widget_->IsVisible())
-      widget_->Show();
   } else {
     if (widget_ && widget_->IsVisible())
       widget_->Hide();
   }
 }
 
 void Pointer::OnScrollEvent(ui::ScrollEvent* event) {
   OnMouseEvent(event);
 }
 
@@ skipping 47 matching lines @@
 Surface* Pointer::GetEffectiveTargetForEvent(ui::Event* event) const {
   Surface* target =
       Surface::AsSurface(static_cast<aura::Window*>(event->target()));
   if (!target)
     return nullptr;
 
   return delegate_->CanAcceptPointerEventsForSurface(target) ? target : nullptr;
 }
 
 }  // namespace exo