Removes WmShelfAura and WmShelfMus

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_shelf_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"
@@ skipping 242 matching lines @@
 
 void RootWindowController::OnWallpaperAnimationFinished(views::Widget* widget) {
   // Make sure the wallpaper is visible.
   system_wallpaper_->SetColor(SK_ColorBLACK);
   boot_splash_screen_.reset();
 }
 
 void RootWindowController::CloseChildWindows() {
   // Remove observer as deactivating keyboard causes
   // docked_window_layout_manager() to fire notifications.
-  if (docked_window_layout_manager() &&
-      wm_shelf_aura_->shelf_layout_manager()) {
+  if (docked_window_layout_manager() && wm_shelf_->shelf_layout_manager()) {
     docked_window_layout_manager()->RemoveObserver(
-        wm_shelf_aura_->shelf_layout_manager());
+        wm_shelf_->shelf_layout_manager());
   }
 
   // Deactivate keyboard container before closing child windows and shutting
   // down associated layout managers.
   DeactivateKeyboard(keyboard::KeyboardController::GetInstance());
 
   wm_root_window_controller_->CloseChildWindows();
 
   aura::client::SetDragDropClient(GetRootWindow(), nullptr);
   aura::client::SetTooltipClient(GetRootWindow(), nullptr);
 }
 
 void RootWindowController::MoveWindowsTo(aura::Window* dst) {
   wm_root_window_controller_->MoveWindowsTo(WmWindowAura::Get(dst));
 }
 
 ShelfLayoutManager* RootWindowController::GetShelfLayoutManager() {
-  return wm_shelf_aura_->shelf_layout_manager();
+  return wm_shelf_->shelf_layout_manager();
 }
 
 StatusAreaWidget* RootWindowController::GetStatusAreaWidget() {
-  ShelfWidget* shelf_widget = wm_shelf_aura_->shelf_widget();
+  ShelfWidget* shelf_widget = wm_shelf_->shelf_widget();
   return shelf_widget ? shelf_widget->status_area_widget() : nullptr;
 }
 
 SystemTray* RootWindowController::GetSystemTray() {
   // We assume in throughout the code that this will not return NULL. If code
   // triggers this for valid reasons, it should test status_area_widget first.
-  CHECK(wm_shelf_aura_->shelf_widget()->status_area_widget());
-  return wm_shelf_aura_->shelf_widget()->status_area_widget()->system_tray();
+  CHECK(wm_shelf_->shelf_widget()->status_area_widget());
+  return wm_shelf_->shelf_widget()->status_area_widget()->system_tray();
 }
 
 void RootWindowController::UpdateShelfVisibility() {
-  wm_shelf_aura_->UpdateVisibilityState();
+  wm_shelf_->UpdateVisibilityState();
 }
 
 aura::Window* RootWindowController::GetWindowForFullscreenMode() {
   return WmWindowAura::GetAuraWindow(
       wm::GetWindowForFullscreenMode(WmWindowAura::Get(GetRootWindow())));
 }
 
 void RootWindowController::ActivateKeyboard(
     keyboard::KeyboardController* keyboard_controller) {
   if (!keyboard::IsKeyboardEnabled() ||
       GetContainer(kShellWindowId_VirtualKeyboardContainer)) {
     return;
   }
   DCHECK(keyboard_controller);
-  keyboard_controller->AddObserver(wm_shelf_aura_->shelf_layout_manager());
+  keyboard_controller->AddObserver(wm_shelf_->shelf_layout_manager());
   keyboard_controller->AddObserver(panel_layout_manager());
   keyboard_controller->AddObserver(docked_window_layout_manager());
   keyboard_controller->AddObserver(workspace_controller()->layout_manager());
   keyboard_controller->AddObserver(
       wm_root_window_controller_->always_on_top_controller()
           ->GetLayoutManager());
   WmShell::Get()->NotifyVirtualKeyboardActivated(true);
   aura::Window* parent = GetContainer(kShellWindowId_ImeWindowParentContainer);
   DCHECK(parent);
   aura::Window* keyboard_container = keyboard_controller->GetContainerWindow();
   keyboard_container->set_id(kShellWindowId_VirtualKeyboardContainer);
   parent->AddChild(keyboard_container);
 }
 
 void RootWindowController::DeactivateKeyboard(
     keyboard::KeyboardController* keyboard_controller) {
   if (!keyboard_controller ||
       !keyboard_controller->keyboard_container_initialized()) {
     return;
   }
   aura::Window* keyboard_container = keyboard_controller->GetContainerWindow();
   if (keyboard_container->GetRootWindow() == GetRootWindow()) {
     aura::Window* parent =
         GetContainer(kShellWindowId_ImeWindowParentContainer);
     DCHECK(parent);
     parent->RemoveChild(keyboard_container);
     // Virtual keyboard may be deactivated while still showing, notify all
     // observers that keyboard bounds changed to 0 before remove them.
     keyboard_controller->NotifyKeyboardBoundsChanging(gfx::Rect());
-    keyboard_controller->RemoveObserver(wm_shelf_aura_->shelf_layout_manager());
+    keyboard_controller->RemoveObserver(wm_shelf_->shelf_layout_manager());
     keyboard_controller->RemoveObserver(panel_layout_manager());
     keyboard_controller->RemoveObserver(docked_window_layout_manager());
     keyboard_controller->RemoveObserver(
         workspace_controller()->layout_manager());
     keyboard_controller->RemoveObserver(
         wm_root_window_controller_->always_on_top_controller()
             ->GetLayoutManager());
     WmShell::Get()->NotifyVirtualKeyboardActivated(false);
   }
 }
 
 bool RootWindowController::IsVirtualKeyboardWindow(aura::Window* window) {
   aura::Window* parent = GetContainer(kShellWindowId_ImeWindowParentContainer);
   return parent ? parent->Contains(window) : false;
 }
 
 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)
     : ash_host_(ash_host),
