Switch all LayoutTests to use new accessibility relative bounding box API.

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 181 matching lines @@
     return new AXLayoutObject(layoutObject, axObjectCache);
 }
 
 AXLayoutObject::~AXLayoutObject()
 {
     ASSERT(isDetached());
 }
 
 LayoutRect AXLayoutObject::elementRect() const
 {
-    if (!m_explicitElementRect.isEmpty())
-        return m_explicitElementRect;
+    if (!m_explicitElementRect.isEmpty()) {
+        LayoutRect bounds = m_explicitElementRect;
+        AXObject* canvas = axObjectCache().objectFromAXID(m_explicitContainerID);
+        if (canvas)
+            bounds.moveBy(canvas->elementRect().location());
+        return bounds;
+    }
 
     // FIXME(dmazzoni): use relative bounds instead since this is a bottleneck.
     // http://crbug.com/618120
     return computeElementRect();
 }
 
 SkMatrix44 AXLayoutObject::transformFromLocalParentFrame() const
 {
     if (!m_layoutObject)
         return SkMatrix44();
@@ skipping 31 matching lines @@
 
     return box->getScrollableArea();
 }
 
 void AXLayoutObject::getRelativeBounds(AXObject** outContainer, FloatRect& outBoundsInContainer, SkMatrix44& outContainerTransform) const
 {
     *outContainer = nullptr;
     outBoundsInContainer = FloatRect();
     outContainerTransform.setIdentity();
 
+    // First check if it has explicit bounds, for example if this element is tied to a
+    // canvas path. When explicit coordinates are provided, the ID of the explicit container
+    // element that the coordinates are relative to must be provided too.
+    if (!m_explicitElementRect.isEmpty()) {
+        *outContainer = axObjectCache().objectFromAXID(m_explicitContainerID);
+        if (*outContainer) {
+            outBoundsInContainer = FloatRect(m_explicitElementRect);
+            return;
+        }
+    }
+
     if (!m_layoutObject)
         return;
 
+    if (isWebArea()) {
+        if (m_layoutObject->frame()->view())
+            outBoundsInContainer.setSize(FloatSize(m_layoutObject->frame()->view()->contentsSize()));
+        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)) {
             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;
     if (m_layoutObject->isText()) {
-        localBounds = toLayoutText(m_layoutObject)->linesBoundingBox();
+        Vector<FloatQuad> quads;
+        toLayoutText(m_layoutObject)->quads(quads, LayoutText::ClipToEllipsis, LayoutText::LocalQuads);
+        for (const FloatQuad& quad : quads)
+            localBounds.unite(LayoutRect(quad.boundingBox()));
     } else if (m_layoutObject->isLayoutInline()) {
-        localBounds = toLayoutInline(m_layoutObject)->linesBoundingBox();
+        Vector<LayoutRect> rects;
+        toLayoutInline(m_layoutObject)->addOutlineRects(rects, LayoutPoint(), LayoutObject::IncludeBlockVisualOverflow);
+        localBounds = unionRect(rects);
     } 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) {
+    if (scrollableArea && !container->isWebArea()) {
         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()) {
@@ skipping 2241 matching lines @@
     if (obj->node()) // If we are a continuation, we want to make sure to use the primary layoutObject.
         obj = obj->node()->layoutObject();
 
     // absoluteFocusRingBoundingBox will query the hierarchy below this element, which for large webpages can be very slow.
     // For a web area, which will have the most elements of any element, absoluteQuads should be used.
     // We should also use absoluteQuads for SVG elements, otherwise transforms won't be applied.
 
     LayoutRect result;
     if (obj->isText()) {
         Vector<FloatQuad> quads;
-        toLayoutText(obj)->absoluteQuads(quads, LayoutText::ClipToEllipsis);
+        toLayoutText(obj)->quads(quads, LayoutText::ClipToEllipsis, LayoutText::AbsoluteQuads);
         result = LayoutRect(boundingBoxForQuads(obj, quads));
     } else if (isWebArea() || obj->isSVGRoot()) {
         result = LayoutRect(obj->absoluteBoundingBoxRect());
     } else {
         result = LayoutRect(obj->absoluteElementBoundingBoxRect());
     }
 
     Document* document = this->getDocument();
     if (document && document->isSVGDocument())
         offsetBoundingBoxForRemoteSVGElement(result);
@@ skipping 18 matching lines @@
                     result.unite(labelRect);
                 }
             }
         }
     }
 
     return result;
 }
 
 } // namespace blink