Move Mus into chrome's process when running with --mus.

services/ui/ws/platform_display_default.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/platform_display_default.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "gpu/ipc/client/gpu_channel_host.h"
 #include "services/ui/display/screen_manager.h"
 #include "services/ui/public/interfaces/cursor/cursor_struct_traits.h"
 #include "services/ui/ws/server_window.h"
-#include "ui/base/cursor/image_cursors.h"
+#include "services/ui/ws/threaded_image_cursors.h"
 #include "ui/display/display.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/platform_window/platform_ime_controller.h"
 #include "ui/platform_window/platform_window.h"
 
 #if defined(OS_WIN)
 #include "ui/platform_window/win/win_window.h"
 #elif defined(USE_X11) && !defined(OS_CHROMEOS)
 #include "ui/platform_window/x11/x11_window.h"
 #elif defined(OS_ANDROID)
 #include "ui/platform_window/android/platform_window_android.h"
 #elif defined(USE_OZONE)
 #include "ui/ozone/public/cursor_factory_ozone.h"
 #include "ui/ozone/public/ozone_platform.h"
 #endif
 
 namespace ui {
 namespace ws {
 
 PlatformDisplayDefault::PlatformDisplayDefault(
     ServerWindow* root_window,
     const display::ViewportMetrics& metrics,
-    std::unique_ptr<ImageCursors> image_cursors)
+    std::unique_ptr<ThreadedImageCursors> image_cursors)
     : root_window_(root_window),
       image_cursors_(std::move(image_cursors)),
       metrics_(metrics),
       widget_(gfx::kNullAcceleratedWidget) {}
 
 PlatformDisplayDefault::~PlatformDisplayDefault() {
   // Don't notify the delegate from the destructor.
   delegate_ = nullptr;
 
   frame_generator_.reset();
+  image_cursors_.reset();
   // Destroy the PlatformWindow early on as it may call us back during
   // destruction and we want to be in a known state. But destroy the surface
-  // first because it can still be using the platform window.
+  // and ThreadedImageCursors first because they can still be using the platform
+  // window.
   platform_window_.reset();
 }
 
 EventSink* PlatformDisplayDefault::GetEventSink() {
   return delegate_->GetEventSink();
 }
 
 void PlatformDisplayDefault::Init(PlatformDisplayDelegate* delegate) {
   DCHECK(delegate);
   delegate_ = delegate;
@@ skipping 35 matching lines @@
 }
 
 void PlatformDisplayDefault::ReleaseCapture() {
   platform_window_->ReleaseCapture();
 }
 
 void PlatformDisplayDefault::SetCursor(const ui::CursorData& cursor_data) {
   if (!image_cursors_)
     return;
 
-  ui::Cursor native_cursor(cursor_data.cursor_type());
+  ui::CursorType cursor_type = cursor_data.cursor_type();
 
 #if defined(USE_OZONE)
-  if (cursor_data.cursor_type() != ui::CursorType::kCustom) {
-    image_cursors_->SetPlatformCursor(&native_cursor);
+  if (cursor_type != ui::CursorType::kCustom) {
+    // |platform_window_| is destroyed after |image_cursors_|, so it is
+    // guaranteed to outlive |image_cursors_|.
+    image_cursors_->SetCursor(cursor_type, platform_window_.get());
   } else {
+    ui::Cursor native_cursor(cursor_type);
     // In Ozone builds, we have an interface available which turns bitmap data
     // into platform cursors.
     ui::CursorFactoryOzone* cursor_factory =
         delegate_->GetOzonePlatform()->GetCursorFactoryOzone();
     native_cursor.SetPlatformCursor(cursor_factory->CreateAnimatedCursor(
         cursor_data.cursor_frames(), cursor_data.hotspot_in_pixels(),
         cursor_data.frame_delay().InMilliseconds(),
         cursor_data.scale_factor()));
+    platform_window_->SetCursor(native_cursor.platform());
   }
 #else
   // Outside of ozone builds, there isn't a single interface for creating
   // PlatformCursors. The closest thing to one is in //content/ instead of
   // //ui/ which means we can't use it from here. For now, just don't handle
   // custom image cursors.
   //
   // TODO(erg): Once blink speaks directly to mus, make blink perform its own
   // cursor management on its own mus windows so we can remove Webcursor from
   // //content/ and do this in way that's safe cross-platform, instead of as an
   // ozone-specific hack.
-  if (cursor_data.cursor_type() == ui::CursorType::kCustom) {
+  if (cursor_type == ui::CursorType::kCustom) {
     NOTIMPLEMENTED() << "No custom cursor support on non-ozone yet.";
-    native_cursor = ui::Cursor(ui::CursorType::kPointer);
+    cursor_type = ui::CursorType::kPointer;
   }
-  image_cursors_->SetPlatformCursor(&native_cursor);
+  image_cursors_->SetCursor(cursor_type, platform_window_.get());
 #endif
-
-  platform_window_->SetCursor(native_cursor.platform());
 }
 
 void PlatformDisplayDefault::MoveCursorTo(
     const gfx::Point& window_pixel_location) {
   platform_window_->MoveCursorTo(window_pixel_location);
 }
 
 void PlatformDisplayDefault::SetCursorSize(const ui::CursorSize& cursor_size) {
   image_cursors_->SetCursorSize(cursor_size);
 }
@@ skipping 123 matching lines @@
 }
 
 void PlatformDisplayDefault::OnAcceleratedWidgetDestroyed() {
   NOTREACHED();
 }
 
 void PlatformDisplayDefault::OnActivationChanged(bool active) {}
 
 }  // namespace ws
 }  // namespace ui