Revert of 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/aura/wm_shelf_aura.h"
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/ash_switches.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_model.h"
-#include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shelf/wm_shelf_util.h"
 #include "ash/common/shell_window_ids.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/shelf/shelf.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_util.h"
 #include "ash/shelf/shelf_view.h"
@@ skipping 48 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(BackgroundAnimator* animator, int alpha) override {
+  void UpdateBackground(int alpha) override {
     alpha_ = alpha;
     SchedulePaint();
   }
 
-  void BackgroundAnimationEnded(BackgroundAnimator* animator) 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 192 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 aura::WindowObserver,
-                                  public ShelfBackgroundAnimatorObserver {
+                                  public BackgroundAnimatorDelegate,
+                                  public aura::WindowObserver {
  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;
 
-  // ShelfBackgroundAnimatorObserver:
-  void UpdateShelfOpaqueBackground(int alpha) override;
-  void UpdateShelfAssetBackground(int alpha) override;
+  // BackgroundAnimatorDelegate overrides:
+  void UpdateBackground(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 asset_background_alpha_;
-  // TODO(bruthig): Remove opaque_background_ (see https://crbug.com/621551).
+  int alpha_;
   // 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),
-      asset_background_alpha_(0),
+      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())
-    return;
-
-  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);
+  if (MaterialDesignController::IsShelfMaterial()) {
+    canvas->FillRect(bounds(), SkColorSetA(kShelfBaseColor, alpha_));
+  } else {
+    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_);
+    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
+      // windows close to the work area is an arched gradient that blends
+      // vertically oriented docked background and horizontal shelf.
+      gfx::ImageSkia shelf_corner =
+          *rb->GetImageSkiaNamed(IDR_ASH_SHELF_CORNER);
+      if (dock_bounds.x() == 0) {
+        shelf_corner = gfx::ImageSkiaOperations::CreateRotatedImage(
+            shelf_corner, SkBitmapOperations::ROTATION_90_CW);
+      }
+      canvas->DrawImageInt(shelf_corner, 0, 0, shelf_corner.width(),
+                           shelf_corner.height(),
+                           dock_bounds.x() > 0 ? dock_bounds.x()
+                                               : dock_bounds.width() - height(),
+                           0, height(), height(), false, paint);
+      // The part of the shelf background that is just below the docked windows
+      // is drawn using the last (lowest) 1-pixel tall strip of the image asset.
+      // This avoids showing the border 3D shadow between the shelf and the
+      // dock.
+      canvas->DrawImageInt(shelf_background, 0, shelf_background.height() - 1,
+                           shelf_background.width(), 1,
+                           dock_bounds.x() > 0 ? dock_bounds.x() + height() : 0,
+                           0, dock_bounds.width() - height(), height(), false,
+                           paint);
+    }
+    gfx::Rect black_rect =
+        shelf_->shelf_layout_manager()->SelectValueForShelfAlignment(
+            gfx::Rect(0, height() - kNumBlackPixels, width(), kNumBlackPixels),
+            gfx::Rect(0, 0, kNumBlackPixels, height()),
+            gfx::Rect(width() - kNumBlackPixels, 0, kNumBlackPixels, height()));
+    canvas->FillRect(black_rect, SK_ColorBLACK);
   }
