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"
@@ skipping 73 matching lines @@
   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),
+Service::Service(scoped_refptr<base::SingleThreadTaskRunner> resource_runner)
+    : resource_runner_(resource_runner),
+      /*in_process_(resource_runner != nullptr),*/
+      test_config_(false),
       ime_registrar_(&ime_server_) {}
 
 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)
@@ skipping 45 matching lines @@
   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 (!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());
+
+  // TODO: Ok?
+  if (!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
 // http://crbug.com/584532
 
 #if !defined(OS_ANDROID)
   event_source_ = ui::PlatformEventSource::CreateDefault();
 #endif
 
   // This needs to happen after DeviceDataManager has been constructed. That
   // happens either during OzonePlatform or PlatformEventSource initialization,
   // so keep this line below both of those.
   input_device_server_.RegisterAsObserver();
 
-  window_server_.reset(new ws::WindowServer(this));
+  window_server_.reset(new ws::WindowServer(this, resource_runner_));
   std::unique_ptr<ws::GpuHost> gpu_host =
       base::MakeUnique<ws::DefaultGpuHost>(window_server_.get());
   std::unique_ptr<ws::FrameSinkManagerClientBinding> frame_sink_manager =
       base::MakeUnique<ws::FrameSinkManagerClientBinding>(window_server_.get(),
                                                           gpu_host.get());
   window_server_->SetGpuHost(std::move(gpu_host));
   window_server_->SetFrameSinkManager(std::move(frame_sink_manager));
 
   ime_server_.Init(context()->connector(), test_config_);
 
@@ skipping 90 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>();
+    screen_manager_ =
+        base::MakeUnique<display::ScreenManagerForwarding>(in_process());
 #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());
 }
@@ skipping 119 matching lines @@
     mojom::WindowServerTestRequest request) {
   if (!test_config_)
     return;
   mojo::MakeStrongBinding(
       base::MakeUnique<ws::WindowServerTestImpl>(window_server_.get()),
       std::move(request));
 }
 
 
 }  // namespace ui