-      wm_shelf_aura_(new WmShelfAura),
+      wm_shelf_(base::MakeUnique<WmShelf>()),
       touch_hud_debug_(NULL),
       touch_hud_projection_(NULL) {
   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);
 
   stacking_controller_.reset(new StackingController);
   aura::client::SetWindowParentingClient(root_window,
@@ skipping 38 matching lines @@
   }
 
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshDisableTouchExplorationMode)) {
     touch_exploration_manager_.reset(new AshTouchExplorationManager(this));
   }
 }
 
 void RootWindowController::InitLayoutManagers() {
   // Create the shelf and status area widgets.
-  DCHECK(!wm_shelf_aura_->shelf_widget());
+  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);
   WmWindow* wm_status_container = WmWindowAura::Get(status_container);
 
   wm_root_window_controller_->CreateLayoutManagers();
 
   // Make it easier to resize windows that partially overlap the shelf. Must
   // occur after the ShelfLayoutManager is constructed by ShelfWidget.
   shelf_container->SetEventTargeter(base::MakeUnique<ShelfWindowTargeter>(
-      wm_shelf_container, wm_shelf_aura_.get()));
+      wm_shelf_container, wm_shelf_.get()));
   status_container->SetEventTargeter(base::MakeUnique<ShelfWindowTargeter>(
-      wm_status_container, wm_shelf_aura_.get()));
+      wm_status_container, wm_shelf_.get()));
 
   panel_container_handler_ = base::MakeUnique<PanelWindowEventHandler>();
   GetContainer(kShellWindowId_PanelContainer)
       ->AddPreTargetHandler(panel_container_handler_.get());
 
   // Install an AttachedPanelWindowTargeter on the panel container to make it
   // easier to correctly target shelf buttons with touch.
   gfx::Insets mouse_extend(-kResizeOutsideBoundsSize, -kResizeOutsideBoundsSize,
                            -kResizeOutsideBoundsSize,
                            -kResizeOutsideBoundsSize);
@@ skipping 53 matching lines @@
 DockedWindowLayoutManager*
 RootWindowController::docked_window_layout_manager() {
   return wm_root_window_controller_->docked_window_layout_manager();
 }
 
 PanelLayoutManager* RootWindowController::panel_layout_manager() {
   return wm_root_window_controller_->panel_layout_manager();
 }
 
 void RootWindowController::OnLoginStateChanged(LoginStatus status) {
-  wm_shelf_aura_->UpdateVisibilityState();
+  wm_shelf_->UpdateVisibilityState();
 }
 
 void RootWindowController::OnTouchHudProjectionToggled(bool enabled) {
   if (enabled)
     EnableTouchHudProjection();
   else
     DisableTouchHudProjection();
 }
 
 RootWindowController* GetRootWindowController(const aura::Window* root_window) {
   return root_window ? GetRootWindowSettings(root_window)->controller : nullptr;
 }
 
 }  // namespace ash