-  const gfx::Rect dock_bounds(shelf_->shelf_layout_manager()->dock_bounds());
-  SkPaint paint;
-  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
-    // windows close to the work area is an arched gradient that blends
-    // vertically oriented docked background and horizontal shelf.
-    gfx::ImageSkia shelf_corner = *rb->GetImageSkiaNamed(IDR_ASH_SHELF_CORNER);
-    if (dock_bounds.x() == 0) {
-      shelf_corner = gfx::ImageSkiaOperations::CreateRotatedImage(
-          shelf_corner, SkBitmapOperations::ROTATION_90_CW);
-    }
-    canvas->DrawImageInt(
-        shelf_corner, 0, 0, shelf_corner.width(), shelf_corner.height(),
-        dock_bounds.x() > 0 ? dock_bounds.x() : dock_bounds.width() - height(),
-        0, height(), height(), false, paint);
-    // The part of the shelf background that is just below the docked windows
-    // is drawn using the last (lowest) 1-pixel tall strip of the image asset.
-    // This avoids showing the border 3D shadow between the shelf and the
-    // dock.
-    canvas->DrawImageInt(shelf_background, 0, shelf_background.height() - 1,
-                         shelf_background.width(), 1,
-                         dock_bounds.x() > 0 ? dock_bounds.x() + height() : 0,
-                         0, dock_bounds.width() - height(), height(), false,
-                         paint);
-  }
-  gfx::Rect black_rect =
-      shelf_->shelf_layout_manager()->SelectValueForShelfAlignment(
-          gfx::Rect(0, height() - kNumBlackPixels, width(), kNumBlackPixels),
-          gfx::Rect(0, 0, kNumBlackPixels, height()),
-          gfx::Rect(width() - kNumBlackPixels, 0, kNumBlackPixels, height()));
-  canvas->FillRect(black_rect, SK_ColorBLACK);
 }
 
 bool ShelfWidget::DelegateView::CanActivate() const {
   // Allow to activate as fallback.
   if (shelf_->activating_as_fallback_)
     return true;
   // Allow to activate from the focus cycler.
   if (focus_cycler_ && focus_cycler_->widget_activating() == GetWidget())
     return true;
   // Disallow activating in other cases, especially when using mouse.
@@ skipping 33 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::UpdateShelfOpaqueBackground(int alpha) {
-  const float kMaxAlpha = 255.0f;
-  opaque_background_.SetOpacity(alpha / kMaxAlpha);
-}
-
-void ShelfWidget::DelegateView::UpdateShelfAssetBackground(int alpha) {
-  asset_background_alpha_ = alpha;
+void ShelfWidget::DelegateView::UpdateBackground(int alpha) {
+  alpha_ = alpha;
   SchedulePaint();
 }
 
 ShelfWidget::ShelfWidget(WmWindow* wm_shelf_container,
                          WmWindow* wm_status_container,
                          WmShelfAura* wm_shelf_aura,
                          WorkspaceController* workspace_controller)
-    : wm_shelf_aura_(wm_shelf_aura),
-      delegate_view_(new DelegateView(this)),
-      background_animator_(SHELF_BACKGROUND_DEFAULT, wm_shelf_aura_),
+    : delegate_view_(new DelegateView(this)),
+      background_animator_(delegate_view_,
+                           0,
+                           GetShelfConstant(SHELF_BACKGROUND_ALPHA)),
       activating_as_fallback_(false) {
-  background_animator_.AddObserver(delegate_view_);
-
   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_.PaintBackground(
-      shelf_layout_manager_->GetShelfBackgroundType(),
-      BACKGROUND_CHANGE_IMMEDIATE);
-  wm_shelf_aura_->SetShelfLayoutManager(shelf_layout_manager_);
+  wm_shelf_aura->SetShelfLayoutManager(shelf_layout_manager_);
 
   // TODO(jamescook): Move ownership to RootWindowController.
   status_area_widget_ =
-      new StatusAreaWidget(wm_status_container, wm_shelf_aura_);
+      new StatusAreaWidget(wm_status_container, wm_shelf_aura);
   status_area_widget_->CreateTrayViews();
   if (WmShell::Get()->GetSessionStateDelegate()->IsActiveUserSessionStarted())
     status_area_widget_->Show();
   WmShell::Get()->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_)));
 
   views::Widget::AddObserver(this);
 }
 
 ShelfWidget::~ShelfWidget() {
   // Must call Shutdown() before destruction.
   DCHECK(!status_area_widget_);
   WmShell::Get()->focus_cycler()->RemoveWidget(this);
   SetFocusCycler(nullptr);
   RemoveObserver(this);
-  background_animator_.RemoveObserver(delegate_view_);
 }
 
 void ShelfWidget::SetPaintsBackground(
     ShelfBackgroundType background_type,
     BackgroundAnimatorChangeType change_type) {
-  background_animator_.PaintBackground(background_type, 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);
 }
 
 ShelfBackgroundType ShelfWidget::GetBackgroundType() const {
-  return background_animator_.target_background_type();
+  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;
 }
 
 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(
@@ skipping 53 matching lines @@
   // status area background, app list button and overflow button.
   if (shelf_)
     shelf_->SchedulePaint();
   status_area_widget_->SchedulePaint();
 }
 
 bool ShelfWidget::GetDimsShelf() const {
   return delegate_view_->GetDimmed();
 }
 
-void ShelfWidget::CreateShelf() {
+void ShelfWidget::CreateShelf(WmShelfAura* wm_shelf_aura) {
   DCHECK(!shelf_);
 
-  shelf_.reset(new Shelf(WmShell::Get()->shelf_model(), wm_shelf_aura_, this,
-                         &background_animator_));
+  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());
+  wm_shelf_aura->SetShelf(shelf_.get());
   WmShell::Get()->shelf_delegate()->OnShelfCreated(shelf_.get());
 
   SetFocusCycler(WmShell::Get()->focus_cycler());
 }
 
 void ShelfWidget::PostCreateShelf() {
   shelf_->SetVisible(
       WmShell::Get()->GetSessionStateDelegate()->IsActiveUserSessionStarted());
   shelf_layout_manager_->LayoutShelf();
   shelf_layout_manager_->UpdateAutoHideState();
@@ skipping 21 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_) {
-    background_animator_.RemoveObserver(status_area_widget_);
     WmShell::Get()->focus_cycler()->RemoveWidget(status_area_widget_);
     status_area_widget_->Shutdown();
     status_area_widget_ = nullptr;
   }
 }
 
 void ShelfWidget::ForceUndimming(bool force) {
   delegate_view_->ForceUndimming(force);
 }
 
@@ skipping 34 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