Removes WmRootWindowController subclasses

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/wm/container_finder.h"
 #include "ash/common/wm/window_state.h"
+#include "ash/common/wm_root_window_controller.h"
 #include "ash/display/screen_position_controller.h"
 #include "ash/mus/accelerators/accelerator_handler.h"
 #include "ash/mus/accelerators/accelerator_ids.h"
 #include "ash/mus/bridge/wm_lookup_mus.h"
-#include "ash/mus/bridge/wm_root_window_controller_mus.h"
 #include "ash/mus/bridge/wm_shell_mus.h"
 #include "ash/mus/bridge/wm_window_mus.h"
 #include "ash/mus/move_event_handler.h"
 #include "ash/mus/non_client_frame_controller.h"
 #include "ash/mus/property_util.h"
 #include "ash/mus/root_window_controller.h"
 #include "ash/mus/screen_mus.h"
 #include "ash/mus/shadow_controller.h"
 #include "ash/mus/shell_delegate_mus.h"
 #include "ash/mus/window_manager_observer.h"
 #include "ash/mus/window_properties.h"
 #include "ash/public/cpp/shell_window_ids.h"
+#include "ash/shell.h"
 #include "ash/wm/ash_focus_rules.h"
 #include "ash/wm/event_client_impl.h"
 #include "ash/wm/window_properties.h"
 #include "base/memory/ptr_util.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/ui/common/accelerator_util.h"
 #include "services/ui/common/types.h"
 #include "services/ui/public/cpp/property_type_converters.h"
 #include "services/ui/public/interfaces/constants.mojom.h"
 #include "services/ui/public/interfaces/window_manager.mojom.h"
