Removes WmRootWindowController subclasses

ash/root_window_controller.cc

 // Copyright (c) 2012 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/root_window_controller.h"
 
 #include <queue>
 #include <vector>
 
 #include "ash/ash_touch_exploration_manager_chromeos.h"
 #include "ash/aura/aura_layout_manager_adapter.h"
-#include "ash/aura/wm_root_window_controller_aura.h"
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/ash_constants.h"
 #include "ash/common/ash_switches.h"
 #include "ash/common/focus_cycler.h"
 #include "ash/common/login_status.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/shelf/shelf_layout_manager.h"
 #include "ash/common/shelf/shelf_widget.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shell_delegate.h"
 #include "ash/common/system/status_area_layout_manager.h"
 #include "ash/common/system/status_area_widget.h"
 #include "ash/common/system/tray/system_tray_delegate.h"
 #include "ash/common/wallpaper/wallpaper_delegate.h"
 #include "ash/common/wallpaper/wallpaper_widget_controller.h"
 #include "ash/common/wm/always_on_top_controller.h"
 #include "ash/common/wm/container_finder.h"
 #include "ash/common/wm/dock/docked_window_layout_manager.h"
 #include "ash/common/wm/fullscreen_window_finder.h"
 #include "ash/common/wm/panels/panel_layout_manager.h"
 #include "ash/common/wm/root_window_layout_manager.h"
 #include "ash/common/wm/switchable_windows.h"
 #include "ash/common/wm/system_modal_container_layout_manager.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/workspace/workspace_layout_manager.h"
 #include "ash/common/wm/workspace_controller.h"
+#include "ash/common/wm_root_window_controller.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "ash/high_contrast/high_contrast_controller.h"
 #include "ash/host/ash_window_tree_host.h"
 #include "ash/public/cpp/shelf_types.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_settings.h"
 #include "ash/shelf/shelf_window_targeter.h"
 #include "ash/shell.h"
 #include "ash/touch/touch_hud_debug.h"
@@ skipping 82 matching lines @@
     // If the target window is above blocking window, the window can handle
     // events.
     return std::find(blocking_iter, windows.end(), target) != windows.end();
   }
 
   return true;
 }
 
 }  // namespace
 
+RootWindowController::~RootWindowController() {
+  Shutdown();
+  ash_host_.reset();
+  mus_window_tree_host_.reset();
+  // The CaptureClient needs to be around for as long as the RootWindow is
+  // valid.
+  capture_client_.reset();
+}
+
 void RootWindowController::CreateForPrimaryDisplay(AshWindowTreeHost* host) {
-  RootWindowController* controller = new RootWindowController(host);
-  controller->Init(RootWindowController::PRIMARY);
+  RootWindowController* controller = new RootWindowController(host, nullptr);
+  controller->Init(RootWindowType::PRIMARY);
 }
 
 void RootWindowController::CreateForSecondaryDisplay(AshWindowTreeHost* host) {
-  RootWindowController* controller = new RootWindowController(host);
-  controller->Init(RootWindowController::SECONDARY);
+  RootWindowController* controller = new RootWindowController(host, nullptr);
+  controller->Init(RootWindowType::SECONDARY);
 }
 
 // static
 RootWindowController* RootWindowController::ForWindow(
     const aura::Window* window) {
-  CHECK(Shell::HasInstance());
+  DCHECK(window);
+  CHECK(WmShell::HasInstance() &&
+        (WmShell::Get()->IsRunningInMash() || Shell::HasInstance()));
   return GetRootWindowController(window->GetRootWindow());
 }
 
 // static
 RootWindowController* RootWindowController::ForTargetRootWindow() {
   CHECK(Shell::HasInstance());
   return GetRootWindowController(Shell::GetTargetRootWindow());
 }
 
