Implement cursor compositing mode on Ash

ash/display/mirror_window_controller.cc

Index: ash/display/mirror_window_controller.cc
diff --git a/ash/display/mirror_window_controller.cc b/ash/display/mirror_window_controller.cc
index 54d6764f4e53c15fc05e9c9b752c15175f1419cf..93ccd129136b352161ae1a01e03193c6673fc155 100644
--- a/ash/display/mirror_window_controller.cc
+++ b/ash/display/mirror_window_controller.cc
@@ -20,18 +20,12 @@
 #include "ash/shell.h"
 #include "base/strings/stringprintf.h"
 #include "ui/aura/client/capture_client.h"
-#include "ui/aura/env.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/root_window_transformer.h"
 #include "ui/aura/window_delegate.h"
-#include "ui/base/cursor/cursors_aura.h"
-#include "ui/base/hit_test.h"
 #include "ui/base/layout.h"
-#include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/reflector.h"
 #include "ui/gfx/canvas.h"
-#include "ui/gfx/image/image_skia.h"
-#include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/native_widget_types.h"
 
 #if defined(USE_X11)
@@ -76,80 +70,8 @@ class NoneCaptureClient : public aura::client::CaptureClient {
 
 }  // namespace
 
-class CursorWindowDelegate : public aura::WindowDelegate {
- public:
-  CursorWindowDelegate() {}
-  virtual ~CursorWindowDelegate() {}
-
-  // aura::WindowDelegate overrides:
-  virtual gfx::Size GetMinimumSize() const OVERRIDE {
-    return size_;
-  }
-  virtual gfx::Size GetMaximumSize() const OVERRIDE {
-    return size_;
-  }
-  virtual void OnBoundsChanged(const gfx::Rect& old_bounds,
-                               const gfx::Rect& new_bounds) OVERRIDE {
-  }
-  virtual gfx::NativeCursor GetCursor(const gfx::Point& point) OVERRIDE {
-    return gfx::kNullCursor;
-  }
-  virtual int GetNonClientComponent(
-      const gfx::Point& point) const OVERRIDE {
-    return HTNOWHERE;
-  }
-  virtual bool ShouldDescendIntoChildForEventHandling(
-      aura::Window* child,
-      const gfx::Point& location) OVERRIDE {
-    return false;
-  }
-  virtual bool CanFocus() OVERRIDE {
-    return false;
-  }
-  virtual void OnCaptureLost() OVERRIDE {
-  }
-  virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE {
-    canvas->DrawImageInt(cursor_image_, 0, 0);
-  }
-  virtual void OnDeviceScaleFactorChanged(
-      float device_scale_factor) OVERRIDE {
-  }
-  virtual void OnWindowDestroying() OVERRIDE {}
-  virtual void OnWindowDestroyed() OVERRIDE {}
-  virtual void OnWindowTargetVisibilityChanged(bool visible) OVERRIDE {
-  }
-  virtual bool HasHitTestMask() const OVERRIDE {
-    return false;
-  }
-  virtual void GetHitTestMask(gfx::Path* mask) const OVERRIDE {}
-  virtual void DidRecreateLayer(ui::Layer* old_layer,
-                                ui::Layer* new_layer) OVERRIDE {}
-
-  // Set the cursor image for the |display|'s scale factor.  Note that
-  // mirror window's scale factor is always 1.0f, therefore we need to
-  // take 2x's image and paint as if it's 1x image.
-  void SetCursorImage(const gfx::ImageSkia& image,
-                      const gfx::Display& display) {
-    const gfx::ImageSkiaRep& image_rep =
-        image.GetRepresentation(display.device_scale_factor());
-    size_ = image_rep.pixel_size();
-    cursor_image_ = gfx::ImageSkia::CreateFrom1xBitmap(image_rep.sk_bitmap());
-  }
-
-  const gfx::Size size() const { return size_; }
-
- private:
-  gfx::ImageSkia cursor_image_;
-  gfx::Size size_;
-
-  DISALLOW_COPY_AND_ASSIGN(CursorWindowDelegate);
-};
-
 MirrorWindowController::MirrorWindowController()
