Handle transient children as a part of transient parent

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 <complex>
 #include <vector>
 
 #include "athena/wm/overview_toolbar.h"
 #include "athena/wm/public/window_list_provider.h"
 #include "athena/wm/public/window_list_provider_observer.h"
 #include "athena/wm/split_view_controller.h"
 #include "base/bind.h"
-#include "base/macros.h"
+#include "base/memory/scoped_vector.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/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_animations.h"
 #include "ui/wm/core/window_util.h"
+#include "ui/wm/public/activation_client.h"
 
 namespace {
 
-const float kOverviewDefaultScale = 0.75f;
-
 struct WindowOverviewState {
   // The current overview state of the window. 0.f means the window is at the
   // topmost position. 1.f means the window is at the bottom-most position.
   float progress;
 
   // The top-most and bottom-most vertical position of the window in overview
   // mode.
   float max_y;
   float min_y;
 
   // |split| is set if this window is one of the two split windows in split-view
   // mode.
   bool split;
 };
 
 }  // namespace
 
-DECLARE_WINDOW_PROPERTY_TYPE(WindowOverviewState*)
+DECLARE_WINDOW_PROPERTY_TYPE(WindowOverviewState*);
 DEFINE_OWNED_WINDOW_PROPERTY_KEY(WindowOverviewState,
                                  kWindowOverviewState,
-                                 NULL)
+                                 NULL);
+
 namespace athena {
 
 namespace {
 
+const float kOverviewDefaultScale = 0.75f;
+
 gfx::Transform GetTransformForSplitWindow(aura::Window* window, float scale) {
   const float kScrollWindowPositionInOverview = 0.65f;
   int x_translate = window->bounds().width() * (1 - scale) / 2;
   gfx::Transform transform;
   transform.Translate(
       x_translate, window->bounds().height() * kScrollWindowPositionInOverview);
   transform.Scale(scale, scale);
   return transform;
 }
 
@@ skipping 18 matching lines @@
   int window_x = window->bounds().x();
   float x_translate = (container_width - (window_width * scale)) / 2 - window_x;
   float y_translate = gfx::Tween::FloatValueBetween(
       state->progress, state->min_y, state->max_y);
   gfx::Transform transform;
   transform.Translate(x_translate, y_translate);
   transform.Scale(scale, scale);
   return transform;
 }
 
-// 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;
+// A utility class used to set the transform/opacity to the window and
+// its transient children.
+class TransientGroupSetter {
+ public:
+  explicit TransientGroupSetter(aura::Window* window) : window_(window) {
+  }
+  ~TransientGroupSetter() {}
 
-  gfx::Transform transform = GetTransformForState(window, state);
-  window->SetTransform(transform);
-}
+  // Aborts all animations including its transient children.
+  void AbortAllAnimations() {
+    window_->layer()->GetAnimator()->AbortAllAnimations();
+    for (auto* transient_child : wm::GetTransientChildren(window_))
+      transient_child->layer()->GetAnimator()->AbortAllAnimations();
+  }
+
+  // Applys transform to the window and its transient children.
+  // Transient children gets a tranfrorm with the offset relateive
+  // it its transient parent.
+  void SetTransform(const gfx::Transform& transform) {
+    window_->SetTransform(transform);
+    for (auto* transient_child : wm::GetTransientChildren(window_)) {
+      gfx::Rect window_bounds = window_->bounds();
+      gfx::Rect child_bounds = transient_child->bounds();
+      gfx::Transform transient_window_transform(TranslateTransformOrigin(
+          child_bounds.origin() - window_bounds.origin(), transform));
+      transient_child->SetTransform(transient_window_transform);
+    }
+  }
+
+  // Sets the opacity to the window and its transient children.
+  void SetOpacity(float opacity) {
+    window_->layer()->SetOpacity(opacity);
+    for (auto* transient_child : wm::GetTransientChildren(window_)) {
+      transient_child->layer()->SetOpacity(opacity);
+    }
+  }
+
+  // Apply the transform with the overview scroll |progress|.
+  void SetWindowProgress(float progress) {
+    WindowOverviewState* state = window_->GetProperty(kWindowOverviewState);
+    state->progress = progress;
+
+    SetTransform(GetTransformForState(window_, state));
+  }
+
+ private:
+  static gfx::Transform TranslateTransformOrigin(
+      const gfx::Vector2d& new_origin,
+      const gfx::Transform& transform) {
+    gfx::Transform result;
+    result.Translate(-new_origin.x(), -new_origin.y());
+    result.PreconcatTransform(transform);
+    result.Translate(new_origin.x(), new_origin.y());
+    return result;
+  }
+
+  aura::Window* window_;
+
+  DISALLOW_COPY_AND_ASSIGN(TransientGroupSetter);
+};
+
+// TransientGroupSetter with animation.
+class AnimateTransientGroupSetter : public TransientGroupSetter {
+ public:
+  explicit AnimateTransientGroupSetter(aura::Window* window)
+      : TransientGroupSetter(window) {
+    animation_settings_.push_back(CreateScopedLayerAnimationSettings(window));
+    for (auto* transient_child : wm::GetTransientChildren(window)) {
+      animation_settings_.push_back(
+          CreateScopedLayerAnimationSettings(transient_child));
+    }
+  }
+  ~AnimateTransientGroupSetter() {}
+
+  ui::ScopedLayerAnimationSettings* GetMainWindowAnimationSettings() {
+    CHECK(animation_settings_.size());
+    return animation_settings_[0];
+  }
+
+ private:
+  static ui::ScopedLayerAnimationSettings* CreateScopedLayerAnimationSettings(
+      aura::Window* window) {
+    const int kTransitionMs = 250;
+
+    ui::ScopedLayerAnimationSettings* settings =
+        new ui::ScopedLayerAnimationSettings(window->layer()->GetAnimator());
+    settings->SetPreemptionStrategy(
+        ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+    settings->SetTransitionDuration(
+        base::TimeDelta::FromMilliseconds(kTransitionMs));
+    return settings;
+  }
+
+  ScopedVector<ui::ScopedLayerAnimationSettings> animation_settings_;
+  DISALLOW_COPY_AND_ASSIGN(AnimateTransientGroupSetter);
+};
 
 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);
