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|
+    // unless the opacity animation is 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 63 matching lines @@
     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(),
-                  std::bind2nd(std::ptr_fun(&RestoreWindowState),
-                               split_view_controller_));
+    std::for_each(windows.begin(), windows.end(), &RestoreWindowState);
   }
 
  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_);
+      delegate_->OnSelectWindow(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;
+      delegate_->OnSelectWindow(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 split_type =
+        WindowOverviewModeDelegate::SPLIT_NONE;
+    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())
+        split_type = WindowOverviewModeDelegate::SPLIT_LEFT;
+      else if (window == split_view_controller_->right_window())
+        split_type = WindowOverviewModeDelegate::SPLIT_RIGHT;
     }
+    delegate_->OnSelectWindow(window, split_type);
+  }
+
+  // WindowOverviewMode:
+  virtual void SelectDefaultWindow() OVERRIDE {
+    // TODO(pkotwicz): Do not select a window which is about to be deleted.
+    aura::Window::Windows windows = window_list_provider_->GetWindowList();
+    SelectWindow(windows.empty() ? NULL : *windows.rbegin());

[pkotwicz, 2014/09/07 01:57:24]

This CL introduces a crash when a user exits overview mode using an accelerator
key while the dragged window is animating closed. That's for a different CL to
fix though

   }
 
   // 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);
       }
@@ skipping 112 matching lines @@
     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