[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 390 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());

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

Correct me if I'm wrong but there is no need for this to be set for each
WindowGrid.  IMO the WindowSelector should be defining whether to use masks or
shapes and the WindowSelectorItem can ask the WindowSelector for this
configuration instead of using statics.

Furthermore, I think we will actually run into an inconsistent state because the
WindowSelectorItem::use_mask_ and use_shape_ are defined as statics.  Consider
multiple WindowGrid instances of which the last one to be constructed only has 1
window.

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

There is since this is dependent on number of windows in each grid (to have the
corner radius correct). I will remove the masks and rounded corners at the
bottom of the window in the next CL however so this will be simplified.

   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);
 }
 
 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.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();
 }
 
 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 244 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;

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

You could consider adding a warning when the commend line specifies a value but
you don't actually use it.  Same applies below.

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

This flag was temporary scaffolding and Will be removed.

+  }
+  int windows_to_use_shapes = kUnlimited;
+  if (command_line->HasSwitch(switches::kAshMaxWindowsToUseShapeInOverview) &&

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

Consider wrapping this duplicate logic in a helper function. e.g.

int ReadCmdLineInt(int default, char[] switch);

Invoked like so:

int windows_to_use_masks = ReadCmdLineInt(kMaxWindowsCountToHideHeaderWithMasks,
switches::kAshMaxWindowsToUseMaskInOverview);

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

Ditto, will keep this in mind.

+      (!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