reflow comments in modules/accessiblity

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

 /*
  * Copyright (C) 2014, Google 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 108 matching lines @@
   m_hasBeenDisposed = true;
 #endif
 }
 
 AXObject* AXObjectCacheImpl::root() {
   return getOrCreate(m_document);
 }
 
 AXObject* AXObjectCacheImpl::focusedImageMapUIElement(
     HTMLAreaElement* areaElement) {
-  // Find the corresponding accessibility object for the HTMLAreaElement. This should be
-  // in the list of children for its corresponding image.
+  // Find the corresponding accessibility object for the HTMLAreaElement. This
+  // should be in the list of children for its corresponding image.
   if (!areaElement)
     return 0;
 
   HTMLImageElement* imageElement = areaElement->imageElement();
   if (!imageElement)
     return 0;
 
   AXObject* axLayoutImage = getOrCreate(imageElement);
   if (!axLayoutImage)
     return 0;
@@ skipping 32 matching lines @@
       if (Element* focusedElementInPopup =
               axPopup->getDocument()->focusedElement())
         focusedNode = focusedElementInPopup;
     }
   }
 
   AXObject* obj = getOrCreate(focusedNode);
   if (!obj)
     return nullptr;
 
-  // the HTML element, for example, is focusable but has an AX object that is ignored
+  // the HTML element, for example, is focusable but has an AX object that is
+  // ignored
   if (obj->accessibilityIsIgnored())
     obj = obj->parentObjectUnignored();
 
   return obj;
 }
 
 AXObject* AXObjectCacheImpl::get(LayoutObject* layoutObject) {
   if (!layoutObject)
     return 0;
 
@@ skipping 14 matching lines @@
   if (!select)
     return false;
   LayoutObject* layoutObject = select->layoutObject();
   return layoutObject && layoutObject->isMenuList();
 }
 
 AXObject* AXObjectCacheImpl::get(Node* node) {
   if (!node)
     return 0;
 
-  // Menu list option and HTML area elements are indexed by DOM node, never by layout object.
+  // Menu list option and HTML area elements are indexed by DOM node, never by
+  // layout object.
   LayoutObject* layoutObject = node->layoutObject();
   if (isMenuListOption(node) || isHTMLAreaElement(node))
     layoutObject = nullptr;
 
   AXID layoutID = layoutObject ? m_layoutObjectMapping.get(layoutObject) : 0;
   ASSERT(!HashTraits<AXID>::isDeletedValue(layoutID));
 
   AXID nodeID = m_nodeObjectMapping.get(node);
   ASSERT(!HashTraits<AXID>::isDeletedValue(nodeID));
 
   if (layoutObject && nodeID && !layoutID) {
     // This can happen if an AXNodeObject is created for a node that's not
-    // laid out, but later something changes and it gets a layoutObject (like if it's
-    // reparented).
+    // laid out, but later something changes and it gets a layoutObject (like if
+    // it's reparented).
     remove(nodeID);
     return 0;
   }
 
   if (layoutID)
     return m_objects.get(layoutID);
 
   if (!nodeID)
     return 0;
 
@@ skipping 98 matching lines @@
   return AXInlineTextBox::create(inlineTextBox, *this);
 }
 
 AXObject* AXObjectCacheImpl::getOrCreate(Node* node) {
   if (!node)
     return 0;
 
   if (AXObject* obj = get(node))
     return obj;
 
-  // If the node has a layout object, prefer using that as the primary key for the AXObject,
-  // with the exception of an HTMLAreaElement, which is created based on its node.
+  // If the node has a layout object, prefer using that as the primary key for
+  // the AXObject, with the exception of an HTMLAreaElement, which is created
+  // based on its node.
   if (node->layoutObject() && !isHTMLAreaElement(node))
     return getOrCreate(node->layoutObject());
 
   if (!node->parentElement())
     return 0;
 
   if (isHTMLHeadElement(node))
     return 0;
 
   AXObject* newObj = createFromNode(node);
@@ skipping 202 matching lines @@
     for (size_t i = 0; i < childAXIDs.size(); ++i)
       m_ariaOwnedChildToOwnerMapping.remove(childAXIDs[i]);
     m_ariaOwnerToChildrenMapping.remove(objID);
   }
   m_ariaOwnedChildToOwnerMapping.remove(objID);
   m_ariaOwnedChildToRealParentMapping.remove(objID);
   m_ariaOwnerToIdsMapping.remove(objID);
 }
 
 void AXObjectCacheImpl::selectionChanged(Node* node) {
-  // Find the nearest ancestor that already has an accessibility object, since we
-  // might be in the middle of a layout.
+  // Find the nearest ancestor that already has an accessibility object, since
+  // we might be in the middle of a layout.
   while (node) {
     if (AXObject* obj = get(node)) {
       obj->selectionChanged();
       return;
     }
     node = node->parentNode();
   }
 }
 
 void AXObjectCacheImpl::textChanged(Node* node) {
   textChanged(getOrCreate(node));
 }
 
 void AXObjectCacheImpl::textChanged(LayoutObject* layoutObject) {
   textChanged(getOrCreate(layoutObject));
 }
 
 void AXObjectCacheImpl::textChanged(AXObject* obj) {
   if (!obj)
     return;
 
   bool parentAlreadyExists = obj->parentObjectIfExists();
   obj->textChanged();
   postNotification(obj, AXObjectCacheImpl::AXTextChanged);
   if (parentAlreadyExists)
     obj->notifyIfIgnoredValueChanged();
 }
 
 void AXObjectCacheImpl::updateCacheAfterNodeIsAttached(Node* node) {
-  // Calling get() will update the AX object if we had an AXNodeObject but now we need
-  // an AXLayoutObject, because it was reparented to a location outside of a canvas.
+  // Calling get() will update the AX object if we had an AXNodeObject but now
+  // we need an AXLayoutObject, because it was reparented to a location outside
+  // of a canvas.
   get(node);
   if (node->isElementNode())
     updateTreeIfElementIdIsAriaOwned(toElement(node));
 }
 
 void AXObjectCacheImpl::childrenChanged(Node* node) {
   childrenChanged(get(node));
 }
 
 void AXObjectCacheImpl::childrenChanged(LayoutObject* layoutObject) {
@@ skipping 78 matching lines @@
 AXObject* AXObjectCacheImpl::getAriaOwnedParent(const AXObject* child) const {
   return objectFromAXID(
       m_ariaOwnedChildToOwnerMapping.get(child->axObjectID()));
 }
 
 void AXObjectCacheImpl::updateAriaOwns(
     const AXObject* owner,
     const Vector<String>& idVector,
     HeapVector<Member<AXObject>>& ownedChildren) {
   //
-  // Update the map from the AXID of this element to the ids of the owned children,
-  // and the reverse map from ids to possible AXID owners.
+  // Update the map from the AXID of this element to the ids of the owned
+  // children, and the reverse map from ids to possible AXID owners.
   //
 
   HashSet<String> currentIds = m_ariaOwnerToIdsMapping.get(owner->axObjectID());
   HashSet<String> newIds;
   bool idsChanged = false;
   for (const String& id : idVector) {
     newIds.add(id);
     if (!currentIds.contains(id)) {
       idsChanged = true;
       HashSet<AXID>* owners = m_idToAriaOwnersMapping.get(id);
@@ skipping 30 matching lines @@
   for (const String& idName : idVector) {
     Element* element = scope.getElementById(AtomicString(idName));
     if (!element)
       continue;
 
     AXObject* child = getOrCreate(element);
     if (!child)
       continue;
 
     // If this child is already aria-owned by a different owner, continue.
-    // It's an author error if this happens and we don't worry about which of the
-    // two owners wins ownership of the child, as long as only one of them does.
+    // It's an author error if this happens and we don't worry about which of
+    // the two owners wins ownership of the child, as long as only one of them
+    // does.
     if (isAriaOwned(child) && getAriaOwnedParent(child) != owner)
       continue;
 
     // You can't own yourself!
     if (child == owner)
       continue;
 
-    // Walk up the parents of the owner object, make sure that this child doesn't appear
-    // there, as that would create a cycle.
+    // Walk up the parents of the owner object, make sure that this child
+    // doesn't appear there, as that would create a cycle.
     bool foundCycle = false;
     for (AXObject* parent = owner->parentObject(); parent && !foundCycle;
          parent = parent->parentObject()) {
       if (parent == child)
         foundCycle = true;
     }
     if (foundCycle)
       continue;
 
     newChildAXIDs.append(child->axObjectID());
     ownedChildren.append(child);
   }
 
-  // Compare this to the current list of owned children, and exit early if there are no changes.
+  // Compare this to the current list of owned children, and exit early if there
+  // are no changes.
   Vector<AXID> currentChildAXIDs =
       m_ariaOwnerToChildrenMapping.get(owner->axObjectID());
   bool same = true;
   if (currentChildAXIDs.size() != newChildAXIDs.size()) {
     same = false;
   } else {
     for (size_t i = 0; i < currentChildAXIDs.size() && same; ++i) {
       if (currentChildAXIDs[i] != newChildAXIDs[i])
         same = false;
     }
   }
   if (same)
     return;
 
-  // The list of owned children has changed. Even if they were just reordered, to be safe
-  // and handle all cases we remove all of the current owned children and add the new list
-  // of owned children.
+  // The list of owned children has changed. Even if they were just reordered,
+  // to be safe and handle all cases we remove all of the current owned children
+  // and add the new list of owned children.
   for (size_t i = 0; i < currentChildAXIDs.size(); ++i) {
     // Find the AXObject for the child that this owner no longer owns.
     AXID removedChildID = currentChildAXIDs[i];
     AXObject* removedChild = objectFromAXID(removedChildID);
 
     // It's possible that this child has already been owned by some other owner,
     // in which case we don't need to do anything.
     if (removedChild && getAriaOwnedParent(removedChild) != owner)
       continue;
 
-    // Remove it from the child -> owner mapping so it's not owned by this owner anymore.
+    // Remove it from the child -> owner mapping so it's not owned by this owner
+    // anymore.
     m_ariaOwnedChildToOwnerMapping.remove(removedChildID);
 
     if (removedChild) {
-      // If the child still exists, find its "real" parent, and reparent it back to
-      // its real parent in the tree by detaching it from its current parent and
-      // calling childrenChanged on its real parent.
+      // If the child still exists, find its "real" parent, and reparent it back
+      // to its real parent in the tree by detaching it from its current parent
+      // and calling childrenChanged on its real parent.
       removedChild->detachFromParent();
       AXID realParentID =
           m_ariaOwnedChildToRealParentMapping.get(removedChildID);
       AXObject* realParent = objectFromAXID(realParentID);
       childrenChanged(realParent);
     }
 
-    // Remove the child -> original parent mapping too since this object has now been
-    // reparented back to its original parent.
+    // Remove the child -> original parent mapping too since this object has now
+    // been reparented back to its original parent.
     m_ariaOwnedChildToRealParentMapping.remove(removedChildID);
   }
 
   for (size_t i = 0; i < newChildAXIDs.size(); ++i) {
     // Find the AXObject for the child that will now be a child of this owner.
     AXID addedChildID = newChildAXIDs[i];
     AXObject* addedChild = objectFromAXID(addedChildID);
 
     // Add this child to the mapping from child to owner.
     m_ariaOwnedChildToOwnerMapping.set(addedChildID, owner->axObjectID());
 
-    // Add its parent object to a mapping from child to real parent. If later this owner
-    // doesn't own this child anymore, we need to return it to its original parent.
+    // Add its parent object to a mapping from child to real parent. If later
+    // this owner doesn't own this child anymore, we need to return it to its
+    // original parent.
     AXObject* originalParent = addedChild->parentObject();
     m_ariaOwnedChildToRealParentMapping.set(addedChildID,
                                             originalParent->axObjectID());
 
-    // Now detach the object from its original parent and call childrenChanged on the
-    // original parent so that it can recompute its list of children.
+    // Now detach the object from its original parent and call childrenChanged
+    // on the original parent so that it can recompute its list of children.
     addedChild->detachFromParent();
     childrenChanged(originalParent);
   }
 
   // Finally, update the mapping from the owner to the list of child IDs.
   m_ariaOwnerToChildrenMapping.set(owner->axObjectID(), newChildAXIDs);
 }
 
 void AXObjectCacheImpl::updateTreeIfElementIdIsAriaOwned(Element* element) {
   if (!element->hasID())
@@ skipping 10 matching lines @@
 
   // If it's already owned, call childrenChanged on the owner to make sure it's
   // still an owner.
   if (isAriaOwned(axElement)) {
     AXObject* ownedParent = getAriaOwnedParent(axElement);
     ASSERT(ownedParent);
     childrenChanged(ownedParent);
     return;
   }
 
-  // If it's not already owned, check the possible owners based on our mapping from
-  // ids to elements that have that id listed in their aria-owns attribute.
+  // If it's not already owned, check the possible owners based on our mapping
+  // from ids to elements that have that id listed in their aria-owns attribute.
   for (const auto& axID : *owners) {
     AXObject* owner = objectFromAXID(axID);
     if (owner)
       childrenChanged(owner);
   }
 }
 
 void AXObjectCacheImpl::checkedStateChanged(Node* node) {
   postNotification(node, AXObjectCacheImpl::AXCheckedStateChanged);
 }
@@ skipping 14 matching lines @@
 
   toAXListBox(obj)->activeIndexChanged();
 }
 
 void AXObjectCacheImpl::radiobuttonRemovedFromGroup(
     HTMLInputElement* groupMember) {
   AXObject* obj = get(groupMember);
   if (!obj || !obj->isAXRadioInput())
     return;
 
-  // The 'posInSet' and 'setSize' attributes should be updated from the first node,
-  // as the removed node is already detached from tree.
+  // The 'posInSet' and 'setSize' attributes should be updated from the first
+  // node, as the removed node is already detached from tree.
   HTMLInputElement* firstRadio =
       toAXRadioInput(obj)->findFirstRadioButtonInGroup(groupMember);
   AXObject* firstObj = get(firstRadio);
   if (!firstObj || !firstObj->isAXRadioInput())
     return;
 
   toAXRadioInput(firstObj)->updatePosAndSetSize(1);
   postNotification(firstObj, AXAriaAttributeChanged);
   toAXRadioInput(firstObj)->requestUpdateToNextNode(true);
 }
 
 void AXObjectCacheImpl::handleLayoutComplete(LayoutObject* layoutObject) {
   if (!layoutObject)
     return;
 
   m_modificationCount++;
 
-  // Create the AXObject if it didn't yet exist - that's always safe at the end of a layout, and it
-  // allows an AX notification to be sent when a page has its first layout, rather than when the
-  // document first loads.
+  // Create the AXObject if it didn't yet exist - that's always safe at the end
+  // of a layout, and it allows an AX notification to be sent when a page has
+  // its first layout, rather than when the document first loads.
   if (AXObject* obj = getOrCreate(layoutObject))
     postNotification(obj, AXLayoutComplete);
 }
 
 void AXObjectCacheImpl::handleClicked(Node* node) {
   if (AXObject* obj = getOrCreate(node))
     postNotification(obj, AXClicked);
 }
 
 void AXObjectCacheImpl::handleAriaExpandedChange(Node* node) {
@@ skipping 304 matching lines @@
   visitor->trace(m_document);
   visitor->trace(m_nodeObjectMapping);
 
   visitor->trace(m_objects);
   visitor->trace(m_notificationsToPost);
 
   AXObjectCache::trace(visitor);
 }
 
 }  // namespace blink