ash: Move ShelfWidget ownership to WmShelf and refactor access to it

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/aura/aura_layout_manager_adapter.h"
@@ skipping 448 matching lines @@
 }
 
 const aura::Window* RootWindowController::GetContainer(int container_id) const {
   return ash_host_->AsWindowTreeHost()->window()->GetChildById(container_id);
 }
 
 void RootWindowController::ShowShelf() {
   if (!wm_shelf_aura_->IsShelfInitialized())
     return;
   // TODO(jamescook): Move this into WmShelf.
-  shelf_widget_->SetShelfVisibility(true);
-  shelf_widget_->status_area_widget()->Show();
+  wm_shelf_aura_->shelf_widget()->SetShelfVisibility(true);
+  wm_shelf_aura_->shelf_widget()->status_area_widget()->Show();
 }
 
 void RootWindowController::CreateShelf() {
   if (wm_shelf_aura_->IsShelfInitialized())
     return;
   wm_shelf_aura_->InitializeShelf();
 
   if (panel_layout_manager_)
     panel_layout_manager_->SetShelf(wm_shelf_aura_.get());
   if (docked_layout_manager_) {
     docked_layout_manager_->SetShelf(wm_shelf_aura_.get());
-    if (shelf_widget_->shelf_layout_manager())
+    if (wm_shelf_aura_->shelf_layout_manager()) {
       docked_layout_manager_->AddObserver(
-          shelf_widget_->shelf_layout_manager());
+          wm_shelf_aura_->shelf_layout_manager());
+    }
   }
 
   // Notify shell observers that the shelf has been created.
   // TODO(jamescook): Move this into WmShelf::InitializeShelf(). This will
   // require changing AttachedPanelWidgetTargeter's access to WmShelf.
   WmShell::Get()->NotifyShelfCreatedForRootWindow(
       WmWindowAura::Get(GetRootWindow()));
 
-  shelf_widget_->PostCreateShelf();
+  wm_shelf_aura_->shelf_widget()->PostCreateShelf();
 }
 
 void RootWindowController::UpdateAfterLoginStatusChange(LoginStatus status) {
   if (status != LoginStatus::NOT_LOGGED_IN)
     mouse_event_target_.reset();
-  if (shelf_widget_->status_area_widget())
-    shelf_widget_->status_area_widget()->UpdateAfterLoginStatusChange(status);
+  StatusAreaWidget* status_area_widget =
+      wm_shelf_aura_->shelf_widget()->status_area_widget();
+  if (status_area_widget)
+    status_area_widget->UpdateAfterLoginStatusChange(status);
 }
 
 void RootWindowController::HandleInitialWallpaperAnimationStarted() {
 #if defined(OS_CHROMEOS)
   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(
@@ skipping 20 matching lines @@
     // Release the old controller and close its wallpaper widget.
     SetWallpaperWidgetController(controller);
   }
 }
 
 void RootWindowController::CloseChildWindows() {
   mouse_event_target_.reset();
 
   // Remove observer as deactivating keyboard causes |docked_layout_manager_|
   // to fire notifications.
-  if (docked_layout_manager_ && shelf_widget_ &&
-      shelf_widget_->shelf_layout_manager())
+  if (docked_layout_manager_ && wm_shelf_aura_->shelf_layout_manager()) {
     docked_layout_manager_->RemoveObserver(
-        shelf_widget_->shelf_layout_manager());
+        wm_shelf_aura_->shelf_layout_manager());
+  }
 
   // Deactivate keyboard container before closing child windows and shutting
   // down associated layout managers.
   DeactivateKeyboard(keyboard::KeyboardController::GetInstance());
 
   // panel_layout_manager_ needs to be shut down before windows are destroyed.
   if (panel_layout_manager_) {
     panel_layout_manager_->Shutdown();
     panel_layout_manager_ = NULL;
   }
   // docked_layout_manager_ needs to be shut down before windows are destroyed.
   if (docked_layout_manager_) {
     docked_layout_manager_->Shutdown();
     docked_layout_manager_ = NULL;
   }
   aura::Window* root_window = GetRootWindow();
   aura::client::SetDragDropClient(root_window, NULL);
 
-  if (shelf_widget_)
-    shelf_widget_->Shutdown();
+  wm_shelf_aura_->ShutdownShelfWidget();
 
   // Close wallpaper widget first as it depends on tooltip.
   wallpaper_widget_controller_.reset();
   animating_wallpaper_widget_controller_.reset();
 
   wm_root_window_controller_->DeleteWorkspaceController();
   aura::client::SetTooltipClient(root_window, NULL);
 
   // Explicitly destroy top level windows. We do this as during part of
   // destruction such windows may query the RootWindow for state.
@@ skipping 19 matching lines @@
   // And then remove the containers.
   while (!root_window->children().empty()) {
     aura::Window* window = root_window->children()[0];
     if (window->owned_by_parent()) {
       delete window;
     } else {
       root_window->RemoveChild(window);
     }
   }
 
