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

services/ui/service.cc

 // Copyright 2014 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/service.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
-#include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/platform_thread.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "components/discardable_memory/service/discardable_shared_memory_manager.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "services/catalog/public/cpp/resource_loader.h"
 #include "services/catalog/public/interfaces/constants.mojom.h"
 #include "services/service_manager/public/c/main.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/service_manager/public/cpp/service_context.h"
 #include "services/ui/clipboard/clipboard_impl.h"
+#include "services/ui/common/image_cursors_set.h"
 #include "services/ui/common/switches.h"
 #include "services/ui/display/screen_manager.h"
 #include "services/ui/ime/ime_driver_bridge.h"
 #include "services/ui/ime/ime_registrar_impl.h"
 #include "services/ui/ws/accessibility_manager.h"
 #include "services/ui/ws/display_binding.h"
 #include "services/ui/ws/display_creation_config.h"
 #include "services/ui/ws/display_manager.h"
 #include "services/ui/ws/frame_sink_manager_client_binding.h"
 #include "services/ui/ws/gpu_host.h"
+#include "services/ui/ws/threaded_image_cursors.h"
+#include "services/ui/ws/threaded_image_cursors_factory.h"
 #include "services/ui/ws/user_activity_monitor.h"
 #include "services/ui/ws/user_display_manager.h"
 #include "services/ui/ws/window_server.h"
 #include "services/ui/ws/window_server_test_impl.h"
 #include "services/ui/ws/window_tree.h"
 #include "services/ui/ws/window_tree_binding.h"
 #include "services/ui/ws/window_tree_factory.h"
 #include "services/ui/ws/window_tree_host_factory.h"
+#include "ui/base/cursor/image_cursors.h"
 #include "ui/base/platform_window_defaults.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/ui_base_paths.h"
 #include "ui/events/event_switches.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gl/gl_surface.h"
 
 #if defined(USE_X11)
 #include <X11/Xlib.h>
