Adds support for point conversions to ui::Layer.

ui/gfx/compositor/layer.cc

 // Copyright (c) 2011 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/gfx/compositor/layer.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
+#include "ui/gfx/point3.h"
 
 namespace ui {
 
 Layer::Layer(Compositor* compositor)
     : compositor_(compositor),
       texture_(compositor->CreateTexture()),
       parent_(NULL),
       fills_bounds_opaquely_(false) {
 }
 
@@ skipping 18 matching lines @@
   std::vector<Layer*>::iterator i =
       std::find(children_.begin(), children_.end(), child);
   DCHECK(i != children_.end());
   children_.erase(i);
   child->parent_ = NULL;
 
   if (child->fills_bounds_opaquely())
     RecomputeHole();
 }
 
+bool Layer::Contains(const Layer* other) const {
+  for (const Layer* parent = other; parent; parent = parent->parent()) {
+    if (parent == this)
+      return true;
+  }
+  return false;
+}
+
 void Layer::SetTransform(const ui::Transform& transform) {
   transform_ = transform;
 
   if (parent() && fills_bounds_opaquely_)
     parent()->RecomputeHole();
 }
 
 void Layer::SetBounds(const gfx::Rect& bounds) {
   bounds_ = bounds;
 
   if (parent() && fills_bounds_opaquely_)
     parent()->RecomputeHole();
 }
 
+// static
+void Layer::ConvertPointToLayer(const Layer* source,
+                                const Layer* target,
+                                gfx::Point* point) {
+  const Layer* inner = NULL;
+  const Layer* outer = NULL;
+  if (source->Contains(target)) {
+    inner = target;
+    outer = source;
+    inner->ConvertPointFromAncestor(outer, point);
+  } else if (target->Contains(source)) {
+    inner = source;
+    outer = target;
+    inner->ConvertPointForAncestor(outer, point);
+  } else {
+    NOTREACHED(); // |source| and |target| are in unrelated hierarchies.
+  }
+}
+
 void Layer::SetFillsBoundsOpaquely(bool fills_bounds_opaquely) {
   if (fills_bounds_opaquely_ == fills_bounds_opaquely)
     return;
 
   fills_bounds_opaquely_ = fills_bounds_opaquely;
 
   if (parent())
     parent()->RecomputeHole();
 }
 
@@ skipping 64 matching lines @@
     if (children_[i]->fills_bounds_opaquely() &&
         !children_[i]->transform().HasChange()) {
       hole_rect_ = children_[i]->bounds();
       return;
     }
   }
   // no opaque child layers, set hole_rect_ to empty
   hole_rect_ = gfx::Rect();
 }
 
+bool Layer::ConvertPointForAncestor(const Layer* ancestor,
+                                    gfx::Point* point) const {
+  ui::Transform transform;
+  bool result = GetTransformRelativeTo(ancestor, &transform);
+  gfx::Point3f p(*point);
+  transform.TransformPoint(p);
+  *point = p.AsPoint();
+  return result;
+}
+
+bool Layer::ConvertPointFromAncestor(const Layer* ancestor,
+                                     gfx::Point* point) const {
+  ui::Transform transform;
+  bool result = GetTransformRelativeTo(ancestor, &transform);
+  gfx::Point3f p(*point);
+  transform.TransformPointReverse(p);
+  *point = p.AsPoint();
+  return result;
+}
+
+bool Layer::GetTransformRelativeTo(const Layer* ancestor,
+                                   ui::Transform* transform) const {
+  const Layer* p = this;
+  for (; p && p != ancestor; p = p->parent()) {
+    if (p->transform().HasChange())
+      transform->ConcatTransform(p->transform());
+    transform->ConcatTranslate(static_cast<float>(p->bounds().x()),
+                               static_cast<float>(p->bounds().y()));
+  }
+  return p == ancestor;
+}
+
 }  // namespace ui