Ensure that an activity is activated when overview mode is exited

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>
 
 #include "athena/wm/overview_toolbar.h"
 #include "athena/wm/public/window_list_provider.h"
 #include "athena/wm/split_view_controller.h"
 #include "base/bind.h"
 #include "base/macros.h"
 #include "ui/aura/scoped_window_targeter.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_property.h"
 #include "ui/aura/window_targeter.h"
 #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/layer_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 {
 
@@ skipping 26 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);
+void HideWindowIfTransparent(aura::Window* window) {
+  if (window->layer()->opacity() == 0.0f) {
+    window->Hide();
+    window->layer()->SetOpacity(1.0f);
   }
-  if (should_hide)
-    window->Hide();
 }
 
 // Resets the overview-related state for |window|.
-void RestoreWindowState(aura::Window* window,
-                        SplitViewController* split_view_controller) {
+void RestoreWindowState(aura::Window* window) {
   window->ClearProperty(kWindowOverviewState);
+  wm::SetShadowType(window, wm::SHADOW_TYPE_NONE);
 
-  ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
-  settings.SetPreemptionStrategy(
-      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
-  settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(250));
+  {
+    ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
+    settings.SetPreemptionStrategy(
+        ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+    settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(250));
+    window->SetTransform(gfx::Transform());
+  }
 
-  settings.AddObserver(new ui::ClosureAnimationObserver(
-      base::Bind(&HideWindowIfNotVisible, window, split_view_controller)));
+  {
+    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(&HideWindowIfTransparent, base::Unretained(window))));
 
-  window->SetTransform(gfx::Transform());
+    // The window opacity may not be 1.0f if the user was dragging a window.
+    window->layer()->SetOpacity(1.0f);
 
-  // Reset the window opacity in case the user is dragging a window.
-  window->layer()->SetOpacity(1.0f);
-
-  wm::SetShadowType(window, wm::SHADOW_TYPE_NONE);
+    // Ideally we would animate the window's visibility. However, animating the
+    // window's visibility causes the web contents to hide before the animation
+    // completes. Enqueue a zero duration opacity animation and hide |window| if
+    // the opacity animation is not aborted.
+    settings.SetPreemptionStrategy(
+        ui::LayerAnimator::ENQUEUE_NEW_ANIMATION);
+    settings.SetTransitionDuration(base::TimeDelta());
+    window->layer()->SetOpacity(0.0f);
+  }
 }
 
 gfx::RectF GetTransformedBounds(aura::Window* window) {
   gfx::Transform transform;
   gfx::RectF bounds = window->bounds();
   transform.Translate(bounds.x(), bounds.y());
   transform.PreconcatTransform(window->layer()->transform());
   transform.Translate(-bounds.x(), -bounds.y());
   transform.TransformRect(&bounds);
   return bounds;
@@ skipping 47 matching lines @@
                          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) {
+        dragged_window_(NULL),
+        selected_window_(false) {
     CHECK(delegate_);
     container_->set_target_handler(this);
 
     // 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();
+
+    // Abort any in progress animations. This can have significant consequences
+    // such as deleting one of |windows|.
     aura::Window::Windows windows = window_list_provider_->GetWindowList();
+    for (size_t i = 0; i < windows.size(); ++i)
+      windows[i]->layer()->GetAnimator()->AbortAllAnimations();
+
+    windows = window_list_provider_->GetWindowList();
     if (windows.empty())
       return;
-    std::for_each(windows.begin(), windows.end(),
-                  std::bind2nd(std::ptr_fun(&RestoreWindowState),
-                               split_view_controller_));
+    std::for_each(windows.begin(), windows.end(), &RestoreWindowState);
+
+    if (!selected_window_) {
+      aura::Window* to_select = *windows.rbegin();
+      SelectWindow(to_select, GetDefaultSplitType(to_select));
+    }
   }
 
  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;
 
@@ skipping 365 matching lines @@
     dragged_window_->layer()->SetOpacity(1.f);
     dragged_window_ = NULL;
   }
 
   void EndDragWindow(const ui::GestureEvent& gesture) {
     CHECK(dragged_window_);
     CHECK(overview_toolbar_);
     OverviewToolbar::ActionType action = overview_toolbar_->current_action();
     overview_toolbar_.reset();
     if (action == OverviewToolbar::ACTION_TYPE_SPLIT) {
-      delegate_->OnSplitViewMode(NULL, dragged_window_);
+      SelectWindow(dragged_window_,
+                   WindowOverviewModeDelegate::SPLIT_RIGHT);
       return;
     }
 
     // If the window is dropped on one of the left/right windows in split-mode,
     // then switch that window.
     aura::Window* split_drop = GetSplitWindowDropTarget(gesture);
     if (split_drop) {
-      aura::Window* left = split_view_controller_->left_window();
-      aura::Window* right = split_view_controller_->right_window();
-      if (left == split_drop)
-        left = dragged_window_;
-      else
-        right = dragged_window_;
-      delegate_->OnSplitViewMode(left, right);
+      WindowOverviewModeDelegate::SplitType split_type =
+          (split_view_controller_->left_window() == split_drop)
+              ? WindowOverviewModeDelegate::SPLIT_LEFT
+              : WindowOverviewModeDelegate::SPLIT_RIGHT;
+      SelectWindow(dragged_window_, split_type);
       return;
     }
 
     if (ShouldCloseDragWindow(gesture))
       CloseDragWindow(gesture);
     else
       RestoreDragWindow();
   }
 