-RootWindowController::~RootWindowController() {
-  Shutdown();
-  ash_host_.reset();
-  // The CaptureClient needs to be around for as long as the RootWindow is
-  // valid.
-  capture_client_.reset();
-}
-
 aura::WindowTreeHost* RootWindowController::GetHost() {
-  return ash_host_->AsWindowTreeHost();
+  return window_tree_host_;
 }
 
 const aura::WindowTreeHost* RootWindowController::GetHost() const {
-  return ash_host_->AsWindowTreeHost();
+  return window_tree_host_;
 }
 
 aura::Window* RootWindowController::GetRootWindow() {
   return GetHost()->window();
 }
 
 const aura::Window* RootWindowController::GetRootWindow() const {
   return GetHost()->window();
 }
 
 WorkspaceController* RootWindowController::workspace_controller() {
   return wm_root_window_controller_->workspace_controller();
 }
 
 void RootWindowController::Shutdown() {
   WmShell::Get()->RemoveShellObserver(this);
 
   touch_exploration_manager_.reset();
 
   wm_root_window_controller_->ResetRootForNewWindowsIfNecessary();
 
   CloseChildWindows();
   aura::Window* root_window = GetRootWindow();
   GetRootWindowSettings(root_window)->controller = NULL;
   // Forget with the display ID so that display lookup
   // ends up with invalid display.
   GetRootWindowSettings(root_window)->display_id = display::kInvalidDisplayId;
-  ash_host_->PrepareForShutdown();
+  if (ash_host_)
+    ash_host_->PrepareForShutdown();
 
   system_wallpaper_.reset();
   aura::client::SetScreenPositionClient(root_window, NULL);
 }
 
 bool RootWindowController::CanWindowReceiveEvents(aura::Window* window) {
   if (GetRootWindow() != window->GetRootWindow())
     return false;
 
   // Always allow events to fall through to the virtual keyboard even if
@@ skipping 35 matching lines @@
         WmWindowAura::Get(window));
 
   return true;
 }
 
 aura::Window* RootWindowController::GetContainer(int container_id) {
   return GetRootWindow()->GetChildById(container_id);
 }
 
 const aura::Window* RootWindowController::GetContainer(int container_id) const {
-  return ash_host_->AsWindowTreeHost()->window()->GetChildById(container_id);
+  return window_tree_host_->window()->GetChildById(container_id);
 }
 
 void RootWindowController::OnInitialWallpaperAnimationStarted() {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshAnimateFromBootSplashScreen) &&
       boot_splash_screen_.get()) {
     // Make the splash screen fade out so it doesn't obscure the wallpaper's
     // brightness/grayscale animation.
     boot_splash_screen_->StartHideAnimation(
         base::TimeDelta::FromMilliseconds(kBootSplashScreenHideDurationMs));
@@ skipping 109 matching lines @@
 
 void RootWindowController::SetTouchAccessibilityAnchorPoint(
     const gfx::Point& anchor_point) {
   if (touch_exploration_manager_)
     touch_exploration_manager_->SetTouchAccessibilityAnchorPoint(anchor_point);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindowController, private:
 
-RootWindowController::RootWindowController(AshWindowTreeHost* ash_host)
+RootWindowController::RootWindowController(
+    AshWindowTreeHost* ash_host,
+    aura::WindowTreeHost* window_tree_host)
     : ash_host_(ash_host),
+      mus_window_tree_host_(window_tree_host),
+      window_tree_host_(ash_host ? ash_host->AsWindowTreeHost()
+                                 : window_tree_host),
       wm_shelf_(base::MakeUnique<WmShelf>()),
       touch_hud_debug_(NULL),
       touch_hud_projection_(NULL) {
+  DCHECK((ash_host && !window_tree_host) || (!ash_host && window_tree_host));
   aura::Window* root_window = GetRootWindow();
   GetRootWindowSettings(root_window)->controller = this;
 
   // Has to happen after this is set as |controller| of RootWindowSettings.
-  wm_root_window_controller_ = WmRootWindowControllerAura::Get(root_window);
+  wm_root_window_controller_ = base::MakeUnique<WmRootWindowController>(
+      this, WmWindowAura::Get(root_window));
 
   stacking_controller_.reset(new StackingController);
   aura::client::SetWindowParentingClient(root_window,
                                          stacking_controller_.get());
   capture_client_.reset(new ::wm::ScopedCaptureClient(root_window));
 }
 
 void RootWindowController::Init(RootWindowType root_window_type) {
   aura::Window* root_window = GetRootWindow();
-  Shell* shell = Shell::GetInstance();
-  shell->InitRootWindow(root_window);
+  WmShell* wm_shell = WmShell::Get();
+  Shell* shell = nullptr;
+  if (!wm_shell->IsRunningInMash()) {
+    shell = Shell::GetInstance();
+    shell->InitRootWindow(root_window);
+  }
 
   wm_root_window_controller_->CreateContainers();
 
   CreateSystemWallpaper(root_window_type);
 
   InitLayoutManagers();
   InitTouchHuds();
 
-  if (WmShell::Get()
-          ->GetPrimaryRootWindowController()
+  if (wm_shell->GetPrimaryRootWindowController()
           ->GetSystemModalLayoutManager(nullptr)
           ->has_window_dimmer()) {
     wm_root_window_controller_->GetSystemModalLayoutManager(nullptr)
         ->CreateModalBackground();
   }
 
-  WmShell::Get()->AddShellObserver(this);
+  wm_shell->AddShellObserver(this);
 
   wm_root_window_controller_->root_window_layout_manager()->OnWindowResized();
-  if (root_window_type == PRIMARY) {
-    shell->InitKeyboard();
+  if (root_window_type == RootWindowType::PRIMARY) {
+    if (!wm_shell->IsRunningInMash())
+      shell->InitKeyboard();
   } else {
-    ash_host_->AsWindowTreeHost()->Show();
+    window_tree_host_->Show();
 
     // Create a shelf if a user is already logged in.
-    if (WmShell::Get()->GetSessionStateDelegate()->NumberOfLoggedInUsers())
+    if (wm_shell->GetSessionStateDelegate()->NumberOfLoggedInUsers())
       wm_root_window_controller_->CreateShelf();
 
     // Notify shell observers about new root window.
-    shell->OnRootWindowAdded(WmWindowAura::Get(root_window));
+    if (!wm_shell->IsRunningInMash())
+      shell->OnRootWindowAdded(WmWindowAura::Get(root_window));
   }
 
+  // TODO: AshTouchExplorationManager doesn't work with mus.
+  // http://crbug.com/679782
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kAshDisableTouchExplorationMode)) {
+          switches::kAshDisableTouchExplorationMode) &&
+      !wm_shell->IsRunningInMash()) {
     touch_exploration_manager_.reset(new AshTouchExplorationManager(this));
   }
 }
 
 void RootWindowController::InitLayoutManagers() {
   // Create the shelf and status area widgets.
   DCHECK(!wm_shelf_->shelf_widget());
   aura::Window* shelf_container = GetContainer(kShellWindowId_ShelfContainer);
   aura::Window* status_container = GetContainer(kShellWindowId_StatusContainer);
   WmWindow* wm_shelf_container = WmWindowAura::Get(shelf_container);
@@ skipping 19 matching lines @@
                            -kResizeOutsideBoundsSize);
   gfx::Insets touch_extend =
       mouse_extend.Scale(kResizeOutsideBoundsScaleForTouch);
   aura::Window* panel_container = GetContainer(kShellWindowId_PanelContainer);
   panel_container->SetEventTargeter(std::unique_ptr<ui::EventTargeter>(
       new AttachedPanelWindowTargeter(panel_container, mouse_extend,
                                       touch_extend, panel_layout_manager())));
 }
 
 void RootWindowController::InitTouchHuds() {
+  if (WmShell::Get()->IsRunningInMash())
+    return;
+
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kAshTouchHud))
     set_touch_hud_debug(new TouchHudDebug(GetRootWindow()));
   if (Shell::GetInstance()->is_touch_hud_projection_enabled())
     EnableTouchHudProjection();
 }
 
 void RootWindowController::CreateSystemWallpaper(
     RootWindowType root_window_type) {
   SkColor color = SK_ColorBLACK;
   // The splash screen appears on the primary display at boot. If this is a
   // secondary monitor (either connected at boot or connected later) or if the
   // browser restarted for a second login then don't use the boot color.
   const bool is_boot_splash_screen =
-      root_window_type == PRIMARY &&
+      root_window_type == RootWindowType::PRIMARY &&
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           chromeos::switches::kFirstExecAfterBoot);
   if (is_boot_splash_screen)
     color = kChromeOsBootColor;
   system_wallpaper_.reset(
       new SystemWallpaperController(GetRootWindow(), color));
 
   // Make a copy of the system's boot splash screen so we can composite it
   // onscreen until the wallpaper is ready.
   if (is_boot_splash_screen &&
@@ skipping 34 matching lines @@
     EnableTouchHudProjection();
   else
     DisableTouchHudProjection();
 }
 
 RootWindowController* GetRootWindowController(const aura::Window* root_window) {
   return root_window ? GetRootWindowSettings(root_window)->controller : nullptr;
 }
 
 }  // namespace ash