exo: Implement lazy cursor changes.

components/exo/surface.h

 // 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.
 
 #ifndef COMPONENTS_EXO_SURFACE_H_
 #define COMPONENTS_EXO_SURFACE_H_
 
 #include <list>
 #include <memory>
+#include <set>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "cc/surfaces/surface_factory_client.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "third_party/skia/include/core/SkXfermode.h"
@@ skipping 12 matching lines @@
 class SurfaceFactory;
 enum class SurfaceDrawStatus;
 }
 
 namespace gfx {
 class Path;
 }
 
 namespace exo {
 class Buffer;
+class Pointer;
 class SurfaceDelegate;
 class SurfaceObserver;
 class Surface;
 
+// The pointer class is currently the only cursor provider class but this can
+// change in the future when better hardware cursor support is added.
+using CursorProvider = Pointer;
+
 // This class owns the SurfaceFactory and keeps track of references to the
 // contents of Buffers. It's keeped alive by references from
 // release_callbacks_. It's destroyed when its owning Surface is destroyed and
 // the last outstanding release callback is called.
 class SurfaceFactoryOwner : public base::RefCounted<SurfaceFactoryOwner>,
                             public cc::SurfaceFactoryClient {
  public:
   SurfaceFactoryOwner();
 
   // Overridden from cc::SurfaceFactoryClient:
@@ skipping 104 matching lines @@
   // Returns true if the current input region is different than the surface
   // bounds.
   bool HasHitTestMask() const;
 
   // Returns the current input region of surface in the form of a hit-test mask.
   void GetHitTestMask(gfx::Path* mask) const;
 
   // Returns the bounds of the surface area that is not know to be transparent.
   gfx::Rect GetNonTransparentBounds() const;
 
+  // Surface does not own cursor providers. It is the responsibility of the
+  // caller to remove the cursor provider before it is destroyed.
+  void RegisterCursorProvider(CursorProvider* provider);
+  void UnregisterCursorProvider(CursorProvider* provider);
+
+  // Returns true if surface has at least one cursor provider registered.
+  bool HasCursorProvider() const;
+
   // Set the surface delegate.
   void SetSurfaceDelegate(SurfaceDelegate* delegate);
 
   // Returns true if surface has been assigned a surface delegate.
   bool HasSurfaceDelegate() const;
 
   // Surface does not own observers. It is the responsibility of the observer
   // to remove itself when it is done observing.
   void AddSurfaceObserver(SurfaceObserver* observer);
   void RemoveSurfaceObserver(SurfaceObserver* observer);
@@ skipping 118 matching lines @@
   // callbacks when compositing successfully ends.
   base::TimeTicks last_compositing_start_time_;
 
   // This is true when the contents of the surface should be updated next time
   // the compositor successfully ends compositing.
   bool update_contents_after_successful_compositing_;
 
   // The compsitor being observer or null if not observing a compositor.
   ui::Compositor* compositor_;
 
+  // Cursor providers. Surface does not own the cursor providers.
+  std::set<CursorProvider*> cursor_providers_;
+
   // This can be set to have some functions delegated. E.g. ShellSurface class
   // can set this to handle Commit() and apply any double buffered state it
   // maintains.
   SurfaceDelegate* delegate_;
 
   // Surface observer list. Surface does not own the observers.
   base::ObserverList<SurfaceObserver, true> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(Surface);
 };
 
 }  // namespace exo
 
 #endif  // COMPONENTS_EXO_SURFACE_H_