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

ash/common/shelf/wm_shelf.cc

 // Copyright 2016 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/common/shelf/shelf_delegate.h"
 #include "ash/common/shelf/shelf_item_delegate.h"
 #include "ash/common/shelf/shelf_layout_manager.h"
 #include "ash/common/shelf/shelf_locking_manager.h"
 #include "ash/common/shelf/shelf_model.h"
 #include "ash/common/shelf/shelf_widget.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shelf/wm_shelf_observer.h"
+#include "ash/common/shell_window_ids.h"
 #include "ash/common/wm_lookup.h"
 #include "ash/common/wm_root_window_controller.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "base/logging.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace ash {
 
 // static
 WmShelf* WmShelf::ForWindow(WmWindow* window) {
   return window->GetRootWindowController()->GetShelf();
 }
 
-void WmShelf::SetShelfLayoutManager(ShelfLayoutManager* manager) {
+void WmShelf::CreateShelfWidget(WmWindow* root) {
+  DCHECK(!shelf_widget_);
+  WmWindow* shelf_container =
+      root->GetChildByShellWindowId(kShellWindowId_ShelfContainer);
+  shelf_widget_.reset(new ShelfWidget(shelf_container, this));
+
   DCHECK(!shelf_layout_manager_);
-  DCHECK(manager);
-  shelf_layout_manager_ = manager;
+  shelf_layout_manager_ = shelf_widget_->shelf_layout_manager();
   shelf_layout_manager_->AddObserver(this);
-  DCHECK(manager->shelf_widget());
-  shelf_widget_ = manager->shelf_widget();
+
+  // Must occur after |shelf_widget_| is constructed because the system tray
+  // constructors call back into WmShelf::shelf_widget().
+  DCHECK(!shelf_widget_->status_area_widget());
+  WmWindow* status_container =
+      root->GetChildByShellWindowId(kShellWindowId_StatusContainer);
+  shelf_widget_->CreateStatusAreaWidget(status_container);
+}
+
+void WmShelf::ShutdownShelfWidget() {
+  if (shelf_widget_)
+    shelf_widget_->Shutdown();
+}
+
+void WmShelf::DestroyShelfWidget() {
+  shelf_widget_.reset();
 }
 
 void WmShelf::InitializeShelf() {
   DCHECK(shelf_layout_manager_);
   DCHECK(shelf_widget_);
   DCHECK(!shelf_view_);
   shelf_view_ = shelf_widget_->CreateShelfView();
   shelf_locking_manager_.reset(new ShelfLockingManager(this));
   // When the shelf is created the alignment is unlocked. Chrome will update the
   // alignment later from preferences.
   alignment_ = SHELF_ALIGNMENT_BOTTOM;
   // NOTE: The delegate may access WmShelf.
   WmShell::Get()->shelf_delegate()->OnShelfCreated(this);
 }
 
 void WmShelf::ShutdownShelf() {
   DCHECK(shelf_view_);
   shelf_locking_manager_.reset();
   shelf_view_ = nullptr;
   WmShell::Get()->shelf_delegate()->OnShelfDestroyed(this);
 }
 
 bool WmShelf::IsShelfInitialized() const {
   return !!shelf_view_;
 }
 
 WmWindow* WmShelf::GetWindow() {
   // Use |shelf_layout_manager_| to access ShelfWidget because it is set before
   // before the Shelf instance is available.
-  return WmLookup::Get()->GetWindowForWidget(
-      shelf_layout_manager_->shelf_widget());
+  return WmLookup::Get()->GetWindowForWidget(shelf_widget_);
 }
 
 void WmShelf::SetAlignment(ShelfAlignment alignment) {
   DCHECK(shelf_layout_manager_);
   DCHECK(shelf_locking_manager_);
 
   if (alignment_ == alignment)
     return;
 
   if (shelf_locking_manager_->is_locked() &&
       alignment != SHELF_ALIGNMENT_BOTTOM_LOCKED) {
     shelf_locking_manager_->set_stored_alignment(alignment);
     return;
   }
 
   alignment_ = alignment;
   // The ShelfWidget notifies the ShelfView of the alignment change.
-  shelf_layout_manager_->shelf_widget()->OnShelfAlignmentChanged();
+  shelf_widget_->OnShelfAlignmentChanged();
   WmShell::Get()->shelf_delegate()->OnShelfAlignmentChanged(this);
   WmShell::Get()->NotifyShelfAlignmentChanged(GetWindow()->GetRootWindow());
   // ShelfLayoutManager will resize the shelf.
 }
 
 bool WmShelf::IsHorizontalAlignment() const {
   switch (alignment_) {
     case SHELF_ALIGNMENT_BOTTOM:
     case SHELF_ALIGNMENT_BOTTOM_LOCKED:
       return true;
@@ skipping 39 matching lines @@
 
 ShelfAutoHideState WmShelf::GetAutoHideState() const {
   return shelf_layout_manager_->auto_hide_state();
 }
 
 void WmShelf::UpdateAutoHideState() {
   shelf_layout_manager_->UpdateAutoHideState();
 }
 
 ShelfBackgroundType WmShelf::GetBackgroundType() const {
-  return shelf_layout_manager_->shelf_widget()->GetBackgroundType();
+  return shelf_widget_->GetBackgroundType();
 }
 
 WmDimmerView* WmShelf::CreateDimmerView(bool disable_animations_for_test) {
   return nullptr;
 }
 
 bool WmShelf::IsDimmed() const {
-  return shelf_layout_manager_->shelf_widget()->GetDimsShelf();
+  return shelf_widget_->GetDimsShelf();
 }
 
 bool WmShelf::IsVisible() const {
   return shelf_widget_->IsShelfVisible();
 }
 
 void WmShelf::UpdateVisibilityState() {
   if (shelf_layout_manager_)
     shelf_layout_manager_->UpdateVisibilityState();
 }
 
 ShelfVisibilityState WmShelf::GetVisibilityState() const {
   return shelf_layout_manager_ ? shelf_layout_manager_->visibility_state()
                                : SHELF_HIDDEN;
 }
 
 gfx::Rect WmShelf::GetIdealBounds() {
   return shelf_layout_manager_->GetIdealBounds();
 }
 
 gfx::Rect WmShelf::GetUserWorkAreaBounds() const {
   return shelf_layout_manager_ ? shelf_layout_manager_->user_work_area_bounds()
                                : gfx::Rect();
 }
 
 void WmShelf::UpdateIconPositionForPanel(WmWindow* panel) {
-  shelf_layout_manager_->shelf_widget()->UpdateIconPositionForPanel(panel);
+  shelf_widget_->UpdateIconPositionForPanel(panel);
 }
 
 gfx::Rect WmShelf::GetScreenBoundsOfItemIconForWindow(WmWindow* window) {
-  if (!shelf_layout_manager_)
+  if (!shelf_widget_)
     return gfx::Rect();
-  return shelf_layout_manager_->shelf_widget()
-      ->GetScreenBoundsOfItemIconForWindow(window);
+  return shelf_widget_->GetScreenBoundsOfItemIconForWindow(window);
 }
 
 // static
 void WmShelf::LaunchShelfItem(int item_index) {
   ShelfModel* shelf_model = WmShell::Get()->shelf_model();
   const ShelfItems& items = shelf_model->items();
   int item_count = shelf_model->item_count();
   int indexes_left = item_index >= 0 ? item_index : item_count;
   int found_index = -1;
 
@@ skipping 42 matching lines @@
 
 void WmShelf::RemoveObserver(WmShelfObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void WmShelf::NotifyShelfIconPositionsChanged() {
   FOR_EACH_OBSERVER(WmShelfObserver, observers_, OnShelfIconPositionsChanged());
 }
 
 StatusAreaWidget* WmShelf::GetStatusAreaWidget() const {
-  return shelf_layout_manager_->shelf_widget()->status_area_widget();
+  return shelf_widget_->status_area_widget();
 }
 
 void WmShelf::SetVirtualKeyboardBoundsForTesting(const gfx::Rect& bounds) {
   shelf_layout_manager_->OnKeyboardBoundsChanging(bounds);
 }
 
 ShelfLockingManager* WmShelf::GetShelfLockingManagerForTesting() {
   return shelf_locking_manager_.get();
 }
 
@@ skipping 23 matching lines @@
 
 void WmShelf::OnBackgroundUpdated(ShelfBackgroundType background_type,
                                   BackgroundAnimatorChangeType change_type) {
   if (background_type == GetBackgroundType())
     return;
   FOR_EACH_OBSERVER(WmShelfObserver, observers_,
                     OnBackgroundTypeChanged(background_type, change_type));
 }
 
 }  // namespace ash