Use mirror layer for minimized windows in overview mode

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"
@@ skipping 158 matching lines @@
     aura::Window* window = CreateTestWindowInShellWithDelegateAndType(
         nullptr, ui::wm::WINDOW_TYPE_PANEL, 0, bounds);
     window->SetProperty(aura::client::kTopViewInset, kHeaderHeight);
     test::TestShelfDelegate::instance()->AddShelfItem(
         WmWindowAura::Get(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);
+    gfx::Rect window1_bounds = GetTransformedTargetBounds(window1);
+    gfx::Rect window2_bounds = GetTransformedTargetBounds(window2);
     return window1_bounds.Intersects(window2_bounds);
   }
 
   WindowSelectorController* window_selector_controller() {
     return WmShell::Get()->window_selector_controller();
   }
 
   WindowSelector* window_selector() {
     return window_selector_controller()->window_selector_.get();
   }
 
   void ToggleOverview() { window_selector_controller()->ToggleOverview(); }
 
-  gfx::RectF GetTransformedBounds(aura::Window* window) {
+  aura::Window* GetOverviewWindowForMinimizedState(int index,
+                                                   aura::Window* window) {
+    WindowSelectorItem* selector = GetWindowItemForWindow(index, window);
+    return WmWindowAura::GetAuraWindow(
+        selector->GetOverviewWindowForMinimizedStateForTest());
+  }
+
+  gfx::Rect GetTransformedBounds(aura::Window* window) {
     gfx::RectF bounds(ScreenUtil::ConvertRectToScreen(
         window->parent(), window->layer()->bounds()));
     gfx::Transform transform(gfx::TransformAboutPivot(
         gfx::ToFlooredPoint(bounds.origin()), window->layer()->transform()));
     transform.TransformRect(&bounds);
-    return bounds;
+    return gfx::ToEnclosingRect(bounds);
   }
 
-  gfx::RectF GetTransformedTargetBounds(aura::Window* window) {
+  gfx::Rect GetTransformedTargetBounds(aura::Window* window) {
     gfx::RectF bounds(ScreenUtil::ConvertRectToScreen(
         window->parent(), window->layer()->GetTargetBounds()));
     gfx::Transform transform(
         gfx::TransformAboutPivot(gfx::ToFlooredPoint(bounds.origin()),
                                  window->layer()->GetTargetTransform()));
     transform.TransformRect(&bounds);
-    return bounds;
+    return gfx::ToEnclosingRect(bounds);
   }
 
-  gfx::RectF GetTransformedBoundsInRootWindow(aura::Window* window) {
+  gfx::Rect GetTransformedBoundsInRootWindow(aura::Window* window) {
     gfx::RectF bounds = gfx::RectF(gfx::SizeF(window->bounds().size()));
     aura::Window* root = window->GetRootWindow();
     CHECK(window->layer());
     CHECK(root->layer());
     gfx::Transform transform;
     if (!window->layer()->GetTargetTransformRelativeTo(root->layer(),
                                                        &transform)) {
-      return gfx::RectF();
+      return gfx::Rect();
     }
     transform.TransformRect(&bounds);
-    return bounds;
+    return gfx::ToEnclosingRect(bounds);
   }
 
   void ClickWindow(aura::Window* window) {
     ui::test::EventGenerator event_generator(window->GetRootWindow(), window);
     event_generator.ClickLeftButton();
   }
 
   void SendKey(ui::KeyboardCode key) {
     ui::test::EventGenerator event_generator(Shell::GetPrimaryRootWindow());
     event_generator.PressKey(key, 0);
@@ skipping 87 matching lines @@
 
   // Tests that a window is contained within a given WindowSelectorItem, and
   // that both the window and its matching close button are within the same
   // screen.
   void IsWindowAndCloseButtonInScreen(aura::Window* window,
                                       WindowSelectorItem* window_item) {
     aura::Window* root_window =
         WmWindowAura::GetAuraWindow(window_item->root_window());
     EXPECT_TRUE(window_item->Contains(WmWindowAura::Get(window)));
     EXPECT_TRUE(root_window->GetBoundsInScreen().Contains(
-        ToEnclosingRect(GetTransformedTargetBounds(window))));
-    EXPECT_TRUE(root_window->GetBoundsInScreen().Contains(
-        ToEnclosingRect(GetTransformedTargetBounds(
-            GetCloseButton(window_item)->GetNativeView()))));
+        GetTransformedTargetBounds(window)));
+    EXPECT_TRUE(
+        root_window->GetBoundsInScreen().Contains(GetTransformedTargetBounds(
+            GetCloseButton(window_item)->GetNativeView())));
   }
 
   void FilterItems(const base::StringPiece& pattern) {
     window_selector()->ContentsChanged(nullptr, base::UTF8ToUTF16(pattern));
   }
 
   test::ShelfViewTestAPI* shelf_view_test() { return shelf_view_test_.get(); }
 
   views::Widget* text_filter_widget() {
     return window_selector()->text_filter_widget_.get();
@@ skipping 101 matching lines @@
   // Clicking window 1 should activate it.
   ClickWindow(window1.get());
   EXPECT_TRUE(wm::IsActiveWindow(window1.get()));
   EXPECT_FALSE(wm::IsActiveWindow(window2.get()));
   EXPECT_EQ(window1.get(), GetFocusedWindow());
 
   // Cursor should have been unlocked.
   EXPECT_FALSE(aura::client::GetCursorClient(root_window)->IsCursorLocked());
 }
 
+// Tests activating minimized window.
+TEST_F(WindowSelectorTest, ActivateMinimized) {
+  gfx::Rect bounds(0, 0, 400, 400);
+  std::unique_ptr<aura::Window> window(CreateWindow(bounds));
+
+  wm::WindowState* window_state = wm::GetWindowState(window.get());
+  wm::WMEvent minimize_event(wm::WM_EVENT_MINIMIZE);
+  window_state->OnWMEvent(&minimize_event);
+  EXPECT_FALSE(window->IsVisible());
+  EXPECT_EQ(wm::WINDOW_STATE_TYPE_MINIMIZED,
+            wm::GetWindowState(window.get())->GetStateType());
+
+  ToggleOverview();
+
+  EXPECT_FALSE(window->IsVisible());
+  EXPECT_EQ(wm::WINDOW_STATE_TYPE_MINIMIZED,
+            wm::GetWindowState(window.get())->GetStateType());
+  aura::Window* window_for_minimized_window =
+      GetOverviewWindowForMinimizedState(0, window.get());
+  EXPECT_TRUE(window_for_minimized_window);
+
+  const gfx::Point point =
+      GetTransformedBoundsInRootWindow(window_for_minimized_window)
+          .CenterPoint();
+  ui::test::EventGenerator event_generator(window->GetRootWindow(), point);
+  event_generator.ClickLeftButton();
+
+  EXPECT_FALSE(IsSelecting());
+
+  EXPECT_TRUE(window->IsVisible());
+  EXPECT_EQ(wm::WINDOW_STATE_TYPE_NORMAL,
+            wm::GetWindowState(window.get())->GetStateType());
+}
+
 // Tests that entering overview mode with an App-list active properly focuses
 // and activates the overview text filter window.
 TEST_F(WindowSelectorTest, TextFilterActive) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   wm::ActivateWindow(window1.get());
 
   EXPECT_TRUE(wm::IsActiveWindow(window1.get()));
   EXPECT_EQ(window1.get(), GetFocusedWindow());
 
@@ skipping 69 matching lines @@
 
   ToggleOverview();
 
   EXPECT_FALSE(WindowsOverlapping(window1.get(), window2.get()));
 
   gfx::Rect container_bounds = docked1->parent()->bounds();
   ShelfWidget* shelf = GetPrimaryShelf()->shelf_widget();
   DockedWindowLayoutManager* manager =
       DockedWindowLayoutManager::Get(WmWindowAura::Get(docked1.get()));
 
-  // Docked windows get shown and transformed.
-  EXPECT_TRUE(docked2->IsVisible());
+  // Minimized docked windows stays invisible.
+  EXPECT_FALSE(docked2->IsVisible());
+  EXPECT_TRUE(GetOverviewWindowForMinimizedState(0, docked2.get()));
 
   // Docked area shrinks.
   EXPECT_EQ(0, manager->docked_bounds().width());
 
   // Work area takes the whole screen minus the shelf.
   gfx::Rect work_area = display::Screen::GetScreen()
                             ->GetDisplayNearestWindow(docked1.get())
                             .work_area();
   gfx::Size expected_work_area_bounds(container_bounds.size());
   expected_work_area_bounds.Enlarge(0,
@@ skipping 48 matching lines @@
 
   // |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();
 
+  // Minimized should stay minimized.
+  EXPECT_FALSE(docked_window2->IsVisible());
+  EXPECT_EQ(wm::WINDOW_STATE_TYPE_DOCKED_MINIMIZED, state2->GetStateType());
+
+  aura::Window* window_for_minimized_docked_window2 =
+      GetOverviewWindowForMinimizedState(0, docked_window2.get());
+  ASSERT_TRUE(window_for_minimized_docked_window2);
+
   // Activate |docked_window2| leaving the overview.
-  const gfx::RectF rect =
-      GetTransformedBoundsInRootWindow(docked_window2.get());
+  const gfx::Rect rect =
+      GetTransformedBoundsInRootWindow(window_for_minimized_docked_window2);
   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();
 
+  EXPECT_FALSE(IsSelecting());
+
   // 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());
   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());
@@ skipping 26 matching lines @@
   // |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);
+  const gfx::Rect rect = GetTransformedBoundsInRootWindow(docked_window2);
   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());
+
+  // Minimized window stays invisible and in the minimized state while in
+  // overview.
+  EXPECT_FALSE(docked_window1->IsVisible());
+  EXPECT_EQ(wm::WINDOW_STATE_TYPE_DOCKED_MINIMIZED, state1->GetStateType());
   EXPECT_TRUE(docked_window2->IsVisible());
   EXPECT_EQ(wm::WINDOW_STATE_TYPE_DOCKED, state2->GetStateType());
 
+  EXPECT_TRUE(GetOverviewWindowForMinimizedState(0, docked_window1.get()));
+
   event_generator.ClickLeftButton();
   // |docked2| widget is closed.
   EXPECT_TRUE(docked2->IsClosed());
 
   // Exit overview.
   ToggleOverview();
 
   // Window bounds are still the same.
   EXPECT_EQ(expected_bounds1.ToString(), docked_window1->bounds().ToString());
 
@@ skipping 28 matching lines @@
 
   // |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);
-  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());
+  EXPECT_FALSE(docked_window2->IsVisible());
+  EXPECT_EQ(wm::WINDOW_STATE_TYPE_DOCKED_MINIMIZED, state2->GetStateType());
 
