Use c++11 range loops in accessibility

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 1002 matching lines @@
 
     return 0;
 }
 
 void AXLayoutObject::accessibilityChildrenFromAttribute(QualifiedName attr, AccessibilityChildrenVector& children) const
 {
     WillBeHeapVector<RawPtrWillBeMember<Element>> elements;
     elementsFromAttribute(elements, attr);
 
     AXObjectCacheImpl* cache = axObjectCache();
-    unsigned count = elements.size();
-    for (unsigned k = 0; k < count; ++k) {
-        Element* element = elements[k];
-        AXObject* child = cache->getOrCreate(element);
-        if (child)
+    for (const auto& element : elements) {
+        if (AXObject* child = cache->getOrCreate(element))
             children.append(child);
     }
 }
 
 void AXLayoutObject::ariaFlowToElements(AccessibilityChildrenVector& flowTo) const
 {
     accessibilityChildrenFromAttribute(aria_flowtoAttr, flowTo);
 }
 
 void AXLayoutObject::ariaControlsElements(AccessibilityChildrenVector& controls) const
@@ skipping 486 matching lines @@
 
     addHiddenChildren();
     addAttachmentChildren();
     addPopupChildren();
     addImageMapChildren();
     addTextFieldChildren();
     addCanvasChildren();
     addRemoteSVGChildren();
     addInlineTextBoxChildren(false);
 
-    for (unsigned i = 0; i < m_children.size(); ++i) {
-        if (!m_children[i].get()->cachedParentObject())
-            m_children[i].get()->setParent(this);
+    for (const auto& child : m_children) {
+        if (!child->cachedParentObject())
+            child->setParent(this);
     }
 }
 
 bool AXLayoutObject::canHaveChildren() const
 {
     if (!m_layoutObject)
         return false;
 
     return AXNodeObject::canHaveChildren();
 }
@@ skipping 386 matching lines @@
         if (role != TreeItemRole && role != StaticTextRole)
             return false;
     }
     return true;
 }
 
 void AXLayoutObject::ariaListboxSelectedChildren(AccessibilityChildrenVector& result)
 {
     bool isMulti = isMultiSelectable();
 
-    const AccessibilityChildrenVector& childObjects = children();
-    unsigned childrenSize = childObjects.size();
-    for (unsigned k = 0; k < childrenSize; ++k) {
+    for (const auto& child : children()) {
         // Every child should have aria-role option, and if so, check for selected attribute/state.
-        AXObject* child = childObjects[k].get();
         if (child->isSelected() && child->ariaRoleAttribute() == ListBoxOptionRole) {
             result.append(child);
             if (!isMulti)
                 return;
         }
     }
 }
 
 AXObject::PlainTextRange AXLayoutObject::ariaSelectedTextRange() const
 {
@@ skipping 36 matching lines @@
     // The ARIA spec says a tab item can also be selected if it is aria-labeled by a tabpanel
     // that has keyboard focus inside of it, or if a tabpanel in its aria-controls list has KB
     // focus inside of it.
     AXObject* focusedElement = focusedUIElement();
     if (!focusedElement)
         return false;
 
     WillBeHeapVector<RawPtrWillBeMember<Element>> elements;
     elementsFromAttribute(elements, aria_controlsAttr);
 
-    unsigned count = elements.size();
-    for (unsigned k = 0; k < count; ++k) {
-        Element* element = elements[k];
+    for (const auto& element : elements) {
         AXObject* tabPanel = axObjectCache()->getOrCreate(element);
 
         // A tab item should only control tab panels.
         if (!tabPanel || tabPanel->roleValue() != TabPanelRole)
             continue;
 
         AXObject* checkFocusElement = focusedElement;
         // Check if the focused element is a descendant of the element controlled by the tab item.
         while (checkFocusElement) {
             if (tabPanel == checkFocusElement)
                 return true;
             checkFocusElement = checkFocusElement->parentObject();
         }
     }
 
     return false;
 }
 
 AXObject* AXLayoutObject::accessibilityImageMapHitTest(HTMLAreaElement* area, const IntPoint& point) const
 {
     if (!area)
         return 0;
 
     AXObject* parent = axObjectCache()->getOrCreate(area->imageElement());
     if (!parent)
         return 0;
 
-    const AccessibilityChildrenVector& children = parent->children();
-    unsigned count = children.size();
-    for (unsigned k = 0; k < count; ++k) {
-        if (children[k]->elementRect().contains(point))
-            return children[k].get();
+    for (const auto& child : parent->children()) {
+        if (child->elementRect().contains(point))
+            return child.get();
     }
 
     return 0;
 }
 
 bool AXLayoutObject::layoutObjectIsObservable(LayoutObject* layoutObject) const
 {
     // AX clients will listen for AXValueChange on a text control.
     if (layoutObject->isTextControl())
         return true;
@@ skipping 124 matching lines @@
         return;
 
     // Iterate through all of the children, including those that may have already been added, and
     // try to insert hidden nodes in the correct place in the DOM order.
     unsigned insertionIndex = 0;
     for (Node& child : NodeTraversal::childrenOf(*node)) {
         if (child.layoutObject()) {
             // Find out where the last layout sibling is located within m_children.
             if (AXObject* childObject = axObjectCache()->get(child.layoutObject())) {
                 if (childObject->accessibilityIsIgnored()) {
-                    const AccessibilityChildrenVector& children = childObject->children();
+                    const auto& children = childObject->children();
                     childObject = children.size() ? children.last().get() : 0;
                 }
                 if (childObject)
                     insertionIndex = m_children.find(childObject) + 1;
                 continue;
             }
         }
 
         if (!isNodeAriaVisible(&child))
             continue;
@@ skipping 86 matching lines @@
 
 void AXLayoutObject::addRemoteSVGChildren()
 {
     AXSVGRoot* root = remoteSVGRootElement();
     if (!root)
         return;
 
     root->setParent(this);
 
     if (root->accessibilityIsIgnored()) {
-        const AccessibilityChildrenVector& children = root->children();
-        unsigned length = children.size();
-        for (unsigned i = 0; i < length; ++i)
-            m_children.append(children[i]);
+        for (const auto& child : root->children())
+            m_children.append(child);
     } else {
         m_children.append(root);
     }
 }
 
 void AXLayoutObject::ariaSelectedRows(AccessibilityChildrenVector& result)
 {
     // Get all the rows.
     AccessibilityChildrenVector allRows;
     if (isTree())
         ariaTreeRows(allRows);
     else if (isAXTable() && toAXTable(this)->supportsSelectedRows())
         allRows = toAXTable(this)->rows();
 
     // Determine which rows are selected.
     bool isMulti = isMultiSelectable();
 
     // Prefer active descendant over aria-selected.
     AXObject* activeDesc = activeDescendant();
     if (activeDesc && (activeDesc->isTreeItem() || activeDesc->isTableRow())) {
         result.append(activeDesc);
         if (!isMulti)
             return;
     }
 
-    unsigned count = allRows.size();
-    for (unsigned k = 0; k < count; ++k) {
-        if (allRows[k]->isSelected()) {
-            result.append(allRows[k]);
+    for (const auto& row : allRows) {
+        if (row->isSelected()) {
+            result.append(row);
             if (!isMulti)
                 break;
         }
     }
 }
 
 bool AXLayoutObject::elementAttributeValue(const QualifiedName& attributeName) const
 {
     if (!m_layoutObject)
         return false;
@@ skipping 75 matching lines @@
         if (label && label->layoutObject()) {
             LayoutRect labelRect = axObjectCache()->getOrCreate(label)->elementRect();
             result.unite(labelRect);
         }
     }
 
     return result;
 }
 
 } // namespace blink