-  void SelectWindow(aura::Window* window) {
-    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_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);
-      }
+  WindowOverviewModeDelegate::SplitType GetDefaultSplitType(
+      aura::Window* window) {
+    if (split_view_controller_->IsSplitViewModeActive()) {
+      // Do not exit split view if the split view's left/right window was
+      // selected.
+      if (window == split_view_controller_->left_window())
+        return WindowOverviewModeDelegate::SPLIT_LEFT;
+      else if (window == split_view_controller_->right_window())
+        return WindowOverviewModeDelegate::SPLIT_RIGHT;
     }
+    return WindowOverviewModeDelegate::SPLIT_NONE;
+  }
+
+  void SelectWindow(aura::Window* window,
+                    WindowOverviewModeDelegate::SplitType split_type) {
+    selected_window_ = true;
+    delegate_->OnSelectWindow(window, split_type);
   }
 
   // ui::EventHandler:
   virtual void OnMouseEvent(ui::MouseEvent* mouse) OVERRIDE {
     if (mouse->type() == ui::ET_MOUSE_PRESSED) {
       aura::Window* select = SelectWindowAt(mouse);
       if (select) {
         mouse->SetHandled();
-        SelectWindow(select);
+        SelectWindow(select, GetDefaultSplitType(select));
       }
     } else if (mouse->type() == ui::ET_MOUSEWHEEL) {
       DoScroll(static_cast<ui::MouseWheelEvent*>(mouse)->y_offset());
     }
   }
 
   virtual void OnScrollEvent(ui::ScrollEvent* scroll) OVERRIDE {
     if (scroll->type() == ui::ET_SCROLL)
       DoScroll(scroll->y_offset());
   }
 
   virtual void OnGestureEvent(ui::GestureEvent* gesture) OVERRIDE {
     if (gesture->type() == ui::ET_GESTURE_TAP) {
       aura::Window* select = SelectWindowAt(gesture);
       if (select) {
         gesture->SetHandled();
-        SelectWindow(select);
+        SelectWindow(select, GetDefaultSplitType(select));
       }
     } else if (gesture->type() == ui::ET_GESTURE_SCROLL_BEGIN) {
       if (std::abs(gesture->details().scroll_x_hint()) >
           std::abs(gesture->details().scroll_y_hint()) * 2) {
         dragged_start_location_ = gesture->location();
         dragged_window_ = SelectWindowAt(gesture);
         if (split_view_controller_->IsSplitViewModeActive() &&
             (dragged_window_ == split_view_controller_->left_window() ||
              dragged_window_ == split_view_controller_->right_window())) {
           // TODO(sad): Allow closing the left/right window. Closing one of
@@ skipping 69 matching lines @@
   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_;
 
+  // Whether a window was selected.
+  bool selected_window_;
+
   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