exo: Implement lazy cursor changes.

components/exo/surface.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/surface.h"
 
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
@@ skipping 60 matching lines @@
  public:
   explicit CustomWindowDelegate(Surface* surface) : surface_(surface) {}
   ~CustomWindowDelegate() override {}
 
   // Overridden from aura::WindowDelegate:
   gfx::Size GetMinimumSize() const override { return gfx::Size(); }
   gfx::Size GetMaximumSize() const override { return gfx::Size(); }
   void OnBoundsChanged(const gfx::Rect& old_bounds,
                        const gfx::Rect& new_bounds) override {}
   gfx::NativeCursor GetCursor(const gfx::Point& point) override {
-    return ui::kCursorNone;
+    // If surface has a cursor provider then return 'none' as cursor providers
+    // are responsible for drawing cursors. Use default cursor if no cursor
+    // provider is registered.
+    return surface_->HasCursorProvider() ? ui::kCursorNone : ui::kCursorNull;

[Daniele Castagna, 2016/05/31 19:32:03]

I understand that when kCursorNull is returns the default cursor is used, but
something like kCursorDefault would make this like more readable.

   }
   int GetNonClientComponent(const gfx::Point& point) const override {
     return HTNOWHERE;
   }
   bool ShouldDescendIntoChildForEventHandling(
       aura::Window* child,
       const gfx::Point& location) override {
     return true;
   }
   bool CanFocus() override { return true; }
@@ skipping 641 matching lines @@
     Surface* sub_surface = sub_surface_entry.first;
     if (!sub_surface->has_contents())
       continue;
     non_transparent_bounds.Union(sub_surface->GetNonTransparentBounds() +
                                  sub_surface->bounds().OffsetFromOrigin());
   }
 
   return non_transparent_bounds;
 }
 
+void Surface::RegisterCursorProvider(Pointer* provider) {
+  cursor_providers_.insert(provider);
+}
+
+void Surface::UnregisterCursorProvider(Pointer* provider) {
+  cursor_providers_.erase(provider);
+}
+
+bool Surface::HasCursorProvider() const {
+  return !cursor_providers_.empty();
+}
+
 void Surface::SetSurfaceDelegate(SurfaceDelegate* delegate) {
   DCHECK(!delegate_ || !delegate);
   delegate_ = delegate;
 }
 
 bool Surface::HasSurfaceDelegate() const {
   return !!delegate_;
 }
 
 void Surface::AddSurfaceObserver(SurfaceObserver* observer) {
@@ skipping 97 matching lines @@
 void Surface::WillDraw(cc::SurfaceId id) {
   while (!active_frame_callbacks_.empty()) {
     active_frame_callbacks_.front().Run(base::TimeTicks::Now());
     active_frame_callbacks_.pop_front();
   }
 }
 
 bool Surface::use_surface_layer_ = false;
 
 }  // namespace exo