[ash-md] Animates overview shield in and out

ash/common/wm/overview/window_grid.cc

 // Copyright 2014 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/wm/overview/window_grid.h"
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "ash/common/ash_switches.h"
 #include "ash/common/material_design/material_design_controller.h"
+#include "ash/common/shelf/shelf_types.h"
+#include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/wm/overview/scoped_overview_animation_settings.h"
 #include "ash/common/wm/overview/scoped_overview_animation_settings_factory.h"
 #include "ash/common/wm/overview/scoped_transform_overview_window.h"
 #include "ash/common/wm/overview/window_selector.h"
+#include "ash/common/wm/overview/window_selector_delegate.h"
 #include "ash/common/wm/overview/window_selector_item.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/wm_screen_util.h"
 #include "ash/common/wm_lookup.h"
 #include "ash/common/wm_root_window_controller.h"
 #include "ash/common/wm_window.h"
 #include "base/command_line.h"
 #include "base/i18n/string_search.h"
 #include "base/memory/scoped_vector.h"
 #include "third_party/skia/include/core/SkColor.h"
@@ skipping 12 matching lines @@
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/window_animations.h"
 
 namespace ash {
 namespace {
 
 using Windows = std::vector<WmWindow*>;
 
 // An observer which holds onto the passed widget until the animation is
 // complete.
 class CleanupWidgetAfterAnimationObserver

[bruthig, 2016/07/15 17:05:38]

Although this is a pretty small class there certainly is a lot of complexity to
it.  It might be worthwhile pulling it out into it's own .h and .cc files so
that you can add some tests around it.  The tests would definitely make it
easier to understand.

[varkha, 2016/07/15 18:53:36]

Done. See if you like this better while I am putting a test together.

-    : public ui::ImplicitAnimationObserver {
+    : public ui::ImplicitAnimationObserver,
+      public DelayedAnimationObserver {
  public:
   explicit CleanupWidgetAfterAnimationObserver(
       std::unique_ptr<views::Widget> widget);
   ~CleanupWidgetAfterAnimationObserver() override;
 
   // ui::ImplicitAnimationObserver:
   void OnImplicitAnimationsCompleted() override;
 
+  // DelayedAnimationObserver:
+  void SetDelegate(WindowSelectorDelegate* delegate) override;
+  void Shutdown() override;
+
  private:
   std::unique_ptr<views::Widget> widget_;
+  WindowSelectorDelegate* delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(CleanupWidgetAfterAnimationObserver);
 };
 
 CleanupWidgetAfterAnimationObserver::CleanupWidgetAfterAnimationObserver(
     std::unique_ptr<views::Widget> widget)
-    : widget_(std::move(widget)) {}
+    : widget_(std::move(widget)), delegate_(nullptr) {}
 
 CleanupWidgetAfterAnimationObserver::~CleanupWidgetAfterAnimationObserver() {}
 
 void CleanupWidgetAfterAnimationObserver::OnImplicitAnimationsCompleted() {

[bruthig, 2016/07/15 17:05:38]

I was looking in to whether or not OnImplicitAnimationsCompleted() is guaranteed
to be called and I think there are some rare cases where it might not be.  If
you look at the ANIMATED_PROPERTY macro here
https://cs.chromium.org/chromium/src/ui/compositor/layer_animator.cc?rcl=1468...
you will see if the duration is zero and some other conditions are true, then
the property value is set directly on the delegate() and no animation is
started.  In which case I believe OnImplicitAnimationsCompleted() will never be
called.

This is clearly not something that should be addressed in this CL, but it makes
me wonder how much risk there is here.  What are your thoughts?

[varkha, 2016/07/15 18:53:36]

Animations here are non-zero duration so this is probably not a concern but
worth commenting.
I can see if there is an easy way to detect this and not pass the ownership but
we use this pattern in a few places so I am not overly concerned.

+  if (!widget_)

[bruthig, 2016/07/15 17:05:38]

Is it accurate that this check will only be true during/after Shutdown() has
been called? If so a comment would be helpful.

It might be worth adding a DCHECK(widget) in the constructor too.

[varkha, 2016/07/15 18:53:36]

Done.

+    return;
+  if (delegate_) {
+    delegate_->RemoveDelayedAnimationObserver(this);
+    return;
+  }
   delete this;
 }
 
+void CleanupWidgetAfterAnimationObserver::SetDelegate(
+    WindowSelectorDelegate* delegate) {
+  delegate_ = delegate;
+}
+
+void CleanupWidgetAfterAnimationObserver::Shutdown() {
+  widget_.reset();
+  delegate_ = nullptr;
+}
+
 // A comparator for locating a given target window.
 struct WindowSelectorItemComparator {
   explicit WindowSelectorItemComparator(const WmWindow* target_window)
       : target(target_window) {}
 
   bool operator()(WindowSelectorItem* window) const {
     return window->GetWindow() == target;
   }
 
   const WmWindow* target;
 };
 
 // Conceptually the window overview is a table or grid of cells having this
 // fixed aspect ratio. The number of columns is determined by maximizing the
 // area of them based on the number of window_list.
 const float kCardAspectRatio = 4.0f / 3.0f;
 
 // The minimum number of cards along the major axis (i.e. horizontally on a
 // landscape orientation).
 const int kMinCardsMajor = 3;
 
 const int kOverviewSelectorTransitionMilliseconds = 250;
 
 // The color and opacity of the screen shield in overview.
-const SkColor kShieldColor = SkColorSetARGB(178, 0, 0, 0);
+const SkColor kShieldColor = SkColorSetARGB(255, 0, 0, 0);
+const float kShieldOpacity = 0.7f;
 
 // The color and opacity of the overview selector.
 const SkColor kWindowSelectionColor = SkColorSetARGB(128, 0, 0, 0);
 const SkColor kWindowSelectionColorMD = SkColorSetARGB(51, 255, 255, 255);
 const SkColor kWindowSelectionBorderColor = SkColorSetARGB(38, 255, 255, 255);
 const SkColor kWindowSelectionBorderColorMD = SkColorSetARGB(76, 255, 255, 255);
 
 // Border thickness of overview selector.
 const int kWindowSelectionBorderThickness = 2;
 const int kWindowSelectionBorderThicknessMD = 1;
@@ skipping 233 matching lines @@
     }
     if (swap_index > i)
       std::swap((*items)[i], (*items)[swap_index]);
   }
 }
 
 // Creates and returns a background translucent widget parented in
 // |root_window|'s default container and having |background_color|.
 // When |border_thickness| is non-zero, a border is created having
 // |border_color|, otherwise |border_color| parameter is ignored.
