Replaced BackgroundAnimator with ShelfBackgroundAnimator.

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/ash_switches.h"
 #include "ash/aura/wm_shelf_aura.h"
 #include "ash/aura/wm_window_aura.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_model.h"
 #include "ash/common/shelf/wm_shelf_util.h"
 #include "ash/common/shell_window_ids.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/focus_cycler.h"
 #include "ash/shelf/shelf_delegate.h"
 #include "ash/shelf/shelf_layout_manager.h"
@@ skipping 51 matching lines @@
   void SetHovered(bool hovered);
 
   // Force the dimmer to be undimmed.
   void ForceUndimming(bool force);
 
   // views::WidgetDelegate overrides:
   views::Widget* GetWidget() override { return View::GetWidget(); }
   const views::Widget* GetWidget() const override { return View::GetWidget(); }
 
   // BackgroundAnimatorDelegate overrides:
-  void UpdateBackground(int alpha) override {
+  void UpdateBackground(BackgroundAnimator* animator, int alpha) override {
     alpha_ = alpha;
     SchedulePaint();
   }
 
+  void BackgroundAnimationEnded(BackgroundAnimator* animator,
+                                bool successful) override {}
+
   // views::View overrides:
   void OnPaintBackground(gfx::Canvas* canvas) override;
 
   // A function to test the current alpha used.
   int get_dimming_alpha_for_test() { return alpha_; }
 
  private:
   // This class monitors mouse events to see if it is on top of the shelf.
   class DimmerEventFilter : public ui::EventHandler {
    public:
@@ skipping 197 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ShelfWindowTargeter);
 };
 
 }  // 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 BackgroundAnimatorDelegate,
