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

chrome/browser/chrome_content_browser_client.cc

 // Copyright (c) 2012 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 "chrome/browser/chrome_content_browser_client.h"
 
 #include <map>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 191 matching lines @@
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_options.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "ppapi/features/features.h"
 #include "ppapi/host/ppapi_host.h"
 #include "printing/features/features.h"
 #include "services/preferences/public/interfaces/preferences.mojom.h"
 #include "services/service_manager/public/cpp/binder_registry.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "services/service_manager/public/cpp/service.h"
+#include "services/ui/public/interfaces/constants.mojom.h"
+// TODO: Is this okay?
+// Note we also do this in chrome/app/mash/embedded_services.cc
+#include "services/ui/service.h"
 #include "storage/browser/fileapi/external_mount_points.h"
 #include "third_party/WebKit/public/platform/modules/installedapp/installed_app_provider.mojom.h"
 #include "third_party/WebKit/public/platform/modules/webshare/webshare.mojom.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/resources/grit/ui_resources.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 #if defined(OS_WIN)
@@ skipping 712 matching lines @@
          base::FieldTrialList::FindFullName("SaveDataHeader")
              .compare("Disabled");
 }
 
 WebContents* GetWebContents(int render_process_id, int render_frame_id) {
   RenderFrameHost* rfh =
       RenderFrameHost::FromID(render_process_id, render_frame_id);
   return WebContents::FromRenderFrameHost(rfh);
 }
 
+std::unique_ptr<service_manager::Service> CreateEmbeddedUIService(
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
+  LOG(ERROR) << "CreateEmbeddedUIService";
+  return base::MakeUnique<ui::Service>(task_runner);
+}
+
 #if BUILDFLAG(ENABLE_EXTENSIONS)
 // Returns true if there is is an extension with the same origin as
 // |source_origin| in |opener_render_process_id| with
 // APIPermission::kBackground.
 bool SecurityOriginHasExtensionBackgroundPermission(
     extensions::ProcessMap* process_map,
     extensions::ExtensionRegistry* registry,
     const GURL& source_origin,
     int opener_render_process_id) {
   // Note: includes web URLs that are part of an extension's web extent.
@@ skipping 2180 matching lines @@
     mojo::ScopedMessagePipeHandle* interface_pipe) {
   if (source_info.identity.name() == content::mojom::kGpuServiceName &&
       gpu_binder_registry_.CanBindInterface(interface_name)) {
     gpu_binder_registry_.BindInterface(source_info, interface_name,
                                        std::move(*interface_pipe));
   }
 }
 
 void ChromeContentBrowserClient::RegisterInProcessServices(
     StaticServiceMap* services) {
+  LOG(ERROR) << "ChromeContentBrowserClient::RegisterInProcessServices";
+//  base::debug::StackTrace().Print();
 #if BUILDFLAG(ENABLE_MOJO_MEDIA_IN_BROWSER_PROCESS)
   content::ServiceInfo info;
   info.factory = base::Bind(&media::CreateMediaService);
   services->insert(std::make_pair("media", info));
 #endif
 #if defined(OS_CHROMEOS)
   {
     content::ServiceInfo info;
     info.factory = base::Bind(&ChromeServiceChromeOS::CreateService);
     info.task_runner = base::ThreadTaskRunnerHandle::Get();
     services->insert(std::make_pair(chromeos::kChromeServiceName, info));
   }
 
   if (features::PrefServiceEnabled()) {
     content::ServiceInfo info;
     info.factory = base::Bind([] {
       return std::unique_ptr<service_manager::Service>(
           base::MakeUnique<ActiveProfilePrefService>());
     });
     info.task_runner = base::ThreadTaskRunnerHandle::Get();
     services->insert(std::make_pair(prefs::mojom::kForwarderServiceName, info));
   }
 
   if (!ash_util::IsRunningInMash()) {
-    content::ServiceInfo info;
-    info.factory = base::Bind(&ash_util::CreateEmbeddedAshService,
-                              base::ThreadTaskRunnerHandle::Get());
-    info.task_runner = base::ThreadTaskRunnerHandle::Get();
-    services->insert(std::make_pair(ash::mojom::kServiceName, info));
+    content::ServiceInfo info_ash;
+    info_ash.factory = base::Bind(&ash_util::CreateEmbeddedAshService,
+                                  base::ThreadTaskRunnerHandle::Get());
+    info_ash.task_runner = base::ThreadTaskRunnerHandle::Get();
+    services->insert(std::make_pair(ash::mojom::kServiceName, info_ash));
+
+    // TODO: Note that even if we wanted, we wouldn't be able to run this on the
+    // UI thread because of WindowTreeClient::WaitForInitialDisplays in AshInit.
+    // On the other hand, running all interfaces on the other thread is also
+    // problematic, because resources have to all be loaded on the same thread -
+    // see CalledOnValidSequence() DCHECKs in ResourceBundle.
+    // WindowServer loads resources for cursor.
+    content::ServiceInfo info_ui;
+    info_ui.factory = base::Bind(
+        &CreateEmbeddedUIService,
+        base::ThreadTaskRunnerHandle::Get());  //, window_server_task_runner);
+    info_ui.use_own_thread = true;
+    info_ui.message_loop_type = base::MessageLoop::TYPE_UI;
+    info_ui.thread_priority = base::ThreadPriority::DISPLAY;
+    services->insert(std::make_pair(ui::mojom::kServiceName, info_ui));
   }
 #endif  // OS_CHROMEOS
 }
 
 void ChromeContentBrowserClient::RegisterOutOfProcessServices(
       OutOfProcessServiceMap* services) {
 #if BUILDFLAG(ENABLE_PRINTING)
   services->emplace(printing::mojom::kServiceName,
                     base::ASCIIToUTF16("PDF Compositor Service"));
 #endif
@@ skipping 318 matching lines @@
     RedirectNonUINonIOBrowserThreadsToTaskScheduler() {
   return variations::GetVariationParamValue(
              "BrowserScheduler", "RedirectNonUINonIOBrowserThreads") == "true";
 }
 
 // static
 void ChromeContentBrowserClient::SetDefaultQuotaSettingsForTesting(
     const storage::QuotaSettings* settings) {
   g_default_quota_settings = settings;
 }