Expose scroll containers via accessibility APIs.

Source/modules/accessibility/AXObject.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 1016 matching lines @@
     if (!elementNode)
         return nullAtom;
 
     if (!elementNode->isElementNode())
         return nullAtom;
 
     Element* element = toElement(elementNode);
     return element->fastGetAttribute(attribute);
 }
 
+//
+// Scrollable containers.
+//
+
+//

[dglazkov, 2015/05/07 18:59:08]

Do we need both of these comments?

[dmazzoni, 2015/05/13 22:07:38]

Done.

+// Scrollable containers.
+//
+
+bool AXObject::isScrollableContainer() const
+{
+    return !!getScrollableAreaIfScrollable();
+}
+
+IntPoint AXObject::scrollOffset() const
+{
+    ScrollableArea* area = getScrollableAreaIfScrollable();
+    if (!area)
+        return IntPoint();
+
+    return IntPoint(area->scrollPosition().x(), area->scrollPosition().y());
+}
+
+IntPoint AXObject::minimumScrollOffset() const
+{
+    ScrollableArea* area = getScrollableAreaIfScrollable();
+    if (!area)
+        return IntPoint();
+
+    return IntPoint(area->minimumScrollPosition().x(), area->minimumScrollPosition().y());
+}
+
+IntPoint AXObject::maximumScrollOffset() const
+{
+    ScrollableArea* area = getScrollableAreaIfScrollable();
+    if (!area)
+        return IntPoint();
+
+    return IntPoint(area->maximumScrollPosition().x(), area->maximumScrollPosition().y());
+}
+
+void AXObject::setScrollOffset(const IntPoint& offset) const
+{
+    ScrollableArea* area = getScrollableAreaIfScrollable();
+    if (!area)
+        return;
+
+    area->setScrollPosition(DoublePoint(offset.x(), offset.y()));
+}
+
+//
+// Modify or take an action on an object.
+//
+
 bool AXObject::press() const
 {
     Element* actionElem = actionElement();
     if (!actionElem)
         return false;
     UserGestureIndicator gestureIndicator(DefinitelyProcessingNewUserGesture);
     actionElem->accessKeyAction(true);
     return true;
 }
 
@@ skipping 95 matching lines @@
     return (objectMin + objectMax - viewportMin - viewportMax) / 2;
 }
 
 void AXObject::scrollToMakeVisibleWithSubFocus(const IntRect& subfocus) const
 {
     // Search up the parent chain until we find the first one that's scrollable.
     AXObject* scrollParent = parentObject();
     ScrollableArea* scrollableArea = 0;
     while (scrollParent) {
         scrollableArea = scrollParent->getScrollableAreaIfScrollable();
-        if (scrollableArea)
+        if (scrollableArea && !scrollParent->isAXScrollView())
             break;
         scrollParent = scrollParent->parentObject();
     }
     if (!scrollParent || !scrollableArea)
         return;
 
     IntRect objectRect = pixelSnappedIntRect(elementRect());
     IntPoint scrollPosition = scrollableArea->scrollPosition();
     IntRect scrollVisibleRect = scrollableArea->visibleContentRect();
 
     // Convert the object rect into local coordinates.
-    if (!scrollParent->isAXScrollView()) {
+    if (!scrollParent->isWebArea()) {
         objectRect.moveBy(scrollPosition);
         objectRect.moveBy(-pixelSnappedIntRect(scrollParent->elementRect()).location());
     }
 
     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));
+    scrollParent->setScrollOffset(IntPoint(desiredX, desiredY));
 
     // Convert the subfocus into the coordinates of the scroll parent.
     IntRect newSubfocus = subfocus;
     IntRect newElementRect = pixelSnappedIntRect(elementRect());
     IntRect scrollParentRect = pixelSnappedIntRect(scrollParent->elementRect());
     newSubfocus.move(newElementRect.x(), newElementRect.y());
     newSubfocus.move(-scrollParentRect.x(), -scrollParentRect.y());
 
     // Recursively make sure the scroll parent itself is visible.
     if (scrollParent->parentObject())
         scrollParent->scrollToMakeVisibleWithSubFocus(newSubfocus);
 }
 
 void AXObject::scrollToGlobalPoint(const IntPoint& globalPoint) const
 {
     // Search up the parent chain and create a vector of all scrollable parent objects
     // and ending with this object itself.
     Vector<const AXObject*> objects;
     AXObject* parentObject;
     for (parentObject = this->parentObject(); parentObject; parentObject = parentObject->parentObject()) {
-        if (parentObject->getScrollableAreaIfScrollable())
+        if (parentObject->getScrollableAreaIfScrollable() && !parentObject->isAXScrollView())
             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 AXObject* outer = objects[i];
         const AXObject* inner = objects[i + 1];
-
         ScrollableArea* scrollableArea = outer->getScrollableAreaIfScrollable();
 
-        IntRect innerRect = inner->isAXScrollView() ? pixelSnappedIntRect(inner->parentObject()->elementRect()) : pixelSnappedIntRect(inner->elementRect());
+        IntRect innerRect = inner->isWebArea() ? pixelSnappedIntRect(inner->parentObject()->elementRect()) : pixelSnappedIntRect(inner->elementRect());
         IntRect objectRect = innerRect;
         IntPoint scrollPosition = scrollableArea->scrollPosition();
 
         // Convert the object rect into local coordinates.
         objectRect.move(offsetX, offsetY);
-        if (!outer->isAXScrollView())
+        if (!outer->isWebArea())
             objectRect.move(scrollPosition.x(), scrollPosition.y());
 
         int desiredX = computeBestScrollOffset(
             0,
             objectRect.x(), objectRect.maxX(),
             objectRect.x(), objectRect.maxX(),
             point.x(), point.x());
         int desiredY = computeBestScrollOffset(
             0,
             objectRect.y(), objectRect.maxY(),
             objectRect.y(), objectRect.maxY(),
             point.y(), point.y());
-        outer->scrollTo(IntPoint(desiredX, desiredY));
+        outer->setScrollOffset(IntPoint(desiredX, desiredY));
 
-        if (outer->isAXScrollView() && !inner->isAXScrollView()) {
-            // If outer object we just scrolled is a scroll view (main window or iframe) but the
-            // inner object is not, keep track of the coordinate transformation to apply to
+        if (outer->isWebArea() && !inner->isWebArea()) {
+            // If outer object we just scrolled is a web area (frame) but the inner object
+            // is not, keep track of the coordinate transformation to apply to
             // future nested calculations.
             scrollPosition = scrollableArea->scrollPosition();
             offsetX -= (scrollPosition.x() + point.x());
             offsetY -= (scrollPosition.y() + point.y());
             point.move(scrollPosition.x() - innerRect.x(), scrollPosition.y() - innerRect.y());
-        } else if (inner->isAXScrollView()) {
-            // Otherwise, if the inner object is a scroll view, reset the coordinate transformation.
+        } else if (inner->isWebArea()) {
+            // Otherwise, if the inner object is a web area, reset the coordinate transformation.
             offsetX = 0;
             offsetY = 0;
         }
     }
 }
 
 void AXObject::notifyIfIgnoredValueChanged()
 {
     bool isIgnored = accessibilityIsIgnored();
     if (lastKnownIsIgnoredValue() != isIgnored) {
@@ skipping 129 matching lines @@
 }
 
 const AtomicString& AXObject::internalRoleName(AccessibilityRole role)
 {
     static const Vector<AtomicString>* internalRoleNameVector = createInternalRoleNameVector();
 
     return internalRoleNameVector->at(role);
 }
 
 } // namespace blink