-  shelf_widget_.reset();
+  wm_shelf_aura_->DestroyShelfWidget();
+
   // CloseChildWindows may be called twice during the shutdown of ash unittests.
   // Avoid notifying WmShelf that the shelf has been destroyed twice.
   if (wm_shelf_aura_->IsShelfInitialized())
     wm_shelf_aura_->ShutdownShelf();
 }
 
 void RootWindowController::MoveWindowsTo(aura::Window* dst) {
   // Clear the workspace controller, so it doesn't incorrectly update the shelf.
   wm_root_window_controller_->DeleteWorkspaceController();
   ReparentAllWindows(GetRootWindow(), dst);
 }
 
 ShelfLayoutManager* RootWindowController::GetShelfLayoutManager() {
-  return shelf_widget_->shelf_layout_manager();
+  return wm_shelf_aura_->shelf_layout_manager();
+}
+
+StatusAreaWidget* RootWindowController::GetStatusAreaWidget() {
+  ShelfWidget* shelf_widget = wm_shelf_aura_->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(shelf_widget_->status_area_widget());
-  return shelf_widget_->status_area_widget()->system_tray();
+  CHECK(wm_shelf_aura_->shelf_widget()->status_area_widget());
+  return wm_shelf_aura_->shelf_widget()->status_area_widget()->system_tray();
 }
 
 void RootWindowController::ShowContextMenu(const gfx::Point& location_in_screen,
                                            ui::MenuSourceType source_type) {
   ShellDelegate* delegate = WmShell::Get()->delegate();
   DCHECK(delegate);
   menu_model_.reset(delegate->CreateContextMenu(wm_shelf_aura_.get(), nullptr));
   if (!menu_model_)
     return;
 
   menu_model_adapter_.reset(new views::MenuModelAdapter(
       menu_model_.get(),
       base::Bind(&RootWindowController::OnMenuClosed, base::Unretained(this))));
 
   // Wallpaper controller may not be set yet if user clicked on status are
   // before initial animation completion. See crbug.com/222218
   if (!wallpaper_widget_controller_.get())
     return;
 
   menu_runner_.reset(new views::MenuRunner(
       menu_model_adapter_->CreateMenu(),
       views::MenuRunner::CONTEXT_MENU | views::MenuRunner::ASYNC));
   ignore_result(
       menu_runner_->RunMenuAt(wallpaper_widget_controller_->widget(), nullptr,
                               gfx::Rect(location_in_screen, gfx::Size()),
                               views::MENU_ANCHOR_TOPLEFT, source_type));
 }
 
 void RootWindowController::UpdateShelfVisibility() {
-  shelf_widget_->shelf_layout_manager()->UpdateVisibilityState();
+  wm_shelf_aura_->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(shelf_widget()->shelf_layout_manager());
+  keyboard_controller->AddObserver(wm_shelf_aura_->shelf_layout_manager());
   keyboard_controller->AddObserver(panel_layout_manager_);
   keyboard_controller->AddObserver(docked_layout_manager_);
   keyboard_controller->AddObserver(workspace_controller()->layout_manager());
   keyboard_controller->AddObserver(
       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(shelf_widget()->shelf_layout_manager());
+    keyboard_controller->RemoveObserver(wm_shelf_aura_->shelf_layout_manager());
     keyboard_controller->RemoveObserver(panel_layout_manager_);
     keyboard_controller->RemoveObserver(docked_layout_manager_);
     keyboard_controller->RemoveObserver(
         workspace_controller()->layout_manager());
     keyboard_controller->RemoveObserver(
         always_on_top_controller_->GetLayoutManager());
     WmShell::Get()->NotifyVirtualKeyboardActivated(false);
   }
 }
 
@@ skipping 95 matching lines @@
   DCHECK(lock_modal_container);
   lock_modal_container->SetLayoutManager(
       new SystemModalContainerLayoutManager(lock_modal_container));
 
   WmWindow* always_on_top_container =
       WmWindowAura::Get(GetContainer(kShellWindowId_AlwaysOnTopContainer));
   always_on_top_controller_.reset(
       new AlwaysOnTopController(always_on_top_container));
 
   // Create the shelf and status area widgets.
-  DCHECK(!shelf_widget_.get());
+  DCHECK(!wm_shelf_aura_->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);
-  shelf_widget_.reset(new ShelfWidget(wm_shelf_container, wm_status_container,
-                                      wm_shelf_aura_.get()));
+  wm_shelf_aura_->CreateShelfWidget(WmWindowAura::Get(root_window));
+
   // 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()));
   status_container->SetEventTargeter(base::MakeUnique<ShelfWindowTargeter>(
       wm_status_container, wm_shelf_aura_.get()));
 
   if (!WmShell::Get()
            ->GetSessionStateDelegate()
            ->IsActiveUserSessionStarted()) {
@@ skipping 80 matching lines @@
 }
 
 void RootWindowController::OnMenuClosed() {
   menu_runner_.reset();
   menu_model_adapter_.reset();
   menu_model_.reset();
   Shell::GetInstance()->UpdateShelfVisibility();
 }
 
 void RootWindowController::OnLoginStateChanged(LoginStatus status) {
-  shelf_widget_->shelf_layout_manager()->UpdateVisibilityState();
+  wm_shelf_aura_->UpdateVisibilityState();
 }
 
 void RootWindowController::OnTouchHudProjectionToggled(bool enabled) {
   if (enabled)
     EnableTouchHudProjection();
   else
     DisableTouchHudProjection();
 }
 
 RootWindowController* GetRootWindowController(const aura::Window* root_window) {
   if (!root_window)
     return nullptr;
 
   if (Shell::GetInstance()->in_mus()) {
     // On mus, like desktop aura, each top-level widget has its own root window,
     // so |root_window| is not necessarily the display's root. For now, just
     // the use the primary display root.
     // TODO(jamescook): Multi-display support. This depends on how mus windows
     // will be owned by displays.
     aura::Window* primary_root_window = Shell::GetInstance()
                                             ->window_tree_host_manager()
                                             ->GetPrimaryRootWindow();
     return GetRootWindowSettings(primary_root_window)->controller;
   }
 
   return GetRootWindowSettings(root_window)->controller;
 }
 
 }  // namespace ash