[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/cleanup_animation_observer.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 11 matching lines @@
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/shadow.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
-    : public ui::ImplicitAnimationObserver {
- public:
-  explicit CleanupWidgetAfterAnimationObserver(
-      std::unique_ptr<views::Widget> widget);
-  ~CleanupWidgetAfterAnimationObserver() override;
-
-  // ui::ImplicitAnimationObserver:
-  void OnImplicitAnimationsCompleted() override;
-
- private:
-  std::unique_ptr<views::Widget> widget_;
-
-  DISALLOW_COPY_AND_ASSIGN(CleanupWidgetAfterAnimationObserver);
-};
-
-CleanupWidgetAfterAnimationObserver::CleanupWidgetAfterAnimationObserver(
-    std::unique_ptr<views::Widget> widget)
-    : widget_(std::move(widget)) {}
-
-CleanupWidgetAfterAnimationObserver::~CleanupWidgetAfterAnimationObserver() {}
-
-void CleanupWidgetAfterAnimationObserver::OnImplicitAnimationsCompleted() {
-  delete this;
-}
-
 // 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);
+    // CleanupAnimationObserver 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<CleanupAnimationObserver> observer(
+        new CleanupAnimationObserver(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 338 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);
 
   if (material) {
     selector_shadow_.reset(new ::wm::Shadow());
@@ skipping 19 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(
-        new CleanupWidgetAfterAnimationObserver(std::move(selection_widget_)));
+    // CleanupAnimationObserver 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<CleanupAnimationObserver> observer(
+        new CleanupAnimationObserver(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 112 matching lines @@
         *min_right = left;
       if (*max_right < left)
         *max_right = left;
     }
     *max_bottom = top + height;
   }
   return windows_fit;
 }
 
 }  // namespace ash