[ash-md] Animates a window closed while in overview mode

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_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 {
 
 namespace {
 
+// When set to true by tests makes closing the widget synchronous.
+bool immediate_close_for_tests = false;
+
 // The opacity level that windows will be set to when they are restored.
 const float kRestoreWindowOpacity = 1.0f;
 
 // Alpha value used to paint mask layer that masks the original window header.
 const int kOverviewContentMaskAlpha = 255;
 
+// Delay closing window with Material Design to allow it to shrink and fade out.
+const int kCloseWindowDelayInMilliseconds = 150;
+
 WmWindow* GetTransientRoot(WmWindow* window) {
-  while (window->GetTransientParent())
+  while (window && window->GetTransientParent())
     window = window->GetTransientParent();
   return window;
 }
 
 std::unique_ptr<ScopedOverviewAnimationSettings>
 CreateScopedOverviewAnimationSettings(OverviewAnimationType animation_type,
                                       WmWindow* window) {
   return ScopedOverviewAnimationSettingsFactory::Get()
       ->CreateOverviewAnimationSettings(animation_type, window);
 }
@@ skipping 187 matching lines @@
     PrepareForLayerBoundsChange() {
   return base::Closure();
 }
 
 ScopedTransformOverviewWindow::ScopedTransformOverviewWindow(WmWindow* window)
     : window_(window),
       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()) {}
+      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;
@@ skipping 121 matching lines @@
                   static_cast<float>(dst_rect.height()) / src_rect.height());
   return transform;
 }
 
 void ScopedTransformOverviewWindow::SetTransform(
     WmWindow* root_window,
     const gfx::Transform& transform,
     int radius) {
   DCHECK(overview_started_);
 
-  if (ash::MaterialDesignController::IsOverviewMaterial()) {
+  if (ash::MaterialDesignController::IsOverviewMaterial() && !mask_) {
     mask_.reset(new OverviewContentMask(
         window()->GetIntProperty(WmWindowProperty::TOP_VIEW_INSET), radius));
     mask_->layer()->SetBounds(GetTargetBoundsInScreen());
     window()->GetLayer()->SetMaskLayer(mask_->layer());
   }
 
   gfx::Point target_origin(GetTargetBoundsInScreen().origin());
 
   for (const 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 (const auto& window : GetTransientTreeIterator(window_)) {
     window->SetOpacity(opacity);
   }
 }
 
 void ScopedTransformOverviewWindow::Close() {
-  GetTransientRoot(window_)->CloseWidget();
+  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));
 }
 
 void ScopedTransformOverviewWindow::PrepareForOverview() {
   DCHECK(!overview_started_);
   overview_started_ = true;
   window_->GetWindowState()->set_ignored_by_shelf(true);
   ShowWindowIfMinimized();
 }
 
+void ScopedTransformOverviewWindow::CloseWidget() {
+  WmWindow* parent_window = GetTransientRoot(window_);
+  if (parent_window)
+    parent_window->CloseWidget();
+}
+
+// static
+void ScopedTransformOverviewWindow::SetImmediateCloseForTests() {
+  immediate_close_for_tests = true;
+}
+
 }  // namespace ash