Makes ash/mus use RootWindowControllerCommon

ash/mus/root_window_controller.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/root_window_controller.h"
 
 #include <stdint.h>
 
 #include <map>
 #include <sstream>
 
+#include "ash/common/root_window_controller_common.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/wm/always_on_top_controller.h"
 #include "ash/common/wm/dock/docked_window_layout_manager.h"
 #include "ash/common/wm/panels/panel_layout_manager.h"
+#include "ash/common/wm/root_window_layout_manager.h"
 #include "ash/common/wm/workspace/workspace_layout_manager.h"
 #include "ash/common/wm/workspace/workspace_layout_manager_delegate.h"
-#include "ash/mus/background_layout.h"
 #include "ash/mus/bridge/wm_globals_mus.h"
 #include "ash/mus/bridge/wm_root_window_controller_mus.h"
 #include "ash/mus/bridge/wm_shelf_mus.h"
 #include "ash/mus/bridge/wm_window_mus.h"
 #include "ash/mus/container_ids.h"
-#include "ash/mus/fill_layout.h"
 #include "ash/mus/screenlock_layout.h"
 #include "ash/mus/shadow_controller.h"
 #include "ash/mus/shelf_layout_manager.h"
 #include "ash/mus/status_layout_manager.h"
 #include "ash/mus/window_manager.h"
 #include "ash/mus/window_manager_application.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "components/mus/common/event_matcher_util.h"
