ash: Refactor Shelf ownership and ShelfView creation

ash/shelf/shelf_widget.cc

 // Copyright 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/shelf/shelf_widget.h"
 
 #include "ash/aura/wm_shelf_aura.h"
 #include "ash/common/focus_cycler.h"
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shelf/shelf_background_animator_observer.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/shelf_delegate.h"
+#include "ash/common/shelf/shelf_view.h"
 #include "ash/common/shelf/wm_dimmer_view.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shelf/wm_shelf_util.h"
 #include "ash/common/system/status_area_widget.h"
 #include "ash/common/system/tray/system_tray_delegate.h"
 #include "ash/common/wm_root_window_controller.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
-#include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/wm/status_area_layout_manager.h"
 #include "base/memory/ptr_util.h"
 #include "grit/ash_resources.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia_operations.h"
@@ skipping 11 matching lines @@
 const int kNumBlackPixels = 3;
 
 }  // namespace
 
 // The contents view of the Shelf. This view contains ShelfView and
 // sizes it to the width of the shelf minus the size of the status area.
 class ShelfWidget::DelegateView : public views::WidgetDelegate,
                                   public views::AccessiblePaneView,
                                   public ShelfBackgroundAnimatorObserver {
  public:
-  explicit DelegateView(ShelfWidget* shelf);
+  DelegateView(WmShelf* wm_shelf, ShelfWidget* shelf);
   ~DelegateView() override;
 
   void set_focus_cycler(FocusCycler* focus_cycler) {
     focus_cycler_ = focus_cycler;
   }
   FocusCycler* focus_cycler() { return focus_cycler_; }
 
   ui::Layer* opaque_background() { return &opaque_background_; }
   ui::Layer* opaque_foreground() { return &opaque_foreground_; }
 
@@ skipping 30 matching lines @@
   // the dimmer is inactive.
   gfx::Rect GetDimmerBoundsForTest();
 
   // Disable dimming animations for running tests. This needs to be called
   // prior to the creation of of the dimmer.
   void disable_dimming_animations_for_test() {
     disable_dimming_animations_for_test_ = true;
   }
 
  private:
+  WmShelf* wm_shelf_;
   ShelfWidget* shelf_widget_;
   FocusCycler* focus_cycler_;
   int asset_background_alpha_;
   // TODO(bruthig): Remove opaque_background_ (see https://crbug.com/621551).
   // A black background layer which is shown when a maximized window is visible.
   ui::Layer opaque_background_;
   // A black foreground layer which is shown while transitioning between users.
   // Note: Since the back- and foreground layers have different functions they
   // can be used simultaneously - so no repurposing possible.
   ui::Layer opaque_foreground_;
 
   // The interface for the view which does the dimming. Null if the shelf is not
   // being dimmed, or if dimming is not supported (e.g. for mus).
   WmDimmerView* dimmer_view_;
 
   // True if dimming animations should be turned off.
   bool disable_dimming_animations_for_test_;
 
   DISALLOW_COPY_AND_ASSIGN(DelegateView);
 };
 
-ShelfWidget::DelegateView::DelegateView(ShelfWidget* shelf_widget)
-    : shelf_widget_(shelf_widget),
+ShelfWidget::DelegateView::DelegateView(WmShelf* wm_shelf,
+                                        ShelfWidget* shelf_widget)
+    : wm_shelf_(wm_shelf),
+      shelf_widget_(shelf_widget),
       focus_cycler_(nullptr),
       asset_background_alpha_(0),
       opaque_background_(ui::LAYER_SOLID_COLOR),
       opaque_foreground_(ui::LAYER_SOLID_COLOR),
       dimmer_view_(nullptr),
       disable_dimming_animations_for_test_(false) {
+  DCHECK(wm_shelf_);
+  DCHECK(shelf_widget_);
   SetLayoutManager(new views::FillLayout());
   set_allow_deactivate_on_esc(true);
   opaque_background_.SetColor(SK_ColorBLACK);
   opaque_background_.SetBounds(GetLocalBounds());
   opaque_background_.SetOpacity(0.0f);
   opaque_foreground_.SetColor(SK_ColorBLACK);
   opaque_foreground_.SetBounds(GetLocalBounds());
   opaque_foreground_.SetOpacity(0.0f);
 }
 
