athena: Hide the windows when exiting from overview mode.

athena/wm/window_overview_mode.cc

 // Copyright 2014 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 "athena/wm/window_overview_mode.h"
 
 #include <algorithm>
 #include <functional>
 #include <vector>
 
@@ skipping 10 matching lines @@
 #include "ui/aura/window_tree_host.h"
 #include "ui/compositor/closure_animation_observer.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/compositor_animation_observer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event_handler.h"
 #include "ui/events/gestures/fling_curve.h"
 #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 {
 
 struct WindowOverviewState {
   // The transform for when the window is at the topmost position.
   gfx::Transform top;
 
   // The transform for when the window is at the bottom-most position.
   gfx::Transform bottom;
 
@@ skipping 19 matching lines @@
                                            state->bottom);
 }
 
 // Sets the progress-state for the window in the overview mode.
 void SetWindowProgress(aura::Window* window, float progress) {
   WindowOverviewState* state = window->GetProperty(kWindowOverviewState);
   state->progress = 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);
 }
 
 // Always returns the same target.
 class StaticWindowTargeter : public aura::WindowTargeter {
  public:
   explicit StaticWindowTargeter(aura::Window* target) : target_(target) {}
   virtual ~StaticWindowTargeter() {}
 
@@ skipping 17 matching lines @@
 class WindowOverviewModeImpl : public WindowOverviewMode,
                                public ui::EventHandler,
                                public ui::CompositorAnimationObserver {
  public:
   WindowOverviewModeImpl(aura::Window* container,
                          const WindowListProvider* window_list_provider,
                          SplitViewController* split_view_controller,
                          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();
     SetInitialWindowStates();
   }
 
   virtual ~WindowOverviewModeImpl() {
     container_->set_target_handler(container_->delegate());
     RemoveAnimationObserver();
     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:
   // Computes the transforms for all windows in both the topmost and bottom-most
   // positions. The transforms are set in the |kWindowOverviewState| property of
   // the windows.
   void ComputeTerminalStatesForAllWindows() {
     aura::Window::Windows windows = window_list_provider_->GetWindowList();
     size_t index = 0;
 
     for (aura::Window::Windows::const_reverse_iterator iter = windows.rbegin();
          iter != windows.rend();
          ++iter, ++index) {
       aura::Window* window = (*iter);
       wm::SetShadowType(window, wm::SHADOW_TYPE_RECTANGULAR_ALWAYS_ACTIVE);
 
       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);
         state->top.Scale(kMaxScale, kMaxScale);
         state->bottom = state->top;
         --index;
         continue;
       }
       UpdateTerminalStateForWindowAtIndex(window, index, windows.size());
     }
@@ skipping 32 matching lines @@
   void SetInitialWindowStates() {
     aura::Window::Windows windows = window_list_provider_->GetWindowList();
     // The initial overview state of the topmost three windows.
     const float kInitialProgress[] = { 0.5f, 0.05f, 0.01f };
     size_t index = 0;
     for (aura::Window::Windows::const_reverse_iterator iter = windows.rbegin();
          iter != windows.rend();
          ++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))
           progress = kInitialProgress[index];
         ++index;
       }
 
       scoped_refptr<ui::LayerAnimator> animator =
           window->layer()->GetAnimator();
 
@@ skipping 67 matching lines @@
           SetWindowProgress(window, std::min(1.f, state->progress + delta_y_p));
           delta_y_p /= 2.f;
         }
       }
     }
   }
 
   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;
   }
 
   void CreateFlingerFor(const ui::GestureEvent& event) {
     gfx::Vector2dF velocity(event.details().velocity_x(),
                             event.details().velocity_y());
     fling_.reset(new ui::FlingCurve(velocity, gfx::FrameTime::Now()));
   }
 
   void AddAnimationObserver() {
@@ skipping 149 matching lines @@
     overview_toolbar_.reset();
     if (action == OverviewToolbar::ACTION_TYPE_SPLIT)
       delegate_->OnSplitViewMode(NULL, dragged_window_);
     else if (ShouldCloseDragWindow(gesture))
       CloseDragWindow(gesture);
     else
       RestoreDragWindow();
   }
 
   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);
       }
     }
   }
 
   // ui::EventHandler:
   virtual void OnMouseEvent(ui::MouseEvent* mouse) OVERRIDE {
     if (mouse->type() == ui::ET_MOUSE_PRESSED) {
       aura::Window* select = SelectWindowAt(mouse);
@@ skipping 70 matching lines @@
 
   const int kMinDistanceForDismissal = 300;
   const float kMinScale = 0.6f;
   const float kMaxScale = 0.75f;
   const float kMaxOpacity = 1.0f;
   const float kMinOpacity = 0.2f;
 
   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_;
 
   aura::Window* dragged_window_;
   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);
 };
 
 }  // namespace
 
 // static
 scoped_ptr<WindowOverviewMode> WindowOverviewMode::Create(
     aura::Window* container,
     const WindowListProvider* window_list_provider,
     SplitViewController* split_view_controller,
     WindowOverviewModeDelegate* delegate) {
   return scoped_ptr<WindowOverviewMode>(
       new WindowOverviewModeImpl(container, window_list_provider,
                                  split_view_controller, delegate));
 }
 
 }  // namespace athena