+  // Close |docked_window2| (staying in overview).
+  aura::Window* window_for_minimized_docked_window2 =
+      GetOverviewWindowForMinimizedState(0, docked_window2);
+  ASSERT_TRUE(window_for_minimized_docked_window2);
+  const gfx::Rect rect =
+      GetTransformedBoundsInRootWindow(window_for_minimized_docked_window2);
+  gfx::Point point(rect.top_right().x() - 10, rect.top_right().y() - 10);
+  ui::test::EventGenerator event_generator(docked_window2->GetRootWindow(),
+                                           point);
   event_generator.ClickLeftButton();
   // |docked2| widget is closed.
   EXPECT_TRUE(docked2->IsClosed());
 
   // Exit overview.
   ToggleOverview();
 
   // Window bounds are still the same.
   EXPECT_EQ(expected_bounds1.ToString(),
             docked_window1->GetTargetBounds().ToString());
 
   // |docked_window1| returns to docked and visible state.
   EXPECT_TRUE(docked_window1->IsVisible());
   EXPECT_EQ(wm::WINDOW_STATE_TYPE_DOCKED, state1->GetStateType());
 }
 
 // Tests selecting a window by tapping on it.
 TEST_F(WindowSelectorTest, BasicGesture) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   wm::ActivateWindow(window1.get());
   EXPECT_EQ(window1.get(), GetFocusedWindow());
   ToggleOverview();
   EXPECT_EQ(text_filter_widget()->GetNativeWindow(), GetFocusedWindow());
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                      window2.get());
   generator.GestureTapAt(
-      gfx::ToEnclosingRect(GetTransformedTargetBounds(window2.get()))
-          .CenterPoint());
+      GetTransformedTargetBounds(window2.get()).CenterPoint());
   EXPECT_EQ(window2.get(), GetFocusedWindow());
 }
 
 // Tests that the user action WindowSelector_ActiveWindowChanged is
 // recorded when the mouse/touchscreen/keyboard are used to select a window
 // in overview mode which is different from the previously-active window.
 TEST_F(WindowSelectorTest, ActiveWindowChangedUserActionRecorded) {
   base::UserActionTester user_action_tester;
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
 
   // Tap on |window2| to activate it and exit overview.
   wm::ActivateWindow(window1.get());
   ToggleOverview();
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                      window2.get());
   generator.GestureTapAt(
-      gfx::ToEnclosingRect(GetTransformedTargetBounds(window2.get()))
-          .CenterPoint());
+      GetTransformedTargetBounds(window2.get()).CenterPoint());
   EXPECT_EQ(
       1, user_action_tester.GetActionCount(kActiveWindowChangedFromOverview));
 
   // Click on |window2| to activate it and exit overview.
   wm::ActivateWindow(window1.get());
   ToggleOverview();
   ClickWindow(window2.get());
   EXPECT_EQ(
       2, user_action_tester.GetActionCount(kActiveWindowChangedFromOverview));
 
