[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_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"
@@ skipping 67 matching lines @@
 // 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 16 matching lines @@
   for (auto* window : windows_in_root) {
     window->AddObserver(this);
     observed_windows_.insert(window);
     window_list_.push_back(new WindowSelectorItem(window, window_selector_));
   }
 }
 
 WindowGrid::~WindowGrid() {
   for (WmWindow* window : observed_windows_)
     window->RemoveObserver(this);
+
+  // 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.
+  views::Widget* shield_widget = shield_widget_.get();
+  animation_settings.AddObserver(
+      new CleanupWidgetAfterAnimationObserver(std::move(shield_widget_)));
+  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) {
@@ skipping 339 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));
+  const float initial_opacity =
+      (root_window_->GetRootWindowController()
+           ->GetShelf()
+           ->GetBackgroundType() == SHELF_BACKGROUND_MAXIMIZED)

[bruthig, 2016/07/12 20:43:37]

nit: This is currently based on some assumptions in the shelf implementation,
e.g. the shelf is black in MAXIMIZED mode.  This assumption will change when we
colour the shelf based on the wallpaper.  I think we can defer a solution that
uses the same source colour until later but I think this warrants a TODO
breadcrumb somewhere in this file.

[varkha, 2016/07/12 20:50:09]

Done.

+          ? 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 125 matching lines @@
         *min_right = left;
       if (*max_right < left)
         *max_right = left;
     }
     *max_bottom = top + height;
   }
   return windows_fit;
 }
 
 }  // namespace ash