Reland of [ash-md] Fades overview header in and out

ash/wm/overview/window_selector_unittest.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 <algorithm>
 #include <vector>
 
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/accessibility_delegate.h"
 #include "ash/common/accessibility_types.h"
 #include "ash/common/ash_switches.h"
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/shelf/shelf_widget.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/system/tray/system_tray.h"
 #include "ash/common/test/material_design_controller_test_api.h"
 #include "ash/common/wm/dock/docked_window_layout_manager.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/common/wm/mru_window_tracker.h"
 #include "ash/common/wm/overview/scoped_transform_overview_window.h"
 #include "ash/common/wm/overview/window_grid.h"
 #include "ash/common/wm/overview/window_selector.h"
 #include "ash/common/wm/overview/window_selector_controller.h"
 #include "ash/common/wm/overview/window_selector_item.h"
 #include "ash/common/wm/panels/panel_layout_manager.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/wm_event.h"
+#include "ash/common/wm_lookup.h"
 #include "ash/common/wm_shell.h"
+#include "ash/common/wm_window_property.h"
 #include "ash/display/display_manager.h"
 #include "ash/drag_drop/drag_drop_controller.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/display_manager_test_api.h"
 #include "ash/test/shelf_view_test_api.h"
 #include "ash/test/shell_test_api.h"
 #include "ash/test/test_shelf_delegate.h"