@@ skipping 18 matching lines @@
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
 
   // Set |window1| to be initially active.
   wm::ActivateWindow(window1.get());
   ToggleOverview();
 
   // Tap on |window1| to exit overview.
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                      window1.get());
   generator.GestureTapAt(
-      gfx::ToEnclosingRect(GetTransformedTargetBounds(window1.get()))
-          .CenterPoint());
+      GetTransformedTargetBounds(window1.get()).CenterPoint());
   EXPECT_EQ(
       0, user_action_tester.GetActionCount(kActiveWindowChangedFromOverview));
 
   // |window1| remains active. Click on it to exit overview.
   ASSERT_EQ(window1.get(), GetFocusedWindow());
   ToggleOverview();
   ClickWindow(window1.get());
   EXPECT_EQ(
       0, user_action_tester.GetActionCount(kActiveWindowChangedFromOverview));
 
@@ skipping 16 matching lines @@
 // Tests that the user action WindowSelector_ActiveWindowChanged is not
 // recorded when overview mode exits as a result of closing its only window.
 TEST_F(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::Rect bounds = GetTransformedBoundsInRootWindow(window);
   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
 // is tapped while a finger is already down over a window.
 TEST_F(WindowSelectorTest, NoCrashWithDesktopTap) {
   std::unique_ptr<aura::Window> window(
       CreateWindow(gfx::Rect(200, 300, 250, 450)));
 
   ToggleOverview();
 
-  gfx::Rect bounds =
-      gfx::ToEnclosingRect(GetTransformedBoundsInRootWindow(window.get()));
+  gfx::Rect bounds = GetTransformedBoundsInRootWindow(window.get());
   ui::test::EventGenerator event_generator(window->GetRootWindow(),
                                            bounds.CenterPoint());
 
   // Press down on the window.
   const int kTouchId = 19;
   event_generator.PressTouchId(kTouchId);
 
   // Tap on the desktop, which should not cause a crash. Overview mode should
   // be disengaged.
   event_generator.GestureTapAt(gfx::Point(0, 0));
   EXPECT_FALSE(IsSelecting());
 
   event_generator.ReleaseTouchId(kTouchId);
 }
 
 // Tests that we do not crash and a window is selected when appropriate when
 // we click on a window during touch.
 TEST_F(WindowSelectorTest, ClickOnWindowDuringTouch) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   wm::ActivateWindow(window2.get());
   EXPECT_FALSE(wm::IsActiveWindow(window1.get()));
   EXPECT_TRUE(wm::IsActiveWindow(window2.get()));
 
   ToggleOverview();
 
-  gfx::Rect window1_bounds =
-      gfx::ToEnclosingRect(GetTransformedBoundsInRootWindow(window1.get()));
+  gfx::Rect window1_bounds = GetTransformedBoundsInRootWindow(window1.get());
   ui::test::EventGenerator event_generator(window1->GetRootWindow(),
                                            window1_bounds.CenterPoint());
 
   // Clicking on |window2| while touching on |window1| should not cause a
   // crash, overview mode should be disengaged and |window2| should be active.
   const int kTouchId = 19;
   event_generator.PressTouchId(kTouchId);
   event_generator.MoveMouseToCenterOf(window2.get());
   event_generator.ClickLeftButton();
   EXPECT_FALSE(IsSelecting());
@@ skipping 28 matching lines @@
   ui::EventTarget* root_target = root_window;
   ui::EventTargeter* targeter = root_target->GetEventTargeter();
 
   // The event should target the window because we are still not in overview
   // mode.
   EXPECT_EQ(window.get(), targeter->FindTargetForEvent(root_target, &event1));
 
   ToggleOverview();
 
   // The bounds have changed, take that into account.
-  gfx::RectF bounds = GetTransformedBoundsInRootWindow(window.get());
+  gfx::Rect bounds = GetTransformedBoundsInRootWindow(window.get());
   gfx::Point point2(bounds.x() + 10, bounds.y() + 10);
   ui::MouseEvent event2(ui::ET_MOUSE_PRESSED, point2, point2,
                         ui::EventTimeForNow(), ui::EF_NONE, ui::EF_NONE);
 
   // Now the transparent window should be intercepting this event.
   EXPECT_NE(window.get(), targeter->FindTargetForEvent(root_target, &event2));
 }
 
 // Tests that clicking on the close button effectively closes the window.
 TEST_F(WindowSelectorTest, CloseButton) {
   std::unique_ptr<views::Widget> widget =
       CreateWindowWidget(gfx::Rect(0, 0, 400, 400));
 
+  std::unique_ptr<views::Widget> minimized_widget =
+      CreateWindowWidget(gfx::Rect(400, 0, 400, 400));
+  minimized_widget->Minimize();
+
   ToggleOverview();
 
   aura::Window* window = widget->GetNativeWindow();
-  gfx::RectF bounds = GetTransformedBoundsInRootWindow(window);
+  gfx::Rect bounds = GetTransformedBoundsInRootWindow(window);
   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());
