Makes ash/mus use RootWindowControllerCommon

ash/mus/window_manager.cc

 // Copyright 2015 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/window_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
+#include "ash/common/shell_window_ids.h"
 #include "ash/common/wm/container_finder.h"
 #include "ash/mus/bridge/wm_window_mus.h"
 #include "ash/mus/non_client_frame_controller.h"
 #include "ash/mus/property_util.h"
 #include "ash/mus/root_window_controller.h"
 #include "ash/public/interfaces/container.mojom.h"
 #include "components/mus/common/types.h"
 #include "components/mus/public/cpp/property_type_converters.h"
 #include "components/mus/public/cpp/window.h"
 #include "components/mus/public/cpp/window_property.h"
@@ skipping 13 matching lines @@
 WindowManager::~WindowManager() {}
 
 void WindowManager::Initialize(RootWindowController* root_controller,
                                mash::session::mojom::Session* session) {
   DCHECK(root_controller);
   DCHECK(!root_controller_);
   root_controller_ = root_controller;
 
   // Observe all the containers so that windows can be added to/removed from the
   // |disconnected_app_handler_|.
-  int count = static_cast<int>(mojom::Container::COUNT);
-  for (int id = static_cast<int>(mojom::Container::ROOT) + 1; id < count;
-       ++id) {
-    ::mus::Window* container = root_controller_->GetWindowForContainer(
-        static_cast<mojom::Container>(id));
-    Add(container);
+  WmWindowMus* root = WmWindowMus::Get(root_controller_->root());
+  for (int shell_window_id = kShellWindowId_Min;
+       shell_window_id < kShellWindowId_Max; ++shell_window_id) {
+    // kShellWindowId_VirtualKeyboardContainer is lazily created.
+    // TODO(sky): http://crbug.com/616909 .
+    // kShellWindowId_PhantomWindow is not a container, but a window.
+    if (shell_window_id == kShellWindowId_VirtualKeyboardContainer ||
+        shell_window_id == kShellWindowId_PhantomWindow)
+      continue;
+
+    WmWindowMus* container = WmWindowMus::AsWmWindowMus(
+        root->GetChildByShellWindowId(shell_window_id));
+    Add(container->mus_window());
 
     // Add any pre-existing windows in the container to
     // |disconnected_app_handler_|.
-    for (auto child : container->children()) {
+    for (auto child : container->mus_window()->children()) {

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

nit: instead of "auto", the actual type (mus::Window*?)

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

Done.

       if (!root_controller_->WindowIsContainer(child))
         disconnected_app_handler_.Add(child);
     }
   }
 
   // The insets are roughly what is needed by CustomFrameView. The expectation
   // is at some point we'll write our own NonClientFrameView and get the insets
   // from it.
   ::mus::mojom::FrameDecorationValuesPtr frame_decoration_values =
       ::mus::mojom::FrameDecorationValues::New();
@@ skipping 21 matching lines @@
       GetWindowType(*properties) == ::mus::mojom::WindowType::WINDOW ||
       GetWindowType(*properties) == ::mus::mojom::WindowType::PANEL;
   if (provide_non_client_frame)
     (*properties)[::mus::mojom::kWaitForUnderlay_Property].clear();
 
   // TODO(sky): constrain and validate properties before passing to server.
   ::mus::Window* window = root->window_tree()->NewWindow(properties);
   window->SetBounds(CalculateDefaultBounds(window));
 
   ::mus::Window* container_window = nullptr;
-  if (window->HasSharedProperty(mojom::kWindowContainer_Property)) {
-    container_window =
-        root_controller_->GetWindowForContainer(GetRequestedContainer(window));
+  mojom::Container container;
+  if (GetRequestedContainer(window, &container)) {
+    container_window = root_controller_->GetWindowForContainer(container);
   } else {
     // TODO(sky): window->bounds() isn't quite right.
     container_window = WmWindowMus::GetMusWindow(
         wm::GetDefaultParent(WmWindowMus::Get(root_controller_->root()),
                              WmWindowMus::Get(window), window->bounds()));
   }
   DCHECK(root_controller_->WindowIsContainer(container_window));
 
   if (provide_non_client_frame) {
     NonClientFrameController::Create(root_controller_->GetConnector(),
@@ skipping 86 matching lines @@
     bool janky) {
   for (auto window : client_windows)
     SetWindowIsJanky(window, janky);
 }
 
 void WindowManager::OnAccelerator(uint32_t id, const ui::Event& event) {
   root_controller_->OnAccelerator(id, std::move(event));
 }
 
 void WindowManager::ScreenlockStateChanged(bool locked) {
-  // Hide USER_PRIVATE_CONTAINER windows when the screen is locked.
-  ::mus::Window* window =
-      root_controller_->GetWindowForContainer(mojom::Container::USER_PRIVATE);
-  window->SetVisible(!locked);
+  WmWindowMus* non_lock_screen_containers_container =
+      root_controller_->GetWindowByShellWindowId(
+          kShellWindowId_NonLockScreenContainersContainer);
+  non_lock_screen_containers_container->mus_window()->SetVisible(!locked);

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

I think this is OK, but I'm not 100% sure. In classic ash the windows are
occluded by moving an opaque background container around. I think this is
equivalent/better, but we should watch for problems.

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

Agreed. It's hard to test this given we don't have the rest of the system
working. I'm hoping as we get more working we'll be able to tell what doesn't
work.

 }
 
 }  // namespace mus
 }  // namespace ash