+    aura::Window* active = aura::client::GetActivationClient(
+                               window->GetRootWindow())->GetActiveWindow();
+    should_hide = active != window && wm::GetTransientParent(active) != window;
   }
   if (should_hide)
     window->Hide();
 }
 
 // Resets the overview-related state for |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));
+  AnimateTransientGroupSetter setter(window);
 
-  settings.AddObserver(new ui::ClosureAnimationObserver(
-      base::Bind(&HideWindowIfNotVisible, window, split_view_controller)));
+  setter.GetMainWindowAnimationSettings()->AddObserver(
+      new ui::ClosureAnimationObserver(
+          base::Bind(&HideWindowIfNotVisible, window, split_view_controller)));
 
-  window->SetTransform(gfx::Transform());
-
+  setter.SetTransform(gfx::Transform());
   // Reset the window opacity in case the user is dragging a window.
-  window->layer()->SetOpacity(1.0f);
+  setter.SetOpacity(1.0f);
 
   wm::SetShadowType(window, wm::SHADOW_TYPE_NONE);
 }
 
 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;
 }
 
 void TransformSplitWindowScale(aura::Window* window, float scale) {
   gfx::Transform transform = window->layer()->GetTargetTransform();
   if (transform.Scale2d() == gfx::Vector2dF(scale, scale))
     return;
-  ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
-  window->SetTransform(GetTransformForSplitWindow(window, scale));
+  AnimateTransientGroupSetter setter(window);
+  setter.SetTransform(GetTransformForSplitWindow(window, scale));
 }
 
 void AnimateWindowTo(aura::Window* animate_window,
                      aura::Window* target_window) {
-  ui::ScopedLayerAnimationSettings settings(
-      animate_window->layer()->GetAnimator());
-  settings.SetPreemptionStrategy(
-      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+  AnimateTransientGroupSetter setter(animate_window);
+
   WindowOverviewState* target_state =
       target_window->GetProperty(kWindowOverviewState);
-  SetWindowProgress(animate_window, target_state->progress);
+  setter.SetWindowProgress(target_state->progress);
 }
 
 // Always returns the same target.
 class StaticWindowTargeter : public aura::WindowTargeter {
  public:
   explicit StaticWindowTargeter(aura::Window* target) : target_(target) {}
   virtual ~StaticWindowTargeter() {}
 
  private:
   // aura::WindowTargeter:
@@ skipping 42 matching lines @@
   }
 
   virtual ~WindowOverviewModeImpl() {
     window_list_provider_->RemoveObserver(this);
     container_->set_target_handler(container_->delegate());
     RemoveAnimationObserver();
     const 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_));