@@ skipping 31 matching lines @@
   ReorderLayers();
 }
 
 void ShelfWidget::DelegateView::OnPaintBackground(gfx::Canvas* canvas) {
   if (MaterialDesignController::IsShelfMaterial())
     return;
 
   ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
   gfx::ImageSkia shelf_background =
       *rb->GetImageSkiaNamed(IDR_ASH_SHELF_BACKGROUND);
-  const bool horizontal = IsHorizontalAlignment(shelf_widget_->GetAlignment());
+  const bool horizontal = wm_shelf_->IsHorizontalAlignment();
   if (!horizontal) {
     shelf_background = gfx::ImageSkiaOperations::CreateRotatedImage(
-        shelf_background, shelf_widget_->GetAlignment() == SHELF_ALIGNMENT_LEFT
+        shelf_background, wm_shelf_->GetAlignment() == SHELF_ALIGNMENT_LEFT
                               ? SkBitmapOperations::ROTATION_90_CW
                               : SkBitmapOperations::ROTATION_270_CW);
   }
   const gfx::Rect dock_bounds(
       shelf_widget_->shelf_layout_manager()->dock_bounds());
   SkPaint paint;
   paint.setAlpha(asset_background_alpha_);
   canvas->DrawImageInt(
       shelf_background, 0, 0, shelf_background.width(),
       shelf_background.height(),
@@ skipping 81 matching lines @@
 
 void ShelfWidget::DelegateView::UpdateShelfAssetBackground(int alpha) {
   asset_background_alpha_ = alpha;
   SchedulePaint();
 }
 
 ShelfWidget::ShelfWidget(WmWindow* shelf_container,
                          WmWindow* status_container,
                          WmShelfAura* wm_shelf_aura)
     : wm_shelf_aura_(wm_shelf_aura),
-      delegate_view_(new DelegateView(this)),
+      shelf_(nullptr),
+      delegate_view_(new DelegateView(wm_shelf_aura, this)),
+      shelf_view_(nullptr),
       background_animator_(SHELF_BACKGROUND_DEFAULT, wm_shelf_aura_),
       activating_as_fallback_(false) {
   background_animator_.AddObserver(this);
   background_animator_.AddObserver(delegate_view_);
 
   views::Widget::InitParams params(
       views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
+  params.name = "ShelfWidget";
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.delegate = delegate_view_;
   shelf_container->GetRootWindowController()
       ->ConfigureWidgetInitParamsForContainer(
           this, shelf_container->GetShellWindowId(), &params);
   Init(params);
 
   // The shelf should not take focus when initially shown.
   set_focus_on_creation(false);
@@ skipping 83 matching lines @@
     case LoginStatus::KIOSK_APP:
     case LoginStatus::NOT_LOGGED_IN:
       return false;
   }
 
   NOTREACHED();
   return false;
 }
 
 ShelfAlignment ShelfWidget::GetAlignment() const {
-  // TODO(msw): This should not be called before |shelf_| is created.
-  return shelf_ ? shelf_->alignment() : SHELF_ALIGNMENT_BOTTOM_LOCKED;
+  WmShelf* wm_shelf = static_cast<WmShelf*>(wm_shelf_aura_);
+  return wm_shelf->GetAlignment();
 }
 
 void ShelfWidget::OnShelfAlignmentChanged() {
   status_area_widget_->SetShelfAlignment(GetAlignment());
   delegate_view_->SchedulePaint();
 }
 
 void ShelfWidget::SetDimsShelf(bool dimming) {
   delegate_view_->SetDimmed(dimming);
   // Repaint all children, allowing updates to reflect dimmed state eg:
   // status area background, app list button and overflow button.
-  if (shelf_)
-    shelf_->SchedulePaint();
+  if (shelf_view_)
+    shelf_view_->SchedulePaintForAllButtons();
   status_area_widget_->SchedulePaint();
 }
 
 bool ShelfWidget::GetDimsShelf() const {
   return delegate_view_->GetDimmed();
 }
 
-void ShelfWidget::CreateShelf() {
+ShelfView* ShelfWidget::CreateShelfView() {
   DCHECK(!shelf_);
+  DCHECK(!shelf_view_);
 
-  shelf_.reset(new Shelf(WmShell::Get()->shelf_model(), wm_shelf_aura_, this));
-  // Must be initialized before the delegate is notified because the delegate
-  // may try to access the WmShelf.
-  wm_shelf_aura_->SetShelf(shelf_.get());
-  WmShell::Get()->shelf_delegate()->OnShelfCreated(shelf_.get());
+  shelf_view_ =
+      new ShelfView(WmShell::Get()->shelf_model(),
+                    WmShell::Get()->shelf_delegate(), wm_shelf_aura_, this);
+  shelf_view_->Init();
+  GetContentsView()->AddChildView(shelf_view_);
+  return shelf_view_;
+}
 
+void ShelfWidget::PostCreateShelf() {
   SetFocusCycler(WmShell::Get()->focus_cycler());
 
   // Ensure the newly created |shelf_| gets current values.
   background_animator_.Initialize(this);
-}
 
-void ShelfWidget::PostCreateShelf() {
-  shelf_->SetVisible(
+  shelf_view_->SetVisible(
       WmShell::Get()->GetSessionStateDelegate()->IsActiveUserSessionStarted());
   shelf_layout_manager_->LayoutShelf();
   shelf_layout_manager_->UpdateAutoHideState();
   Show();
 }
 
 bool ShelfWidget::IsShelfVisible() const {
-  return shelf_.get() && shelf_->IsVisible();
+  return shelf_view_ && shelf_view_->visible();
 }
 
 void ShelfWidget::SetShelfVisibility(bool visible) {
-  if (shelf_)
-    shelf_->SetVisible(visible);
+  if (shelf_view_)
+    shelf_view_->SetVisible(visible);
 }
 
 void ShelfWidget::SetFocusCycler(FocusCycler* focus_cycler) {
   delegate_view_->set_focus_cycler(focus_cycler);
   if (focus_cycler)
     focus_cycler->AddWidget(this);
 }
 
 FocusCycler* ShelfWidget::GetFocusCycler() {
   return delegate_view_->focus_cycler();
@@ skipping 43 matching lines @@
     return delegate_view_->GetDimmerBoundsForTest();
   return gfx::Rect();
 }
 
 void ShelfWidget::DisableDimmingAnimationsForTest() {
   DCHECK(delegate_view_);
   delegate_view_->disable_dimming_animations_for_test();
 }
 
 void ShelfWidget::UpdateShelfItemBackground(int alpha) {
-  if (shelf_)
-    shelf_->UpdateShelfItemBackground(alpha);
+  if (shelf_view_)
+    shelf_view_->UpdateShelfItemBackground(alpha);
 }
 
 void ShelfWidget::WillDeleteShelfLayoutManager() {
   shelf_layout_manager_->RemoveObserver(this);
   shelf_layout_manager_ = nullptr;
 }
 
 }  // namespace ash