[ash-md] Fades overview header in and out

ash/common/wm/overview/window_selector_item.cc

 // Copyright 2013 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_selector_item.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/metrics/user_metrics_action.h"
 #include "ash/common/shell_window_ids.h"
+#include "ash/common/wm/overview/cleanup_animation_observer.h"
 #include "ash/common/wm/overview/overview_animation_type.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_controller.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm_lookup.h"
 #include "ash/common/wm_root_window_controller.h"
 #include "ash/common/wm_shell.h"
@@ skipping 38 matching lines @@
 static const int kWindowSelectorMargin = kWindowMarginMD * 2;
 
 // Foreground label color.
 static const SkColor kLabelColor = SK_ColorWHITE;
 
 // TODO(tdanderson): Move this to a central location.
 static const SkColor kCloseButtonColor = SK_ColorWHITE;
 
 // Label background color used with Material Design.
 // TODO(varkha): Make background color conform to window header.
-static const SkColor kLabelBackgroundColor = SkColorSetARGB(25, 255, 255, 255);
+static const SkColor kLabelBackgroundColor = SkColorSetARGB(254, 225, 225, 225);
 
 // Corner radius for the selection tiles used with Material Design.
 static int kLabelBackgroundRadius = 2;
 
 // Label shadow color.
 static const SkColor kLabelShadow = SkColorSetARGB(176, 0, 0, 0);
 
 // Vertical padding for the label, on top of it.
 static const int kVerticalLabelPadding = 20;
 
 // Horizontal padding for the label, on both sides. Used with Material Design.
 static const int kHorizontalLabelPaddingMD = 8;
 
 // Solid shadow length from the label
 static const int kVerticalShadowOffset = 1;
 
 // Amount of blur applied to the label shadow
 static const int kShadowBlur = 10;
 
 // Height of an item header in Material Design.
 static const int kHeaderHeight = 32;
 
 // Opacity for dimmed items.
 static const float kDimmedItemOpacity = 0.5f;
 
 // Opacity for fading out during closing a window.
 static const float kClosingItemOpacity = 0.8f;
 
+// Opacity for the item header.
+static const float kHeaderOpacity = 0.2f;
+
 // Duration of background opacity transition for the selected label.
 static const int kSelectorFadeInMilliseconds = 350;
 
+// The time duration for fade out animations when exiting overview mode.
+const int kTransitionMilliseconds = 300;

[bruthig, 2016/08/30 17:57:33]

Should this have 'static' just like the rest of the consts?

[varkha, 2016/09/02 11:22:51]

Done.

+
 // Before closing a window animate both the window and the caption to shrink by
 // this fraction of size.
 static const float kPreCloseScale = 0.02f;
 
 // Convenience method to fade in a Window with predefined animation settings.
 // Note: The fade in animation will occur after a delay where the delay is how
 // long the lay out animations take.
 void SetupFadeInAfterLayout(views::Widget* widget) {
   WmWindow* window = WmLookup::Get()->GetWindowForWidget(widget);
   window->SetOpacity(0.0f);
   std::unique_ptr<ScopedOverviewAnimationSettings>
       scoped_overview_animation_settings =
           ScopedOverviewAnimationSettingsFactory::Get()
               ->CreateOverviewAnimationSettings(
                   OverviewAnimationType::
                       OVERVIEW_ANIMATION_ENTER_OVERVIEW_MODE_FADE_IN,
                   window);
   window->SetOpacity(1.0f);
 }
 
+void SetupOpacityAfterLayout(views::Widget* widget) {
+  WmWindow* window = WmLookup::Get()->GetWindowForWidget(widget);
+  std::unique_ptr<ScopedOverviewAnimationSettings>
+      scoped_overview_animation_settings =
+          ScopedOverviewAnimationSettingsFactory::Get()
+              ->CreateOverviewAnimationSettings(
+                  OverviewAnimationType::OVERVIEW_ANIMATION_FADE_IN_HEADER,
+                  window);
+  window->SetOpacity(kHeaderOpacity);
+}
+
 // An image button with a close window icon.
 class OverviewCloseButton : public views::ImageButton {
  public:
   explicit OverviewCloseButton(views::ButtonListener* listener);
   ~OverviewCloseButton() override;
 
  private:
   gfx::ImageSkia icon_image_;
 
   DISALLOW_COPY_AND_ASSIGN(OverviewCloseButton);
@@ skipping 125 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(CaptionContainerView);
 };
 
 WindowSelectorItem::WindowSelectorItem(WmWindow* window,
                                        WindowSelector* window_selector)
     : dimmed_(false),
       root_window_(window->GetRootWindow()),
       transform_window_(window),
       in_bounds_update_(false),