@@ skipping 30 matching lines @@
 #include "ui/wm/core/window_util.h"
 #include "ui/wm/public/activation_delegate.h"
 
 namespace ash {
 namespace {
 
 // With Material Design the label covers selector item windows with a padding
 // in order to prevent them from receiving user input events while in overview.
 static const int kWindowMarginMD = 5;
 
+// With Material Design the overview mode header overlaps original window
+// header. This value is used to set top inset property on the windows.
+static const int kHeaderHeight = 32;
+
 const char kActiveWindowChangedFromOverview[] =
     "WindowSelector_ActiveWindowChanged";
 
 class NonActivatableActivationDelegate
     : public aura::client::ActivationDelegate {
  public:
   bool ShouldActivate() const override { return false; }
 };
 
 void CancelDrag(DragDropController* controller, bool* canceled) {
@@ skipping 31 matching lines @@
     }
     ASSERT_TRUE(test::TestShelfDelegate::instance());
 
     shelf_view_test_.reset(new test::ShelfViewTestAPI(
         GetPrimaryShelf()->GetShelfViewForTesting()));
     shelf_view_test_->SetAnimationDuration(1);
     ScopedTransformOverviewWindow::SetImmediateCloseForTests();
   }
 
   aura::Window* CreateWindow(const gfx::Rect& bounds) {
-    return CreateTestWindowInShellWithDelegate(&delegate_, -1, bounds);
+    aura::Window* window =
+        CreateTestWindowInShellWithDelegate(&delegate_, -1, bounds);
+    window->SetProperty(aura::client::kTopViewInset, kHeaderHeight);
+    return window;
   }
 
   aura::Window* CreateWindowWithId(const gfx::Rect& bounds, int id) {
-    return CreateTestWindowInShellWithDelegate(&delegate_, id, bounds);
+    aura::Window* window =
+        CreateTestWindowInShellWithDelegate(&delegate_, id, bounds);
+    window->SetProperty(aura::client::kTopViewInset, kHeaderHeight);
+    return window;
   }
   aura::Window* CreateNonActivatableWindow(const gfx::Rect& bounds) {
     aura::Window* window = CreateWindow(bounds);
     aura::client::SetActivationDelegate(window,
                                         &non_activatable_activation_delegate_);
     EXPECT_FALSE(wm::CanActivateWindow(window));
     return window;
   }
 
   // Creates a Widget containing a Window with the given |bounds|. This should
   // be used when the test requires a Widget. For example any test that will
   // cause a window to be closed via
   // views::Widget::GetWidgetForNativeView(window)->Close().
   std::unique_ptr<views::Widget> CreateWindowWidget(const gfx::Rect& bounds) {
     std::unique_ptr<views::Widget> widget(new views::Widget);
     views::Widget::InitParams params;
     params.bounds = bounds;
     params.type = views::Widget::InitParams::TYPE_WINDOW;
     params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
     widget->Init(params);
     widget->Show();
+    WmWindow* window = WmLookup::Get()->GetWindowForWidget(widget.get());
+    window->SetIntProperty(WmWindowProperty::TOP_VIEW_INSET, kHeaderHeight);
     ParentWindowInPrimaryRootWindow(widget->GetNativeWindow());
     return widget;
   }
 
   aura::Window* CreatePanelWindow(const gfx::Rect& bounds) {
     aura::Window* window = CreateTestWindowInShellWithDelegateAndType(
         nullptr, ui::wm::WINDOW_TYPE_PANEL, 0, bounds);
+    window->SetProperty(aura::client::kTopViewInset, kHeaderHeight);
     test::TestShelfDelegate::instance()->AddShelfItem(window);
     shelf_view_test()->RunMessageLoopUntilAnimationsDone();
     return window;
   }
 
   bool WindowsOverlapping(aura::Window* window1, aura::Window* window2) {
     gfx::RectF window1_bounds = GetTransformedTargetBounds(window1);
     gfx::RectF window2_bounds = GetTransformedTargetBounds(window2);
     return window1_bounds.Intersects(window2_bounds);
   }
@@ skipping 233 matching lines @@
 
 // Tests that there are no crashes when there is not enough screen space
 // available to show all of the windows.
 TEST_P(WindowSelectorTest, SmallDisplay) {
   UpdateDisplay("3x1");
   gfx::Rect bounds(0, 0, 1, 1);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window3(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window4(CreateWindow(bounds));
+  window1->SetProperty(aura::client::kTopViewInset, 0);
+  window2->SetProperty(aura::client::kTopViewInset, 0);
+  window3->SetProperty(aura::client::kTopViewInset, 0);
+  window4->SetProperty(aura::client::kTopViewInset, 0);
   ToggleOverview();
 }
 
 // Tests entering overview mode with two windows and selecting one by clicking.
 TEST_P(WindowSelectorTest, Basic) {
   gfx::Rect bounds(0, 0, 400, 400);
   aura::Window* root_window = Shell::GetPrimaryRootWindow();
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   std::unique_ptr<aura::Window> panel1(CreatePanelWindow(bounds));
@@ skipping 260 matching lines @@
 
   // aura::Window* root_window = Shell::GetPrimaryRootWindow();
   gfx::Rect bounds(300, 0, 200, 200);
   std::unique_ptr<views::Widget> widget1 = CreateWindowWidget(bounds);
   std::unique_ptr<views::Widget> widget2 = CreateWindowWidget(bounds);
 
   aura::test::TestWindowDelegate delegate;
   delegate.set_minimum_size(gfx::Size(200, 500));
   std::unique_ptr<aura::Window> docked_window1(
       CreateTestWindowInShellWithDelegate(&delegate, -1, bounds));
+  docked_window1->SetProperty(aura::client::kTopViewInset, kHeaderHeight);
   std::unique_ptr<aura::Window> docked_window2(
       CreateTestWindowInShellWithDelegate(&delegate, -1, bounds));
+  docked_window2->SetProperty(aura::client::kTopViewInset, kHeaderHeight);
   wm::WindowState* state1 = wm::GetWindowState(docked_window1.get());
   wm::WindowState* state2 = wm::GetWindowState(docked_window2.get());
 
   // Dock the second window first, then the first window.
   wm::WMEvent dock_event(wm::WM_EVENT_DOCK);
   state2->OnWMEvent(&dock_event);
   state1->OnWMEvent(&dock_event);
 
   // Both windows' restored bounds are same.
   const gfx::Rect expected_bounds = docked_window1->bounds();
   EXPECT_EQ(expected_bounds.ToString(), docked_window2->bounds().ToString());
 
   // |docked_window1| is docked and visible.
   EXPECT_TRUE(docked_window1->IsVisible());
   EXPECT_EQ(wm::WINDOW_STATE_TYPE_DOCKED, state1->GetStateType());
   // |docked_window2| is docked-minimized and hidden.
   EXPECT_FALSE(docked_window2->IsVisible());
   EXPECT_EQ(wm::WINDOW_STATE_TYPE_DOCKED_MINIMIZED, state2->GetStateType());
 
   ToggleOverview();
 
   // Activate |docked_window2| leaving the overview.
   const gfx::RectF rect =
       GetTransformedBoundsInRootWindow(docked_window2.get());
-  gfx::Point point(rect.top_right().x() - 50, rect.top_right().y() + 10);
+  gfx::Point point(rect.top_right().x() - 50, rect.top_right().y() + 50);
   ui::test::EventGenerator event_generator(docked_window2->GetRootWindow(),
                                            point);
   event_generator.ClickLeftButton();
 
   // Windows' bounds are still the same.
   EXPECT_EQ(expected_bounds.ToString(), docked_window1->bounds().ToString());
   EXPECT_EQ(expected_bounds.ToString(), docked_window2->bounds().ToString());
 
   // |docked_window1| is docked-minimized and hidden.
   EXPECT_FALSE(docked_window1->IsVisible());
@@ skipping 10 matching lines @@
 
   // aura::Window* root_window = Shell::GetPrimaryRootWindow();
   gfx::Rect bounds(300, 0, 200, 200);
   std::unique_ptr<views::Widget> widget1 = CreateWindowWidget(bounds);
   std::unique_ptr<views::Widget> widget2 = CreateWindowWidget(bounds);
 
   aura::test::TestWindowDelegate delegate;
   delegate.set_minimum_size(gfx::Size(200, 500));
   std::unique_ptr<aura::Window> docked_window1(
       CreateTestWindowInShellWithDelegate(&delegate, -1, bounds));
+  docked_window1->SetProperty(aura::client::kTopViewInset, kHeaderHeight);
   std::unique_ptr<views::Widget> docked2 = CreateWindowWidget(bounds);
   aura::Window* docked_window2 = docked2->GetNativeWindow();
   wm::WindowState* state1 = wm::GetWindowState(docked_window1.get());
   wm::WindowState* state2 = wm::GetWindowState(docked_window2);
 
   // Dock the first window first, then the second window.
   wm::WMEvent dock_event(wm::WM_EVENT_DOCK);
   state1->OnWMEvent(&dock_event);
   state2->OnWMEvent(&dock_event);
 
   const gfx::Rect expected_bounds1 = docked_window1->bounds();
 
   // |docked_window1| is docked-minimized and hidden.
   EXPECT_FALSE(docked_window1->IsVisible());
   EXPECT_EQ(wm::WINDOW_STATE_TYPE_DOCKED_MINIMIZED, state1->GetStateType());
   // |docked_window2| is docked and visible.
   EXPECT_TRUE(docked_window2->IsVisible());
   EXPECT_EQ(wm::WINDOW_STATE_TYPE_DOCKED, state2->GetStateType());
 
   ToggleOverview();
 
   // Close |docked_window2| (staying in overview).
   const gfx::RectF rect = GetTransformedBoundsInRootWindow(docked_window2);
-  gfx::Point point(rect.top_right().x() - 5, rect.top_right().y() - 5);
+  gfx::Point point(rect.top_right().x() - 5, rect.top_right().y() + 5);
   ui::test::EventGenerator event_generator(docked_window2->GetRootWindow(),
                                            point);
   // Both windows are visible while in overview.
   EXPECT_TRUE(docked_window1->IsVisible());
   EXPECT_EQ(wm::WINDOW_STATE_TYPE_DOCKED, state1->GetStateType());
   EXPECT_TRUE(docked_window2->IsVisible());
   EXPECT_EQ(wm::WINDOW_STATE_TYPE_DOCKED, state2->GetStateType());
 
   event_generator.ClickLeftButton();
   // |docked2| widget is closed.
@@ skipping 17 matching lines @@
 
   // aura::Window* root_window = Shell::GetPrimaryRootWindow();
   gfx::Rect bounds(300, 0, 200, 200);
   std::unique_ptr<views::Widget> widget1 = CreateWindowWidget(bounds);
   std::unique_ptr<views::Widget> widget2 = CreateWindowWidget(bounds);
 
   aura::test::TestWindowDelegate delegate;
   delegate.set_minimum_size(gfx::Size(200, 500));
   std::unique_ptr<aura::Window> docked_window1(
       CreateTestWindowInShellWithDelegate(&delegate, -1, bounds));
+  docked_window1->SetProperty(aura::client::kTopViewInset, kHeaderHeight);
   std::unique_ptr<views::Widget> docked2 = CreateWindowWidget(bounds);
   aura::Window* docked_window2 = docked2->GetNativeWindow();
   wm::WindowState* state1 = wm::GetWindowState(docked_window1.get());
   wm::WindowState* state2 = wm::GetWindowState(docked_window2);
 
   // Dock the second window first, then the first window.
   wm::WMEvent dock_event(wm::WM_EVENT_DOCK);
   state2->OnWMEvent(&dock_event);
   state1->OnWMEvent(&dock_event);
 
   const gfx::Rect expected_bounds1 = docked_window1->bounds();
 
   // |docked_window1| is docked and visible.
   EXPECT_TRUE(docked_window1->IsVisible());
   EXPECT_EQ(wm::WINDOW_STATE_TYPE_DOCKED, state1->GetStateType());
   // |docked_window2| is docked-minimized and hidden.
   EXPECT_FALSE(docked_window2->IsVisible());
   EXPECT_EQ(wm::WINDOW_STATE_TYPE_DOCKED_MINIMIZED, state2->GetStateType());
 
   ToggleOverview();
 
   // Close |docked_window2| (staying in overview).
   const gfx::RectF rect = GetTransformedBoundsInRootWindow(docked_window2);
-  gfx::Point point(rect.top_right().x() - 5, rect.top_right().y() - 5);
+  gfx::Point point(rect.top_right().x() - 5, rect.top_right().y() + 5);
   ui::test::EventGenerator event_generator(docked_window2->GetRootWindow(),
                                            point);
   // Both windows are visible while in overview.
   EXPECT_TRUE(docked_window1->IsVisible());
   EXPECT_EQ(wm::WINDOW_STATE_TYPE_DOCKED, state1->GetStateType());
   EXPECT_TRUE(docked_window2->IsVisible());
   EXPECT_EQ(wm::WINDOW_STATE_TYPE_DOCKED, state2->GetStateType());
 
   event_generator.ClickLeftButton();
   // |docked2| widget is closed.
@@ skipping 115 matching lines @@
 // recorded when overview mode exits as a result of closing its only window.
 TEST_P(WindowSelectorTest, ActiveWindowChangedUserActionWindowClose) {
   base::UserActionTester user_action_tester;
   std::unique_ptr<views::Widget> widget =
       CreateWindowWidget(gfx::Rect(0, 0, 400, 400));
 
   ToggleOverview();
 
   aura::Window* window = widget->GetNativeWindow();
   gfx::RectF bounds = GetTransformedBoundsInRootWindow(window);
-  gfx::Point point(bounds.top_right().x() - 1, bounds.top_right().y() - 1);
+  gfx::Point point(bounds.top_right().x() - 1, bounds.top_right().y() + 5);
   ui::test::EventGenerator event_generator(window->GetRootWindow(), point);
 
   ASSERT_FALSE(widget->IsClosed());
   event_generator.ClickLeftButton();
   ASSERT_TRUE(widget->IsClosed());
   EXPECT_EQ(
       0, user_action_tester.GetActionCount(kActiveWindowChangedFromOverview));
 }
 
 // Tests that we do not crash and overview mode remains engaged if the desktop
@@ skipping 94 matching lines @@
 
 // Tests that clicking on the close button effectively closes the window.
 TEST_P(WindowSelectorTest, CloseButton) {
   std::unique_ptr<views::Widget> widget =
       CreateWindowWidget(gfx::Rect(0, 0, 400, 400));
 
   ToggleOverview();
 
   aura::Window* window = widget->GetNativeWindow();
   gfx::RectF bounds = GetTransformedBoundsInRootWindow(window);
-  gfx::Point point(bounds.top_right().x() - 1, bounds.top_right().y() - 1);
+  gfx::Point point(bounds.top_right().x() - 1, bounds.top_right().y() + 5);
   ui::test::EventGenerator event_generator(window->GetRootWindow(), point);
 
   EXPECT_FALSE(widget->IsClosed());
   event_generator.ClickLeftButton();
   EXPECT_TRUE(widget->IsClosed());
 }
 
 // Tests that clicking on the close button on a secondary display effectively
 // closes the window.
 TEST_P(WindowSelectorTest, CloseButtonOnMultipleDisplay) {
@@ skipping 10 matching lines @@
   // via the widget. We also use the widget to determine if the window has been
   // closed or not. We explicity create the widget so that the window can be
   // parented to a non-primary root window.
   std::unique_ptr<views::Widget> widget(new views::Widget);
   views::Widget::InitParams params;
   params.bounds = gfx::Rect(650, 0, 400, 400);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.parent = window1->parent();
   widget->Init(params);
   widget->Show();
+  WmWindow* window = WmLookup::Get()->GetWindowForWidget(widget.get());
+  window->SetIntProperty(WmWindowProperty::TOP_VIEW_INSET, kHeaderHeight);
 
   ASSERT_EQ(root_windows[1], window1->GetRootWindow());
 
   ToggleOverview();
 
   aura::Window* window2 = widget->GetNativeWindow();
   gfx::RectF bounds = GetTransformedBoundsInRootWindow(window2);
-  gfx::Point point(bounds.top_right().x() - 1, bounds.top_right().y() - 1);
+  gfx::Point point(bounds.top_right().x() - 1, bounds.top_right().y() + 5);
   ui::test::EventGenerator event_generator(window2->GetRootWindow(), point);
 
   EXPECT_FALSE(widget->IsClosed());
   event_generator.ClickLeftButton();
   EXPECT_TRUE(widget->IsClosed());
 }
 
 // Tests entering overview mode with two windows and selecting one.
 TEST_P(WindowSelectorTest, FullscreenWindow) {
   gfx::Rect bounds(0, 0, 400, 400);
@@ skipping 119 matching lines @@
         ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
     ToggleOverview();
     EXPECT_FALSE(window1->IsVisible());
     EXPECT_FALSE(window1->layer()->GetTargetVisibility());
   }
 }
 
 // Tests that a bounds change during overview is corrected for.
 TEST_P(WindowSelectorTest, BoundsChangeDuringOverview) {
   std::unique_ptr<aura::Window> window(CreateWindow(gfx::Rect(0, 0, 400, 400)));
+  // Use overview headers above the window in this test.
+  window->SetProperty(aura::client::kTopViewInset, 0);
   ToggleOverview();
   gfx::Rect overview_bounds =
       ToEnclosingRect(GetTransformedTargetBounds(window.get()));
   window->SetBounds(gfx::Rect(200, 0, 200, 200));
   gfx::Rect new_overview_bounds =
       ToEnclosingRect(GetTransformedTargetBounds(window.get()));
   EXPECT_EQ(overview_bounds.x(), new_overview_bounds.x());
   EXPECT_EQ(overview_bounds.y(), new_overview_bounds.y());
   EXPECT_EQ(overview_bounds.width(), new_overview_bounds.width());
   EXPECT_EQ(overview_bounds.height(), new_overview_bounds.height());
@@ skipping 842 matching lines @@
       bounds.y());
   EXPECT_LE(transformed_rect.bottom(), bounds.bottom());
   EXPECT_NEAR(transformed_rect.x() - bounds.x(),
               bounds.right() - transformed_rect.right(), 1);
   EXPECT_NEAR(
       transformed_rect.y() + (int)(scale * inset) - header_height - bounds.y(),
       bounds.bottom() - transformed_rect.bottom(), 1);
 }
 
 }  // namespace ash