@@ skipping 15 matching lines @@
 using ui::mojom::WindowTreeHostFactory;
 
 namespace ui {
 
 namespace {
 
 const char kResourceFileStrings[] = "mus_app_resources_strings.pak";
 const char kResourceFile100[] = "mus_app_resources_100.pak";
 const char kResourceFile200[] = "mus_app_resources_200.pak";
 
+class ThreadedImageCursorsFactoryImpl : public ws::ThreadedImageCursorsFactory {
+ public:
+  // Uses the same InProcessConfig as the UI Service. |config| will be null when
+  // the UI Service runs in it's own separate process as opposed to the WM's
+  // process.
+  explicit ThreadedImageCursorsFactoryImpl(Service::InProcessConfig* config) {
+    if (config) {
+      resource_runner_ = config->resource_runner;
+      image_cursors_set_weak_ptr_ = config->image_cursors_set_weak_ptr;
+      DCHECK(resource_runner_);
+    }
+  }
+
+  ~ThreadedImageCursorsFactoryImpl() override {}
+
+  // ws::ThreadedImageCursorsFactory:
+  std::unique_ptr<ws::ThreadedImageCursors> CreateCursors() override {
+    // |resource_runner_| will not be initialized if and only if UI Service runs
+    // in it's own separate process. In this case we can (lazily) initialize it
+    // to the current thread (i.e. the UI Services's thread). We also initialize
+    // the local |image_cursors_set_| and make |image_cursors_set_weak_ptr_|
+    // point to it.
+    if (!resource_runner_) {
+      resource_runner_ = base::ThreadTaskRunnerHandle::Get();
+      image_cursors_set_ = base::MakeUnique<ui::ImageCursorsSet>();
+      image_cursors_set_weak_ptr_ = image_cursors_set_->GetWeakPtr();
+    }
+    return base::MakeUnique<ws::ThreadedImageCursors>(
+        resource_runner_, image_cursors_set_weak_ptr_);
+  }
+
+ private:
+  scoped_refptr<base::SingleThreadTaskRunner> resource_runner_;
+  base::WeakPtr<ui::ImageCursorsSet> image_cursors_set_weak_ptr_;
+
+  // Used when UI Service doesn't run inside WM's process.
+  std::unique_ptr<ui::ImageCursorsSet> image_cursors_set_;
+
+  DISALLOW_COPY_AND_ASSIGN(ThreadedImageCursorsFactoryImpl);
+};
+
 }  // namespace
 
 // TODO(sky): this is a pretty typical pattern, make it easier to do.
 struct Service::PendingRequest {
   service_manager::BindSourceInfo source_info;
   std::unique_ptr<mojom::WindowTreeFactoryRequest> wtf_request;
   std::unique_ptr<mojom::DisplayManagerRequest> dm_request;
 };
 
 struct Service::UserState {
   std::unique_ptr<clipboard::ClipboardImpl> clipboard;
   std::unique_ptr<ws::AccessibilityManager> accessibility;
   std::unique_ptr<ws::WindowTreeHostFactory> window_tree_host_factory;
 };
 
-Service::Service() : test_config_(false), ime_registrar_(&ime_driver_) {}
+Service::InProcessConfig::InProcessConfig() = default;
+
+Service::InProcessConfig::InProcessConfig(const InProcessConfig& params) =
+    default;
+
+Service::InProcessConfig::~InProcessConfig() = default;
+
+Service::Service(InProcessConfig* config)
+    : is_in_process_(config != nullptr),
+      threaded_image_cursors_factory_(
+          base::MakeUnique<ThreadedImageCursorsFactoryImpl>(config)),
+      test_config_(false),
+      ime_registrar_(&ime_driver_) {}
 
 Service::~Service() {
   // Destroy |window_server_| first, since it depends on |event_source_|.
   // WindowServer (or more correctly its Displays) may have state that needs to
   // be destroyed before GpuState as well.
   window_server_.reset();
 
 #if defined(USE_OZONE)
 #if defined(OS_CHROMEOS)
   // InputDeviceController uses ozone.
   input_device_controller_.reset();
 #endif
 
   OzonePlatform::Shutdown();
 #endif
 }
 
 bool Service::InitializeResources(service_manager::Connector* connector) {
-  if (ui::ResourceBundle::HasSharedInstance())
+  if (is_in_process() || ui::ResourceBundle::HasSharedInstance())
     return true;
 
   std::set<std::string> resource_paths;
   resource_paths.insert(kResourceFileStrings);
   resource_paths.insert(kResourceFile100);
   resource_paths.insert(kResourceFile200);
 
   catalog::ResourceLoader loader;
   filesystem::mojom::DirectoryPtr directory;
   connector->BindInterface(catalog::mojom::kServiceName, &directory);
   if (!loader.OpenFiles(std::move(directory), resource_paths)) {
     LOG(ERROR) << "Service failed to open resource files.";
     return false;
   }
 
   ui::RegisterPathProvider();
 
   // Initialize resource bundle with 1x and 2x cursor bitmaps.
   ui::ResourceBundle::InitSharedInstanceWithPakFileRegion(
       loader.TakeFile(kResourceFileStrings),
       base::MemoryMappedFile::Region::kWholeFile);
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   rb.AddDataPackFromFile(loader.TakeFile(kResourceFile100),
                          ui::SCALE_FACTOR_100P);
   rb.AddDataPackFromFile(loader.TakeFile(kResourceFile200),
                          ui::SCALE_FACTOR_200P);
+
   return true;
 }
 
 Service::UserState* Service::GetUserState(
     const service_manager::Identity& remote_identity) {
   const ws::UserId& user_id = remote_identity.user_id();
   auto it = user_id_to_user_state_.find(user_id);
   if (it != user_id_to_user_state_.end())
     return it->second.get();
   user_id_to_user_state_[user_id] = base::WrapUnique(new UserState);
   return user_id_to_user_state_[user_id].get();
 }
 
 void Service::AddUserIfNecessary(
     const service_manager::Identity& remote_identity) {
   window_server_->user_id_tracker()->AddUserId(remote_identity.user_id());
 }
 
 void Service::OnStart() {
-  base::PlatformThread::SetName("mus");
+  if (!is_in_process())
+    base::PlatformThread::SetName("mus");
+
   TRACE_EVENT0("mus", "Service::Initialize started");
 
   test_config_ = base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kUseTestConfig);
+
 #if defined(USE_X11)
   XInitThreads();
   ui::SetDefaultX11ErrorHandlers();
 #endif
 
   if (test_config_)
     ui::test::EnableTestConfigForPlatformWindows();
 
   // If resources are unavailable do not complete start-up.
   if (!InitializeResources(context()->connector())) {
     context()->QuitNow();
     return;
   }
 
 #if defined(USE_OZONE)
   // The ozone platform can provide its own event source. So initialize the
   // platform before creating the default event source.
   // Because GL libraries need to be initialized before entering the sandbox,
   // in MUS, |InitializeForUI| will load the GL libraries.
   ui::OzonePlatform::InitParams params;
   params.connector = context()->connector();
   params.single_process = false;
   ui::OzonePlatform::InitializeForUI(params);
 
   // Assume a client will change the layout to an appropriate configuration.
   ui::KeyboardLayoutEngineManager::GetKeyboardLayoutEngine()
       ->SetCurrentLayoutByName("us");
-  client_native_pixmap_factory_ = ui::CreateClientNativePixmapFactoryOzone();
-  gfx::ClientNativePixmapFactory::SetInstance(
-      client_native_pixmap_factory_.get());
+
+  if (!is_in_process()) {
+    client_native_pixmap_factory_ = ui::CreateClientNativePixmapFactoryOzone();
+    gfx::ClientNativePixmapFactory::SetInstance(
+        client_native_pixmap_factory_.get());
+  }
 
   DCHECK(gfx::ClientNativePixmapFactory::GetInstance());
 
 #if defined(OS_CHROMEOS)
   input_device_controller_ = base::MakeUnique<InputDeviceController>();
   input_device_controller_->AddInterface(&registry_);
 #endif
 #endif
 
 // TODO(rjkroege): Enter sandbox here before we start threads in GpuState
@@ skipping 112 matching lines @@
 
   DVLOG(3) << "OnWillCreateTreeForWindowManager "
            << automatically_create_display_roots;
   ws::DisplayCreationConfig config = automatically_create_display_roots
                                          ? ws::DisplayCreationConfig::AUTOMATIC
                                          : ws::DisplayCreationConfig::MANUAL;
   window_server_->SetDisplayCreationConfig(config);
   if (window_server_->display_creation_config() ==
       ws::DisplayCreationConfig::MANUAL) {
 #if defined(USE_OZONE) && defined(OS_CHROMEOS)
-    screen_manager_ = base::MakeUnique<display::ScreenManagerForwarding>();
+    display::ScreenManagerForwarding::Mode mode =
+        is_in_process() ? display::ScreenManagerForwarding::Mode::IN_WM_PROCESS
+                        : display::ScreenManagerForwarding::Mode::OWN_PROCESS;
+    screen_manager_ = base::MakeUnique<display::ScreenManagerForwarding>(mode);
 #else
     CHECK(false);
 #endif
   } else {
     screen_manager_ = display::ScreenManager::Create();
   }
   screen_manager_->AddInterfaces(&registry_);
   if (is_gpu_ready_)
     screen_manager_->Init(window_server_->display_manager());
 }
 
+ws::ThreadedImageCursorsFactory* Service::GetThreadedImageCursorsFactory() {
+  return threaded_image_cursors_factory_.get();
+}
+
 void Service::BindAccessibilityManagerRequest(
     const service_manager::BindSourceInfo& source_info,
     mojom::AccessibilityManagerRequest request) {
   UserState* user_state = GetUserState(source_info.identity);
   if (!user_state->accessibility) {
     const ws::UserId& user_id = source_info.identity.user_id();
     user_state->accessibility.reset(
         new ws::AccessibilityManager(window_server_.get(), user_id));
   }
   user_state->accessibility->Bind(std::move(request));
@@ skipping 108 matching lines @@
     mojom::WindowServerTestRequest request) {
   if (!test_config_)
     return;
   mojo::MakeStrongBinding(
       base::MakeUnique<ws::WindowServerTestImpl>(window_server_.get()),
       std::move(request));
 }
 
 
 }  // namespace ui