-    : current_cursor_type_(ui::kCursorNone),
-      current_cursor_rotation_(gfx::Display::ROTATE_0),
-      cursor_window_(NULL),
-      cursor_window_delegate_(new CursorWindowDelegate) {
+    : CursorWindowController(true) {
 }
 
 MirrorWindowController::~MirrorWindowController() {
@@ -196,11 +118,7 @@ void MirrorWindowController::UpdateWindow(const DisplayInfo& display_info) {
         Shell::GetPrimaryRootWindow()->GetDispatcher()->host()->compositor(),
         mirror_window->layer());
 
-    cursor_window_ = new aura::Window(cursor_window_delegate_.get());
-    cursor_window_->SetTransparent(true);
-    cursor_window_->Init(aura::WINDOW_LAYER_TEXTURED);
-    root_window_->window()->AddChild(cursor_window_);
-    cursor_window_->Show();
+    InitCursorWindow(root_window_->window());
   } else {
     GetRootWindowSettings(root_window_->window())->display_id =
         display_info.id();
@@ -242,82 +160,10 @@ void MirrorWindowController::Close() {
         Shell::GetInstance()->display_controller());
     root_window_->RemoveRootWindowObserver(this);
     root_window_.reset();
-    cursor_window_ = NULL;
+    CloseCursorWindow();
   }
 }
 
-void MirrorWindowController::UpdateCursorLocation() {
-  if (cursor_window_) {
-    // TODO(oshima): Rotate cursor image (including hotpoint).
-    gfx::Point point = aura::Env::GetInstance()->last_mouse_location();
-    Shell::GetPrimaryRootWindow()->GetDispatcher()->host()->ConvertPointToHost(
-        &point);
-    point.Offset(-hot_point_.x(), -hot_point_.y());
-    gfx::Rect bounds = cursor_window_->bounds();
-    bounds.set_origin(point);
-    cursor_window_->SetBounds(bounds);
-  }
-}
-
-void MirrorWindowController::SetMirroredCursor(gfx::NativeCursor cursor) {
-  const gfx::Display& display = Shell::GetScreen()->GetPrimaryDisplay();
-  if (current_cursor_type_ == cursor.native_type() &&
-      current_cursor_rotation_ == display.rotation())
-    return;
-  current_cursor_type_ = cursor.native_type();
-  current_cursor_rotation_ = display.rotation();
-  int resource_id;
-  bool success = ui::GetCursorDataFor(
-      ui::CURSOR_SET_NORMAL,  // Not support custom cursor set.
-      current_cursor_type_,
-      display.device_scale_factor(),
-      &resource_id,
-      &hot_point_);
-  if (!success)
-    return;
-  const gfx::ImageSkia* image =
-      ResourceBundle::GetSharedInstance().GetImageSkiaNamed(resource_id);
-  gfx::ImageSkia rotated = *image;
-  switch (current_cursor_rotation_) {
-    case gfx::Display::ROTATE_0:
-      break;
-    case gfx::Display::ROTATE_90:
-      rotated = gfx::ImageSkiaOperations::CreateRotatedImage(
-          *image, SkBitmapOperations::ROTATION_90_CW);
-      hot_point_.SetPoint(
-          rotated.width() - hot_point_.y(),
-          hot_point_.x());
-      break;
-    case gfx::Display::ROTATE_180:
-      rotated = gfx::ImageSkiaOperations::CreateRotatedImage(
-          *image, SkBitmapOperations::ROTATION_180_CW);
-      hot_point_.SetPoint(
-          rotated.height() - hot_point_.x(),
-          rotated.width() - hot_point_.y());
-      break;
-    case gfx::Display::ROTATE_270:
-      rotated = gfx::ImageSkiaOperations::CreateRotatedImage(
-          *image, SkBitmapOperations::ROTATION_270_CW);
-      hot_point_.SetPoint(
-          hot_point_.y(),
-          rotated.height() - hot_point_.x());
-      break;
-  }
-  cursor_window_delegate_->SetCursorImage(rotated, display);
-
-  if (cursor_window_) {
-    cursor_window_->SetBounds(gfx::Rect(cursor_window_delegate_->size()));
-    cursor_window_->SchedulePaintInRect(
-        gfx::Rect(cursor_window_->bounds().size()));
-    UpdateCursorLocation();
-  }
-}
-
-void MirrorWindowController::SetMirroredCursorVisibility(bool visible) {
-  if (cursor_window_)
-    visible ? cursor_window_->Show() : cursor_window_->Hide();
-}
-
 void MirrorWindowController::OnWindowTreeHostResized(
     const aura::RootWindow* root) {
   // Do not use |old_size| as it contains RootWindow's (but not host's) size,