[ash-md] Hides frame headers in overview mode not using a mask

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:
-  OverviewContentMask(int inset, int radius);
+  OverviewContentMask(float radius);

[tdanderson, 2016/07/09 21:23:21]

Make this constructor explicit

[varkha, 2016/07/09 22:00:17]

Done.

   ~OverviewContentMask() override;
 
   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_;
-  int inset_;
-  int radius_;
+  float radius_;
 
   DISALLOW_COPY_AND_ASSIGN(OverviewContentMask);
 };
 
 ScopedTransformOverviewWindow::OverviewContentMask::OverviewContentMask(
-    int inset,
-    int radius)
-    : layer_(ui::LAYER_TEXTURED), inset_(inset), radius_(radius) {
+    float radius)
+    : layer_(ui::LAYER_TEXTURED), radius_(radius) {
   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 15 matching lines @@
   // Redrawing will take care of scale factor change.
 }
 
 base::Closure ScopedTransformOverviewWindow::OverviewContentMask::
     PrepareForLayerBoundsChange() {
   return base::Closure();
 }
 
 ScopedTransformOverviewWindow::ScopedTransformOverviewWindow(WmWindow* window)
     : window_(window),
+      alpha_shape_set_(false),
       minimized_(window->GetShowState() == ui::SHOW_STATE_MINIMIZED),
       ignored_by_shelf_(window->GetWindowState()->ignored_by_shelf()),
       overview_started_(false),
       original_transform_(window->GetTargetTransform()),
       original_opacity_(window->GetTargetOpacity()),
       weak_ptr_factory_(this) {}
 
 ScopedTransformOverviewWindow::~ScopedTransformOverviewWindow() {}
 
 void ScopedTransformOverviewWindow::RestoreWindow() {
-  if (ash::MaterialDesignController::IsOverviewMaterial()) {
-    window()->GetLayer()->SetMaskLayer(nullptr);
-    mask_.reset();
-  }
-
   ScopedAnimationSettings animation_settings_list;
   BeginScopedAnimation(OverviewAnimationType::OVERVIEW_ANIMATION_RESTORE_WINDOW,
                        &animation_settings_list);
   SetTransform(window()->GetRootWindow(), original_transform_, 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.
     // Hiding the window needs to be done before the target opacity is 0,
     // otherwise the layer's visibility will not be updated
     // (See VisibilityController::UpdateLayerVisibility).
     window_->Hide();
     window_->SetOpacity(0);
     window_->SetShowState(ui::SHOW_STATE_MINIMIZED);
   }
   window_->GetWindowState()->set_ignored_by_shelf(ignored_by_shelf_);
   SetOpacity(original_opacity_);
+
+  if (ash::MaterialDesignController::IsOverviewMaterial()) {
+    ui::Layer* layer = window()->GetLayer();
+    layer->SetMaskLayer(nullptr);
+    mask_.reset();
+
+    if (original_alpha_shape_) {
+      layer->SetAlphaShape(
+          base::WrapUnique(new SkRegion(*original_alpha_shape_.get())));
+    } else {
+      layer->SetAlphaShape(nullptr);
+    }
+    window()->SetMasksToBounds(false);
+    alpha_shape_set_ = false;
+  }
 }
 
 void ScopedTransformOverviewWindow::BeginScopedAnimation(
     OverviewAnimationType animation_type,
     ScopedAnimationSettings* animation_settings) {
   for (auto* window : GetTransientTreeIterator(window_)) {
     animation_settings->push_back(
         CreateScopedOverviewAnimationSettings(animation_type, window));
   }
 }
@@ skipping 86 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,
-    int radius) {
+    float radius) {
   DCHECK(overview_started_);
 
-  if (ash::MaterialDesignController::IsOverviewMaterial() && !mask_) {
-    mask_.reset(new OverviewContentMask(
-        window()->GetIntProperty(WmWindowProperty::TOP_VIEW_INSET), radius));
-    mask_->layer()->SetBounds(GetTargetBoundsInScreen());
+  if (ash::MaterialDesignController::IsOverviewMaterial() &&
+      &transform != &original_transform_) {

[tdanderson, 2016/07/09 21:23:21]

Hmm, shouldn't all of  SetTransform() be a no-op if this is true? i.e.,

void ScopedTransformOverviewWindow::SetTransform(...) {
  if (&transform == &original_transform)
    return;

  ...
}

That, or perhaps I don't understand why you're including this check.

[varkha, 2016/07/09 22:00:17]

No. This method is used to both set the transform on a a window that scales it
into overview and also to revert back to original transform. But when reverting
there is no point to refresh the header mask since it is about to be removed
anyway. See a call site above in RestoreWindow().

+    gfx::Rect bounds(GetTargetBoundsInScreen().size());
+    mask_.reset(new OverviewContentMask(radius));
+    mask_->layer()->SetBounds(bounds);

[tdanderson, 2016/07/09 21:23:21]

I don't understand why you're setting bounds with an origin of (0,0) (from line
410) rather than the true bounds.

[varkha, 2016/07/09 22:00:17]

This is for a mask layer - my understanding is that this is using coordinates
relative to the window()->GetLayer().

     window()->GetLayer()->SetMaskLayer(mask_->layer());
+
+    if (!alpha_shape_set_) {

[tdanderson, 2016/07/09 21:23:21]

I don't think you need |alpha_shape_set_| at all. Assuming that calling
window()->SetMasksToBounds(true) is a no-op if SMTB(true) has already been
called on window(), then it seems that lines 415-421 could be replaced with:

SkRegion* alpha_shape = window()->GetLayer()->alpha_shape();
if (!original_alpha_shape_ && alpha_shape)
  original_alpha_shape_.reset(new SKRegion(*alpha_shape));
window()->SetMasksToBounds(true);

Furthermore, line 297 seems unnecessary anyway since (iiuc) RestoreWindow() is
called right before |this| is destroyed.

[varkha, 2016/07/09 22:00:17]

Done.

+      if (window()->GetLayer()->alpha_shape())

[tdanderson, 2016/07/09 21:23:21]

{} since call to reset() spans two lines

[varkha, 2016/07/09 22:00:17]

Done.

+        original_alpha_shape_.reset(
+            new SkRegion(*window()->GetLayer()->alpha_shape()));
+      window()->SetMasksToBounds(true);
+      alpha_shape_set_ = true;
+    }
+    bounds.Inset(0, window()->GetIntProperty(WmWindowProperty::TOP_VIEW_INSET),
+                 0, 0);
+    SkRegion* region = new SkRegion;
+    region->setRect(RectToSkIRect(bounds));
+    if (original_alpha_shape_)
+      region->op(*original_alpha_shape_, SkRegion::kIntersect_Op);
+    window()->GetLayer()->SetAlphaShape(base::WrapUnique(region));

[varkha, 2016/07/09 21:07:32]

Self review: this could be done only for windows that need to mask a header
(i.e. non-zero TOP_VIEW_INSET) rather than for all windows.

[varkha, 2016/07/09 22:00:17]

Done.

   }
 
   gfx::Point target_origin(GetTargetBoundsInScreen().origin());
 
   for (auto* window : GetTransientTreeIterator(window_)) {
     WmWindow* parent_window = window->GetParent();
     gfx::Point original_origin =
         parent_window->ConvertRectToScreen(window->GetTargetBounds()).origin();
     gfx::Transform new_transform =
         TransformAboutPivot(gfx::Point(target_origin.x() - original_origin.x(),
@@ skipping 33 matching lines @@
   if (parent_window)
     parent_window->CloseWidget();
 }
 
 // static
 void ScopedTransformOverviewWindow::SetImmediateCloseForTests() {
   immediate_close_for_tests = true;
 }
 
 }  // namespace ash