make menus, bubbles, etc. top level windows on aura

ui/views/corewm/window_animations.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/views/corewm/window_animations.h"
 
 #include <math.h>
 
 #include <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/time.h"
+#include "ui/aura/client/animation_host.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
+#include "ui/aura/window_delegate.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_property.h"
 #include "ui/compositor/compositor_observer.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/interpolated_transform.h"
+#include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/vector3d_f.h"
 #include "ui/views/corewm/corewm_switches.h"
 #include "ui/views/corewm/window_util.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 
 DECLARE_WINDOW_PROPERTY_TYPE(int)
 DECLARE_WINDOW_PROPERTY_TYPE(views::corewm::WindowVisibilityAnimationType)
 DECLARE_WINDOW_PROPERTY_TYPE(views::corewm::WindowVisibilityAnimationTransition)
@@ skipping 84 matching lines @@
     window_->AddObserver(this);
   }
   virtual ~HidingWindowAnimationObserver() {
     STLDeleteElements(&layers_);
   }
 
  private:
   // Overridden from ui::ImplicitAnimationObserver:
   virtual void OnImplicitAnimationsCompleted() OVERRIDE {
     // Window may have been destroyed by this point.
-    if (window_)
+    if (window_) {
+      aura::client::AnimationHost* animation_host =
+          aura::client::GetAnimationHost(window_);
+      if (animation_host)
+        animation_host->OnWindowHidingAnimationCompleted();
       window_->RemoveObserver(this);
+    }
     delete this;
   }
 
   // Overridden from aura::WindowObserver:
   virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
     DCHECK_EQ(window, window_);
     DCHECK(layers_.empty());
     AcquireAllLayers(window_);
 
     // If the Widget has views with layers, then it is necessary to take
@@ skipping 27 matching lines @@
       }
     }
   }
 
   aura::Window* window_;
   std::vector<ui::Layer*> layers_;
 
   DISALLOW_COPY_AND_ASSIGN(HidingWindowAnimationObserver);
 };
 
+void GetTransformRelativeToRoot(ui::Layer* layer, gfx::Transform* transform) {
+  const Layer* root = layer;
+  while (root->parent())
+    root = root->parent();
+  layer->GetTargetTransformRelativeTo(root, transform);
+}
+
+gfx::Rect GetLayerWorldBoundsAfterTransform(ui::Layer* layer,
+                                            const gfx::Transform& transform) {
+  gfx::Transform in_world = transform;
+  GetTransformRelativeToRoot(layer, &in_world);
+
+  gfx::RectF transformed = layer->bounds();
+  in_world.TransformRect(&transformed);
+
+  return gfx::ToEnclosingRect(transformed);
+}
+
+// Augment the host window so that the enclosing bounds of the full
+// animation will fit inside of it.
+void AugmentWindowSize(aura::Window* window,
+                       const gfx::Transform& start_transform,
+                       const gfx::Transform& end_transform) {
+  gfx::Rect world_at_start =

[sky, 2013/03/18 15:49:42]

Can you early out here if animation_host is NULL?

[scottmg, 2013/03/18 21:47:48]

Done.

+      GetLayerWorldBoundsAfterTransform(window->layer(), start_transform);
+  gfx::Rect world_at_end =
+      GetLayerWorldBoundsAfterTransform(window->layer(), end_transform);
+  gfx::Rect union_in_window_space =
+      gfx::UnionRects(world_at_start, world_at_end);
+  gfx::Rect current_bounds = window->bounds();
+  gfx::Rect result(union_in_window_space.x() - current_bounds.x(),
+                   union_in_window_space.y() - current_bounds.y(),
+                   union_in_window_space.width() - current_bounds.width(),
+                   union_in_window_space.height() - current_bounds.height());
+
+  aura::client::AnimationHost* animation_host =
+      aura::client::GetAnimationHost(window);
+  if (animation_host)
+    animation_host->SetHostTransitionBounds(result);
+}
+
 // Shows a window using an animation, animating its opacity from 0.f to 1.f,
 // its visibility to true, and its transform from |start_transform| to
 // |end_transform|.
 void AnimateShowWindowCommon(aura::Window* window,
                              const gfx::Transform& start_transform,
                              const gfx::Transform& end_transform) {
   window->layer()->set_delegate(window);
+
+  AugmentWindowSize(window, start_transform, end_transform);
+
   window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
   window->layer()->SetTransform(start_transform);
   window->layer()->SetVisible(true);
 
   {
     // Property sets within this scope will be implicitly animated.
     ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
     base::TimeDelta duration = GetWindowVisibilityAnimationDuration(window);
     if (duration.ToInternalValue() > 0)
       settings.SetTransitionDuration(duration);
 
     window->layer()->SetTransform(end_transform);
     window->layer()->SetOpacity(kWindowAnimation_ShowOpacity);
   }
 }
 
 // Hides a window using an animation, animating its opacity from 1.f to 0.f,
 // its visibility to false, and its transform to |end_transform|.
 void AnimateHideWindowCommon(aura::Window* window,
                              const gfx::Transform& end_transform) {
+  AugmentWindowSize(window, gfx::Transform(), end_transform);
   window->layer()->set_delegate(NULL);
 
   // Property sets within this scope will be implicitly animated.
   ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
   settings.AddObserver(new HidingWindowAnimationObserver(window));
 
   base::TimeDelta duration = GetWindowVisibilityAnimationDuration(window);
   if (duration.ToInternalValue() > 0)
     settings.SetTransitionDuration(duration);
 
@@ skipping 266 matching lines @@
 
 bool WindowAnimationsDisabled(aura::Window* window) {
   return (window &&
           window->GetProperty(aura::client::kAnimationsDisabledKey)) ||
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kWindowAnimationsDisabled);
 }
 
 }  // namespace corewm
 }  // namespace views