Stops animations when removing a window from its parent

ui/aura/window.cc

 // Copyright (c) 2012 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 "ui/aura/window.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 11 matching lines @@
 #include "ui/aura/client/window_stacking_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer.h"
+#include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event_target_iterator.h"
-#include "ui/gfx/animation/multi_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/scoped_canvas.h"
 #include "ui/gfx/screen.h"
 
 namespace aura {
 
 namespace {
 
 ui::LayerType WindowLayerTypeToUILayerType(WindowLayerType window_layer_type) {
@@ skipping 449 matching lines @@
   if (children_.size() <= 1 || child == children_.front())
     return;  // At the bottom already.
   StackChildBelow(child, children_.front());
 }
 
 void Window::StackChildBelow(Window* child, Window* target) {
   StackChildRelativeTo(child, target, STACK_BELOW);
 }
 
 void Window::AddChild(Window* child) {
+  scoped_ptr<ui::ScopedLayerAnimationSettings> animation_settings;
+  if (child->layer() &&
+      child->layer()->GetAnimator() &&
+      child->layer()->GetAnimator()->is_animating()) {
+    animation_settings.reset(
+        new ui::ScopedLayerAnimationSettings(child->layer()->GetAnimator()));
+    animation_settings->SetPreemptionStrategy(
+        ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);

[oshima, 2014/04/23 16:34:44]

I feels like animation should be canceled upon parent change, and the client
code should take care of applying animation correctly (after reparent in this
case)?

Is there any reason why drag code can't be fixed instead?

[varkha, 2014/04/23 16:44:05]

I was thinking that this would be an option. It is just that the paths that may
cause animation to be active during reparenting are many and not easily
controlled or visible in code inspection so fixing it here made sense. Stopping
animation also has some issues - I have seen the window bounds getting out of
sync with layers bounds because we revert window bounds_ in ReparentLayers and
UnparentLayers which only makes sense if the animation is allowed to continue.
If you look at the crashing bug
https://code.google.com/p/chromium/issues/detail?id=364498 - it has a few call
stacks mentioned that are all slightly different but all similar in that they
all involve animation during reparenting. It feels that we would have to hunt
each of those separately with the same recipe.

+  }
   WindowObserver::HierarchyChangeParams params;
   params.target = child;
   params.new_parent = this;
   params.old_parent = child->parent();
   params.phase = WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGING;
   NotifyWindowHierarchyChange(params);
 
   Window* old_root = child->GetRootWindow();
 
   DCHECK(std::find(children_.begin(), children_.end(), child) ==
       children_.end());
   if (child->parent())
     child->parent()->RemoveChildImpl(child, this);
 
   gfx::Vector2d offset;
   aura::Window* ancestor_with_layer = GetAncestorWithLayer(&offset);
+  gfx::Rect target_bounds = child->GetTargetBounds();
+
+  child->parent_ = this;
+
   if (ancestor_with_layer) {
-    offset += child->bounds().OffsetFromOrigin();
+    offset += target_bounds.OffsetFromOrigin();
     child->ReparentLayers(ancestor_with_layer->layer(), offset);
   }
 
-  child->parent_ = this;
-
   children_.push_back(child);
   if (layout_manager_)
     layout_manager_->OnWindowAddedToLayout(child);
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowAdded(child));
   child->OnParentChanged();
 
   Window* root_window = GetRootWindow();
   if (root_window && old_root != root_window) {
     root_window->GetHost()->dispatcher()->OnWindowAddedToRootWindow(child);
     child->NotifyAddedToRootWindow();
@@ skipping 121 matching lines @@
 bool Window::ContainsPointInRoot(const gfx::Point& point_in_root) const {
   const Window* root_window = GetRootWindow();
   if (!root_window)
     return false;
   gfx::Point local_point(point_in_root);
   ConvertPointToTarget(root_window, this, &local_point);
   return gfx::Rect(GetTargetBounds().size()).Contains(local_point);
 }
 
 bool Window::ContainsPoint(const gfx::Point& local_point) const {
-  return gfx::Rect(bounds().size()).Contains(local_point);
+  return gfx::Rect(GetTargetBounds().size()).Contains(local_point);
 }
 
 Window* Window::GetEventHandlerForPoint(const gfx::Point& local_point) {
   return GetWindowForPoint(local_point, true, true);
 }
 
 Window* Window::GetTopWindowContainingPoint(const gfx::Point& local_point) {
   return GetWindowForPoint(local_point, false, false);
 }
 
@@ skipping 364 matching lines @@
       children_[i]->UnparentLayers(true, new_offset);
     }
   } else {
     // Only remove the layer if we still own it.  Someone else may have acquired
     // ownership of it via AcquireLayer() and may expect the hierarchy to go
     // unchanged as the Window is destroyed.
     if (OwnsLayer()) {
       if (layer()->parent())
         layer()->parent()->Remove(layer());
       if (has_layerless_ancestor) {
-        const gfx::Rect real_bounds(bounds_);
-        gfx::Rect layer_bounds(layer()->bounds());
+        const gfx::Rect real_bounds(bounds());
+        gfx::Rect layer_bounds(layer()->GetTargetBounds());
         layer_bounds.Offset(-offset);
         layer()->SetBounds(layer_bounds);
         bounds_ = real_bounds;
       }
     }
   }
 }
 
 void Window::ReparentLayers(ui::Layer* parent_layer,
                             const gfx::Vector2d& offset) {
   if (!layer()) {
     for (size_t i = 0; i < children_.size(); ++i) {
       children_[i]->ReparentLayers(
           parent_layer,
           offset + children_[i]->bounds().OffsetFromOrigin());
     }
   } else {
     const gfx::Rect real_bounds(bounds());
     parent_layer->Add(layer());
-    gfx::Rect layer_bounds(layer()->bounds().size());
+    gfx::Rect layer_bounds(layer()->GetTargetBounds().size());
     layer_bounds += offset;
     layer()->SetBounds(layer_bounds);
     bounds_ = real_bounds;
   }
 }
 
 void Window::OffsetLayerBounds(const gfx::Vector2d& offset) {
   if (!layer()) {
     for (size_t i = 0; i < children_.size(); ++i)
       children_[i]->OffsetLayerBounds(offset);
   } else {
-    gfx::Rect layer_bounds(layer()->bounds());
+    gfx::Rect layer_bounds(layer()->GetTargetBounds());
     layer_bounds += offset;
     layer()->SetBounds(layer_bounds);
   }
 }
 
 void Window::OnParentChanged() {
   FOR_EACH_OBSERVER(
       WindowObserver, observers_, OnWindowParentChanged(this, parent_));
 }
 
@@ skipping 331 matching lines @@
         ContainsPointInRoot(host->dispatcher()->GetLastMouseLocationInRoot());
   }
   return contains_mouse;
 }
 
 const Window* Window::GetAncestorWithLayer(gfx::Vector2d* offset) const {
   for (const aura::Window* window = this; window; window = window->parent()) {
     if (window->layer())
       return window;
     if (offset)
-      *offset += window->bounds().OffsetFromOrigin();
+      *offset += window->GetTargetBounds().OffsetFromOrigin();
   }
   if (offset)
     *offset = gfx::Vector2d();
   return NULL;
 }
 
 }  // namespace aura