[ash-md] Improves smoothness with many windows in overview

ash/common/wm/overview/scoped_transform_overview_window.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/scoped_transform_overview_window.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/common/material_design/material_design_controller.h"
@@ skipping 162 matching lines @@
       TransientDescendantIterator(GetTransientRoot(window)));
 }
 
 }  // namespace
 
 // Mask layer that clips the window's original header in overview mode.
 // Only used with Material Design.
 class ScopedTransformOverviewWindow::OverviewContentMask
     : public ui::LayerDelegate {
  public:
-  explicit OverviewContentMask(float radius);
+  explicit OverviewContentMask();
   ~OverviewContentMask() override;
 
   void set_radius(float radius) { radius_ = radius; }
+  void set_inset(int inset) { inset_ = inset; }
   ui::Layer* layer() { return &layer_; }
 
   // Overridden from LayerDelegate.
   void OnPaintLayer(const ui::PaintContext& context) override;
   void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
   void OnDeviceScaleFactorChanged(float device_scale_factor) override;
   base::Closure PrepareForLayerBoundsChange() override;
 
  private:
   ui::Layer layer_;
   float radius_;
+  int inset_;
 
   DISALLOW_COPY_AND_ASSIGN(OverviewContentMask);
 };
 
-ScopedTransformOverviewWindow::OverviewContentMask::OverviewContentMask(
-    float radius)
-    : layer_(ui::LAYER_TEXTURED), radius_(radius) {
+ScopedTransformOverviewWindow::OverviewContentMask::OverviewContentMask()
+    : layer_(ui::LAYER_TEXTURED), radius_(0), inset_(0) {
   layer_.set_delegate(this);
 }
 
 ScopedTransformOverviewWindow::OverviewContentMask::~OverviewContentMask() {
   layer_.set_delegate(nullptr);
 }
 
 void ScopedTransformOverviewWindow::OverviewContentMask::OnPaintLayer(
     const ui::PaintContext& context) {
   ui::PaintRecorder recorder(context, layer()->size());
   gfx::Rect bounds(layer()->bounds().size());
+  bounds.Inset(0, inset_, 0, 0);
 
   // Tile a window into an area, rounding the bottom corners.
   const SkRect rect = gfx::RectToSkRect(bounds);
   const SkScalar corner_radius_scalar = SkIntToScalar(radius_);
   SkScalar radii[8] = {0,
                        0,  // top-left
                        0,
                        0,  // top-right
                        corner_radius_scalar,
                        corner_radius_scalar,  // bottom-right
@@ skipping 29 matching lines @@
       original_transform_(window->GetTargetTransform()),
       original_opacity_(window->GetTargetOpacity()),
       weak_ptr_factory_(this) {}
 
 ScopedTransformOverviewWindow::~ScopedTransformOverviewWindow() {}
 
 void ScopedTransformOverviewWindow::RestoreWindow() {
   ScopedAnimationSettings animation_settings_list;
   BeginScopedAnimation(OverviewAnimationType::OVERVIEW_ANIMATION_RESTORE_WINDOW,
                        &animation_settings_list);
-  SetTransform(window()->GetRootWindow(), original_transform_, 0);
+  SetTransform(window()->GetRootWindow(), original_transform_,
+               false /* use_mask */, false /* use_shape */, 0);
 
   std::unique_ptr<ScopedOverviewAnimationSettings> animation_settings =
       CreateScopedOverviewAnimationSettings(
           OverviewAnimationType::OVERVIEW_ANIMATION_LAY_OUT_SELECTOR_ITEMS,
           window_);
   gfx::Transform transform;
   if (minimized_ && window_->GetShowState() != ui::SHOW_STATE_MINIMIZED) {
     // Setting opacity 0 and visible false ensures that the property change
     // to SHOW_STATE_MINIMIZED will not animate the window from its original
     // bounds to the minimized position.
@@ skipping 119 matching lines @@
   gfx::Transform transform;
   transform.Translate(dst_rect.x() - src_rect.x(), dst_rect.y() - src_rect.y());
   transform.Scale(static_cast<float>(dst_rect.width()) / src_rect.width(),
                   static_cast<float>(dst_rect.height()) / src_rect.height());
   return transform;
 }
 
 void ScopedTransformOverviewWindow::SetTransform(
     WmWindow* root_window,
     const gfx::Transform& transform,
+    bool use_mask,
+    bool use_shape,
     float radius) {
   DCHECK(overview_started_);
 
   if (ash::MaterialDesignController::IsOverviewMaterial() &&
       &transform != &original_transform_) {
-    if (!mask_) {
-      mask_.reset(new OverviewContentMask(radius));
+    if (use_mask && !mask_) {
+      mask_.reset(new OverviewContentMask());
       mask_->layer()->SetFillsBoundsOpaquely(false);
       window()->GetLayer()->SetMaskLayer(mask_->layer());
     }
-    gfx::Rect bounds(GetTargetBoundsInScreen().size());
-    mask_->layer()->SetBounds(bounds);
-    mask_->set_radius(radius);
-    window()->GetLayer()->SchedulePaint(bounds);
-
     if (!determined_original_window_shape_) {
       determined_original_window_shape_ = true;
       SkRegion* window_shape = window()->GetLayer()->alpha_shape();
       if (!original_window_shape_ && window_shape)
         original_window_shape_.reset(new SkRegion(*window_shape));
     }
+    gfx::Rect bounds(GetTargetBoundsInScreen().size());
     const int inset =
-        window()->GetIntProperty(WmWindowProperty::TOP_VIEW_INSET);
-    if (inset > 0) {
+        (use_mask || use_shape)
+            ? window()->GetIntProperty(WmWindowProperty::TOP_VIEW_INSET)
+            : 0;
+    if (mask_) {
+      // Mask layer is used both to hide the window header and to use rounded
+      // corners. Its layout needs to be update when setting a transform.
+      mask_->layer()->SetBounds(bounds);
+      mask_->set_inset(inset);
+      mask_->set_radius(radius);
+      window()->GetLayer()->SchedulePaint(bounds);
+    } else if (inset > 0) {
+      // Alpha shape is only used to to hide the window header and only when
+      // not using a mask layer.
       bounds.Inset(0, inset, 0, 0);
       SkRegion* region = new SkRegion;
       region->setRect(RectToSkIRect(bounds));
       if (original_window_shape_)
         region->op(*original_window_shape_, SkRegion::kIntersect_Op);
       window()->GetLayer()->SetAlphaShape(base::WrapUnique(region));
       window()->SetMasksToBounds(true);
     }
   }
 
@@ skipping 41 matching lines @@
   if (parent_window)
     parent_window->CloseWidget();
 }
 
 // static
 void ScopedTransformOverviewWindow::SetImmediateCloseForTests() {
   immediate_close_for_tests = true;
 }
 
 }  // namespace ash