[ash-md] Fades overview header 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>
@@ skipping 392 matching lines @@
   }
 
   if (!ash::MaterialDesignController::IsOverviewMaterial() &&
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshEnableStableOverviewOrder)) {
     // Reorder windows to try to minimize movement to target overview positions.
     // This also creates a stable window ordering.
     ReorderItemsGreedyLeastMovement(&windows_in_root, root_window_,
                                     window_selector_->text_filter_bottom());
   }
+  PrepareForUsingMasksOrShapes(windows_in_root.size());
   for (auto* window : windows_in_root) {
     window_observer_.Add(window);
     window_list_.push_back(new WindowSelectorItem(window, window_selector_));
   }
 }
 
 WindowGrid::~WindowGrid() {}
 
 void WindowGrid::Shutdown() {
+  for (auto iter = window_list_.begin(); iter != window_list_.end(); ++iter)
+    (*iter)->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.SetTweenType(gfx::Tween::EASE_IN_2);
     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();
   prepared_for_overview_ = true;
 }
 
 void WindowGrid::PositionWindowsMD(bool animate) {
   if (window_list_.empty())
     return;
-
-  const int kUnlimited = -1;
-  const size_t windows_count = window_list_.size();
-  const base::CommandLine* command_line =
-      base::CommandLine::ForCurrentProcess();
-  int windows_to_use_masks = kMaxWindowsCountToHideHeaderWithMasks;
-  if (command_line->HasSwitch(switches::kAshMaxWindowsToUseMaskInOverview) &&
-      (!base::StringToInt(command_line->GetSwitchValueASCII(
-                              switches::kAshMaxWindowsToUseMaskInOverview),
-                          &windows_to_use_masks) ||
-       windows_to_use_masks <= kUnlimited)) {
-    windows_to_use_masks = kMaxWindowsCountToHideHeaderWithMasks;
-  }
-  int windows_to_use_shapes = kUnlimited;
-  if (command_line->HasSwitch(switches::kAshMaxWindowsToUseShapeInOverview) &&
-      (!base::StringToInt(command_line->GetSwitchValueASCII(
-                              switches::kAshMaxWindowsToUseShapeInOverview),
-                          &windows_to_use_shapes) ||
-       windows_to_use_shapes <= kUnlimited)) {
-    windows_to_use_shapes = kUnlimited;
-  }
-  WindowSelectorItem::set_use_mask(windows_to_use_masks <= kUnlimited ||
-                                   static_cast<int>(windows_count) <=
-                                       windows_to_use_masks);
-  WindowSelectorItem::set_use_shape(windows_to_use_shapes <= kUnlimited ||
-                                    static_cast<int>(windows_count) <=
-                                        windows_to_use_shapes);
-
+  PrepareForUsingMasksOrShapes(window_list_.size());
   gfx::Rect total_bounds =
       root_window_->ConvertRectToScreen(wm::GetDisplayWorkAreaBoundsInParent(
           root_window_->GetChildByShellWindowId(
               kShellWindowId_DefaultContainer)));
   // Windows occupy vertically centered area with additional vertical insets.
   int horizontal_inset =
       gfx::ToFlooredInt(std::min(kOverviewInsetRatio * total_bounds.width(),
                                  kOverviewInsetRatio * total_bounds.height()));
   int vertical_inset =
       horizontal_inset +
@@ skipping 88 matching lines @@
   // |right_bound| was reverted. Perform one last pass to position the |rects|.
   if (make_last_adjustment) {
     gfx::Rect overview_bounds(total_bounds);
     overview_bounds.set_width(right_bound - total_bounds.x());
     FitWindowRectsInBounds(overview_bounds,
                            std::min(kMaxHeight + 2 * kWindowMarginMD, height),
                            &rects, &max_bottom, &min_right, &max_right);
   }
   // Position the windows centering the left-aligned rows vertically.
   gfx::Vector2d offset(0, (total_bounds.bottom() - max_bottom) / 2);
-  for (size_t i = 0; i < windows_count; ++i) {
+  for (size_t i = 0; i < window_list_.size(); ++i) {
     window_list_[i]->SetBounds(
         rects[i] + offset,
         animate
             ? OverviewAnimationType::OVERVIEW_ANIMATION_LAY_OUT_SELECTOR_ITEMS
             : OverviewAnimationType::OVERVIEW_ANIMATION_NONE);
   }
 
   // If the selection widget is active, reposition it without any animation.
   if (selection_widget_)
     MoveSelectionWidgetToTarget(animate);
@@ skipping 248 matching lines @@
   WmWindow* widget_window =
       WmLookup::Get()->GetWindowForWidget(shield_widget_.get());
   const gfx::Rect bounds = widget_window->GetParent()->GetBounds();
   widget_window->SetBounds(bounds);
   widget_window->SetName("OverviewModeShield");
 
   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.SetTweenType(gfx::Tween::EASE_IN);
   animation_settings.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   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 =
@@ skipping 179 matching lines @@
       if (*min_right > left)
         *min_right = left;
       if (*max_right < left)
         *max_right = left;
     }
     *max_bottom = top + height;
   }
   return windows_fit;
 }
 
+void WindowGrid::PrepareForUsingMasksOrShapes(size_t windows_count) const {
+  const int kUnlimited = -1;
+  const base::CommandLine* command_line =
+      base::CommandLine::ForCurrentProcess();
+  int windows_to_use_masks = kMaxWindowsCountToHideHeaderWithMasks;
+  if (command_line->HasSwitch(switches::kAshMaxWindowsToUseMaskInOverview) &&
+      (!base::StringToInt(command_line->GetSwitchValueASCII(
+                              switches::kAshMaxWindowsToUseMaskInOverview),
+                          &windows_to_use_masks) ||
+       windows_to_use_masks <= kUnlimited)) {
+    windows_to_use_masks = kMaxWindowsCountToHideHeaderWithMasks;
+  }
+  int windows_to_use_shapes = kUnlimited;
+  if (command_line->HasSwitch(switches::kAshMaxWindowsToUseShapeInOverview) &&
+      (!base::StringToInt(command_line->GetSwitchValueASCII(
+                              switches::kAshMaxWindowsToUseShapeInOverview),
+                          &windows_to_use_shapes) ||
+       windows_to_use_shapes <= kUnlimited)) {
+    windows_to_use_shapes = kUnlimited;
+  }
+  WindowSelectorItem::set_use_mask(windows_to_use_masks <= kUnlimited ||
+                                   static_cast<int>(windows_count) <=
+                                       windows_to_use_masks);
+  WindowSelectorItem::set_use_shape(windows_to_use_shapes <= kUnlimited ||
+                                    static_cast<int>(windows_count) <=
+                                        windows_to_use_shapes);
+}
+
 }  // namespace ash