mus: Rename mojom::Cursor to mojom::CursorType.

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"
@@ skipping 10 matching lines @@
 namespace ui {
 namespace ws {
 namespace test {
 namespace {
 
 // -----------------------------------------------------------------------------
 // Empty implementation of PlatformDisplay.
 class TestPlatformDisplay : public PlatformDisplay {
  public:
   explicit TestPlatformDisplay(const display::ViewportMetrics& metrics,
-                               mojom::Cursor* cursor_storage)
+                               mojom::CursorType* 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::Cursor cursor) override {
+  void SetCursorById(mojom::CursorType 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::Cursor* cursor_storage_;
+  mojom::CursorType* 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 68 matching lines @@
   // Reset everything.
   display_ids_.clear();
   display::Screen::SetScreenInstance(nullptr);
   screen_ = base::MakeUnique<display::ScreenBase>();
   display::Screen::SetScreenInstance(screen_.get());
 }
 
 // TestPlatformDisplayFactory  -------------------------------------------------
 
 TestPlatformDisplayFactory::TestPlatformDisplayFactory(
-    mojom::Cursor* cursor_storage)
+    mojom::CursorType* 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 235 matching lines @@
     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::Cursor cursor_id) {
+    mojom::CursorType cursor_id) {
   tracker_.OnWindowPredefinedCursorChanged(window_id, cursor_id);
 }
 
 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) {}
 
@@ skipping 84 matching lines @@
   return std::move(binding);
 }
 
 bool TestWindowServerDelegate::IsTestConfig() const {
   return true;
 }
 
 // WindowServerTestHelper  ---------------------------------------------------
 
 WindowServerTestHelper::WindowServerTestHelper()
-    : cursor_id_(mojom::Cursor::CURSOR_NULL),
+    : cursor_id_(mojom::CursorType::CURSOR_NULL),
       platform_display_factory_(&cursor_id_) {
   // 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() {
@@ skipping 142 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