views/mus: Connect cursor events to the mus window.

ui/views/mus/native_widget_mus.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 "ui/views/mus/native_widget_mus.h"
 
 #include "base/macros.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/mus/public/cpp/property_type_converters.h"
 #include "components/mus/public/cpp/window.h"
 #include "components/mus/public/cpp/window_observer.h"
 #include "components/mus/public/cpp/window_property.h"
 #include "components/mus/public/cpp/window_tree_connection.h"
+#include "components/mus/public/interfaces/cursor.mojom.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "ui/aura/client/default_capture_client.h"
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/mus/mus_util.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/hit_test.h"
 #include "ui/gfx/canvas.h"
 #include "ui/native_theme/native_theme_aura.h"
 #include "ui/views/mus/platform_window_mus.h"
 #include "ui/views/mus/surface_context_factory.h"
 #include "ui/views/mus/window_manager_constants_converters.h"
 #include "ui/views/mus/window_manager_frame_values.h"
 #include "ui/views/mus/window_tree_host_mus.h"
 #include "ui/views/widget/native_widget_aura.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/views/window/custom_frame_view.h"
 #include "ui/wm/core/base_focus_rules.h"
 #include "ui/wm/core/capture_controller.h"
+#include "ui/wm/core/cursor_manager.h"
 #include "ui/wm/core/default_screen_position_client.h"
 #include "ui/wm/core/focus_controller.h"
+#include "ui/wm/core/native_cursor_manager.h"
 
 DECLARE_WINDOW_PROPERTY_TYPE(mus::Window*);
 
 namespace views {
 namespace {
 
 DEFINE_WINDOW_PROPERTY_KEY(mus::Window*, kMusWindow, nullptr);
 
 MUS_DEFINE_WINDOW_PROPERTY_KEY(NativeWidgetMus*, kNativeWidgetMusKey, nullptr);
 
@@ skipping 81 matching lines @@
     point->Offset(mus_bounds.x(), mus_bounds.y());
     wm::DefaultScreenPositionClient::ConvertPointFromScreen(window, point);
   }
 
  private:
   mus::Window* mus_window_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenPositionClientMus);
 };
 
+class NativeCursorManagerMus : public wm::NativeCursorManager {
+ public:
+  explicit NativeCursorManagerMus(mus::Window* mus_window)
+      : mus_window_(mus_window) {}
+  ~NativeCursorManagerMus() override {}
+
+  // wm::NativeCursorManager:
+  void SetDisplay(const display::Display& display,
+                  wm::NativeCursorManagerDelegate* delegate) override {
+    // We ignore this entirely, as cursor are set on the client.
+  }
+
+  void SetCursor(gfx::NativeCursor cursor,
+                 wm::NativeCursorManagerDelegate* delegate) override {
+    mus_window_->SetPredefinedCursor(mus::mojom::Cursor(cursor.native_type()));
+    delegate->CommitCursor(cursor);
+  }
+
+  void SetVisibility(bool visible,
+                     wm::NativeCursorManagerDelegate* delegate) override {
+    delegate->CommitVisibility(visible);
+
+    if (visible)
+      SetCursor(delegate->GetCursor(), delegate);
+    else
+      mus_window_->SetPredefinedCursor(mus::mojom::Cursor::NONE);
+  }
+
+  void SetCursorSet(ui::CursorSetType cursor_set,
+                    wm::NativeCursorManagerDelegate* delegate) override {
+    // TODO(erg): For now, ignore the difference between SET_NORMAL and
+    // SET_LARGE here. This feels like a thing that mus should decide instead.
+    //
+    // Also, it's NOTIMPLEMENTED() in the desktop version!? Including not
+    // acknowledging the call in the delegate.
+    NOTIMPLEMENTED();
+  }
+
+  void SetMouseEventsEnabled(
+      bool enabled,
+      wm::NativeCursorManagerDelegate* delegate) override {
+    // TODO(erg): How do we actually implement this?
+    //
+    // Mouse event dispatch is potentially done in a different process,
+    // definitely in a different mojo service. Each app is fairly locked down.
+    delegate->CommitMouseEventsEnabled(enabled);
+    NOTIMPLEMENTED();
+  }
+
+ private:
+  mus::Window* mus_window_;
+
+  DISALLOW_COPY_AND_ASSIGN(NativeCursorManagerMus);
+};
+
 // As the window manager renderers the non-client decorations this class does
 // very little but honor the client area insets from the window manager.
 class ClientSideNonClientFrameView : public NonClientFrameView {
  public:
   explicit ClientSideNonClientFrameView(views::Widget* widget)
       : widget_(widget) {}
   ~ClientSideNonClientFrameView() override {}
 
  private:
   // Returns the default values of client area insets from the window manager.
@@ skipping 174 matching lines @@
 aura::Window* NativeWidgetMus::GetRootWindow() {
   return window_tree_host_->window();
 }
 
 void NativeWidgetMus::OnPlatformWindowClosed() {
   native_widget_delegate_->OnNativeWidgetDestroying();
 
   window_tree_client_.reset();  // Uses |content_|.
   capture_client_.reset();      // Uses |content_|.
 
+  cursor_manager_.reset();      // Uses |window_|.
+
   window_tree_host_->RemoveObserver(this);
   window_tree_host_.reset();
 
   mus_window_observer_.reset(nullptr);
 
   window_ = nullptr;
   content_ = nullptr;
 
   native_widget_delegate_->OnNativeWidgetDestroyed();
   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
@@ skipping 79 matching lines @@
   focus_client_.reset(new wm::FocusController(new FocusRulesImpl));
 
   aura::client::SetFocusClient(window_tree_host_->window(),
                                focus_client_.get());
   aura::client::SetActivationClient(window_tree_host_->window(),
                                     focus_client_.get());
   screen_position_client_.reset(new ScreenPositionClientMus(window_));
   aura::client::SetScreenPositionClient(window_tree_host_->window(),
                                         screen_position_client_.get());
 
+  // TODO(erg): Remove this check when mash/wm/frame/move_event_handler.cc's
+  // direct usage of mus::Window::SetPredefinedCursor() is switched to a
+  // private method on WindowManagerClient.
+  if (surface_type_ == mus::mojom::SurfaceType::DEFAULT) {
+    cursor_manager_.reset(new wm::CursorManager(
+        base::WrapUnique(new NativeCursorManagerMus(window_))));
+    aura::client::SetCursorClient(window_tree_host_->window(),
+                                  cursor_manager_.get());
+  }
+
   window_tree_client_.reset(
       new NativeWidgetMusWindowTreeClient(window_tree_host_->window()));
   window_tree_host_->window()->AddPreTargetHandler(focus_client_.get());
   window_tree_host_->window()->SetLayoutManager(
       new ContentWindowLayoutManager(window_tree_host_->window(), content_));
   capture_client_.reset(
       new aura::client::DefaultCaptureClient(window_tree_host_->window()));
 
   content_->SetType(ui::wm::WINDOW_TYPE_NORMAL);
   content_->Init(ui::LAYER_TEXTURED);
@@ skipping 610 matching lines @@
     window_tree_host_->Show();
     GetNativeWindow()->Show();
   } else {
     window_tree_host_->Hide();
     GetNativeWindow()->Hide();
   }
   native_widget_delegate_->OnNativeWidgetVisibilityChanged(window->visible());
 }
 
 }  // namespace views