Rework ash::CursorManager into a corewm object, to share code with desktop.

ui/views/corewm/cursor_manager.h

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright (c) 2013 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 ASH_WM_CURSOR_MANAGER_H_
-#define ASH_WM_CURSOR_MANAGER_H_
+#ifndef UI_VIEWS_COREWM_CURSOR_MANAGER_H_
+#define UI_VIEWS_COREWM_CURSOR_MANAGER_H_
 
-#include "ash/ash_export.h"
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/point.h"
+#include "ui/views/corewm/cursor_manager_delegate.h"
+#include "ui/views/views_export.h"
 
-namespace ash {
+namespace views {
+namespace corewm {
 
 namespace internal {
 class CursorState;
 }
 
-namespace test {
-class CursorManagerTestApi;
-}
+class CursorPlatformDelegate;
 
-class ImageCursors;
-
-// This class controls the visibility and the type of the cursor.
-// The cursor type can be locked so that the type stays the same
-// until it's unlocked.
-class ASH_EXPORT CursorManager : public aura::client::CursorClient {
+// This class controls the visibility and the type of the cursor.  The cursor
+// type can be locked so that the type stays the same until it's unlocked.
+class VIEWS_EXPORT CursorManager : public aura::client::CursorClient,
+                                   public CursorManagerDelegate {

[Ben Goodger (Google), 2013/02/22 18:00:06]

It is confusing to me that you have a class CursorManager that is itself its own
delegate. Perhaps this is just a terminology issue.

[Elliot Glaysher, 2013/02/22 18:40:07]

In the previous implementation, if you wanted to muck about with the
CursorManager's internal state, you derived from it. Nice and simple.

You didn't like that, so that makes this a bit harder. The platform specific
parts must be able to modify the current state...while forcing everything else
to go through the public interface. (The point of CursorManager is to queue up
changes while the cursor is locked.)

As a rough sketch:
- The CursorManager executes or queues up state changes in a 
cross platform way, tells the CursorPlatformDelegate to actually change the
properties, and reports the current state to users.
- The CursroPlatformDelegate performs the ash/desktop specific mutations, and
reports the changes (which can be different from what was requested) back to
CursorManager via...
- The CursorManagerDelegate, which is an interface that allows the CPD to tell
the CursorManager what the actual state is.

Naming proposal:
- Rename CursorManagerDelegate to CursorManagerDelegateInterface.

  public:
-  CursorManager();
+  CursorManager(scoped_ptr<CursorPlatformDelegate> delegate);
   virtual ~CursorManager();
 
   bool is_cursor_locked() const { return cursor_lock_count_ > 0; }
 
   // Overridden from aura::client::CursorClient:
   virtual void SetCursor(gfx::NativeCursor) OVERRIDE;
   virtual void ShowCursor() OVERRIDE;
   virtual void HideCursor() OVERRIDE;
   virtual bool IsCursorVisible() const OVERRIDE;
   virtual void EnableMouseEvents() OVERRIDE;
   virtual void DisableMouseEvents() OVERRIDE;
   virtual bool IsMouseEventsEnabled() const OVERRIDE;
   virtual void SetDeviceScaleFactor(float device_scale_factor) OVERRIDE;
   virtual void LockCursor() OVERRIDE;
   virtual void UnlockCursor() OVERRIDE;
 
  private:
-  friend class test::CursorManagerTestApi;
+  // Overridden from CursorManagerDelegate:
+  virtual gfx::NativeCursor GetCurrentCursor() const OVERRIDE;
+  virtual bool GetCurrentVisibility() const OVERRIDE;
+  virtual bool GetMouseEventsEnabled() const OVERRIDE;
+  virtual void CommitCursor(gfx::NativeCursor cursor) OVERRIDE;
+  virtual void CommitVisibility(bool visible) OVERRIDE;
+  virtual void CommitMouseEventsEnabled(bool enabled) OVERRIDE;
 
-  void SetCursorInternal(gfx::NativeCursor cursor);
-  void SetCursorVisibility(bool visible);
-  void SetMouseEventsEnabled(bool enabled);
-
-  // Returns the current cursor.
-  gfx::NativeCursor GetCurrentCursor() const;
+  scoped_ptr<CursorPlatformDelegate> delegate_;
 
   // Number of times LockCursor() has been invoked without a corresponding
   // UnlockCursor().
   int cursor_lock_count_;
 
-  // The cursor location where the cursor was disabled.
-  gfx::Point disabled_cursor_location_;
-
   // The current state of the cursor.
   scoped_ptr<internal::CursorState> current_state_;
 
   // The cursor state to restore when the cursor is unlocked.
   scoped_ptr<internal::CursorState> state_on_unlock_;
 
-  scoped_ptr<ImageCursors> image_cursors_;
-
   DISALLOW_COPY_AND_ASSIGN(CursorManager);
 };
 
-}  // namespace ash
+}  // namespace corewm
+}  // namespace views
 
-#endif  // UI_AURA_CURSOR_MANAGER_H_
+#endif  // UI_VIEWS_COREWM_CURSOR_MANAGER_H_