chromeos: get SingleProcessMash working

BUG=847992
TEST=covered by tests

Change-Id: I94ea9b06426f100520c019759c2d10e477fbede3
Reviewed-on: https://chromium-review.googlesource.com/1173354Reviewed-by: Sadrul Chowdhury <sadrul@chromium.org>
Reviewed-by: Michael Wasserman <msw@chromium.org>
Commit-Queue: Scott Violet <sky@chromium.org>
Cr-Commit-Position: refs/heads/master@{#582921}

chrome/browser/ui/ash/chrome_browser_main_extra_parts_ash.cc

@@ -50,6 +50,7 @@
 #include "components/session_manager/core/session_manager.h"
 #include "components/session_manager/core/session_manager_observer.h"
 #include "components/startup_metric_utils/browser/startup_metric_utils.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
@@ -143,13 +144,27 @@ void ChromeBrowserMainExtraPartsAsh::ServiceManagerConnectionStarted(
   if (!features::IsAshInBrowserProcess()) {
     // ash::Shell will not be created because ash is running out-of-process.
     ash::Shell::SetIsBrowserProcessWithMash();
-    DCHECK(views::MusClient::Exists());
-    views::MusClient* mus_client = views::MusClient::Get();
-    aura::WindowTreeClientDelegate* delegate = mus_client;
+  }
+  if (features::IsUsingWindowService()) {
+    // Start up the window service and the ash system UI service.
+    connection->GetConnector()->StartService(
+        service_manager::Identity(ui::mojom::kServiceName));
+    connection->GetConnector()->StartService(
+        service_manager::Identity(ash::mojom::kServiceName));
+
+    views::MusClient::InitParams params;
+    params.connector = connection->GetConnector();
+    params.io_task_runner = content::BrowserThread::GetTaskRunnerForThread(
+        content::BrowserThread::IO);
+    // WMState has already been created, so don't have MusClient create it.
+    params.create_wm_state = false;
+    params.running_in_ws_process = features::IsSingleProcessMash();
+    params.create_cursor_factory = !features::IsSingleProcessMash();
+    mus_client_ = std::make_unique<views::MusClient>(params);
     // Register ash-specific window properties with Chrome's property converter.
     // Values of registered properties will be transported between the services.
-    ash::RegisterWindowProperties(delegate->GetPropertyConverter());
-    mus_client->SetMusPropertyMirror(
+    ash::RegisterWindowProperties(mus_client_->property_converter());
+    mus_client_->SetMusPropertyMirror(
         std::make_unique<ash::MusPropertyMirrorAsh>());
   }
 }

chrome/browser/ui/ash/chrome_browser_main_extra_parts_ash.h

@@ -23,6 +23,10 @@ namespace ui {
 class UserActivityDetector;
 }
 
+namespace views {
+class MusClient;
+}
+
 class AccessibilityControllerClient;
 class AppListClientImpl;
 class AshShellInit;
@@ -116,6 +120,9 @@ class ChromeBrowserMainExtraPartsAsh : public ChromeBrowserMainExtraParts {
   std::unique_ptr<DataPromoNotification> data_promo_notification_;
   std::unique_ptr<NightLightClient> night_light_client_;
 
+  // Created for mash (both in single and multi-process).
+  std::unique_ptr<views::MusClient> mus_client_;
+
   DISALLOW_COPY_AND_ASSIGN(ChromeBrowserMainExtraPartsAsh);
 };
 

chrome/browser/ui/views/chrome_browser_main_extra_parts_views.cc

@@ -51,12 +51,6 @@
 #include "ui/base/l10n/l10n_util.h"
 #endif  // defined(OS_LINUX) && !defined(OS_CHROMEOS)
 
-#if defined(OS_CHROMEOS)
-#include "ash/public/interfaces/constants.mojom.h"
-#include "content/public/common/content_switches.h"
-#include "ui/base/ui_base_features.h"
-#endif  // defined(OS_CHROMEOS)
-
 ChromeBrowserMainExtraPartsViews::ChromeBrowserMainExtraPartsViews() {
 }
 
@@ -152,31 +146,6 @@ void ChromeBrowserMainExtraPartsViews::PreProfileInit() {
 #endif  // defined(OS_LINUX) && !defined(OS_CHROMEOS)
 }
 
-void ChromeBrowserMainExtraPartsViews::ServiceManagerConnectionStarted(
-    content::ServiceManagerConnection* connection) {
-  DCHECK(connection);
-#if defined(OS_CHROMEOS)
-  if (aura::Env::GetInstance()->mode() == aura::Env::Mode::LOCAL ||
-      features::IsAshInBrowserProcess()) {
-    return;
-  }
-
-  // Start up the window service and the ash system UI service.
-  connection->GetConnector()->StartService(
-      service_manager::Identity(ui::mojom::kServiceName));
-  connection->GetConnector()->StartService(
-      service_manager::Identity(ash::mojom::kServiceName));
-
-  views::MusClient::InitParams params;
-  params.connector = connection->GetConnector();
-  params.io_task_runner = content::BrowserThread::GetTaskRunnerForThread(
-      content::BrowserThread::IO);
-  // WMState is owned as a member, so don't have MusClient create it.
-  params.create_wm_state = false;
-  mus_client_ = std::make_unique<views::MusClient>(params);
-#endif  // defined(OS_CHROMEOS)
-}
-
 void ChromeBrowserMainExtraPartsViews::PostBrowserStart() {
   relaunch_notification_controller_ =
       std::make_unique<RelaunchNotificationController>(

chrome/browser/ui/views/chrome_browser_main_extra_parts_views.h

@@ -19,9 +19,6 @@ class ViewsDelegate;
 namespace ui_devtools {
 class UiDevToolsServer;
 }
-namespace views {
-class MusClient;
-}
 namespace wm {
 class WMState;
 }
@@ -38,8 +35,6 @@ class ChromeBrowserMainExtraPartsViews : public ChromeBrowserMainExtraParts {
   void ToolkitInitialized() override;
   void PreCreateThreads() override;
   void PreProfileInit() override;
-  void ServiceManagerConnectionStarted(
-      content::ServiceManagerConnection* connection) override;
   void PostBrowserStart() override;
   void PostMainMessageLoopRun() override;
 
@@ -52,10 +47,6 @@ class ChromeBrowserMainExtraPartsViews : public ChromeBrowserMainExtraParts {
   std::unique_ptr<ui_devtools::UiDevToolsServer> devtools_server_;
 
   std::unique_ptr<wm::WMState> wm_state_;
-
-  // Only used when Ash is running out of process.
-  // TODO: make ash specific.
-  std::unique_ptr<views::MusClient> mus_client_;
 #endif
 
   // Manages the relaunch notification prompts.

chrome/browser/ui/views/frame/browser_frame_mash.cc

@@ -36,7 +36,7 @@ BrowserFrameMash::BrowserFrameMash(BrowserFrame* browser_frame,
       browser_view_(browser_view) {
   DCHECK(browser_frame_);
   DCHECK(browser_view_);
-  DCHECK(!features::IsAshInBrowserProcess());
+  DCHECK(features::IsUsingWindowService());
 }
 
 BrowserFrameMash::~BrowserFrameMash() {}
@@ -82,7 +82,7 @@ views::Widget::InitParams BrowserFrameMash::GetWidgetParams() {
   std::unique_ptr<views::DesktopWindowTreeHostMus> desktop_window_tree_host =
       std::make_unique<views::DesktopWindowTreeHostMus>(
           std::move(window_tree_host_init_params), browser_frame_, this);
-  // BrowserNonClientFrameViewMash::OnBoundsChanged() takes care of updating
+  // BrowserNonClientFrameViewAsh::OnBoundsChanged() takes care of updating
   // the insets.
   desktop_window_tree_host->set_auto_update_client_area(false);
   SetDesktopWindowTreeHost(std::move(desktop_window_tree_host));

chrome/browser/ui/views/frame/browser_non_client_frame_view_ash.cc

@@ -74,7 +74,7 @@ constexpr SkColor kNormalWindowTitleTextColor = SkColorSetRGB(40, 40, 40);
 constexpr SkColor kIncognitoWindowTitleTextColor = SK_ColorWHITE;
 
 bool IsMash() {
-  return !features::IsAshInBrowserProcess();
+  return features::IsUsingWindowService();
 }
 
 bool IsV1AppBackButtonEnabled() {

chrome/browser/ui/views/frame/native_browser_frame_factory_chromeos.cc

@@ -11,7 +11,7 @@
 NativeBrowserFrame* NativeBrowserFrameFactory::Create(
     BrowserFrame* browser_frame,
     BrowserView* browser_view) {
-  if (!features::IsAshInBrowserProcess())
+  if (features::IsUsingWindowService())
     return new BrowserFrameMash(browser_frame, browser_view);
   return new BrowserFrameAsh(browser_frame, browser_view);
 }

content/browser/browser_main_loop.cc

@@ -1331,7 +1331,9 @@ int BrowserMainLoop::BrowserThreadsStarted() {
   }
 
 #if defined(USE_AURA)
-  if (browser_is_viz_host) {
+  // In single process mash mode the aura::Env created here uses the
+  // WindowService, and needs to use the context-factory from aura.
+  if (browser_is_viz_host && !features::IsSingleProcessMash()) {
     env_->set_context_factory(GetContextFactory());
     env_->set_context_factory_private(GetContextFactoryPrivate());
   }
@@ -1558,9 +1560,9 @@ bool BrowserMainLoop::InitializeToolkit() {
 
   // Env creates the compositor. Aura widgets need the compositor to be created
   // before they can be initialized by the browser.
-  env_ = aura::Env::CreateInstance(features::IsAshInBrowserProcess()
-                                       ? aura::Env::Mode::LOCAL
-                                       : aura::Env::Mode::MUS);
+  env_ = aura::Env::CreateInstance(features::IsUsingWindowService()
+                                       ? aura::Env::Mode::MUS
+                                       : aura::Env::Mode::LOCAL);
 #endif  // defined(USE_AURA)
 
   if (parts_)

ui/base/ui_base_features.cc

@@ -132,6 +132,10 @@ const base::Feature kMash = {"Mash", base::FEATURE_DISABLED_BY_DEFAULT};
 const base::Feature kSingleProcessMash = {"SingleProcessMash",
                                           base::FEATURE_DISABLED_BY_DEFAULT};
 
+bool IsUsingWindowService() {
+  return IsSingleProcessMash() || !IsAshInBrowserProcess();
+}
+
 bool IsAshInBrowserProcess() {
   return !base::FeatureList::IsEnabled(features::kMash);
 }

ui/base/ui_base_features.h

@@ -52,6 +52,9 @@ UI_BASE_EXPORT extern const base::Feature kMash;
 
 UI_BASE_EXPORT extern const base::Feature kSingleProcessMash;
 
+// Returns true if Chrome's aura usage is backed by the WindowService.
+UI_BASE_EXPORT bool IsUsingWindowService();
+
 // Returns true if ash is in process (the default). A value of false means ash
 // is running in a separate process (and is hosting the UI Service and Viz).
 UI_BASE_EXPORT bool IsAshInBrowserProcess();

ui/views/mus/mus_client.cc

@@ -8,7 +8,6 @@
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
-#include "base/threading/thread.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/ui/public/cpp/gpu/gpu.h"
 #include "services/ui/public/cpp/input_devices/input_device_client.h"
@@ -97,9 +96,13 @@ MusClient::MusClient(const InitParams& params) : identity_(params.identity) {
   service_manager::Connector* connector = params.connector;
 
   if (!params.window_tree_client) {
+    // If this process is running in the WindowService, then discardable memory
+    // should have already been created.
+    const bool create_discardable_memory = !params.running_in_ws_process;
     owned_window_tree_client_ =
         aura::WindowTreeClient::CreateForWindowTreeFactory(
-            connector, this, true, std::move(params.io_task_runner));
+            connector, this, create_discardable_memory,
+            std::move(params.io_task_runner));
     window_tree_client_ = owned_window_tree_client_.get();
     aura::Env::GetInstance()->SetWindowTreeClient(window_tree_client_);
   } else {
@@ -109,13 +112,17 @@ MusClient::MusClient(const InitParams& params) : identity_(params.identity) {
   pointer_watcher_event_router_ =
       std::make_unique<PointerWatcherEventRouter>(window_tree_client_);
 
-  if (connector) {
+  if (connector && !params.running_in_ws_process) {
     input_device_client_ = std::make_unique<ui::InputDeviceClient>();
     ui::mojom::InputDeviceServerPtr input_device_server;
     connector->BindInterface(ui::mojom::kServiceName, &input_device_server);
     input_device_client_->Connect(std::move(input_device_server));
 
     screen_ = std::make_unique<ScreenMus>(this);
+    display::Screen::SetScreenInstance(screen_.get());
+
+    // NOTE: this deadlocks if |running_in_ws_process| is true (because the main
+    // thread is running the WindowService).
     window_tree_client_->WaitForDisplays();
 
     ui::mojom::ClipboardHostPtr clipboard_host_ptr;
@@ -154,6 +161,11 @@ MusClient::~MusClient() {
         ViewsDelegate::DesktopWindowTreeHostFactory());
   }
 
+  if (screen_) {
+    display::Screen::SetScreenInstance(nullptr);
+    screen_.reset();
+  }
+
   DCHECK_EQ(instance_, this);
   instance_ = nullptr;
   DCHECK(aura::Env::GetInstance());
@@ -162,6 +174,19 @@ MusClient::~MusClient() {
 // static
 bool MusClient::ShouldCreateDesktopNativeWidgetAura(
     const Widget::InitParams& init_params) {
+  const bool from_window_service =
+      (init_params.context &&
+       init_params.context->env()->mode() == aura::Env::Mode::LOCAL) ||
+      (init_params.parent &&
+       init_params.parent->env()->mode() == aura::Env::Mode::LOCAL);
+  // |from_window_service| is true if the aura::Env has a mode of LOCAL. If
+  // the mode is LOCAL there are two envs, one used by the window service
+  // (LOCAL), and the other for non-window-service code. Windows created with
+  // LOCAL should use NativeWidgetAura (which happens if false is returned
+  // here).
+  if (from_window_service)
+    return false;
+
   // TYPE_CONTROL and child widgets require a NativeWidgetAura.
   return init_params.type != Widget::InitParams::TYPE_CONTROL &&
          !init_params.child;
@@ -363,8 +388,10 @@ void MusClient::OnDisplaysChanged(
     int64_t primary_display_id,
     int64_t internal_display_id,
     int64_t display_id_for_new_windows) {
-  screen_->OnDisplaysChanged(std::move(ws_displays), primary_display_id,
-                             internal_display_id, display_id_for_new_windows);
+  if (screen_) {
+    screen_->OnDisplaysChanged(std::move(ws_displays), primary_display_id,
+                               internal_display_id, display_id_for_new_windows);
+  }
 }
 
 void MusClient::OnWindowManagerFrameValuesChanged() {

ui/views/mus/mus_client.h

@@ -27,7 +27,6 @@ class WindowTreeClient;
 
 namespace base {
 class SingleThreadTaskRunner;
-class Thread;
 }
 
 namespace service_manager {
@@ -88,6 +87,10 @@ class VIEWS_MUS_EXPORT MusClient : public aura::WindowTreeClientDelegate,
     // Connect to the accessibility host service in the browser (e.g. to support
     // ChromeVox).
     bool use_accessibility_host = false;
+
+    // Set to true if the WindowService is running in the same process and on
+    // the same thread as MusClient.
+    bool running_in_ws_process = false;
   };
 
   // Most clients should use AuraInit, which creates a MusClient.
@@ -111,6 +114,10 @@ class VIEWS_MUS_EXPORT MusClient : public aura::WindowTreeClientDelegate,
   static std::map<std::string, std::vector<uint8_t>>
   ConfigurePropertiesFromParams(const Widget::InitParams& init_params);
 
+  aura::PropertyConverter* property_converter() {
+    return property_converter_.get();
+  }
+
   aura::WindowTreeClient* window_tree_client() { return window_tree_client_; }
 
   PointerWatcherEventRouter* pointer_watcher_event_router() {
@@ -179,8 +186,6 @@ class VIEWS_MUS_EXPORT MusClient : public aura::WindowTreeClientDelegate,
 
   service_manager::Identity identity_;
 
-  std::unique_ptr<base::Thread> io_thread_;
-
   base::ObserverList<MusClientObserver> observer_list_;
 
 #if defined(USE_OZONE)

ui/views/mus/screen_mus.cc

@@ -36,13 +36,9 @@ using Type = display::DisplayList::Type;
 
 ScreenMus::ScreenMus(ScreenMusDelegate* delegate) : delegate_(delegate) {
   DCHECK(delegate);
-  display::Screen::SetScreenInstance(this);
 }
 
-ScreenMus::~ScreenMus() {
-  DCHECK_EQ(this, display::Screen::GetScreen());
-  display::Screen::SetScreenInstance(nullptr);
-}
+ScreenMus::~ScreenMus() = default;
 
 void ScreenMus::OnDisplaysChanged(
     std::vector<ui::mojom::WsDisplayPtr> ws_displays,
@@ -61,7 +57,6 @@ void ScreenMus::OnDisplaysChanged(
     handled_display_id = primary_display_id;
     for (auto& ws_display_ptr : ws_displays) {
       if (ws_display_ptr->display.id() == primary_display_id) {
-        // TODO(sky): Make WindowManagerFrameValues per display.
         WindowManagerFrameValues frame_values =
             ws_display_ptr->frame_decoration_values
                 .To<WindowManagerFrameValues>();

ui/views/mus/screen_mus.h

@@ -15,6 +15,8 @@ class ScreenMusDelegate;
 
 // Screen implementation that gets information from
 // ui::mojom::ScreenProviderObserver.
+//
+// NOTE: this is not necessarily installed as the Screen implementation.
 class VIEWS_MUS_EXPORT ScreenMus : public display::ScreenBase,
                                    public ui::mojom::ScreenProviderObserver {
  public: