[ash-md] Fades overview header in and out

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"
 #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/window_selector_item.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm_window.h"
 #include "ash/common/wm_window_property.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "ui/compositor/layer.h"
+#include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_delegate.h"
 #include "ui/compositor/paint_recorder.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/transform_util.h"
 
 using WmWindows = std::vector<ash::WmWindow*>;
 
 namespace ash {
 
@@ skipping 207 matching lines @@
 void ScopedTransformOverviewWindow::OverviewContentMask::
     OnDeviceScaleFactorChanged(float device_scale_factor) {
   // Redrawing will take care of scale factor change.
 }
 
 base::Closure ScopedTransformOverviewWindow::OverviewContentMask::
     PrepareForLayerBoundsChange() {
   return base::Closure();
 }
 
+// A class that hides the original window's header and optionally sets a mask
+// or a shape on the target to make the corners rounded. The header is hidden
+// once the animations complete. When not animating, the changes are done
+// immediately upon construction.
+class ScopedTransformOverviewWindow::OverviewWindowAnimationObserver
+    : public ui::LayerAnimationObserver {
+ public:
+  OverviewWindowAnimationObserver(
+      ScopedTransformOverviewWindow* window,
+      bool animate,
+      bool use_mask,
+      bool use_shape,
+      int radius,
+      ScopedTransformOverviewWindow::OverviewContentMask* mask,
+      SkRegion* original_window_shape)
+      : window_(window),
+        animate_(animate),
+        use_mask_(use_mask),
+        use_shape_(use_shape),
+        radius_(radius),
+        mask_(mask),
+        original_window_shape_(original_window_shape) {
+    if (animate_) {
+      window_->window()->GetLayer()->GetAnimator()->AddObserver(this);
+      return;
+    }
+    HideHeaderAndSetShape();
+  }
+
+  ~OverviewWindowAnimationObserver() override {
+    if (animate_)
+      window_->window()->GetLayer()->GetAnimator()->RemoveObserver(this);
+  }
+
+  // ui::LayerAnimationObserver:
+  void OnLayerAnimationEnded(ui::LayerAnimationSequence* sequence) override {
+    window_->window()->GetLayer()->GetAnimator()->RemoveObserver(this);
+    HideHeaderAndSetShape();
+  }
+
+  void OnLayerAnimationAborted(ui::LayerAnimationSequence* sequence) override {}

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

Would it make sense to perform the same actions in Aborted as in Ended?

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

I've reworked this and the observer now lives in window_selector_item.cc. From
my debugging I get Aborted when cancelling overview mode while animating and so
we should not hide the header in this case.

+
+  void OnLayerAnimationScheduled(
+      ui::LayerAnimationSequence* sequence) override {}
+
+ private:
+  void HideHeaderAndSetShape() {
+    gfx::Rect bounds(window_->GetTargetBoundsInScreen().size());
+    const int inset = (use_mask_ || use_shape_) ? window_->GetTopInset() : 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_->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_->window()->GetLayer()->SetAlphaShape(base::WrapUnique(region));
+      window_->window()->SetMasksToBounds(true);
+    }
+  }
+
+  ScopedTransformOverviewWindow* window_;
+  bool animate_;
+  bool use_mask_;

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

I find it confusing that there is a bool |use_mask_| and an actual |mask_| that
is used even when |use_mask_| is false.  Also |use_mask_| and |use_shape_|
appear to be functionally equivalent?  Perhaps some docs would help or combining
|use_mask_| and |use_shape_| into an enum if they are mutually exclusive. ;) 
Additionally if there are some mutually exclusive states perhaps having distinct
classes makes more sense.

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

Masks will be removed in the next CL and there will be no need for those flags.

[bruthig, 2016/09/02 16:00:12]

Acknowledged.

+  bool use_shape_;
+  int radius_;
+  ScopedTransformOverviewWindow::OverviewContentMask* mask_;
+  SkRegion* original_window_shape_;
+
+  DISALLOW_COPY_AND_ASSIGN(OverviewWindowAnimationObserver);
+};
+
 ScopedTransformOverviewWindow::ScopedTransformOverviewWindow(WmWindow* window)
     : window_(window),
       determined_original_window_shape_(false),
       original_visibility_(
           window->GetWindowState()->GetStateType() ==
                   wm::WINDOW_STATE_TYPE_DOCKED_MINIMIZED
               ? ORIGINALLY_DOCKED_MINIMIZED
               : (window->GetShowState() == ui::SHOW_STATE_MINIMIZED
                      ? ORIGINALLY_MINIMIZED
                      : ORIGINALLY_VISIBLE)),
       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() {
   ScopedAnimationSettings animation_settings_list;
   BeginScopedAnimation(OverviewAnimationType::OVERVIEW_ANIMATION_RESTORE_WINDOW,
                        &animation_settings_list);
   SetTransform(window()->GetRootWindow(), original_transform_,
-               false /* use_mask */, false /* use_shape */, 0);
+               false /* use_mask */, false /* use_shape */, 0,
+               true /* animate */);
 
   std::unique_ptr<ScopedOverviewAnimationSettings> animation_settings =
       CreateScopedOverviewAnimationSettings(
           OverviewAnimationType::OVERVIEW_ANIMATION_LAY_OUT_SELECTOR_ITEMS,
           window_);
   gfx::Transform transform;
   if ((original_visibility_ == ORIGINALLY_MINIMIZED &&
        window_->GetShowState() != ui::SHOW_STATE_MINIMIZED) ||
       (original_visibility_ == ORIGINALLY_DOCKED_MINIMIZED &&
        window_->GetWindowState()->GetStateType() !=
@@ skipping 53 matching lines @@
       continue;
     }
     bounds.Union(
         window->GetParent()->ConvertRectToScreen(window->GetTargetBounds()));
   }
   return bounds;
 }
 
 gfx::Rect ScopedTransformOverviewWindow::GetTransformedBounds(
     bool hide_header) const {
+  if (window_->GetWindowState()->IsMinimized())
+    return window_->GetMinimizeAnimationTargetBoundsInScreen();
+
   const bool material = ash::MaterialDesignController::IsOverviewMaterial();
   const int top_inset = hide_header ? GetTopInset() : 0;
   gfx::Rect bounds;
   for (auto* window : GetTransientTreeIterator(window_)) {
     // Ignore other window types when computing bounding box of window
     // selector target item.
     if (window != window_ &&
         (!material || (window->GetType() != ui::wm::WINDOW_TYPE_NORMAL &&
                        window->GetType() != ui::wm::WINDOW_TYPE_PANEL))) {
       continue;
@@ skipping 103 matching lines @@
   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) {
+    float radius,
+    bool animate) {
   DCHECK(overview_started_);
 
   if (ash::MaterialDesignController::IsOverviewMaterial() &&
       &transform != &original_transform_) {
     if (use_mask && !mask_) {
       mask_.reset(new OverviewContentMask());
       mask_->layer()->SetFillsBoundsOpaquely(false);
       window()->GetLayer()->SetMaskLayer(mask_->layer());
     }
     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 = (use_mask || use_shape) ? GetTopInset() : 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);
-    }
+    animation_observer_.reset(new OverviewWindowAnimationObserver(
+        this, animate, use_mask, use_shape, radius, mask_.get(),
+        original_window_shape_.get()));
   }
 
   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