Simplify and add caching for accessible bounding box calculation.

Source/core/accessibility/AccessibilityObject.cpp

 /*
  * Copyright (C) 2008, 2009, 2011 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 335 matching lines @@
     int level = 0;
     for (Node* elementNode = node(); elementNode; elementNode = elementNode->parentNode()) {
         if (elementNode->hasTagName(blockquoteTag))
             ++level;
     }
 
     return level;
 }
 
 // Lacking concrete evidence of orientation, horizontal means width > height. vertical is height > width;
-AccessibilityOrientation AccessibilityObject::orientation() const
+AccessibilityOrientation AccessibilityObject::orientation()
 {
     LayoutRect bounds = elementRect();
     if (bounds.size().width() > bounds.size().height())
         return AccessibilityOrientationHorizontal;
     if (bounds.size().height() > bounds.size().width())
         return AccessibilityOrientationVertical;
 
     // A tie goes to horizontal.
     return AccessibilityOrientationHorizontal;
 }
@@ skipping 196 matching lines @@
         return true;
 
     for (AccessibilityObject* axParent = parentObject(); axParent; axParent = axParent->parentObject()) {
         if (axParent->supportsARIALiveRegion())
             return true;
     }
 
     return false;
 }
 
+void AccessibilityObject::markCachedElementRectDirty()
+{
+    AccessibilityChildrenVector axChildren = children();
+    for (unsigned i = 0; i < axChildren.size(); ++i) {
+        axChildren[i].get()->markCachedElementRectDirty();
+    }
+}
+
 IntPoint AccessibilityObject::clickPoint()
 {
     LayoutRect rect = elementRect();
     return roundedIntPoint(LayoutPoint(rect.x() + rect.width() / 2, rect.y() + rect.height() / 2));
 }
 
 IntRect AccessibilityObject::boundingBoxForQuads(RenderObject* obj, const Vector<FloatQuad>& quads)
 {
     ASSERT(obj);
     if (!obj)
         return IntRect();
 
     size_t count = quads.size();
     if (!count)
         return IntRect();
 
     IntRect result;
     for (size_t i = 0; i < count; ++i) {
         IntRect r = quads[i].enclosingBoundingBox();
         if (!r.isEmpty()) {
             if (obj->style()->hasAppearance())
                 obj->theme()->adjustRepaintRect(obj, r);
             result.unite(r);
         }
     }
     return result;
 }
 
-AccessibilityObject* AccessibilityObject::elementAccessibilityHitTest(const IntPoint& point) const
+AccessibilityObject* AccessibilityObject::elementAccessibilityHitTest(const IntPoint& point)
 {
     // Send the hit test back into the sub-frame if necessary.
     if (isAttachment()) {
         Widget* widget = widgetForAttachmentView();
         // Normalize the point for the widget's bounds.
         if (widget && widget->isFrameView())
             return axObjectCache()->getOrCreate(widget)->accessibilityHitTest(IntPoint(point - widget->frameRect().location()));
     }
 
     // Check if there are any mock elements that need to be handled.
@@ skipping 166 matching lines @@
     if (!actionElem)
         return false;
     if (Frame* f = actionElem->document()->frame())
         f->loader()->resetMultipleFormSubmissionProtection();
 
     UserGestureIndicator gestureIndicator(DefinitelyProcessingNewUserGesture);
     actionElem->accessKeyAction(true);
     return true;
 }
 
-void AccessibilityObject::scrollToMakeVisible() const
+void AccessibilityObject::scrollToMakeVisible()
 {
-    IntRect objectRect = pixelSnappedIntRect(boundingBoxRect());
+    IntRect objectRect = pixelSnappedIntRect(elementRect());
     objectRect.setLocation(IntPoint());
     scrollToMakeVisibleWithSubFocus(objectRect);
 }
 
 // This is a 1-dimensional scroll offset helper function that's applied
 // separately in the horizontal and vertical directions, because the
 // logic is the same. The goal is to compute the best scroll offset
 // in order to make an object visible within a viewport.
 //
 // In case the whole object cannot fit, you can specify a
@@ skipping 56 matching lines @@
     // Scroll right if we're too far to the left.
     if (objectMin - currentScrollOffset < viewportMin)
         return objectMin - viewportMin;
 
     ASSERT_NOT_REACHED();
 
     // This shouldn't happen.
     return currentScrollOffset;
 }
 
-void AccessibilityObject::scrollToMakeVisibleWithSubFocus(const IntRect& subfocus) const
+void AccessibilityObject::scrollToMakeVisibleWithSubFocus(const IntRect& subfocus)
 {
     // Search up the parent chain until we find the first one that's scrollable.
     AccessibilityObject* scrollParent = parentObject();
     ScrollableArea* scrollableArea;
     for (scrollableArea = 0;
          scrollParent && !(scrollableArea = scrollParent->getScrollableAreaIfScrollable());
          scrollParent = scrollParent->parentObject()) { }
     if (!scrollableArea)
         return;
 
-    LayoutRect objectRect = boundingBoxRect();
+    LayoutRect objectRect = elementRect();
     IntPoint scrollPosition = scrollableArea->scrollPosition();
     IntRect scrollVisibleRect = scrollableArea->visibleContentRect();
 
     int desiredX = computeBestScrollOffset(
         scrollPosition.x(),
         objectRect.x() + subfocus.x(), objectRect.x() + subfocus.maxX(),
         objectRect.x(), objectRect.maxX(),
         0, scrollVisibleRect.width());
     int desiredY = computeBestScrollOffset(
         scrollPosition.y(),
         objectRect.y() + subfocus.y(), objectRect.y() + subfocus.maxY(),
         objectRect.y(), objectRect.maxY(),
         0, scrollVisibleRect.height());
 
     scrollParent->scrollTo(IntPoint(desiredX, desiredY));
 
     // Recursively make sure the scroll parent itself is visible.
     if (scrollParent->parentObject())
         scrollParent->scrollToMakeVisible();
 }
 
-void AccessibilityObject::scrollToGlobalPoint(const IntPoint& globalPoint) const
+void AccessibilityObject::scrollToGlobalPoint(const IntPoint& globalPoint)
 {
     // Search up the parent chain and create a vector of all scrollable parent objects
     // and ending with this object itself.
-    Vector<const AccessibilityObject*> objects;
+    Vector<AccessibilityObject*> objects;
     AccessibilityObject* parentObject;
     for (parentObject = this->parentObject(); parentObject; parentObject = parentObject->parentObject()) {
         if (parentObject->getScrollableAreaIfScrollable())
             objects.prepend(parentObject);
     }
     objects.append(this);
 
     // Start with the outermost scrollable (the main window) and try to scroll the
     // next innermost object to the given point.
     int offsetX = 0, offsetY = 0;
     IntPoint point = globalPoint;
     size_t levels = objects.size() - 1;
     for (size_t i = 0; i < levels; i++) {
-        const AccessibilityObject* outer = objects[i];
-        const AccessibilityObject* inner = objects[i + 1];
+        AccessibilityObject* outer = objects[i];
+        AccessibilityObject* inner = objects[i + 1];
 
         ScrollableArea* scrollableArea = outer->getScrollableAreaIfScrollable();
 
-        LayoutRect innerRect = inner->isAccessibilityScrollView() ? inner->parentObject()->boundingBoxRect() : inner->boundingBoxRect();
+        LayoutRect innerRect = inner->isAccessibilityScrollView() ? inner->parentObject()->elementRect() : inner->elementRect();
         LayoutRect objectRect = innerRect;
         IntPoint scrollPosition = scrollableArea->scrollPosition();
 
         // Convert the object rect into local coordinates.
         objectRect.move(offsetX, offsetY);
         if (!outer->isAccessibilityScrollView())
             objectRect.move(scrollPosition.x(), scrollPosition.y());
 
         int desiredX = computeBestScrollOffset(
             0,
@@ skipping 381 matching lines @@
 
     for (AccessibilityObject* object = parentObject(); object; object = object->parentObject()) {
         if (equalIgnoringCase(object->getAttribute(aria_hiddenAttr), "true"))
             return true;
     }
 
     return false;
 }
 
 } // namespace WebCore