+
+  EXPECT_TRUE(IsSelecting());
+
+  aura::Window* window_for_minimized_window =
+      GetOverviewWindowForMinimizedState(0,
+                                         minimized_widget->GetNativeWindow());
+  ASSERT_TRUE(window_for_minimized_window);
+  const gfx::Rect rect =
+      GetTransformedBoundsInRootWindow(window_for_minimized_window);
+
+  event_generator.MoveMouseTo(
+      gfx::Point(rect.top_right().x() - 10, rect.top_right().y() - 10));
+
+  EXPECT_FALSE(minimized_widget->IsClosed());
+  event_generator.ClickLeftButton();
+  EXPECT_TRUE(minimized_widget->IsClosed());
+
+  // All minimized windows are closed, so it should exit overview mode.
+  RunAllPendingInMessageLoop();
+  EXPECT_FALSE(IsSelecting());
+}
+
+// Tests minimizing/unminimizing in overview mode.
+TEST_F(WindowSelectorTest, MinimizeUnminimizei) {
+  std::unique_ptr<views::Widget> widget =
+      CreateWindowWidget(gfx::Rect(0, 0, 400, 400));
+  aura::Window* window = widget->GetNativeWindow();
+
+  ToggleOverview();
+
+  EXPECT_FALSE(GetOverviewWindowForMinimizedState(0, window));
+  widget->Minimize();
+  EXPECT_TRUE(widget->IsMinimized());
+  EXPECT_TRUE(IsSelecting());
+
+  EXPECT_TRUE(GetOverviewWindowForMinimizedState(0, window));
+
+  widget->Restore();
+  EXPECT_FALSE(widget->IsMinimized());
+
+  EXPECT_FALSE(GetOverviewWindowForMinimizedState(0, window));
+  EXPECT_TRUE(IsSelecting());
 }
 
 // Tests that clicking on the close button on a secondary display effectively
 // closes the window.
 TEST_F(WindowSelectorTest, CloseButtonOnMultipleDisplay) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("600x400,600x400");
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
@@ skipping 13 matching lines @@
   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::Rect bounds = GetTransformedBoundsInRootWindow(window2);
   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_F(WindowSelectorTest, FullscreenWindow) {
@@ skipping 154 matching lines @@
     }
   }
 }
 
 // Tests that a bounds change during overview is corrected for.
 TEST_F(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()));