+// The new background widget starts with |initial_opacity| and then fades in.
 views::Widget* CreateBackgroundWidget(WmWindow* root_window,
                                       SkColor background_color,
                                       int border_thickness,
                                       int border_radius,
-                                      SkColor border_color) {
+                                      SkColor border_color,
+                                      float initial_opacity) {
   views::Widget* widget = new views::Widget;
   views::Widget::InitParams params;
   params.type = views::Widget::InitParams::TYPE_POPUP;
   params.keep_on_top = false;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.accept_events = false;
   widget->set_focus_on_creation(false);
   // Parenting in kShellWindowId_DesktopBackgroundContainer allows proper
   // layering of the shield and selection widgets. Since that container is
@@ skipping 17 matching lines @@
     content_view->set_background(
         views::Background::CreateSolidBackground(background_color));
     if (border_thickness) {
       content_view->SetBorder(
           views::Border::CreateSolidBorder(border_thickness, border_color));
     }
   }
   widget->SetContentsView(content_view);
   widget_window->GetParent()->StackChildAtTop(widget_window);
   widget->Show();
-  // New background widget starts with 0 opacity and then fades in.
-  widget_window->SetOpacity(0.f);
+  widget_window->SetOpacity(initial_opacity);
   return widget;
 }
 
 }  // namespace
 
 WindowGrid::WindowGrid(WmWindow* root_window,
                        const std::vector<WmWindow*>& windows,
                        WindowSelector* window_selector)
     : root_window_(root_window),
       window_selector_(window_selector),
@@ skipping 18 matching lines @@
     observed_windows_.insert(window);
     window_list_.push_back(new WindowSelectorItem(window, window_selector_));
   }
 }
 
 WindowGrid::~WindowGrid() {
   for (WmWindow* window : observed_windows_)
     window->RemoveObserver(this);
 }
 
