WIP: simplified display management in ash

ash/mus/bridge/shell_port_mash.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 "ash/mus/bridge/shell_port_mash.h"
 
 #include <utility>
 
 #include "ash/accelerators/accelerator_controller.h"
 #include "ash/accelerators/accelerator_controller_delegate_aura.h"
 #include "ash/aura/key_event_watcher_aura.h"
 #include "ash/aura/pointer_watcher_adapter.h"
-#include "ash/host/ash_window_tree_host.h"
+#include "ash/display/window_tree_host_manager.h"
+#include "ash/host/ash_window_tree_host_init_params.h"
 #include "ash/key_event_watcher.h"
 #include "ash/laser/laser_pointer_controller.h"
 #include "ash/magnifier/partial_magnification_controller.h"
 #include "ash/mus/accelerators/accelerator_controller_delegate_mus.h"
 #include "ash/mus/accelerators/accelerator_controller_registrar.h"
+#include "ash/mus/ash_window_tree_host_mus.h"
 #include "ash/mus/bridge/immersive_handler_factory_mus.h"
 #include "ash/mus/bridge/workspace_event_handler_mus.h"
 #include "ash/mus/drag_window_resizer.h"
 #include "ash/mus/keyboard_ui_mus.h"
 #include "ash/mus/screen_mus.h"
 #include "ash/mus/window_manager.h"
 #include "ash/public/cpp/config.h"
 #include "ash/root_window_controller.h"
 #include "ash/root_window_settings.h"
 #include "ash/session/session_state_delegate.h"
@@ skipping 13 matching lines @@
 #include "ash/wm/maximize_mode/scoped_disable_internal_mouse_and_keyboard_ozone.h"
 #include "ash/wm/mru_window_tracker.h"
 #include "ash/wm/window_cycle_event_filter.h"
 #include "ash/wm/window_cycle_event_filter_aura.h"
 #include "ash/wm/window_resizer.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace/workspace_event_handler_aura.h"
 #include "ash/wm_window.h"
 #include "base/memory/ptr_util.h"
 #include "components/user_manager/user_info_impl.h"
+#include "services/ui/public/interfaces/constants.mojom.h"
 #include "ui/aura/env.h"
+#include "ui/aura/mus/window_manager_delegate.h"
 #include "ui/aura/mus/window_tree_client.h"
 #include "ui/aura/mus/window_tree_host_mus.h"
+#include "ui/aura/mus/window_tree_host_mus_init_params.h"
 #include "ui/aura/window.h"
+#include "ui/display/manager/display_manager.h"
 #include "ui/display/manager/managed_display_info.h"
 #include "ui/display/screen.h"
 #include "ui/display/types/native_display_delegate.h"
 #include "ui/views/mus/pointer_watcher_event_router.h"
 