+  gfx::Rect overview_bounds = GetTransformedTargetBounds(window.get());
   window->SetBounds(gfx::Rect(200, 0, 200, 200));
-  gfx::Rect new_overview_bounds =
-      ToEnclosingRect(GetTransformedTargetBounds(window.get()));
+  gfx::Rect new_overview_bounds = 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());
   ToggleOverview();
 }
 
 // Tests that a newly created window aborts overview.
 TEST_F(WindowSelectorTest, NewWindowCancelsOveriew) {
   gfx::Rect bounds(0, 0, 400, 400);
@@ skipping 52 matching lines @@
   window1.reset();
   window2.reset();
   EXPECT_FALSE(IsSelecting());
 }
 
 // Tests that entering overview mode restores a window to its original
 // target location.
 TEST_F(WindowSelectorTest, QuickReentryRestoresInitialTransform) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window(CreateWindow(bounds));
-  gfx::Rect initial_bounds =
-      ToEnclosingRect(GetTransformedBounds(window.get()));
+  gfx::Rect initial_bounds = GetTransformedBounds(window.get());
   ToggleOverview();
   // Quickly exit and reenter overview mode. The window should still be
   // animating when we reenter. We cannot short circuit animations for this but
   // we also don't have to wait for them to complete.
   {
     ui::ScopedAnimationDurationScaleMode test_duration_mode(
         ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
     ToggleOverview();
     ToggleOverview();
   }
-  EXPECT_NE(initial_bounds,
-            ToEnclosingRect(GetTransformedTargetBounds(window.get())));
+  EXPECT_NE(initial_bounds, GetTransformedTargetBounds(window.get()));
   ToggleOverview();
   EXPECT_FALSE(IsSelecting());
-  EXPECT_EQ(initial_bounds,
-            ToEnclosingRect(GetTransformedTargetBounds(window.get())));
+  EXPECT_EQ(initial_bounds, GetTransformedTargetBounds(window.get()));
 }
 
 // Tests that windows with modal child windows are transformed with the modal
 // child even though not activatable themselves.
 TEST_F(WindowSelectorTest, ModalChild) {
   gfx::Rect bounds(0, 0, 400, 400);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> child1(CreateWindow(bounds));
   child1->SetProperty(aura::client::kModalKey, ui::MODAL_TYPE_WINDOW);
   ::wm::AddTransientChild(window1.get(), child1.get());
   EXPECT_EQ(window1->parent(), child1->parent());
   ToggleOverview();
   EXPECT_TRUE(window1->IsVisible());
   EXPECT_TRUE(child1->IsVisible());
-  EXPECT_EQ(ToEnclosingRect(GetTransformedTargetBounds(child1.get())),
-            ToEnclosingRect(GetTransformedTargetBounds(window1.get())));
+  EXPECT_EQ(GetTransformedTargetBounds(child1.get()),
+            GetTransformedTargetBounds(window1.get()));
   ToggleOverview();
 }
 
 // Tests that clicking a modal window's parent activates the modal window in
 // overview.
 TEST_F(WindowSelectorTest, ClickModalWindowParent) {
   std::unique_ptr<aura::Window> window1(
       CreateWindow(gfx::Rect(0, 0, 180, 180)));
   std::unique_ptr<aura::Window> child1(
       CreateWindow(gfx::Rect(200, 0, 180, 180)));
@@ skipping 181 matching lines @@
   EXPECT_EQ("0,0 600x200", root_window->bounds().ToString());
   gfx::Rect window_bounds(0, 0, 150, 150);
   ScopedVector<aura::Window> windows;
   for (int i = 0; i < 3; i++) {
     windows.push_back(CreateWindow(window_bounds));
   }
 
   ToggleOverview();
   for (ScopedVector<aura::Window>::iterator iter = windows.begin();
        iter != windows.end(); ++iter) {
-    EXPECT_TRUE(root_window->bounds().Contains(
-        ToEnclosingRect(GetTransformedTargetBounds(*iter))));
+    EXPECT_TRUE(
+        root_window->bounds().Contains(GetTransformedTargetBounds(*iter)));
   }
 
   // Rotate the display, windows should be repositioned to be within the screen
   // bounds.
   UpdateDisplay("600x200/r");
   EXPECT_EQ("0,0 200x600", root_window->bounds().ToString());
   for (ScopedVector<aura::Window>::iterator iter = windows.begin();
        iter != windows.end(); ++iter) {
-    EXPECT_TRUE(root_window->bounds().Contains(
-        ToEnclosingRect(GetTransformedTargetBounds(*iter))));
+    EXPECT_TRUE(
+        root_window->bounds().Contains(GetTransformedTargetBounds(*iter)));
   }
 }
 
 // Tests traversing some windows in overview mode with the tab key.
 TEST_F(WindowSelectorTest, BasicTabKeyNavigation) {
   gfx::Rect bounds(0, 0, 100, 100);
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   ToggleOverview();
 
@@ skipping 500 matching lines @@
                           HTCAPTION, aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   ASSERT_TRUE(resizer.get());
   gfx::Point location = resizer->GetInitialLocation();
   location.Offset(20, 20);
   resizer->Drag(location, 0);
   ToggleOverview();
   resizer->RevertDrag();
 }
 
 }  // namespace ash