+void WindowGrid::Shutdown() {
+  if (shield_widget_) {
+    // Fade out the shield widget. This animation continues past the lifetime
+    // of |this|.
+    WmWindow* widget_window =
+        WmLookup::Get()->GetWindowForWidget(shield_widget_.get());
+    ui::ScopedLayerAnimationSettings animation_settings(
+        widget_window->GetLayer()->GetAnimator());
+    animation_settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
+        kOverviewSelectorTransitionMilliseconds));
+    animation_settings.SetTweenType(gfx::Tween::EASE_IN);
+    animation_settings.SetPreemptionStrategy(
+        ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+    // CleanupWidgetAfterAnimationObserver will delete itself (and the shield
+    // widget) when the opacity animation is complete.
+    // Ownership over the observer is passed to the window_selector_->delegate()
+    // which has longer lifetime so that animations can continue even after the
+    // overview mode is shut down.
+    views::Widget* shield_widget = shield_widget_.get();
+    std::unique_ptr<CleanupWidgetAfterAnimationObserver> observer(
+        new CleanupWidgetAfterAnimationObserver(std::move(shield_widget_)));
+    animation_settings.AddObserver(observer.get());
+    window_selector_->delegate()->AddDelayedAnimationObserver(
+        std::move(observer));
+    shield_widget->SetOpacity(0.f);
+  }
+}
+
 void WindowGrid::PrepareForOverview() {
   if (ash::MaterialDesignController::IsOverviewMaterial())
     InitShieldWidget();
   for (auto iter = window_list_.begin(); iter != window_list_.end(); ++iter)
     (*iter)->PrepareForOverview();
 }
 
 void WindowGrid::PositionWindowsMD(bool animate) {
   if (window_list_.empty())
     return;
@@ skipping 337 matching lines @@
 
   if (ash::MaterialDesignController::IsOverviewMaterial()) {
     PositionWindows(false);
     return;
   }
   // Recompute the transform for the window.
   (*iter)->RecomputeWindowTransforms();
 }
 
 void WindowGrid::InitShieldWidget() {
-  shield_widget_.reset(CreateBackgroundWidget(root_window_, kShieldColor, 0, 0,
-                                              SK_ColorTRANSPARENT));
+  // TODO(varkha): The code assumes that SHELF_BACKGROUND_MAXIMIZED is
+  // synonymous with a black shelf background. Update this code if that
+  // assumption is no longer valid.
+  const float initial_opacity =
+      (root_window_->GetRootWindowController()
+           ->GetShelf()
+           ->GetBackgroundType() == SHELF_BACKGROUND_MAXIMIZED)
+          ? 1.f
+          : 0.f;
+  shield_widget_.reset(CreateBackgroundWidget(
+      root_window_, kShieldColor, 0, 0, SK_ColorTRANSPARENT, initial_opacity));
 
   WmWindow* widget_window =
       WmLookup::Get()->GetWindowForWidget(shield_widget_.get());
   const gfx::Rect bounds = widget_window->GetParent()->GetBounds();
   widget_window->SetBounds(bounds);
 
   ui::ScopedLayerAnimationSettings animation_settings(
       widget_window->GetLayer()->GetAnimator());
   animation_settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
       kOverviewSelectorTransitionMilliseconds));
   animation_settings.SetTweenType(gfx::Tween::LINEAR_OUT_SLOW_IN);
   animation_settings.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
-  shield_widget_->SetOpacity(1.f);
+  shield_widget_->SetOpacity(kShieldOpacity);
 }
 
 void WindowGrid::InitSelectionWidget(WindowSelector::Direction direction) {
   const bool material = ash::MaterialDesignController::IsOverviewMaterial();
   const int border_thickness = material ? kWindowSelectionBorderThicknessMD
                                         : kWindowSelectionBorderThickness;
   const int border_color =
       material ? kWindowSelectionBorderColorMD : kWindowSelectionBorderColor;
   const int selection_color =
       material ? kWindowSelectionColorMD : kWindowSelectionColor;
   const int border_radius =
       material ? kWindowSelectionRadiusMD : kWindowSelectionRadius;
-  selection_widget_.reset(CreateBackgroundWidget(root_window_, selection_color,
-                                                 border_thickness,
-                                                 border_radius, border_color));
+  selection_widget_.reset(
+      CreateBackgroundWidget(root_window_, selection_color, border_thickness,
+                             border_radius, border_color, 0.f));
 
   WmWindow* widget_window =
       WmLookup::Get()->GetWindowForWidget(selection_widget_.get());
   const gfx::Rect target_bounds =
       root_window_->ConvertRectFromScreen(SelectedWindow()->target_bounds());
   gfx::Vector2d fade_out_direction =
       GetSlideVectorForFadeIn(direction, target_bounds);
   widget_window->SetBounds(target_bounds - fade_out_direction);
 }
 
@@ skipping 11 matching lines @@
     gfx::Vector2d fade_out_direction =
         GetSlideVectorForFadeIn(direction, old_selection_window->GetBounds());
 
     ui::ScopedLayerAnimationSettings animation_settings(
         old_selection_window->GetLayer()->GetAnimator());
     animation_settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
         kOverviewSelectorTransitionMilliseconds));
     animation_settings.SetPreemptionStrategy(
         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
     animation_settings.SetTweenType(gfx::Tween::FAST_OUT_LINEAR_IN);
-    // CleanupWidgetAfterAnimationObserver will delete itself (and the
-    // widget) when the movement animation is complete.
-    animation_settings.AddObserver(
+    // CleanupWidgetAfterAnimationObserver will delete itself (and the widget)
+    // when the motion animation is complete.
+    // Ownership over the observer is passed to the window_selector_->delegate()
+    // which has longer lifetime so that animations can continue even after the
+    // overview mode is shut down.
+    std::unique_ptr<CleanupWidgetAfterAnimationObserver> observer(
         new CleanupWidgetAfterAnimationObserver(std::move(selection_widget_)));
+    animation_settings.AddObserver(observer.get());
+    window_selector_->delegate()->AddDelayedAnimationObserver(
+        std::move(observer));
     old_selection->SetOpacity(0.f);
     old_selection_window->SetBounds(old_selection_window->GetBounds() +
                                     fade_out_direction);
     old_selection->Hide();
   }
   if (out_of_bounds)
     return;
 
   if (!selection_widget_)
     InitSelectionWidget(direction);
@@ skipping 90 matching lines @@
         *min_right = left;
       if (*max_right < left)
         *max_right = left;
     }
     *max_bottom = top + height;
   }
   return windows_fit;
 }
 
 }  // namespace ash