+      selected_(false),
+      first_time_(true),
       caption_container_view_(nullptr),
       window_label_button_view_(nullptr),
       close_button_(new OverviewCloseButton(this)),
       window_selector_(window_selector) {
   CreateWindowLabel(window->GetTitle());
   if (!ash::MaterialDesignController::IsOverviewMaterial()) {
     views::Widget::InitParams params;
     params.type = views::Widget::InitParams::TYPE_POPUP;
     params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
     params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
@@ skipping 24 matching lines @@
 WindowSelectorItem::~WindowSelectorItem() {
   GetWindow()->RemoveObserver(this);
 }
 
 WmWindow* WindowSelectorItem::GetWindow() {
   return transform_window_.window();
 }
 
 void WindowSelectorItem::RestoreWindow() {
   transform_window_.RestoreWindow();
+  UpdateHeaderLayout(
+      OverviewAnimationType::OVERVIEW_ANIMATION_LAY_OUT_SELECTOR_ITEMS);
+  FadeOut(std::move(window_label_));
+  if (window_label_selector_)
+    FadeOut(std::move(window_label_selector_));
 }
 
 void WindowSelectorItem::ShowWindowOnExit() {
   transform_window_.ShowWindowOnExit();
 }
 
 void WindowSelectorItem::PrepareForOverview() {
   transform_window_.PrepareForOverview();
 }
 
@@ skipping 18 matching lines @@
   // SetItemBounds is called before UpdateHeaderLayout so the header can
   // properly use the updated windows bounds.
   UpdateHeaderLayout(animation_type);
   if (!ash::MaterialDesignController::IsOverviewMaterial())
     UpdateWindowLabel(target_bounds, animation_type);
 }
 
 void WindowSelectorItem::SetSelected(bool selected) {
   if (!ash::MaterialDesignController::IsOverviewMaterial())
     return;
+  selected_ = selected;
   WmWindow* window =
       WmLookup::Get()->GetWindowForWidget(window_label_selector_.get());
   ui::ScopedLayerAnimationSettings animation_settings(
       window->GetLayer()->GetAnimator());
   animation_settings.SetTransitionDuration(
       base::TimeDelta::FromMilliseconds(kSelectorFadeInMilliseconds));
   animation_settings.SetTweenType(selected ? gfx::Tween::FAST_OUT_LINEAR_IN
                                            : gfx::Tween::LINEAR_OUT_SLOW_IN);
   animation_settings.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
-  window->SetOpacity(selected ? 0.0f : 1.0f);
+  window->SetOpacity(selected ? 0.0f : kHeaderOpacity);
 
   ui::ScopedLayerAnimationSettings animation_settings_shadow(
       shadow_->shadow_layer()->GetAnimator());
   animation_settings_shadow.SetTransitionDuration(
       base::TimeDelta::FromMilliseconds(kSelectorFadeInMilliseconds));
   animation_settings_shadow.SetTweenType(selected
                                              ? gfx::Tween::FAST_OUT_LINEAR_IN
                                              : gfx::Tween::LINEAR_OUT_SLOW_IN);
   animation_settings_shadow.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
@@ skipping 100 matching lines @@
           screen_rect, target_bounds, top_view_inset, title_height);
   gfx::Transform transform = ScopedTransformOverviewWindow::GetTransformForRect(
       screen_rect, selector_item_bounds);
   ScopedTransformOverviewWindow::ScopedAnimationSettings animation_settings;
   transform_window_.BeginScopedAnimation(animation_type, &animation_settings);
   // Rounded corners are achieved by using a mask layer on the original window
   // before the transform. Dividing by scale factor obtains the corner radius
   // which when scaled will yield |kLabelBackgroundRadius|.
   transform_window_.SetTransform(
       root_window_, transform, use_mask_, use_shape_,
-      (kLabelBackgroundRadius / GetItemScale(target_bounds.size())));
+      (kLabelBackgroundRadius / GetItemScale(target_bounds.size())),
+      animation_type != OverviewAnimationType::OVERVIEW_ANIMATION_NONE);
   transform_window_.set_overview_transform(transform);
 }
 
 void WindowSelectorItem::SetOpacity(float opacity) {
   window_label_->SetOpacity(opacity);
+  if (window_label_selector_) {
+    window_label_selector_->SetOpacity(selected_ ? 0.f
+                                                 : kHeaderOpacity * opacity);
+  }
+
   if (!ash::MaterialDesignController::IsOverviewMaterial())
     close_button_widget_->SetOpacity(opacity);
 
   transform_window_.SetOpacity(opacity);
 }
 
 void WindowSelectorItem::UpdateWindowLabel(
     const gfx::Rect& window_bounds,
     OverviewAnimationType animation_type) {
   if (!window_label_->IsVisible()) {
@@ skipping 10 matching lines @@
               animation_type,
               WmLookup::Get()->GetWindowForWidget(window_label_.get()));
 
   WmWindow* window_label_window =
       WmLookup::Get()->GetWindowForWidget(window_label_.get());
   window_label_window->SetBounds(label_bounds);
 }
 
 void WindowSelectorItem::CreateWindowLabel(const base::string16& title) {
   const bool material = ash::MaterialDesignController::IsOverviewMaterial();
-  window_label_.reset(new views::Widget);
   views::Widget::InitParams params;
   params.type = views::Widget::InitParams::TYPE_POPUP;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.visible_on_all_workspaces = true;
   params.name = "OverviewModeLabel";
-  window_label_->set_focus_on_creation(false);
   root_window_->GetRootWindowController()
       ->ConfigureWidgetInitParamsForContainer(
           window_label_.get(), kShellWindowId_StatusContainer, &params);
+
+  if (material) {
+    views::View* background_view =
+        new RoundedContainerView(kLabelBackgroundRadius, kLabelBackgroundColor);
+    window_label_selector_.reset(new views::Widget);
+    params.activatable = views::Widget::InitParams::Activatable::ACTIVATABLE_NO;

[bruthig, 2016/08/30 17:57:33]

I feel like re-using |params| like this creates more risk than what it's worth.
e.g. If this block overwrites an attribute set in
ConfigureWidgetInitParamsForContainer() but it never gets reset below.  It would
be much safer, and future proof to create a copy of |params| here and modify the
copy as needed.

[varkha, 2016/09/02 11:22:51]

I've managed to kill the second widget with some rework. PTAL.

+    params.accept_events = false;
+    window_label_selector_->Init(params);
+    window_label_selector_->set_focus_on_creation(false);
+    window_label_selector_->SetContentsView(background_view);
+    window_label_selector_->Show();
+  }
+
+  params.activatable =
+      views::Widget::InitParams::Activatable::ACTIVATABLE_DEFAULT;
+  params.accept_events = true;
+  params.name = "OverviewModeLabelSelector";
+  window_label_.reset(new views::Widget);
+  window_label_->set_focus_on_creation(false);
   window_label_->Init(params);
   window_label_button_view_ = new OverviewLabelButton(this, title);
   window_label_button_view_->SetBorder(views::Border::NullBorder());
   window_label_button_view_->SetEnabledTextColors(kLabelColor);
   window_label_button_view_->set_animate_on_state_change(false);
   if (material) {
     window_label_button_view_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
   } else {
     window_label_button_view_->SetHorizontalAlignment(gfx::ALIGN_CENTER);
     window_label_button_view_->SetTextShadows(gfx::ShadowValues(
@@ skipping 11 matching lines @@
         new CaptionContainerView(window_label_button_view_, close_button_);
     window_label_->SetContentsView(caption_container_view_);
     window_label_button_view_->SetVisible(false);
     window_label_->Show();
 
     shadow_.reset(new ::wm::Shadow());
     shadow_->Init(::wm::Shadow::STYLE_INACTIVE);
     shadow_->layer()->SetVisible(true);
     window_label_->GetLayer()->Add(shadow_->layer());
     window_label_->GetLayer()->SetMasksToBounds(false);
-
-    views::View* background_view =
-        new RoundedContainerView(kLabelBackgroundRadius, kLabelBackgroundColor);
-    window_label_selector_.reset(new views::Widget);
-    params.activatable = views::Widget::InitParams::Activatable::ACTIVATABLE_NO;
-    params.accept_events = false;
-    params.name = "OverviewModeLabelSelector";
-    window_label_selector_->Init(params);
-    window_label_selector_->set_focus_on_creation(false);
-    window_label_selector_->SetContentsView(background_view);
-    window_label_selector_->Show();
+    UpdateHeaderLayout(OverviewAnimationType::OVERVIEW_ANIMATION_NONE);
   } else {
     // Indicate that the label will be drawn onto a transparent background
     // (disables subpixel antialiasing).
     window_label_button_view_->SetBackgroundColorHint(SK_ColorTRANSPARENT);
     window_label_->SetContentsView(window_label_button_view_);
   }
+  first_time_ = false;
 }
 
 void WindowSelectorItem::UpdateHeaderLayout(
     OverviewAnimationType animation_type) {
   gfx::Rect transformed_window_bounds = root_window_->ConvertRectFromScreen(
       transform_window_.GetTransformedBounds(hide_header()));
 
   if (ash::MaterialDesignController::IsOverviewMaterial()) {
     gfx::Rect label_rect(close_button_->GetPreferredSize());
-    label_rect.set_y(-label_rect.height());
+    if (first_time_) {
+      if (transform_window_.GetTopInset() == 0) {
+        label_rect.set_y(0);
+        label_rect.set_height(0);
+      } else {
+        label_rect.set_y(-transform_window_.GetTopInset());
+      }
+    } else {
+      label_rect.set_y(-label_rect.height());
+    }
     label_rect.set_width(transformed_window_bounds.width());
 
     if (!window_label_button_view_->visible()) {
       window_label_button_view_->SetVisible(true);
       SetupFadeInAfterLayout(window_label_.get());
       SetupFadeInAfterLayout(window_label_selector_.get());
+      SetupOpacityAfterLayout(window_label_selector_.get());
     }
     WmWindow* window_label_window =
         WmLookup::Get()->GetWindowForWidget(window_label_.get());
     WmWindow* window_label_selector_window =
         WmLookup::Get()->GetWindowForWidget(window_label_selector_.get());
     std::unique_ptr<ScopedOverviewAnimationSettings> animation_settings =
         ScopedOverviewAnimationSettingsFactory::Get()
             ->CreateOverviewAnimationSettings(animation_type,
                                               window_label_window);
     std::unique_ptr<ScopedOverviewAnimationSettings>
@@ skipping 38 matching lines @@
 }
 
 void WindowSelectorItem::AnimateOpacity(float opacity,
                                         OverviewAnimationType animation_type) {
   DCHECK_GE(opacity, 0.f);
   DCHECK_LE(opacity, 1.f);
   ScopedTransformOverviewWindow::ScopedAnimationSettings animation_settings;
   transform_window_.BeginScopedAnimation(animation_type, &animation_settings);
   transform_window_.SetOpacity(opacity);
 
+  const float header_opacity = selected_ ? 0.f : kHeaderOpacity * opacity;
   WmWindow* window_label_window =
       WmLookup::Get()->GetWindowForWidget(window_label_.get());
   std::unique_ptr<ScopedOverviewAnimationSettings> animation_settings_label =
       ScopedOverviewAnimationSettingsFactory::Get()
           ->CreateOverviewAnimationSettings(animation_type,
                                             window_label_window);
-  window_label_window->SetOpacity(opacity);
+  window_label_window->SetOpacity(header_opacity);
 
   WmWindow* window_label_selector_window =
       WmLookup::Get()->GetWindowForWidget(window_label_selector_.get());
   std::unique_ptr<ScopedOverviewAnimationSettings> animation_settings_selector =
       ScopedOverviewAnimationSettingsFactory::Get()
           ->CreateOverviewAnimationSettings(animation_type,
                                             window_label_selector_window);
-  window_label_selector_window->SetOpacity(opacity);
+  window_label_selector_window->SetOpacity(header_opacity);
 }
 
 void WindowSelectorItem::UpdateCloseButtonAccessibilityName() {
   close_button_->SetAccessibleName(l10n_util::GetStringFUTF16(
       IDS_ASH_OVERVIEW_CLOSE_ITEM_BUTTON_ACCESSIBLE_NAME,
       GetWindow()->GetTitle()));
 }
 
+void WindowSelectorItem::FadeOut(std::unique_ptr<views::Widget> widget) {
+  widget->SetOpacity(1.f);
+
+  // Fade out the widget. This animation continues past the lifetime of |this|.
+  WmWindow* widget_window = WmLookup::Get()->GetWindowForWidget(widget.get());
+  ui::ScopedLayerAnimationSettings animation_settings(

[bruthig, 2016/08/30 17:57:33]

For consistency, would it make more sense to add an OverviewAnimationType and
use a ScopedOverviewAnimationSettingsAura object here instead?

Maybe we need to add a
ScopedOverviewAnimationSettings::AddObserver(ImplicitAnimationObserver*
observer) method.

[varkha, 2016/09/02 11:22:51]

Yes, will do.

+      widget_window->GetLayer()->GetAnimator());
+  animation_settings.SetTransitionDuration(
+      base::TimeDelta::FromMilliseconds(kTransitionMilliseconds));
+  animation_settings.SetTweenType(gfx::Tween::EASE_OUT);
+  animation_settings.SetPreemptionStrategy(
+      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+  // CleanupAnimationObserver will delete itself (and the 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* widget_ptr = widget.get();
+  std::unique_ptr<CleanupAnimationObserver> observer(
+      new CleanupAnimationObserver(std::move(widget)));
+  animation_settings.AddObserver(observer.get());
+  window_selector_->delegate()->AddDelayedAnimationObserver(
+      std::move(observer));
+  widget_ptr->SetOpacity(0.f);
+}
+
 }  // namespace ash