+    for (auto* window : windows)
+      RestoreWindowState(window, 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() {
     size_t index = 0;
 
     const aura::Window::Windows& windows =
@@ skipping 59 matching lines @@
       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();
+      TransientGroupSetter setter(window);
 
       // Unset any in-progress animation.
-      animator->AbortAllAnimations();
+      setter.AbortAllAnimations();
+
+      // Showing transient parent will show the transient children if any.
       window->Show();
-      window->SetTransform(gfx::Transform());
+
+      setter.SetTransform(gfx::Transform());
       // Setup the animation.
       {
-        ui::ScopedLayerAnimationSettings settings(animator);
-        settings.SetPreemptionStrategy(
-            ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
-        settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(250));
-        SetWindowProgress(window, progress);
+        AnimateTransientGroupSetter setter(window);
+        setter.SetWindowProgress(progress);
       }
     }
   }
 
   aura::Window* SelectWindowAt(ui::LocatedEvent* event) {
     CHECK_EQ(container_, event->target());
     // Find the old targeter to find the target of the event.
     ui::EventTarget* window = container_;
     ui::EventTargeter* targeter = scoped_targeter_->old_targeter();
     while (!targeter && window->GetParentTarget()) {
       window = window->GetParentTarget();
       targeter = window->GetEventTargeter();
     }
     if (!targeter)
       return NULL;
     aura::Window* target = static_cast<aura::Window*>(
         targeter->FindTargetForLocatedEvent(container_, event));
     while (target && target->parent() != container_)
       target = target->parent();
-    return target;
+    aura::Window* transient_parent = wm::GetTransientParent(target);
+    return transient_parent ? transient_parent : target;
   }
 
   // Scroll the window list by |delta_y| amount. |delta_y| is negative when
   // scrolling up; and positive when scrolling down.
   void DoScroll(float delta_y) {
     const float kEpsilon = 1e-3f;
     float delta_y_p = std::abs(delta_y) / GetScrollableHeight();
     const aura::Window::Windows& windows =
         window_list_provider_->GetWindowList();
     if (delta_y < 0) {
       // Scroll up. Start with the top-most (i.e. behind-most in terms of
       // z-index) window, and try to scroll them up.
       for (aura::Window::Windows::const_iterator iter = windows.begin();
            delta_y_p > kEpsilon && iter != windows.end();
            ++iter) {
         aura::Window* window = (*iter);
         WindowOverviewState* state = window->GetProperty(kWindowOverviewState);
         if (state->progress > kEpsilon) {
           // It is possible to scroll |window| up. Scroll it up, and update
           // |delta_y_p| for the next window.
           float apply = delta_y_p * state->progress;
-          SetWindowProgress(window, std::max(0.f, state->progress - apply * 3));
+          TransientGroupSetter setter(window);
+          setter.SetWindowProgress(std::max(0.f, state->progress - apply * 3));
           delta_y_p -= apply;
         }
       }
     } else {
       // Scroll down. Start with the bottom-most (i.e. front-most in terms of
       // z-index) window, and try to scroll them down.
       aura::Window::Windows::const_reverse_iterator iter;
       for (iter = windows.rbegin();
            delta_y_p > kEpsilon && iter != windows.rend();
            ++iter) {
         aura::Window* window = (*iter);
         WindowOverviewState* state = window->GetProperty(kWindowOverviewState);
         if (1.f - state->progress > kEpsilon) {
           // It is possible to scroll |window| down. Scroll it down, and update
           // |delta_y_p| for the next window.
-          SetWindowProgress(window, std::min(1.f, state->progress + delta_y_p));
+          TransientGroupSetter setter(window);
+          setter.SetWindowProgress(std::min(1.f, state->progress + delta_y_p));
           delta_y_p /= 2.f;
         }
       }
     }
   }
 
   int GetScrollableHeight() const {
     const float kScrollableFraction = 0.85f;
     const float kScrollableFractionInSplit = 0.5f;
     const float fraction = split_view_controller_->IsSplitViewModeActive()
@@ skipping 40 matching lines @@
     CHECK_EQ(ui::ET_GESTURE_SCROLL_UPDATE, event.type());
     CHECK(overview_toolbar_);
     gfx::Vector2dF dragged_distance =
         dragged_start_location_ - event.location();
     WindowOverviewState* dragged_state =
         dragged_window_->GetProperty(kWindowOverviewState);
     CHECK(dragged_state);
     gfx::Transform transform =
         GetTransformForState(dragged_window_, dragged_state);
     transform.Translate(-dragged_distance.x(), 0);
-    dragged_window_->SetTransform(transform);
+    TransientGroupSetter setter(dragged_window_);
+    setter.SetTransform(transform);
 
     // Update the toolbar.
     const int kMinDistanceForActionButtons = 20;
     if (fabs(dragged_distance.x()) > kMinDistanceForActionButtons)
       overview_toolbar_->ShowActionButtons();
     else
       overview_toolbar_->HideActionButtons();
 
     // See if the touch-point is above one of the action-buttons.
     OverviewToolbar::ActionType new_action =
@@ skipping 21 matching lines @@
         (new_action != previous_action) &&
         ((new_action == OverviewToolbar::ACTION_TYPE_SPLIT) ||
          (previous_action == OverviewToolbar::ACTION_TYPE_SPLIT));
     float ratio = std::min(
         1.f, std::abs(dragged_distance.x()) / kMinDistanceForDismissal);
     float opacity =
         (new_action == OverviewToolbar::ACTION_TYPE_SPLIT || split_drop)
             ? 1
             : gfx::Tween::FloatValueBetween(ratio, kMaxOpacity, kMinOpacity);
     if (animate_opacity) {
-      ui::ScopedLayerAnimationSettings settings(
-          dragged_window_->layer()->GetAnimator());
-      dragged_window_->layer()->SetOpacity(opacity);
+      AnimateTransientGroupSetter setter(dragged_window_);
+      setter.SetOpacity(opacity);
     } else {
-      dragged_window_->layer()->SetOpacity(opacity);
+      TransientGroupSetter setter(dragged_window_);
+      setter.SetOpacity(opacity);
     }
 
     if (split_view_controller_->IsSplitViewModeActive()) {
       float scale = kOverviewDefaultScale;
       if (split_drop == split_view_controller_->left_window())
         scale = kMaxScaleForSplitTarget;
       TransformSplitWindowScale(split_view_controller_->left_window(), scale);
 
       scale = kOverviewDefaultScale;
       if (split_drop == split_view_controller_->right_window())
@@ skipping 12 matching lines @@
     const bool swipe_towards_right = event.details().velocity_x() > 0;
     if (dragging_towards_right != swipe_towards_right)
       return false;
     const float kMinVelocityForDismissal = 500.f;
     return std::abs(event.details().velocity_x()) > kMinVelocityForDismissal;
   }
 
   void CloseDragWindow(const ui::GestureEvent& gesture) {
     // Animate |dragged_window_| offscreen first, then destroy it.
     {
-      wm::ScopedHidingAnimationSettings settings(dragged_window_);
-      settings.layer_animation_settings()->SetPreemptionStrategy(
-          ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+      AnimateTransientGroupSetter setter(dragged_window_);
 
       WindowOverviewState* dragged_state =
           dragged_window_->GetProperty(kWindowOverviewState);
       CHECK(dragged_state);
       gfx::Transform transform = dragged_window_->layer()->transform();
       gfx::RectF transformed_bounds = dragged_window_->bounds();
       transform.TransformRect(&transformed_bounds);
       float transform_x = 0.f;
       if (gesture.location().x() > dragged_start_location_.x())
         transform_x = container_->bounds().right() - transformed_bounds.x();
       else
         transform_x = -(transformed_bounds.x() + transformed_bounds.width());
       transform.Translate(transform_x / kOverviewDefaultScale, 0);
-      dragged_window_->SetTransform(transform);
-      dragged_window_->layer()->SetOpacity(kMinOpacity);
+
+      setter.SetOpacity(kMinOpacity);
     }
     delete dragged_window_;
     dragged_window_ = NULL;
   }
 
   void RestoreDragWindow() {
     CHECK(dragged_window_);
     WindowOverviewState* dragged_state =
         dragged_window_->GetProperty(kWindowOverviewState);
     CHECK(dragged_state);
 
-    ui::ScopedLayerAnimationSettings settings(
-        dragged_window_->layer()->GetAnimator());
-    settings.SetPreemptionStrategy(
-        ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
-    dragged_window_->SetTransform(
-        GetTransformForState(dragged_window_, dragged_state));
-    dragged_window_->layer()->SetOpacity(1.f);
+    AnimateTransientGroupSetter setter(dragged_window_);
+    setter.SetTransform(GetTransformForState(dragged_window_, dragged_state));
+    setter.SetOpacity(1.0f);
     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_->OnSelectSplitViewWindow(NULL,
@@ skipping 202 matching lines @@
     aura::Window* container,
     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