-                                  public aura::WindowObserver {
+                                  public aura::WindowObserver,
+                                  public ShelfBackgroundAnimatorObserver {
  public:
   explicit DelegateView(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_; }
@@ skipping 19 matching lines @@
 
   // aura::WindowObserver overrides:
   // This will be called when the shelf itself changes its absolute position.
   // Since the |dimmer_| panel needs to be placed in screen coordinates it needs
   // to be repositioned. The difference to the OnBoundsChanged call above is
   // that this gets also triggered when the shelf only moves.
   void OnWindowBoundsChanged(aura::Window* window,
                              const gfx::Rect& old_bounds,
                              const gfx::Rect& new_bounds) override;
 
-  // BackgroundAnimatorDelegate overrides:
-  void UpdateBackground(int alpha) override;
+  // ShelfBackgroundAnimatorObserver:
+  void UpdateShelfOpaqueBackground(int alpha) override;
+  void UpdateShelfAssetBackground(int alpha) override;
 
   // Force the shelf to be presented in an undimmed state.
   void ForceUndimming(bool force);
 
   // A function to test the current alpha used by the dimming bar. If there is
   // no dimmer active, the function will return -1.
   int GetDimmingAlphaForTest();
 
   // A function to test the bounds of the dimming bar. Returns gfx::Rect() if
   // 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:
   ShelfWidget* shelf_;
   std::unique_ptr<views::Widget> dimmer_;
   FocusCycler* focus_cycler_;
-  int alpha_;
+  int asset_background_alpha_;

[James Cook, 2016/06/14 17:50:02]

Hooray for more explicit variable names!

+  // TODO(bruthig): Remove opaque_background_.

[James Cook, 2016/06/14 17:50:02]

Please file a bug for this and reference it here.

[bruthig, 2016/07/26 19:50:03]

Done.

   // 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 view which does the dimming.
   DimmerView* 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)
     : shelf_(shelf),
       focus_cycler_(NULL),
-      alpha_(0),
+      asset_background_alpha_(0),
       opaque_background_(ui::LAYER_SOLID_COLOR),
       opaque_foreground_(ui::LAYER_SOLID_COLOR),
       dimmer_view_(NULL),
       disable_dimming_animations_for_test_(false) {
   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);
@@ skipping 42 matching lines @@
   return dimmer_.get() && dimmer_->IsVisible();
 }
 
 void ShelfWidget::DelegateView::SetParentLayer(ui::Layer* layer) {
   layer->Add(&opaque_background_);
   layer->Add(&opaque_foreground_);
   ReorderLayers();
 }
 
 void ShelfWidget::DelegateView::OnPaintBackground(gfx::Canvas* canvas) {
-  if (MaterialDesignController::IsShelfMaterial()) {
-    canvas->FillRect(bounds(), SkColorSetA(kShelfBaseColor, alpha_));
-  } else {
+  if (!MaterialDesignController::IsShelfMaterial()) {
     ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
     gfx::ImageSkia shelf_background =
         *rb->GetImageSkiaNamed(IDR_ASH_SHELF_BACKGROUND);
     const bool horizontal = IsHorizontalAlignment(shelf_->GetAlignment());
     if (!horizontal) {
       shelf_background = gfx::ImageSkiaOperations::CreateRotatedImage(
           shelf_background, shelf_->GetAlignment() == SHELF_ALIGNMENT_LEFT
                                 ? SkBitmapOperations::ROTATION_90_CW
                                 : SkBitmapOperations::ROTATION_270_CW);
     }
     const gfx::Rect dock_bounds(shelf_->shelf_layout_manager()->dock_bounds());
     SkPaint paint;
-    paint.setAlpha(alpha_);
+    paint.setAlpha(asset_background_alpha_);
     canvas->DrawImageInt(
         shelf_background, 0, 0, shelf_background.width(),
         shelf_background.height(),
         (horizontal && dock_bounds.x() == 0 && dock_bounds.width() > 0)
             ? dock_bounds.width()
             : 0,
         0, horizontal ? width() - dock_bounds.width() : width(), height(),
         false, paint);
     if (horizontal && dock_bounds.width() > 0) {
       // The part of the shelf background that is in the corner below the docked
@@ skipping 74 matching lines @@
     return dimmer_view_->get_dimming_alpha_for_test();
   return -1;
 }
 
 gfx::Rect ShelfWidget::DelegateView::GetDimmerBoundsForTest() {
   if (GetDimmed())
     return dimmer_view_->GetBoundsInScreen();
   return gfx::Rect();
 }
 
-void ShelfWidget::DelegateView::UpdateBackground(int alpha) {
-  alpha_ = alpha;
+void ShelfWidget::DelegateView::UpdateShelfOpaqueBackground(int alpha) {
+  const double kMaxAlpha = 255.0;

[James Cook, 2016/06/14 17:50:02]

could be a float

[bruthig, 2016/07/26 19:50:03]

Done.

+  opaque_background_.SetOpacity(alpha / kMaxAlpha);
+}
+
+void ShelfWidget::DelegateView::UpdateShelfAssetBackground(int alpha) {
+  asset_background_alpha_ = alpha;
   SchedulePaint();
 }
 
 ShelfWidget::ShelfWidget(WmWindow* wm_shelf_container,
                          WmWindow* wm_status_container,
                          WorkspaceController* workspace_controller)
     : delegate_view_(new DelegateView(this)),
-      background_animator_(
-          delegate_view_, 0, GetShelfConstant(SHELF_BACKGROUND_ALPHA)),
       activating_as_fallback_(false) {
   views::Widget::InitParams params(
       views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.delegate = delegate_view_;
   wm_shelf_container->GetRootWindowController()
       ->ConfigureWidgetInitParamsForContainer(
           this, wm_shelf_container->GetShellWindowId(), &params);
   Init(params);
 
   // The shelf should not take focus when initially shown.
   set_focus_on_creation(false);
   SetContentsView(delegate_view_);
   delegate_view_->SetParentLayer(GetLayer());
 
   shelf_layout_manager_ = new ShelfLayoutManager(this);
   shelf_layout_manager_->AddObserver(this);
   aura::Window* shelf_container =
       WmWindowAura::GetAuraWindow(wm_shelf_container);
   shelf_container->SetLayoutManager(shelf_layout_manager_);
   shelf_layout_manager_->set_workspace_controller(workspace_controller);
   workspace_controller->SetShelf(shelf_layout_manager_);
 
+  background_animator_.AddObserver(delegate_view_);

[James Cook, 2016/06/14 17:50:02]

Does this need to be done here, or could it happen around line 582, nearer to
where delegate_view_ is constructed?

Where is this observer removed?

[bruthig, 2016/07/26 19:50:03]

Done.

+
   status_area_widget_ = new StatusAreaWidget(wm_status_container, this);
   status_area_widget_->CreateTrayViews();
   if (Shell::GetInstance()->session_state_delegate()->
           IsActiveUserSessionStarted()) {
     status_area_widget_->Show();
   }
   Shell::GetInstance()->focus_cycler()->AddWidget(status_area_widget_);
+  background_animator_.AddObserver(status_area_widget_);
 
   aura::Window* status_container =
       WmWindowAura::GetAuraWindow(wm_status_container);
   status_container->SetLayoutManager(
       new StatusAreaLayoutManager(status_container, this));
 
   shelf_container->SetEventTargeter(std::unique_ptr<ui::EventTargeter>(
       new ShelfWindowTargeter(shelf_container, shelf_layout_manager_)));
   status_container->SetEventTargeter(std::unique_ptr<ui::EventTargeter>(
       new ShelfWindowTargeter(status_container, shelf_layout_manager_)));
 
+  // Forcefully paint the background after all observers have been added so they
+  // paint properly the first time.
+  background_animator_.PaintBackground(SHELF_BACKGROUND_DEFAULT,
+                                       BACKGROUND_CHANGE_IMMEDIATE);
+
   views::Widget::AddObserver(this);
 }
 
 ShelfWidget::~ShelfWidget() {
   // Must call Shutdown() before destruction.
   DCHECK(!status_area_widget_);
   Shell::GetInstance()->focus_cycler()->RemoveWidget(this);
   SetFocusCycler(nullptr);
   RemoveObserver(this);
 }
 
 void ShelfWidget::SetPaintsBackground(
     ShelfBackgroundType background_type,
     BackgroundAnimatorChangeType change_type) {
-  ui::Layer* opaque_background = delegate_view_->opaque_background();
-  float target_opacity =
-      (background_type == SHELF_BACKGROUND_MAXIMIZED) ? 1.0f : 0.0f;
-  std::unique_ptr<ui::ScopedLayerAnimationSettings> opaque_background_animation;
-  if (change_type != BACKGROUND_CHANGE_IMMEDIATE) {
-    opaque_background_animation.reset(new ui::ScopedLayerAnimationSettings(
-        opaque_background->GetAnimator()));
-    opaque_background_animation->SetTransitionDuration(
-        base::TimeDelta::FromMilliseconds(kTimeToSwitchBackgroundMs));
-  }
-  opaque_background->SetOpacity(target_opacity);
-
-  // TODO(mukai): use ui::Layer on both opaque_background and normal background
-  // retire background_animator_ at all. It would be simpler.
-  // See also DockedBackgroundWidget::SetPaintsBackground.
-  background_animator_.SetPaintsBackground(
-      background_type != SHELF_BACKGROUND_DEFAULT, change_type);
+  background_animator_.PaintBackground(background_type, change_type);
 }
 
 ShelfBackgroundType ShelfWidget::GetBackgroundType() const {
-  if (delegate_view_->opaque_background()->GetTargetOpacity() == 1.0f)
-    return SHELF_BACKGROUND_MAXIMIZED;
-  if (background_animator_.paints_background())
-    return SHELF_BACKGROUND_OVERLAP;
-
-  return SHELF_BACKGROUND_DEFAULT;
+  return background_animator_.target_background_type();
 }
 
 void ShelfWidget::HideShelfBehindBlackBar(bool hide, int animation_time_ms) {
   if (IsShelfHiddenBehindBlackBar() == hide)
     return;
 
   ui::Layer* opaque_foreground = delegate_view_->opaque_foreground();
   float target_opacity = hide ? 1.0f : 0.0f;
   std::unique_ptr<ui::ScopedLayerAnimationSettings> opaque_foreground_animation;
   opaque_foreground_animation.reset(new ui::ScopedLayerAnimationSettings(
@@ skipping 62 matching lines @@
 
 void ShelfWidget::CreateShelf(WmShelfAura* wm_shelf_aura) {
   DCHECK(!shelf_);
 
   Shell* shell = Shell::GetInstance();
   ShelfDelegate* delegate = shell->GetShelfDelegate();
   shelf_.reset(new Shelf(shell->shelf_model(), delegate, 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());
+  // TODO(bruthig): Is this the best/right place to attach the
+  // |background_animator_|? Does |background_animator_| need to be removed as
+  // an observer?
+  wm_shelf_aura->AddObserver(&background_animator_);

[James Cook, 2016/06/14 17:50:02]

Given that the items being animated are built in the ShelfWidget constructor,
maybe the observer should be added there?

If so, you could pass in WmShelf there. WmShelf exists for the lifetime of the
RootWindowController.

Also, I think the observer should be removed.

[bruthig, 2016/07/26 19:50:03]

Done.

   delegate->OnShelfCreated(shelf_.get());
 
   SetFocusCycler(shell->focus_cycler());
 }
 
 void ShelfWidget::PostCreateShelf() {
   shelf_->SetVisible(Shell::GetInstance()
                          ->session_state_delegate()
                          ->IsActiveUserSessionStarted());
   shelf_layout_manager_->LayoutShelf();
@@ skipping 23 matching lines @@
 void ShelfWidget::Shutdown() {
   // Shutting down the status area widget may cause some widgets (e.g. bubbles)
   // to close, so uninstall the ShelfLayoutManager event filters first. Don't
   // reset the pointer until later because other widgets (e.g. app list) may
   // access it later in shutdown.
   if (shelf_layout_manager_)
     shelf_layout_manager_->PrepareForShutdown();
 
   if (status_area_widget_) {
     Shell::GetInstance()->focus_cycler()->RemoveWidget(status_area_widget_);
+    background_animator_.RemoveObserver(status_area_widget_);
     status_area_widget_->Shutdown();
     status_area_widget_ = nullptr;
   }
 }
 
 void ShelfWidget::ForceUndimming(bool force) {
   delegate_view_->ForceUndimming(force);
 }
 
 void ShelfWidget::OnWidgetActivationChanged(views::Widget* widget,
@@ skipping 33 matching lines @@
     shelf_layout_manager_->UpdateAutoHideForMouseEvent(event);
 }
 
 void ShelfWidget::OnGestureEvent(ui::GestureEvent* event) {
   Widget::OnGestureEvent(event);
   if (Shell::GetInstance()->in_mus() && shelf_layout_manager_)
     shelf_layout_manager_->UpdateAutoHideForGestureEvent(event);
 }
 
 }  // namespace ash