@@ skipping 14 matching lines @@
 namespace ash {
 namespace mus {
 namespace {
 
 const uint32_t kWindowSwitchAccelerator = 1;
 
 void AssertTrue(bool success) {
   DCHECK(success);
 }
 
-int ContainerToLocalId(Container container) {
-  return static_cast<int>(container);
-}
-
 class WorkspaceLayoutManagerDelegateImpl
     : public wm::WorkspaceLayoutManagerDelegate {
  public:
   explicit WorkspaceLayoutManagerDelegateImpl(
       WmRootWindowControllerMus* root_window_controller)
       : root_window_controller_(root_window_controller) {}
   ~WorkspaceLayoutManagerDelegateImpl() override = default;
 
   // WorkspaceLayoutManagerDelegate:
   void UpdateShelfVisibility() override { NOTIMPLEMENTED(); }
@@ skipping 33 matching lines @@
     delete this;
   }
 }
 
 shell::Connector* RootWindowController::GetConnector() {
   return app_->connector();
 }
 
 ::mus::Window* RootWindowController::GetWindowForContainer(
     Container container) {
-  return root_->GetChildByLocalId(ContainerToLocalId(container));
+  WmWindowMus* wm_window =
+      GetWindowByShellWindowId(MashContainerToAshShellWindowId(container));
+  DCHECK(wm_window);
+  return wm_window->mus_window();
 }
 
-bool RootWindowController::WindowIsContainer(
-    const ::mus::Window* window) const {
-  return window && window->local_id() > ContainerToLocalId(Container::ROOT) &&
-         window->local_id() < ContainerToLocalId(Container::COUNT);
+bool RootWindowController::WindowIsContainer(::mus::Window* window) {
+  return window &&
+         WmWindowMus::Get(window)->GetShellWindowId() != kShellWindowId_Invalid;

[James Cook, 2016/06/03 00:24:58]

It's hard to see where kShellWindowId_Invalid is returned. Can the constant be
used in WmWindowAura/Mus instead of literal -1?

[sky, 2016/06/03 03:07:03]

It's actually set in aura::Window and mus::Window.

[James Cook, 2016/06/03 16:13:16]

Yeah, I found them, but it's a magic number that has to match. I know those
classes are at a lower level, but can you share a constant somehow (like in
ui/base)? Or comment next to
kShellWindowId_Invalid/mus::Window::local_id/aura::Window::id that the "invalid"
number has to match the ash constant for everything to work?

[sky, 2016/06/03 17:39:04]

I ended up going with a static_assert for aura and using kShellWindowId_Invalid
for WmWindowMus.

+}
+
+WmWindowMus* RootWindowController::GetWindowByShellWindowId(int id) {
+  return WmWindowMus::AsWmWindowMus(
+      WmWindowMus::Get(root_)->GetChildByShellWindowId(id));
 }
 
 ::mus::WindowManagerClient* RootWindowController::window_manager_client() {
   return window_manager_->window_manager_client();
 }
 
 void RootWindowController::OnAccelerator(uint32_t id, const ui::Event& event) {
   switch (id) {
     case kWindowSwitchAccelerator:
       window_manager_client()->ActivateNextWindow();
@@ skipping 25 matching lines @@
 void RootWindowController::AddAccelerators() {
   window_manager_client()->AddAccelerator(
       kWindowSwitchAccelerator,
       ::mus::CreateKeyMatcher(::mus::mojom::KeyboardCode::TAB,
                               ::mus::mojom::kEventFlagControlDown),
       base::Bind(&AssertTrue));
 }
 
 void RootWindowController::OnEmbed(::mus::Window* root) {
   root_ = root;
-  root_->set_local_id(ContainerToLocalId(Container::ROOT));
   root_->AddObserver(this);
-  layout_managers_[root_].reset(new FillLayout(root_));
 
   app_->OnRootWindowControllerGotRoot(this);
 
   wm_root_window_controller_.reset(
       new WmRootWindowControllerMus(app_->globals(), this));
 
-  CreateContainers();
+  root_window_controller_common_.reset(
+      new RootWindowControllerCommon(WmWindowMus::Get(root_)));
+  root_window_controller_common_->CreateContainers();
+  root_window_controller_common_->CreateLayoutManagers();
+  CreateLayoutManagers();
+
+  // Force a layout of the root, and its children, RootWindowLayout handles
+  // both.
+  root_window_controller_common_->root_window_layout()->OnWindowResized();
 
   for (size_t i = 0; i < kNumActivationContainers; ++i) {
-    window_manager_client()->AddActivationParent(
-        GetWindowForContainer(kActivationContainers[i]));
+    // kShellWindowId_VirtualKeyboardContainer is lazily created.
+    // TODO(sky): http://crbug.com/616909 .
+    if (kActivationContainers[i] != kShellWindowId_VirtualKeyboardContainer) {
+      window_manager_client()->AddActivationParent(
+          GetWindowByShellWindowId(kActivationContainers[i])->mus_window());
+    }
   }
 
-  wm::WmWindow* always_on_top_container =
-      WmWindowMus::Get(root)->GetChildByShellWindowId(
-          kShellWindowId_AlwaysOnTopContainer);
+  WmWindowMus* always_on_top_container =
+      GetWindowByShellWindowId(kShellWindowId_AlwaysOnTopContainer);
   always_on_top_controller_.reset(
       new AlwaysOnTopController(always_on_top_container));
 
   AddAccelerators();
 
   window_manager_->Initialize(this, app_->session());
 
   shadow_controller_.reset(new ShadowController(root->window_tree()));
 
   app_->OnRootWindowControllerDoneInit(this);
@@ skipping 25 matching lines @@
       ->SetShelf(wm_shelf_.get());
 
   PanelLayoutManager::Get(WmWindowMus::Get(root_))->SetShelf(wm_shelf_.get());
 
   // TODO: http://crbug.com/614182 Ash's ShelfLayoutManager implements
   // DockedWindowLayoutManagerObserver so that it can inset by the docked
   // windows.
   // docked_layout_manager_->AddObserver(shelf_->shelf_layout_manager());
 }
 
-void RootWindowController::CreateContainer(Container container,
-                                           Container parent_container) {
-  // Set the window's name to the container name (e.g. "Container::LOGIN"),
-  // which makes the window hierarchy easier to read.
-  std::map<std::string, std::vector<uint8_t>> properties;
-  std::ostringstream container_name;
-  container_name << container;
-  properties[::mus::mojom::WindowManager::kName_Property] =
-      mojo::ConvertTo<std::vector<uint8_t>>(container_name.str());
+void RootWindowController::CreateLayoutManagers() {
+  // Override the default layout managers for certain containers.
+  WmWindowMus* lock_screen_container =
+      GetWindowByShellWindowId(kShellWindowId_LockScreenContainer);
+  layout_managers_[lock_screen_container->mus_window()].reset(
+      new ScreenlockLayout(lock_screen_container->mus_window()));
 
-  ::mus::Window* window = root_->window_tree()->NewWindow(&properties);
-  window->set_local_id(ContainerToLocalId(container));
-  layout_managers_[window].reset(new FillLayout(window));
-  WmWindowMus::Get(window)->SetShellWindowId(
-      MashContainerToAshContainer(container));
-
-  // User private windows are hidden by default until the window manager learns
-  // the lock state, so their contents are never accidentally revealed. Tests,
-  // however, usually assume the screen is unlocked.
-  const bool is_test = base::CommandLine::ForCurrentProcess()->HasSwitch(

[James Cook, 2016/06/03 00:24:58]

views_mus_unittests are OK after removing this? I'm not sure what classic ash
does with the non_lock_screen_related_containers during tests.

[sky, 2016/06/03 03:07:03]

They passed locally. I'll find out shortly if the bots like it.

[James Cook, 2016/06/03 16:13:16]

Oh, I think it's actually views_mus_interactive_ui_tests that needed this. Maybe
try that one locally -- I'm pretty sure I added it to the bots, but not 100%.

[sky, 2016/06/03 17:39:04]

They pass locally. Fingers crossed.

-      ::mus::switches::kUseTestConfig);
-  window->SetVisible(container != Container::USER_PRIVATE || is_test);
-
-  ::mus::Window* parent =
-      root_->GetChildByLocalId(ContainerToLocalId(parent_container));
-  parent->AddChild(window);
-}
-
-void RootWindowController::CreateContainers() {
-  CreateContainer(Container::ALL_USER_BACKGROUND, Container::ROOT);
-  CreateContainer(Container::USER, Container::ROOT);
-  CreateContainer(Container::USER_BACKGROUND, Container::USER);
-  CreateContainer(Container::USER_PRIVATE, Container::USER);
-  CreateContainer(Container::USER_PRIVATE_WINDOWS, Container::USER_PRIVATE);
-  CreateContainer(Container::USER_PRIVATE_ALWAYS_ON_TOP_WINDOWS,
-                  Container::USER_PRIVATE);
-  CreateContainer(Container::USER_PRIVATE_DOCKED_WINDOWS,
-                  Container::USER_PRIVATE);
-  CreateContainer(Container::USER_PRIVATE_PRESENTATION_WINDOWS,
-                  Container::USER_PRIVATE);
-  CreateContainer(Container::USER_PRIVATE_SHELF, Container::USER_PRIVATE);
-  CreateContainer(Container::USER_PRIVATE_PANELS, Container::USER_PRIVATE);
-  CreateContainer(Container::USER_PRIVATE_APP_LIST, Container::USER_PRIVATE);
-  CreateContainer(Container::USER_PRIVATE_SYSTEM_MODAL,
-                  Container::USER_PRIVATE);
-  CreateContainer(Container::LOGIN, Container::ROOT);
-  CreateContainer(Container::LOGIN_WINDOWS, Container::LOGIN);
-  CreateContainer(Container::LOGIN_APP, Container::LOGIN);
-  CreateContainer(Container::LOGIN_SHELF, Container::LOGIN);
-  CreateContainer(Container::STATUS, Container::ROOT);
-  CreateContainer(Container::BUBBLES, Container::ROOT);
-  CreateContainer(Container::SYSTEM_MODAL_WINDOWS, Container::ROOT);
-  CreateContainer(Container::KEYBOARD, Container::ROOT);
-  CreateContainer(Container::MENUS, Container::ROOT);
-  CreateContainer(Container::DRAG_AND_TOOLTIPS, Container::ROOT);
-
-  // Override the default layout managers for certain containers.
-  ::mus::Window* user_background =
-      GetWindowForContainer(Container::USER_BACKGROUND);
-  layout_managers_[user_background].reset(
-      new BackgroundLayout(user_background));
-
-  ::mus::Window* login_app = GetWindowForContainer(Container::LOGIN_APP);
-  layout_managers_[login_app].reset(new ScreenlockLayout(login_app));
-
-  ::mus::Window* user_shelf =
-      GetWindowForContainer(Container::USER_PRIVATE_SHELF);
+  WmWindowMus* shelf_container =
+      GetWindowByShellWindowId(kShellWindowId_ShelfContainer);
   ShelfLayoutManager* shelf_layout_manager =
-      new ShelfLayoutManager(user_shelf, this);
-  layout_managers_[user_shelf].reset(shelf_layout_manager);
+      new ShelfLayoutManager(shelf_container->mus_window(), this);
+  layout_managers_[shelf_container->mus_window()].reset(shelf_layout_manager);
 
   wm_shelf_.reset(new WmShelfMus(shelf_layout_manager));
 
-  ::mus::Window* status = GetWindowForContainer(Container::STATUS);
-  layout_managers_[status].reset(new StatusLayoutManager(status));
+  WmWindowMus* status_container =
+      GetWindowByShellWindowId(kShellWindowId_StatusContainer);
+  layout_managers_[status_container->mus_window()].reset(
+      new StatusLayoutManager(status_container->mus_window()));
 
-  ::mus::Window* user_private_windows =
-      GetWindowForContainer(Container::USER_PRIVATE_WINDOWS);
+  WmWindowMus* default_container =
+      GetWindowByShellWindowId(kShellWindowId_DefaultContainer);
   // WorkspaceLayoutManager is not a mash::wm::LayoutManager (it's a
   // wm::LayoutManager), so it can't be in |layout_managers_|.
-  layout_managers_.erase(user_private_windows);
   std::unique_ptr<WorkspaceLayoutManagerDelegateImpl>
       workspace_layout_manager_delegate(new WorkspaceLayoutManagerDelegateImpl(
           wm_root_window_controller_.get()));
-  WmWindowMus* user_private_windows_wm = WmWindowMus::Get(user_private_windows);
-  user_private_windows_wm->SetSnapsChildrenToPhysicalPixelBoundary();
-  user_private_windows_wm->SetChildrenUseExtendedHitRegion();
-  user_private_windows_wm->SetLayoutManager(
+  default_container->SetLayoutManager(
       base::WrapUnique(new WorkspaceLayoutManager(
-          user_private_windows_wm,
-          std::move(workspace_layout_manager_delegate))));
+          default_container, std::move(workspace_layout_manager_delegate))));
 
-  ::mus::Window* user_private_docked_windows =
-      GetWindowForContainer(Container::USER_PRIVATE_DOCKED_WINDOWS);
-  WmWindowMus* user_private_docked_windows_wm =
-      WmWindowMus::Get(user_private_docked_windows);
-  user_private_docked_windows_wm->SetSnapsChildrenToPhysicalPixelBoundary();
-  layout_managers_.erase(user_private_docked_windows);
-  user_private_docked_windows_wm->SetChildrenUseExtendedHitRegion();
-  user_private_docked_windows_wm->SetLayoutManager(base::WrapUnique(
-      new DockedWindowLayoutManager(user_private_docked_windows_wm)));
+  WmWindowMus* docked_container =
+      GetWindowByShellWindowId(kShellWindowId_DockedContainer);
+  docked_container->SetLayoutManager(
+      base::WrapUnique(new DockedWindowLayoutManager(docked_container)));
 
-  ::mus::Window* user_private_panels =
-      GetWindowForContainer(Container::USER_PRIVATE_PANELS);
-  WmWindowMus* user_private_panels_wm = WmWindowMus::Get(user_private_panels);
-  user_private_panels_wm->SetSnapsChildrenToPhysicalPixelBoundary();
-  layout_managers_.erase(user_private_panels);
-  user_private_panels_wm->SetChildrenUseExtendedHitRegion();
-  user_private_panels_wm->SetLayoutManager(
-      base::WrapUnique(new PanelLayoutManager(user_private_panels_wm)));
-
-  ::mus::Window* user_private_always_on_top =
-      GetWindowForContainer(Container::USER_PRIVATE_ALWAYS_ON_TOP_WINDOWS);
-  WmWindowMus* user_private_always_on_top_wm =
-      WmWindowMus::Get(user_private_always_on_top);
-  user_private_always_on_top_wm->SetChildrenUseExtendedHitRegion();
-  user_private_always_on_top_wm->SetSnapsChildrenToPhysicalPixelBoundary();
+  WmWindowMus* panel_container =
+      GetWindowByShellWindowId(kShellWindowId_PanelContainer);
+  panel_container->SetLayoutManager(
+      base::WrapUnique(new PanelLayoutManager(panel_container)));
 }
 
 }  // namespace mus
 }  // namespace ash