athena: Hide the windows when exiting from overview mode.

Going into overview mode makes all the windows visible. At the end of the
overview mode, make sure the windows that aren't visible (i.e. windows
other than the active window, or the left/right windows in split-view mode)
are marked as hidden correctly.

BUG=none
R=oshima@chromium.org

Review URL: https://codereview.chromium.org/525443002

Cr-Commit-Position: refs/heads/master@{#292682}

athena/wm/window_manager_unittest.cc

@@ -48,6 +48,7 @@ TEST_F(WindowManagerTest, OverviewModeBasics) {
       first.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
   aura::client::ParentWindowWithContext(
       second.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
+  wm::ActivateWindow(second.get());
 
   ASSERT_FALSE(WindowManager::GetInstance()->IsOverviewModeActive());
   EXPECT_EQ(first->bounds().ToString(), second->bounds().ToString());
@@ -69,6 +70,37 @@ TEST_F(WindowManagerTest, OverviewModeBasics) {
                 .size()
                 .ToString(),
             first->bounds().size().ToString());
+  EXPECT_TRUE(first->IsVisible());
+  EXPECT_TRUE(second->IsVisible());
+
+  // Terminate overview mode. |first| should be hidden, since it's not visible
+  // to the user anymore.
+  WindowManager::GetInstance()->ToggleOverview();
+  ASSERT_FALSE(WindowManager::GetInstance()->IsOverviewModeActive());
+  EXPECT_FALSE(first->IsVisible());
+  EXPECT_TRUE(second->IsVisible());
+}
+
+TEST_F(WindowManagerTest, OverviewToSplitViewMode) {
+  test::WindowManagerImplTestApi wm_api;
+
+  aura::test::TestWindowDelegate delegate;
+  scoped_ptr<aura::Window> w1(CreateTestWindow(&delegate, gfx::Rect()));
+  scoped_ptr<aura::Window> w2(CreateTestWindow(&delegate, gfx::Rect()));
+  scoped_ptr<aura::Window> w3(CreateTestWindow(&delegate, gfx::Rect()));
+  wm::ActivateWindow(w3.get());
+
+  WindowManager::GetInstance()->ToggleOverview();
+  EXPECT_TRUE(w1->IsVisible());
+  EXPECT_TRUE(w2->IsVisible());
+  EXPECT_TRUE(w3->IsVisible());
+
+  // Go into split-view mode.
+  WindowOverviewModeDelegate* overview_delegate = wm_api.wm();
+  overview_delegate->OnSplitViewMode(NULL, w2.get());
+  EXPECT_TRUE(w3->IsVisible());
+  EXPECT_TRUE(w2->IsVisible());
+  EXPECT_FALSE(w1->IsVisible());
 }
 
 TEST_F(WindowManagerTest, BezelGestureToSplitViewMode) {
@@ -333,6 +365,10 @@ TEST_F(WindowManagerTest, OverviewModeFromSplitMode) {
   WindowOverviewModeDelegate* overview_delegate = wm_api.wm();
   overview_delegate->OnSelectWindow(w1.get());
   EXPECT_FALSE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
+  EXPECT_TRUE(w1->IsVisible());
+  // Make sure the windows that were in split-view mode are hidden.
+  EXPECT_FALSE(w2->IsVisible());
+  EXPECT_FALSE(w3->IsVisible());
 }
 
 }  // namespace athena

athena/wm/window_overview_mode.cc

@@ -28,6 +28,7 @@
 #include "ui/gfx/frame_time.h"
 #include "ui/gfx/transform.h"
 #include "ui/wm/core/shadow_types.h"
+#include "ui/wm/core/window_util.h"
 
 namespace {
 
@@ -67,14 +68,32 @@ void SetWindowProgress(aura::Window* window, float progress) {
   window->SetTransform(GetTransformForState(state));
 }
 
+void HideWindowIfNotVisible(aura::Window* window,
+                            SplitViewController* split_view_controller) {
+  bool should_hide = true;
+  if (split_view_controller->IsSplitViewModeActive()) {
+    should_hide = window != split_view_controller->left_window() &&
+                  window != split_view_controller->right_window();
+  } else {
+    should_hide = !wm::IsActiveWindow(window);
+  }
+  if (should_hide)
+    window->Hide();
+}
+
 // Resets the overview-related state for |window|.
-void RestoreWindowState(aura::Window* window) {
+void RestoreWindowState(aura::Window* window,
+                        SplitViewController* split_view_controller) {
   window->ClearProperty(kWindowOverviewState);
 
   ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
   settings.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(250));
+
+  settings.AddObserver(new ui::ClosureAnimationObserver(
+      base::Bind(&HideWindowIfNotVisible, window, split_view_controller)));
+
   window->SetTransform(gfx::Transform());
   wm::SetShadowType(window, wm::SHADOW_TYPE_NONE);
 }
@@ -112,22 +131,16 @@ class WindowOverviewModeImpl : public WindowOverviewMode,
                          WindowOverviewModeDelegate* delegate)
       : container_(container),
         window_list_provider_(window_list_provider),
+        split_view_controller_(split_view_controller),
         delegate_(delegate),
         scoped_targeter_(new aura::ScopedWindowTargeter(
             container,
             scoped_ptr<ui::EventTargeter>(
                 new StaticWindowTargeter(container)))),
-        dragged_window_(NULL),
-        split_({false, NULL, NULL}) {
+        dragged_window_(NULL) {
     CHECK(delegate_);
     container_->set_target_handler(this);
 
-    split_.enabled = split_view_controller->IsSplitViewModeActive();
-    if (split_.enabled) {
-      split_.left = split_view_controller->left_window();
-      split_.right = split_view_controller->right_window();
-    }
-
     // Prepare the desired transforms for all the windows, and set the initial
     // state on the windows.
     ComputeTerminalStatesForAllWindows();
@@ -140,7 +153,9 @@ class WindowOverviewModeImpl : public WindowOverviewMode,
     aura::Window::Windows windows = window_list_provider_->GetWindowList();
     if (windows.empty())
       return;
-    std::for_each(windows.begin(), windows.end(), &RestoreWindowState);
+    std::for_each(windows.begin(), windows.end(),
+                  std::bind2nd(std::ptr_fun(&RestoreWindowState),
+                               split_view_controller_));
   }
 
  private:
@@ -159,7 +174,9 @@ class WindowOverviewModeImpl : public WindowOverviewMode,
 
       WindowOverviewState* state = new WindowOverviewState;
       window->SetProperty(kWindowOverviewState, state);
-      if (split_.enabled && (window == split_.left || window == split_.right)) {
+      if (split_view_controller_->IsSplitViewModeActive() &&
+          (window == split_view_controller_->left_window() ||
+           window == split_view_controller_->right_window())) {
         // Do not let the left/right windows be scrolled.
         int x_translate = window->bounds().width() * (1 - kMaxScale) / 2;
         state->top.Translate(x_translate, window->bounds().height() * 0.65);
@@ -212,7 +229,9 @@ class WindowOverviewModeImpl : public WindowOverviewMode,
          ++iter) {
       float progress = 0.f;
       aura::Window* window = *iter;
-      if (split_.enabled && (window == split_.left || window == split_.right)) {
+      if (split_view_controller_->IsSplitViewModeActive() &&
+          (window == split_view_controller_->left_window() ||
+           window == split_view_controller_->right_window())) {
         progress = 1;
       } else {
         if (index < arraysize(kInitialProgress))
@@ -300,8 +319,9 @@ class WindowOverviewModeImpl : public WindowOverviewMode,
   int GetScrollableHeight() const {
     const float kScrollableFraction = 0.65f;
     const float kScrollableFractionInSplit = 0.5f;
-    const float fraction =
-        split_.enabled ? kScrollableFractionInSplit : kScrollableFraction;
+    const float fraction = split_view_controller_->IsSplitViewModeActive()
+                               ? kScrollableFractionInSplit
+                               : kScrollableFraction;
     return container_->bounds().height() * fraction;
   }
 
@@ -471,13 +491,15 @@ class WindowOverviewModeImpl : public WindowOverviewMode,
   }
 
   void SelectWindow(aura::Window* window) {
-    if (!split_.enabled) {
+    if (!split_view_controller_->IsSplitViewModeActive()) {
       delegate_->OnSelectWindow(window);
     } else {
       // If the selected window is one of the left/right windows, then keep the
       // current state.
-      if (window == split_.left || window == split_.right) {
-        delegate_->OnSplitViewMode(split_.left, split_.right);
+      if (window == split_view_controller_->left_window() ||
+          window == split_view_controller_->right_window()) {
+        delegate_->OnSplitViewMode(split_view_controller_->left_window(),
+                                   split_view_controller_->right_window());
       } else {
         delegate_->OnSelectWindow(window);
       }
@@ -568,6 +590,8 @@ class WindowOverviewModeImpl : public WindowOverviewMode,
   aura::Window* container_;
   // Provider of the stack of windows to show in the overview mode. Not owned.
   const WindowListProvider* window_list_provider_;
+  SplitViewController* split_view_controller_;
+
   WindowOverviewModeDelegate* delegate_;
   scoped_ptr<aura::ScopedWindowTargeter> scoped_targeter_;
   scoped_ptr<ui::FlingCurve> fling_;
@@ -576,12 +600,6 @@ class WindowOverviewModeImpl : public WindowOverviewMode,
   gfx::Point dragged_start_location_;
   scoped_ptr<OverviewToolbar> overview_toolbar_;
 
-  struct {
-    bool enabled;
-    aura::Window* left;
-    aura::Window* right;
-  } split_;
-
   DISALLOW_COPY_AND_ASSIGN(WindowOverviewModeImpl);
 };