@@ skipping 48 matching lines @@
   property_converter_->RegisterProperty(
       kRenderTitleAreaProperty,
       ui::mojom::WindowManager::kRenderParentTitleArea_Property);
   property_converter_->RegisterProperty(
       kShelfItemTypeKey, ui::mojom::WindowManager::kShelfItemType_Property);
 }
 
 WindowManager::~WindowManager() {
   Shutdown();
   aura::Env::GetInstance()->RemoveObserver(this);
+  ash::Shell::set_window_tree_client(nullptr);
 }
 
 void WindowManager::Init(
     std::unique_ptr<aura::WindowTreeClient> window_tree_client,
     const scoped_refptr<base::SequencedWorkerPool>& blocking_pool) {
   DCHECK(window_manager_client_);
   DCHECK(!window_tree_client_);
   window_tree_client_ = std::move(window_tree_client);
 
+  DCHECK_EQ(nullptr, ash::Shell::window_tree_client());
+  ash::Shell::set_window_tree_client(window_tree_client_.get());
+
   aura::Env::GetInstance()->AddObserver(this);
 
   // |connector_| will be null in some tests.
   if (connector_)
     connector_->BindInterface(ui::mojom::kServiceName, &display_controller_);
 
   screen_ = base::MakeUnique<ScreenMus>();
   display::Screen::SetScreenInstance(screen_.get());
 
   pointer_watcher_event_router_ =
@@ skipping 80 matching lines @@
 void WindowManager::RemoveObserver(WindowManagerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 display::mojom::DisplayController* WindowManager::GetDisplayController() {
   return display_controller_ ? display_controller_.get() : nullptr;
 }
 
 RootWindowController* WindowManager::CreateRootWindowController(
     std::unique_ptr<aura::WindowTreeHostMus> window_tree_host,
-    const display::Display& display) {
-  // TODO(sky): this is temporary, should use RootWindowController directly.
-  aura::client::SetCaptureClient(window_tree_host->window(),
-                                 wm_state_->capture_controller());
+    const display::Display& display,
+    ash::RootWindowController::RootWindowType root_window_type) {
+  // TODO(sky): all of these calls to SetFooClient() are done in
+  // Shell::InitRootWindow(). When Shell is used these can be removed.
   aura::client::SetFocusClient(window_tree_host->window(),
                                focus_controller_.get());
   aura::client::SetActivationClient(window_tree_host->window(),
                                     focus_controller_.get());
   aura::client::SetEventClient(window_tree_host->window(), event_client_.get());
   aura::client::SetScreenPositionClient(window_tree_host->window(),
                                         screen_position_controller_.get());
 
   std::unique_ptr<RootWindowController> root_window_controller_ptr(
-      new RootWindowController(this, std::move(window_tree_host), display));
+      new RootWindowController(this, std::move(window_tree_host), display,
+                               root_window_type));
   RootWindowController* root_window_controller =
       root_window_controller_ptr.get();
   root_window_controllers_.insert(std::move(root_window_controller_ptr));
 
   // TODO: this should be called when logged in. See http://crbug.com/654606.
-  root_window_controller->wm_root_window_controller()->CreateShelf();
+  root_window_controller->ash_root_window_controller()
+      ->wm_root_window_controller()
+      ->CreateShelf();
 
   for (auto& observer : observers_)
     observer.OnRootWindowControllerAdded(root_window_controller);
 
   for (auto& observer : *screen_->display_list().observers())
     observer.OnDisplayAdded(root_window_controller->display());
 
   return root_window_controller;
 }
 
 void WindowManager::DestroyRootWindowController(
     RootWindowController* root_window_controller) {
   if (root_window_controllers_.size() > 1) {
     DCHECK_NE(root_window_controller, GetPrimaryRootWindowController());
-    root_window_controller->wm_root_window_controller()->MoveWindowsTo(
-        WmWindowMus::Get(GetPrimaryRootWindowController()->root()));
+    root_window_controller->ash_root_window_controller()->MoveWindowsTo(
+        GetPrimaryRootWindowController()->root());
   }
 
   root_window_controller->Shutdown();
 
   // NOTE: classic ash deleted RootWindowController after a delay (DeleteSoon())
   // this may need to change to mirror that.
   for (auto iter = root_window_controllers_.begin();
        iter != root_window_controllers_.end(); ++iter) {
     if (iter->get() == root_window_controller) {
       root_window_controllers_.erase(iter);
@@ skipping 43 matching lines @@
   pointer_watcher_event_router_.reset();
 
   window_tree_client_.reset();
   window_manager_client_ = nullptr;
 
   DCHECK_EQ(screen_.get(), display::Screen::GetScreen());
   display::Screen::SetScreenInstance(nullptr);
 }
 
 RootWindowController* WindowManager::GetPrimaryRootWindowController() {
-  return static_cast<WmRootWindowControllerMus*>(
-             WmShell::Get()->GetPrimaryRootWindowController())
-      ->root_window_controller();
+  return RootWindowController::ForWindow(
+      static_cast<WmWindowMus*>(
+          WmShell::Get()->GetPrimaryRootWindowController()->GetWindow())
+          ->aura_window());
 }
 
 RootWindowController*
 WindowManager::GetRootWindowControllerForNewTopLevelWindow(
     std::map<std::string, std::vector<uint8_t>>* properties) {
   // If a specific display was requested, use it.
   const int64_t display_id = GetInitialDisplayId(*properties);
   for (auto& root_window_controller_ptr : root_window_controllers_) {
     if (root_window_controller_ptr->display().id() == display_id)
       return root_window_controller_ptr.get();
   }
 
-  return static_cast<WmRootWindowControllerMus*>(
-             WmShellMus::Get()
-                 ->GetRootWindowForNewWindows()
-                 ->GetRootWindowController())
-      ->root_window_controller();
+  return RootWindowController::ForWindow(
+      static_cast<WmWindowMus*>(WmShellMus::Get()->GetRootWindowForNewWindows())
+          ->aura_window());
 }
 
 void WindowManager::OnEmbed(
     std::unique_ptr<aura::WindowTreeHostMus> window_tree_host) {
   // WindowManager should never see this, instead OnWmNewDisplay() is called.
   NOTREACHED();
 }
 
 void WindowManager::OnEmbedRootDestroyed(
     aura::WindowTreeHostMus* window_tree_host) {
@@ skipping 84 matching lines @@
   const bool is_first_display = screen_->display_list().displays().empty();
   // TODO(sky): should be passed whether display is primary.
   screen_->display_list().AddDisplay(
       display, is_first_display ? display::DisplayList::Type::PRIMARY
                                 : display::DisplayList::Type::NOT_PRIMARY);
 }
 
 void WindowManager::OnWmNewDisplay(
     std::unique_ptr<aura::WindowTreeHostMus> window_tree_host,
     const display::Display& display) {
-  CreateRootWindowController(std::move(window_tree_host), display);
+  ash::RootWindowController::RootWindowType root_window_type =
+      screen_->display_list().displays().size() == 1
+          ? ash::RootWindowController::RootWindowType::PRIMARY
+          : ash::RootWindowController::RootWindowType::SECONDARY;
+  CreateRootWindowController(std::move(window_tree_host), display,
+                             root_window_type);
 }
 
 void WindowManager::OnWmDisplayRemoved(
     aura::WindowTreeHostMus* window_tree_host) {
   for (auto& root_window_controller_ptr : root_window_controllers_) {
     if (root_window_controller_ptr->window_tree_host() == window_tree_host) {
       DestroyRootWindowController(root_window_controller_ptr.get());
       break;
     }
   }
@@ skipping 60 matching lines @@
 
 void WindowManager::OnWindowInitialized(aura::Window* window) {
   // This ensures WmWindowAura won't be called before WmWindowMus. This is
   // important as if WmWindowAura::Get() is called first, then WmWindowAura
   // would be created, not WmWindowMus.
   WmWindowMus::Get(window);
 }
 
 }  // namespace mus
 }  // namespace ash