[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"
@@ skipping 253 matching lines @@
       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 */);
+  set_overview_transform(original_transform_);
 
   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() !=
            wm::WINDOW_STATE_TYPE_DOCKED_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_window_shape_) {
-      layer->SetAlphaShape(
-          base::MakeUnique<SkRegion>(*original_window_shape_.get()));
-    } else {
-      layer->SetAlphaShape(nullptr);
-    }
-    window()->SetMasksToBounds(false);
-  }
+  if (ash::MaterialDesignController::IsOverviewMaterial())
+    ShowHeaderAndResetShape();

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

AFAICT it is not guaranteed that HideHeaderAndSetShape() will be called on
|this| at this point.  Thus we either need to ensure ShowHeaderAndResetShape()
is allowed to be called in such a case, or you should add some tracking meta
data to know when to invoke it.  At the very least a comment to this effect
would be helpful somewhere.

[varkha, 2016/09/08 00:09:50]

Done. Added a comment in the header since I think it is safe to call
ShowHeaderAndResetShape() even when HideHeaderAndSetShape() is not going to be
called.

 }
 
 void ScopedTransformOverviewWindow::BeginScopedAnimation(
     OverviewAnimationType animation_type,
     ScopedAnimationSettings* animation_settings) {
   for (auto* window : GetTransientTreeIterator(window_)) {
     animation_settings->push_back(
         CreateScopedOverviewAnimationSettings(animation_type, window));
   }
 }
@@ skipping 16 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 12 matching lines @@
       header_bounds.set_height(top_inset);
       new_transform.TransformRect(&header_bounds);
       window_bounds.Inset(0, gfx::ToCeiledInt(header_bounds.height()), 0, 0);
     }
     bounds.Union(window->GetParent()->ConvertRectToScreen(
         ToEnclosingRect(window_bounds)));
   }
   return bounds;
 }
 
+SkColor ScopedTransformOverviewWindow::GetTopColor() const {
+  for (auto* window : GetTransientTreeIterator(window_)) {
+    // If there are regular windows in the transient ancestor tree, all those
+    // windows are shown in the same overview item and the header is not masked.
+    if (window != window_ && (window->GetType() == ui::wm::WINDOW_TYPE_NORMAL ||
+                              window->GetType() == ui::wm::WINDOW_TYPE_PANEL)) {
+      return SK_ColorTRANSPARENT;
+    }
+  }
+  return static_cast<SkColor>(
+      window_->GetIntProperty(WmWindowProperty::TOP_VIEW_COLOR));
+}
+
 int ScopedTransformOverviewWindow::GetTopInset() const {
   for (auto* window : GetTransientTreeIterator(window_)) {
     // If there are regular windows in the transient ancestor tree, all those
     // windows are shown in the same overview item and the header is not masked.
     if (window != window_ && (window->GetType() == ui::wm::WINDOW_TYPE_NORMAL ||
                               window->GetType() == ui::wm::WINDOW_TYPE_PANEL)) {
       return 0;
     }
   }
   return window_->GetIntProperty(WmWindowProperty::TOP_VIEW_INSET);
@@ skipping 69 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) {
+    bool use_mask) {
   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);
-    }
   }
 
   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(),
                                        target_origin.y() - original_origin.y()),
                             transform);
     window->SetTransform(new_transform);
   }
 }
 
 void ScopedTransformOverviewWindow::SetOpacity(float opacity) {
   for (auto* window : GetTransientTreeIterator(window_)) {
     window->SetOpacity(opacity);
   }
 }
 
+void ScopedTransformOverviewWindow::HideHeaderAndSetShape(bool use_mask,
+                                                          bool use_shape,
+                                                          int radius) {
+  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 updated 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 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);
+  }
+}
+
+void ScopedTransformOverviewWindow::ShowHeaderAndResetShape() {
+  ui::Layer* layer = window()->GetLayer();
+  layer->SetMaskLayer(nullptr);
+  mask_.reset();
+
+  if (original_window_shape_) {
+    layer->SetAlphaShape(
+        base::MakeUnique<SkRegion>(*original_window_shape_.get()));
+  } else {
+    layer->SetAlphaShape(nullptr);
+  }
+  window()->SetMasksToBounds(false);
+}
+
 void ScopedTransformOverviewWindow::Close() {
   if (immediate_close_for_tests ||
       !ash::MaterialDesignController::IsOverviewMaterial()) {
     CloseWidget();
     return;
   }
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&ScopedTransformOverviewWindow::CloseWidget,
                             weak_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kCloseWindowDelayInMilliseconds));
@@ skipping 11 matching lines @@
   if (parent_window)
     parent_window->CloseWidget();
 }
 
 // static
 void ScopedTransformOverviewWindow::SetImmediateCloseForTests() {
   immediate_close_for_tests = true;
 }
 
 }  // namespace ash