Use mirror layer for minimized windows 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/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_lookup.h"
+#include "ash/common/wm_root_window_controller.h"
+#include "ash/common/wm_shell.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 "ui/compositor/layer.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/transform_util.h"
+#include "ui/views/widget/widget.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;
-
 // Delay closing window to allow it to shrink and fade out.
 const int kCloseWindowDelayInMilliseconds = 150;
 
 WmWindow* GetTransientRoot(WmWindow* window) {
   while (window && window->GetTransientParent())
     window = window->GetTransientParent();
   return window;
 }
 
 std::unique_ptr<ScopedOverviewAnimationSettings>
@@ skipping 116 matching lines @@
 TransientDescendantIteratorRange GetTransientTreeIterator(WmWindow* window) {
   return TransientDescendantIteratorRange(
       TransientDescendantIterator(GetTransientRoot(window)));
 }
 
 }  // namespace
 
 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() {
+  if (minimized_) {
+    // TODO(oshima): Use unminimize animation instead of hiding animation.
+    minimized_->CloseNow();
+    minimized_.reset();
+    return;
+  }
   ScopedAnimationSettings animation_settings_list;
   BeginScopedAnimation(OverviewAnimationType::OVERVIEW_ANIMATION_RESTORE_WINDOW,
                        &animation_settings_list);
   SetTransform(window()->GetRootWindow(), 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_);
   ShowHeader();
 }
 
 void ScopedTransformOverviewWindow::BeginScopedAnimation(
     OverviewAnimationType animation_type,
     ScopedAnimationSettings* animation_settings) {
-  for (auto* window : GetTransientTreeIterator(window_)) {
+  for (auto* window : GetTransientTreeIterator(GetOverviewWindow())) {
     animation_settings->push_back(
         CreateScopedOverviewAnimationSettings(animation_type, window));
   }
 }
 
 bool ScopedTransformOverviewWindow::Contains(const WmWindow* target) const {
   for (auto* window : GetTransientTreeIterator(window_)) {
     if (window->Contains(target))
       return true;
   }
-  return false;
+  WmWindow* mirror = GetOverviewWindowForMinimizedState();
+  return mirror && mirror->Contains(target);
 }
 
 gfx::Rect ScopedTransformOverviewWindow::GetTargetBoundsInScreen() const {
   gfx::Rect bounds;
-  for (auto* window : GetTransientTreeIterator(window_)) {
+  WmWindow* overview_window = GetOverviewWindow();
+  for (auto* window : GetTransientTreeIterator(overview_window)) {
     // Ignore other window types when computing bounding box of window
     // selector target item.
-    if (window != window_ && window->GetType() != ui::wm::WINDOW_TYPE_NORMAL &&
+    if (window != overview_window &&
+        window->GetType() != ui::wm::WINDOW_TYPE_NORMAL &&
         window->GetType() != ui::wm::WINDOW_TYPE_PANEL) {
       continue;
     }
     bounds.Union(
         window->GetParent()->ConvertRectToScreen(window->GetTargetBounds()));
   }
   return bounds;
 }
 
 gfx::Rect ScopedTransformOverviewWindow::GetTransformedBounds() const {
-  if (window_->GetWindowState()->IsMinimized())
-    return window_->GetMinimizeAnimationTargetBoundsInScreen();
-
   const int top_inset = GetTopInset();
   gfx::Rect bounds;
-  for (auto* window : GetTransientTreeIterator(window_)) {
+  WmWindow* overview_window = GetOverviewWindow();
+  for (auto* window : GetTransientTreeIterator(overview_window)) {
     // Ignore other window types when computing bounding box of window
     // selector target item.
-    if (window != window_ && (window->GetType() != ui::wm::WINDOW_TYPE_NORMAL &&
-                              window->GetType() != ui::wm::WINDOW_TYPE_PANEL)) {
+    if (window != overview_window &&
+        (window->GetType() != ui::wm::WINDOW_TYPE_NORMAL &&
+         window->GetType() != ui::wm::WINDOW_TYPE_PANEL)) {
       continue;
     }
     gfx::RectF window_bounds(window->GetTargetBounds());
     gfx::Transform new_transform =
         TransformAboutPivot(gfx::Point(window_bounds.x(), window_bounds.y()),
                             window->GetTargetTransform());
     new_transform.TransformRect(&window_bounds);
 
     // The preview title is shown above the preview window. Hide the window
     // header for apps or browser windows with no tabs (web apps) to avoid
@@ skipping 16 matching lines @@
     // 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 window_->GetColorProperty(WmWindowProperty::TOP_VIEW_COLOR);
 }
 
 int ScopedTransformOverviewWindow::GetTopInset() const {
+  // Mirror window doesn't have insets.
+  if (minimized_)
+    return 0;

[varkha, 2016/11/08 00:02:56]

I don't think this is right. I tried it with the web browser running in a window
(menu->More tools->Add to shelf...) and I now see both the overview header and
the original scaled window header when in overview. I expected to only see the
fake overview header.
This might be the right thing for ARC, are you able to try that and maybe
restrict to just ARC, say by manipulating what this property returns in exo when
a window is minimized?

[oshima, 2016/11/10 23:58:47]

Updated the mirror window to do the right thing and this will fix ARC++ windows
too.

   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);
 }
 
-void ScopedTransformOverviewWindow::ShowWindowIfMinimized() {
-  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)) {
-    window_->Show();
-  }
-}
-
-void ScopedTransformOverviewWindow::ShowWindowOnExit() {
-  if (original_visibility_ != ORIGINALLY_VISIBLE) {
-    original_visibility_ = ORIGINALLY_VISIBLE;
-    original_transform_ = gfx::Transform();
-    original_opacity_ = kRestoreWindowOpacity;
-  }
-}
-
 void ScopedTransformOverviewWindow::OnWindowDestroyed() {
   window_ = nullptr;
 }
 
 float ScopedTransformOverviewWindow::GetItemScale(const gfx::Size& source,
                                                   const gfx::Size& target,
                                                   int top_view_inset,
                                                   int title_height) {
   return std::min(2.0f, static_cast<float>((target.height() - title_height)) /
                             (source.height() - top_view_inset));
@@ skipping 37 matching lines @@
 
   if (&transform != &original_transform_ &&
       !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::Point target_origin(GetTargetBoundsInScreen().origin());
-
-  for (auto* window : GetTransientTreeIterator(window_)) {
+  for (auto* window : GetTransientTreeIterator(GetOverviewWindow())) {
     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_)) {
+  for (auto* window : GetTransientTreeIterator(GetOverviewWindow())) {
     window->SetOpacity(opacity);
   }
 }
 
 void ScopedTransformOverviewWindow::HideHeader() {
+  // Mirrored Window does not have a header.
+  if (minimized_)
+    return;

[varkha, 2016/11/08 00:02:56]

Ditto.

   gfx::Rect bounds(GetTargetBoundsInScreen().size());
   const int inset = GetTopInset();
   if (inset > 0) {
     // Use alpha shape to hide the window header.
     bounds.Inset(0, inset, 0, 0);
     std::unique_ptr<SkRegion> region(new SkRegion);
     region->setRect(RectToSkIRect(bounds));
     if (original_window_shape_)
       region->op(*original_window_shape_, SkRegion::kIntersect_Op);
-    window()->GetLayer()->SetAlphaShape(std::move(region));
-    window()->SetMasksToBounds(true);
+    WmWindow* window = GetOverviewWindow();
+    window->GetLayer()->SetAlphaShape(std::move(region));
+    window->SetMasksToBounds(true);
   }
 }
 
 void ScopedTransformOverviewWindow::ShowHeader() {
   ui::Layer* layer = window()->GetLayer();
   if (original_window_shape_) {
     layer->SetAlphaShape(
         base::MakeUnique<SkRegion>(*original_window_shape_.get()));
   } else {
     layer->SetAlphaShape(nullptr);
   }
   window()->SetMasksToBounds(false);
 }
 
+void ScopedTransformOverviewWindow::UpdateMirrorWindowForMinimizedState() {
+  // TODO(oshima): Disable animation.
+  if (window_->GetShowState() == ui::SHOW_STATE_MINIMIZED) {
+    if (!minimized_.get())
+      CreateMirrorWindowForMinimizedState();
+  } else {
+    minimized_->CloseNow();
+    minimized_.reset();
+  }
+}
+
 void ScopedTransformOverviewWindow::Close() {
   if (immediate_close_for_tests) {
     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();
+  if (window_->GetShowState() == ui::SHOW_STATE_MINIMIZED)
+    CreateMirrorWindowForMinimizedState();
 }
 
 void ScopedTransformOverviewWindow::CloseWidget() {
   WmWindow* parent_window = GetTransientRoot(window_);
   if (parent_window)
     parent_window->CloseWidget();
 }
 
 // static
 void ScopedTransformOverviewWindow::SetImmediateCloseForTests() {
   immediate_close_for_tests = true;
 }
 
+WmWindow* ScopedTransformOverviewWindow::GetOverviewWindow() const {
+  if (minimized_)
+    return GetOverviewWindowForMinimizedState();
+  return window_;
+}
+
+void ScopedTransformOverviewWindow::OnGestureEvent(ui::GestureEvent* event) {
+  if (event->type() == ui::ET_GESTURE_TAP) {
+    window_->Show();
+    window_->Activate();
+  }
+}
+
+void ScopedTransformOverviewWindow::OnMouseEvent(ui::MouseEvent* event) {
+  if (event->type() == ui::ET_MOUSE_PRESSED && event->IsOnlyLeftMouseButton()) {
+    window_->Show();
+    window_->Activate();
+  }
+}
+
+WmWindow* ScopedTransformOverviewWindow::GetOverviewWindowForMinimizedState()
+    const {
+  return minimized_ ? WmLookup::Get()->GetWindowForWidget(minimized_.get())
+                    : nullptr;
+}
+
+void ScopedTransformOverviewWindow::CreateMirrorWindowForMinimizedState() {
+  DCHECK(!minimized_.get());
+  views::Widget::InitParams params;
+  params.type = views::Widget::InitParams::TYPE_WINDOW_FRAMELESS;
+  params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
+  params.visible_on_all_workspaces = true;
+  params.name = "OverviewModeMinmized";

[varkha, 2016/11/08 00:02:56]

nit: s/OverviewModeMinmized/OverviewModeMinimized

[oshima, 2016/11/10 23:58:47]

Done.

+  params.activatable = views::Widget::InitParams::Activatable::ACTIVATABLE_NO;
+  params.accept_events = true;
+  minimized_.reset(new views::Widget);
+  window_->GetRootWindow()
+      ->GetRootWindowController()
+      ->ConfigureWidgetInitParamsForContainer(
+          minimized_.get(), window_->GetParent()->GetShellWindowId(), &params);
+  minimized_->set_focus_on_creation(false);
+  minimized_->Init(params);
+
+  views::View* mirror_view = window_->CreateViewWithRecreatedLayers().release();
+  mirror_view->SetVisible(true);
+  mirror_view->SetTargetHandler(this);
+  minimized_->SetContentsView(mirror_view);
+  gfx::Rect bounds(window_->GetBoundsInScreen());
+  gfx::Size preferred = mirror_view->GetPreferredSize();
+  // In unit tests, the content view can have empty size.
+  if (!preferred.IsEmpty()) {
+    int inset = bounds.height() - preferred.height();
+    bounds.Inset(0, 0, 0, inset);
+  }
+  minimized_->SetBounds(bounds);
+  minimized_->Show();
+}
+
 }  // namespace ash