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

ui/compositor/layer.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/compositor/layer.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 390 matching lines @@
 
   const Layer* root_layer = GetRoot(source);
   CHECK_EQ(root_layer, GetRoot(target));
 
   if (source != root_layer)
     source->ConvertPointForAncestor(root_layer, point);
   if (target != root_layer)
     target->ConvertPointFromAncestor(root_layer, point);
 }
 
+bool Layer::GetTargetTransformRelativeTo(const Layer* ancestor,
+                                         gfx::Transform* transform) const {
+  const Layer* p = this;
+  for (; p && p != ancestor; 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);
+  }
+  return p == ancestor;
+}
+
 // static
 gfx::Transform Layer::ConvertTransformToCCTransform(
     const gfx::Transform& transform,
     const gfx::Rect& bounds,
     float device_scale_factor) {
   gfx::Transform cc_transform;
   cc_transform.Scale(device_scale_factor, device_scale_factor);
   cc_transform.Translate(bounds.x(), bounds.y());
   cc_transform.PreconcatTransform(transform);
   cc_transform.Scale(1.0f / device_scale_factor, 1.0f / device_scale_factor);
@@ skipping 242 matching lines @@
 bool Layer::ConvertPointFromAncestor(const Layer* ancestor,
                                      gfx::Point* point) const {
   gfx::Transform transform;
   bool result = GetTargetTransformRelativeTo(ancestor, &transform);
   gfx::Point3F p(*point);
   transform.TransformPointReverse(p);
   *point = gfx::ToFlooredPoint(p.AsPointF());
   return result;
 }
 
-bool Layer::GetTargetTransformRelativeTo(const Layer* ancestor,
-                                   gfx::Transform* transform) const {
-  const Layer* p = this;
-  for (; p && p != ancestor; 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);
-  }
-  return p == ancestor;
-}
-
 void Layer::SetBoundsImmediately(const gfx::Rect& bounds) {
   if (bounds == bounds_)
     return;
 
   base::Closure closure;
   if (delegate_)
     closure = delegate_->PrepareForLayerBoundsChange();
   bool was_move = bounds_.size() == bounds.size();
   gfx::Transform transform = this->transform();
   bounds_ = bounds;
@@ skipping 217 matching lines @@
     texture_layer_->SetUV(uv_top_left, uv_bottom_right);
   } else if (delegated_renderer_layer_.get()) {
     delegated_renderer_layer_->SetDisplaySize(
         ConvertSizeToPixel(this, delegated_frame_size_in_dip_));
     size.ClampToMax(delegated_frame_size_in_dip_);
   }
   cc_layer_->SetBounds(ConvertSizeToPixel(this, size));
 }
 
 }  // namespace ui