[views-mus] Support custom cursors.

services/ui/ws/test_utils.cc

 // Copyright 2016 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 "services/ui/ws/test_utils.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "cc/output/copy_output_request.h"
 #include "gpu/ipc/client/gpu_channel_host.h"
 #include "services/service_manager/public/interfaces/connector.mojom.h"
 #include "services/ui/public/interfaces/cursor/cursor.mojom.h"
 #include "services/ui/ws/display_binding.h"
 #include "services/ui/ws/display_manager.h"
 #include "services/ui/ws/window_manager_access_policy.h"
 #include "services/ui/ws/window_manager_window_tree_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/base/cursor/cursor.h"
 #include "ui/gfx/geometry/dip_util.h"
 
 namespace ui {
 namespace ws {
 namespace test {
 namespace {
 
 // -----------------------------------------------------------------------------
 // Empty implementation of PlatformDisplay.
 class TestPlatformDisplay : public PlatformDisplay {
  public:
   explicit TestPlatformDisplay(const display::ViewportMetrics& metrics,
-                               mojom::CursorType* cursor_storage)
+                               ui::CursorData* cursor_storage)
       : metrics_(metrics), cursor_storage_(cursor_storage) {}
   ~TestPlatformDisplay() override {}
 
   // PlatformDisplay:
   void Init(PlatformDisplayDelegate* delegate) override {
     delegate->OnAcceleratedWidgetAvailable();
   }
   void SetViewportSize(const gfx::Size& size) override {}
   void SetTitle(const base::string16& title) override {}
   void SetCapture() override {}
   void ReleaseCapture() override {}
-  void SetCursorById(mojom::CursorType cursor) override {
+  void SetCursor(const ui::CursorData& cursor) override {
     *cursor_storage_ = cursor;
   }
   void UpdateTextInputState(const ui::TextInputState& state) override {}
   void SetImeVisibility(bool visible) override {}
   void UpdateViewportMetrics(const display::ViewportMetrics& metrics) override {
     metrics_ = metrics;
   }
   gfx::AcceleratedWidget GetAcceleratedWidget() const override {
     return gfx::kNullAcceleratedWidget;
   }
   FrameGenerator* GetFrameGenerator() override { return nullptr; }
   EventSink* GetEventSink() override { return nullptr; }
 
  private:
   display::ViewportMetrics metrics_;
-  mojom::CursorType* cursor_storage_;
+  ui::CursorData* cursor_storage_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPlatformDisplay);
 };
 
 ClientWindowId NextUnusedClientWindowId(WindowTree* tree) {
   ClientWindowId client_id;
   for (ClientSpecificId id = 1;; ++id) {
     // Used the id of the client in the upper bits to simplify things.
     const ClientWindowId client_id =
         ClientWindowId(WindowIdToTransportId(WindowId(tree->id(), id)));
@@ skipping 72 matching lines @@
   display::Screen::SetScreenInstance(screen_.get());
 }
 
 display::ScreenBase* TestScreenManager::GetScreen() {
   return screen_.get();
 }
 
 // TestPlatformDisplayFactory  -------------------------------------------------
 
 TestPlatformDisplayFactory::TestPlatformDisplayFactory(
-    mojom::CursorType* cursor_storage)
+    ui::CursorData* cursor_storage)
     : cursor_storage_(cursor_storage) {}
 
 TestPlatformDisplayFactory::~TestPlatformDisplayFactory() {}
 
 std::unique_ptr<PlatformDisplay>
 TestPlatformDisplayFactory::CreatePlatformDisplay(
     ServerWindow* root_window,
     const display::ViewportMetrics& metrics) {
   return base::MakeUnique<TestPlatformDisplay>(metrics, cursor_storage_);
 }
@@ skipping 253 matching lines @@
     std::unique_ptr<ui::Event> event,
     uint32_t window_id,
     int64_t display_id) {
   tracker_.OnPointerEventObserved(*event.get(), window_id);
 }
 
 void TestWindowTreeClient::OnWindowFocused(uint32_t focused_window_id) {
   tracker_.OnWindowFocused(focused_window_id);
 }
 
-void TestWindowTreeClient::OnWindowPredefinedCursorChanged(
-    uint32_t window_id,
-    mojom::CursorType cursor_id) {
-  tracker_.OnWindowPredefinedCursorChanged(window_id, cursor_id);
+void TestWindowTreeClient::OnWindowCursorChanged(uint32_t window_id,
+                                                 ui::CursorData cursor) {
+  tracker_.OnWindowCursorChanged(window_id, cursor);
 }
 
 void TestWindowTreeClient::OnWindowSurfaceChanged(
     Id window_id,
     const cc::SurfaceInfo& surface_info) {}
 
 void TestWindowTreeClient::OnDragDropStart(
     const std::unordered_map<std::string, std::vector<uint8_t>>& mime_data) {}
 
 void TestWindowTreeClient::OnDragEnter(uint32_t window,
@@ skipping 83 matching lines @@
   return std::move(binding);
 }
 
 bool TestWindowServerDelegate::IsTestConfig() const {
   return true;
 }
 
 // WindowServerTestHelper  ---------------------------------------------------
 
 WindowServerTestHelper::WindowServerTestHelper()
-    : cursor_id_(mojom::CursorType::kNull),
-      platform_display_factory_(&cursor_id_) {
+    : cursor_(ui::CursorType::kNull), platform_display_factory_(&cursor_) {
   // Some tests create their own message loop, for example to add a task runner.
   if (!base::MessageLoop::current())
     message_loop_ = base::MakeUnique<base::MessageLoop>();
   PlatformDisplay::set_factory_for_testing(&platform_display_factory_);
   window_server_ = base::MakeUnique<WindowServer>(&window_server_delegate_);
   window_server_delegate_.set_window_server(window_server_.get());
 }
 
 WindowServerTestHelper::~WindowServerTestHelper() {
   // Destroy |window_server_| while the message-loop is still alive.
@@ skipping 145 matching lines @@
   if (!tree->AddWindow(parent_client_id, client_window_id))
     return nullptr;
   if (client_id)
     *client_id = client_window_id;
   return tree->GetWindowByClientId(client_window_id);
 }
 
 }  // namespace test
 }  // namespace ws
 }  // namespace ui