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/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_) {
+      if (window_->delegate())
+        window_->delegate()->OnWindowHidingAnimationCompleted();

[sky, 2013/03/14 20:06:37]

Add a test for coverage of this.

[scottmg, 2013/03/14 22:51:53]

ui/views/corewm/window_animations_unittest.cc wasn't being built. :( I added it
to views_unittests where it looks like it belonged, removed the tests that
didn't compile (using ash internals) and added a test there for this delegate
notification.

       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* p = layer;

[sky, 2013/03/14 20:06:37]

This use Layer::GetTargetTransformRelativeTo (that would require making it
public).

[scottmg, 2013/03/14 22:51:53]

Done.

+  for (; p->parent(); p = p->parent()) {
+    gfx::Transform translation;
+    translation.Translate(static_cast<float>(p->bounds().x()),
+                          static_cast<float>(p->bounds().y()));
+    // Use target transform so that result will be correct once animation is
+    // finished.
+    if (!p->GetTargetTransform().IsIdentity())
+      transform->ConcatTransform(p->GetTargetTransform());
+    transform->ConcatTransform(translation);
+  }
+}
+gfx::Rect GetLayerWorldBoundsAfterTransform(ui::Layer* layer,

[sky, 2013/03/14 20:06:37]

nit: newline between 199/200.

[scottmg, 2013/03/14 22:51:53]

Done.

+                                            const gfx::Transform& transform) {
+  gfx::Transform in_world = transform;
+  GetTransformRelativeToRoot(layer, &in_world);
+
+  gfx::RectF transformed = layer->bounds();
+  transform.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 =
+      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());
+  if (window->delegate())
+    window->delegate()->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);

[sky, 2013/03/14 20:06:37]

Don't we only need to do this for some windows? For example, chromeos and
HOST_DESKTOP_TYPE_ASH never need this, right?

[scottmg, 2013/03/14 22:51:53]

That's right. It's ignored by the delegate in those cases since ui/views doesn't
know about desktop types. Maybe there's a better way to do this here though.

+
   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);
-
   window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
   window->layer()->SetTransform(end_transform);
   window->layer()->SetVisible(false);
 }
 
 static gfx::Transform GetScaleForWindow(aura::Window* window) {
   gfx::Rect bounds = window->bounds();
   gfx::Transform scale = gfx::GetScaleTransform(
       gfx::Point(kWindowAnimation_TranslateFactor * bounds.width(),
                  kWindowAnimation_TranslateFactor * bounds.height()),
@@ skipping 256 matching lines @@
 
 bool WindowAnimationsDisabled(aura::Window* window) {
   return (window &&
           window->GetProperty(aura::client::kAnimationsDisabledKey)) ||
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kWindowAnimationsDisabled);
 }
 
 }  // namespace corewm
 }  // namespace views