+#if defined(USE_OZONE)
+#include "ui/display/manager/forwarding_display_delegate.h"
+#endif
+
 namespace ash {
 namespace mus {
 
 namespace {
 
 // TODO(jamescook): After ShellDelegate is ported to ash/common use
 // ShellDelegate::CreateSessionStateDelegate() to construct the mus version
 // of SessionStateDelegate.
 class SessionStateDelegateStub : public SessionStateDelegate {
  public:
@@ skipping 30 matching lines @@
 
 ShellPortMash::ShellPortMash(
     WmWindow* primary_root_window,
     WindowManager* window_manager,
     views::PointerWatcherEventRouter* pointer_watcher_event_router,
     bool create_session_state_delegate_stub)
     : window_manager_(window_manager),
       primary_root_window_(primary_root_window) {
   if (create_session_state_delegate_stub)
     session_state_delegate_ = base::MakeUnique<SessionStateDelegateStub>();
-  DCHECK(primary_root_window_);
+  // DCHECK(primary_root_window_);
 
   if (GetAshConfig() == Config::MASH) {
     mash_state_ = base::MakeUnique<MashSpecificState>();
     mash_state_->pointer_watcher_event_router = pointer_watcher_event_router;
     mash_state_->immersive_handler_factory =
         base::MakeUnique<ImmersiveHandlerFactoryMus>();
   } else {
     DCHECK_EQ(Config::MUS, GetAshConfig());
     mus_state_ = base::MakeUnique<MusSpecificState>();
   }
@@ skipping 24 matching lines @@
 aura::WindowTreeClient* ShellPortMash::window_tree_client() {
   return window_manager_->window_tree_client();
 }
 
 void ShellPortMash::Shutdown() {
   if (mus_state_)
     mus_state_->pointer_watcher_adapter.reset();
 
   ShellPort::Shutdown();
 
-  window_manager_->DeleteAllRootWindowControllers();
+  // TODO(sky): Config::MASH should use WindowTreeHostManager too.
+  if (GetAshConfig() == Config::MUS)
+    Shell::Get()->window_tree_host_manager()->Shutdown();
+  else
+    window_manager_->DeleteAllRootWindowControllers();
 }
 
 Config ShellPortMash::GetAshConfig() const {
   return window_manager_->config();
 }
 
 WmWindow* ShellPortMash::GetPrimaryRootWindow() {
+  if (GetAshConfig() == Config::MUS) {
+    return WmWindow::Get(
+        Shell::Get()->window_tree_host_manager()->GetPrimaryRootWindow());
+  }
   // NOTE: This is called before the RootWindowController has been created, so
   // it can't call through to RootWindowController to get all windows.
   return primary_root_window_;
 }
 
 WmWindow* ShellPortMash::GetRootWindowForDisplayId(int64_t display_id) {
+  if (GetAshConfig() == Config::MUS) {
+    return WmWindow::Get(
+        Shell::Get()->window_tree_host_manager()->GetRootWindowForDisplayId(
+            display_id));
+  }
   RootWindowController* root_window_controller =
       GetRootWindowControllerWithDisplayId(display_id);
   return root_window_controller
              ? WmWindow::Get(root_window_controller->GetRootWindow())
              : nullptr;
 }
 
 const display::ManagedDisplayInfo& ShellPortMash::GetDisplayInfo(
     int64_t display_id) const {
   // TODO(mash): implement http://crbug.com/622480.
@@ skipping 21 matching lines @@
 }
 
 bool ShellPortMash::IsInUnifiedModeIgnoreMirroring() const {
   // TODO(mash): implement http://crbug.com/622480.
   NOTIMPLEMENTED();
   return false;
 }
 
 void ShellPortMash::SetDisplayWorkAreaInsets(WmWindow* window,
                                              const gfx::Insets& insets) {
+  if (GetAshConfig() == Config::MUS) {
+    Shell::Get()
+        ->window_tree_host_manager()
+        ->UpdateWorkAreaOfDisplayNearestWindow(window->aura_window(), insets);
+    return;
+  }
   window_manager_->screen()->SetWorkAreaInsets(window->aura_window(), insets);
 }
 
 void ShellPortMash::LockCursor() {
   // TODO: http://crbug.com/637853
   NOTIMPLEMENTED();
 }
 
 void ShellPortMash::UnlockCursor() {
   // TODO: http://crbug.com/637853
   NOTIMPLEMENTED();
 }
 
 bool ShellPortMash::IsMouseEventsEnabled() {
   // TODO: http://crbug.com/637853
   NOTIMPLEMENTED();
   return true;
 }
 
 std::vector<WmWindow*> ShellPortMash::GetAllRootWindows() {
+  if (GetAshConfig() == Config::MUS) {
+    aura::Window::Windows root_windows =
+        Shell::Get()->window_tree_host_manager()->GetAllRootWindows();
+    std::vector<WmWindow*> wm_windows(root_windows.size());
+    for (size_t i = 0; i < root_windows.size(); ++i)
+      wm_windows[i] = WmWindow::Get(root_windows[i]);
+    return wm_windows;
+  }
   std::vector<WmWindow*> root_windows;
   for (RootWindowController* root_window_controller :
        RootWindowController::root_window_controllers()) {
     root_windows.push_back(root_window_controller->GetWindow());
   }
   return root_windows;
 }
 
 void ShellPortMash::RecordGestureAction(GestureActionType action) {
   if (GetAshConfig() == Config::MUS) {
@@ skipping 179 matching lines @@
   // In Config::MUS PointerWatcherAdapter must be created when this function is
   // called (it is order dependent), that is not the case with Config::MASH.
   if (GetAshConfig() == Config::MUS) {
     mus_state_->pointer_watcher_adapter =
         base::MakeUnique<PointerWatcherAdapter>();
   }
 }
 
 std::unique_ptr<AshWindowTreeHost> ShellPortMash::CreateAshWindowTreeHost(
     const AshWindowTreeHostInitParams& init_params) {
-  return nullptr;
+  // TODO(sky): make this work for mash too.
+  if (GetAshConfig() != Config::MUS)
+    return nullptr;
+
+  std::unique_ptr<aura::DisplayInitParams> display_params =
+      base::MakeUnique<aura::DisplayInitParams>();
+  display_params->viewport_metrics.bounds_in_pixels =
+      init_params.initial_bounds;
+  display_params->viewport_metrics.device_scale_factor =
+      init_params.device_scale_factor;
+  display_params->viewport_metrics.ui_scale_factor =
+      init_params.ui_scale_factor;
+  display::Display mirrored_display =
+      Shell::Get()->display_manager()->GetMirroringDisplayById(
+          init_params.display_id);
+  if (mirrored_display.is_valid()) {
+    display_params->display =
+        base::MakeUnique<display::Display>(mirrored_display);
+  }
+  // TODO: wire this up correctly.
+  display_params->is_primary_display = true;
+  aura::WindowTreeHostMusInitParams aura_init_params =
+      window_manager_->window_manager_client()->CreateInitParamsForNewDisplay();
+  aura_init_params.display_id = init_params.display_id;
+  aura_init_params.display_init_params = std::move(display_params);
+  return base::MakeUnique<AshWindowTreeHostMus>(std::move(aura_init_params));
 }
 
-void ShellPortMash::CreatePrimaryHost() {}
+void ShellPortMash::CreatePrimaryHost() {
+  if (GetAshConfig() == Config::MASH)
+    return;
+
+  DCHECK_EQ(Config::MUS, GetAshConfig());
+  Shell::Get()->window_tree_host_manager()->Start();
+  AshWindowTreeHostInitParams ash_init_params;
+  Shell::Get()->window_tree_host_manager()->CreatePrimaryHost(ash_init_params);
+}
 
 void ShellPortMash::InitHosts(const ShellInitParams& init_params) {
-  window_manager_->CreatePrimaryRootWindowController(
-      base::WrapUnique(init_params.primary_window_tree_host));
+  if (GetAshConfig() == Config::MUS) {
+    Shell::Get()->window_tree_host_manager()->InitHosts();
+  } else {
+    window_manager_->CreatePrimaryRootWindowController(
+        base::WrapUnique(init_params.primary_window_tree_host));
+  }
 }
 
 std::unique_ptr<display::NativeDisplayDelegate>
 ShellPortMash::CreateNativeDisplayDelegate() {
+#if defined(USE_OZONE)
+  display::mojom::NativeDisplayDelegatePtr native_display_delegate;
+  if (window_manager_->connector()) {
+    window_manager_->connector()->BindInterface(ui::mojom::kServiceName,
+                                                &native_display_delegate);
+  }
+  return base::MakeUnique<display::ForwardingDisplayDelegate>(
+      std::move(native_display_delegate));
+#else
+  // The bots compile this config, but it is never run.
+  CHECK(false);
   return nullptr;
+#endif
 }
 
 std::unique_ptr<AcceleratorController>
 ShellPortMash::CreateAcceleratorController() {
   if (GetAshConfig() == Config::MUS) {
     DCHECK(!mus_state_->accelerator_controller_delegate);
     mus_state_->accelerator_controller_delegate =
         base::MakeUnique<AcceleratorControllerDelegateAura>();
     return base::MakeUnique<AcceleratorController>(
         mus_state_->accelerator_controller_delegate.get(), nullptr);
@@ skipping 13 matching lines @@
   mash_state_->accelerator_controller_registrar =
       base ::MakeUnique<AcceleratorControllerRegistrar>(
           window_manager_, accelerator_namespace_id);
   return base::MakeUnique<AcceleratorController>(
       mash_state_->accelerator_controller_delegate.get(),
       mash_state_->accelerator_controller_registrar.get());
 }
 
 }  // namespace mus
 }  // namespace ash