Add interface to get relative bounding box rect of AX objects.

third_party/WebKit/Source/modules/accessibility/AXLayoutObject.cpp

 /*
 * Copyright (C) 2008 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1.  Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 238 matching lines @@
     if (!m_layoutObject || !m_layoutObject->isBox())
         return 0;
 
     LayoutBox* box = toLayoutBox(m_layoutObject);
     if (!box->canBeScrolledAndHasScrollableArea())
         return 0;
 
     return box->getScrollableArea();
 }
 
+void AXLayoutObject::getRelativeBounds(AXObject** outContainer, FloatRect& outBoundsInContainer, SkMatrix44& outContainerTransform) const
+{
+    *outContainer = nullptr;
+    outBoundsInContainer = FloatRect();
+    outContainerTransform.setIdentity();
+
+    if (!m_layoutObject)

[aboxhall, 2016/06/09 23:05:30]

Any reason not to do this before the above three lines?

[dmazzoni, 2016/06/10 16:55:40]

These are all out parameters, I think it's safer to always return something
valid rather than possibly leave them uninitialized.

+        return;
+
+    // First compute the container. The container must be an ancestor in the accessibility tree, and
+    // its LayoutObject must be an ancestor in the layout tree. Get the first such ancestor that's
+    // either scrollable or has a paint layer.
+    AXObject* container = parentObjectUnignored();
+    LayoutObject* containerLayoutObject = nullptr;
+    while (container) {
+        containerLayoutObject = container->getLayoutObject();
+        if (containerLayoutObject && containerLayoutObject->isBoxModelObject() && m_layoutObject->isDescendantOf(containerLayoutObject)) {

[aboxhall, 2016/06/09 23:05:30]

Under what circumstances would
`m_layoutObject->isDescendantOf(containerLayoutObject)` return false here?

[dmazzoni, 2016/06/10 16:55:39]

For example, if you used aria-owns to rearrange the accessibility tree, you
could end up with an ancestor in the accessibility tree that's not an ancestor
in the layout tree. In that case we'll be forced to keep walking up until we
find an ancestor that is in the tree.

I added a new test for that case.

+            if (container->isScrollableContainer() || containerLayoutObject->hasLayer())
+                break;
+        }
+
+        container = container->parentObjectUnignored();
+    }
+
+    if (!container)
+        return;
+    *outContainer = container;
+
+    // Next get the local bounds of this LayoutObject, which is typically
+    // a rect at point (0, 0) with the width and height of the LayoutObject.
+    LayoutRect localBounds;

[chrishtr, 2016/06/09 22:24:53]

Does visualOverflowRect() meet your needs? There is also
localOverfowRectForPaintInvalidation, which
works for SVG, but has a paint-invalidation sounding name.

[dmazzoni, 2016/06/09 22:45:29]

It's in the right coordinate system but it seems to be a few pixels larger in
all dimensions. Perhaps it takes outline into account?

[chrishtr, 2016/06/09 23:06:42]

For what example? But yes it takes into account everything, including outline.

+    if (m_layoutObject->isText()) {
+        localBounds = toLayoutText(m_layoutObject)->linesBoundingBox();
+    } else if (m_layoutObject->isLayoutInline()) {
+        localBounds = toLayoutInline(m_layoutObject)->linesBoundingBox();
+    } else if (m_layoutObject->isBox()) {
+        localBounds = LayoutRect(LayoutPoint(), toLayoutBox(m_layoutObject)->size());
+    } else if (m_layoutObject->isSVG()) {
+        localBounds = LayoutRect(m_layoutObject->strokeBoundingBox());
+    } else {
+        DCHECK(false);
+    }
+    outBoundsInContainer = FloatRect(localBounds);
+
+    // If the container has a scroll offset, subtract that out because we want our
+    // bounds to be relative to the *unscrolled* position of the container object.
+    ScrollableArea* scrollableArea = container->getScrollableAreaIfScrollable();
+    if (scrollableArea) {
+        IntPoint scrollPosition = scrollableArea->scrollPosition();
+        outBoundsInContainer.move(FloatSize(scrollPosition.x(), scrollPosition.y()));
+    }
+
+    // Compute the transform between the container's coordinate space and this object.
+    // If the transform is just a simple translation, apply that to the bounding box, but
+    // if it's a non-trivial transformation like a rotation, scaling, etc. then return
+    // the full matrix instead.
+    TransformationMatrix transform = m_layoutObject->localToAncestorTransform(toLayoutBoxModelObject(containerLayoutObject));
+    if (transform.isIdentityOr2DTranslation()) {
+        outBoundsInContainer.move(transform.to2DTranslation());
+    } else {
+        outContainerTransform = TransformationMatrix::toSkMatrix44(transform);
+    }
+}
+
 static bool isImageOrAltText(LayoutBoxModelObject* box, Node* node)
 {
     if (box && box->isImage())
         return true;
     if (isHTMLImageElement(node))
         return true;
     if (isHTMLInputElement(node) && toHTMLInputElement(node)->hasFallbackContent())
         return true;
     return false;
 }
@@ skipping 2233 matching lines @@
                     result.unite(labelRect);
                 }
             }
         }
     }
 
     return result;
 }
 
 } // namespace blink