Replace ASSERT with DCHECK in modules/accessibility

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 150 matching lines @@
   LayoutObject* prev = layoutObject;
   LayoutObject* cur = layoutObject;
 
   if (!cur->isLayoutInline() && !cur->isLayoutBlockFlow())
     return layoutObject;
 
   while (cur) {
     prev = cur;
     if (cur->isLayoutInline()) {
       cur = toLayoutInline(cur)->inlineElementContinuation();
-      ASSERT(cur || !toLayoutInline(prev)->continuation());
+      DCHECK(cur || !toLayoutInline(prev)->continuation());
     } else {
       cur = toLayoutBlockFlow(cur)->inlineElementContinuation();
     }
   }
 
   return prev;
 }
 
 static inline bool lastChildHasContinuation(LayoutObject* layoutObject) {
   LayoutObject* lastChild = layoutObject->slowLastChild();
   return lastChild && isInlineWithContinuation(lastChild);
 }
 
 static LayoutBoxModelObject* nextContinuation(LayoutObject* layoutObject) {
-  ASSERT(layoutObject);
+  DCHECK(layoutObject);
   if (layoutObject->isLayoutInline() && !layoutObject->isAtomicInlineLevel())
     return toLayoutInline(layoutObject)->continuation();
   if (layoutObject->isLayoutBlockFlow())
     return toLayoutBlockFlow(layoutObject)->inlineElementContinuation();
   return 0;
 }
 
 AXLayoutObject::AXLayoutObject(LayoutObject* layoutObject,
                                AXObjectCacheImpl& axObjectCache)
     : AXNodeObject(layoutObject->node(), axObjectCache),
       m_layoutObject(layoutObject) {
 #if DCHECK_IS_ON()
   m_layoutObject->setHasAXObject(true);
 #endif
 }
 
 AXLayoutObject* AXLayoutObject::create(LayoutObject* layoutObject,
                                        AXObjectCacheImpl& axObjectCache) {
   return new AXLayoutObject(layoutObject, axObjectCache);
 }
 
 AXLayoutObject::~AXLayoutObject() {
-  ASSERT(isDetached());
+  DCHECK(isDetached());
 }
 
 LayoutBoxModelObject* AXLayoutObject::getLayoutBoxModelObject() const {
   if (!m_layoutObject || !m_layoutObject->isBoxModelObject())
     return 0;
   return toLayoutBoxModelObject(m_layoutObject);
 }
 
 ScrollableArea* AXLayoutObject::getScrollableAreaIfScrollable() const {
   if (isWebArea())
@@ skipping 168 matching lines @@
     return false;
 
   return !toHTMLAnchorElement(*anchor).href().isEmpty();
 }
 
 bool AXLayoutObject::isLoaded() const {
   return !m_layoutObject->document().parser();
 }
 
 bool AXLayoutObject::isOffScreen() const {
-  ASSERT(m_layoutObject);
+  DCHECK(m_layoutObject);
   IntRect contentRect =
       pixelSnappedIntRect(m_layoutObject->absoluteVisualRect());
   FrameView* view = m_layoutObject->frame()->view();
   IntRect viewRect = view->visibleContentRect();
   viewRect.intersect(contentRect);
   return viewRect.isEmpty();
 }
 
 bool AXLayoutObject::isReadOnly() const {
-  ASSERT(m_layoutObject);
+  DCHECK(m_layoutObject);
 
   if (isWebArea()) {
     Document& document = m_layoutObject->document();
     HTMLElement* body = document.body();
     if (body && hasEditableStyle(*body)) {
       AXObject* axBody = axObjectCache().getOrCreate(body);
       return !axBody || axBody == axBody->ariaHiddenRoot();
     }
 
     return !hasEditableStyle(document);
@@ skipping 80 matching lines @@
       ignoredReasons->push_back(IgnoredReason(AXNotVisible));
     return IgnoreObject;
   }
 
   return AXObject::defaultObjectInclusion(ignoredReasons);
 }
 
 bool AXLayoutObject::computeAccessibilityIsIgnored(
     IgnoredReasons* ignoredReasons) const {
 #if DCHECK_IS_ON()
-  ASSERT(m_initialized);
+  DCHECK(m_initialized);
 #endif
 
   if (!m_layoutObject)
     return true;
 
   // Check first if any of the common reasons cause this element to be ignored.
   // Then process other use cases that need to be applied to all the various
   // roles that AXLayoutObjects take on.
   AXObjectInclusion decision = defaultObjectInclusion(ignoredReasons);
   if (decision == IncludeObject)
@@ skipping 922 matching lines @@
     return remoteSVGElementHitTest(point);
 
   return AXObject::elementAccessibilityHitTest(point);
 }
 
 //
 // High-level accessibility tree access.
 //
 
 AXObject* AXLayoutObject::computeParent() const {
-  ASSERT(!isDetached());
+  DCHECK(!isDetached());
   if (!m_layoutObject)
     return 0;
 
   if (ariaRoleAttribute() == MenuBarRole)
     return axObjectCache().getOrCreate(m_layoutObject->parent());
 
   // menuButton and its corresponding menu are DOM siblings, but Accessibility
   // needs them to be parent/child.
   if (ariaRoleAttribute() == MenuRole) {
     AXObject* parent = menuButtonForMenu();
@@ skipping 109 matching lines @@
     }
   }
 
   if (!nextSibling)
     return 0;
 
   return axObjectCache().getOrCreate(nextSibling);
 }
 
 void AXLayoutObject::addChildren() {
-  ASSERT(!isDetached());
+  DCHECK(!isDetached());
   // If the need to add more children in addition to existing children arises,
   // childrenChanged should have been called, leaving the object with no
   // children.
-  ASSERT(!m_haveChildren);
+  DCHECK(!m_haveChildren);
 
   m_haveChildren = true;
 
   if (!canHaveChildren())
     return;
 
   HeapVector<Member<AXObject>> ownedChildren;
   computeAriaOwnsChildren(ownedChildren);
 
   for (AXObject* obj = rawFirstChild(); obj; obj = obj->rawNextSibling()) {
@@ skipping 139 matching lines @@
     return AXRange();
 
   VisiblePosition visibleStart = selection.visibleStart();
   Position start = visibleStart.toParentAnchoredPosition();
   TextAffinity startAffinity = visibleStart.affinity();
   VisiblePosition visibleEnd = selection.visibleEnd();
   Position end = visibleEnd.toParentAnchoredPosition();
   TextAffinity endAffinity = visibleEnd.affinity();
 
   Node* anchorNode = start.anchorNode();
-  ASSERT(anchorNode);
+  DCHECK(anchorNode);
 
   AXLayoutObject* anchorObject = nullptr;
   // Find the closest node that has a corresponding AXObject.
   // This is because some nodes may be aria hidden or might not even have
   // a layout object if they are part of the shadow DOM.
   while (anchorNode) {
     anchorObject = getUnignoredObjectFromNode(*anchorNode);
     if (anchorObject)
       break;
 
     if (anchorNode->nextSibling())
       anchorNode = anchorNode->nextSibling();
     else
       anchorNode = anchorNode->parentNode();
   }
 
   Node* focusNode = end.anchorNode();
-  ASSERT(focusNode);
+  DCHECK(focusNode);
 
   AXLayoutObject* focusObject = nullptr;
   while (focusNode) {
     focusObject = getUnignoredObjectFromNode(*focusNode);
     if (focusObject)
       break;
 
     if (focusNode->previousSibling())
       focusNode = focusNode->previousSibling();
     else
       focusNode = focusNode->parentNode();
   }
 
   if (!anchorObject || !focusObject)
     return AXRange();
 
   int anchorOffset = anchorObject->indexForVisiblePosition(visibleStart);
-  ASSERT(anchorOffset >= 0);
+  DCHECK(anchorOffset >= 0);

[tkent, 2017/04/09 23:21:22]

Use DCHECK_GE

   int focusOffset = focusObject->indexForVisiblePosition(visibleEnd);
-  ASSERT(focusOffset >= 0);
+  DCHECK(focusOffset >= 0);

[tkent, 2017/04/09 23:21:22]

Use DCHECK_GE

   return AXRange(anchorObject, anchorOffset, startAffinity, focusObject,
                  focusOffset, endAffinity);
 }
 
 // Gets only the start and end offsets of the selection computed using the
 // current object as the starting point. Returns a null selection if there is
 // no selection in the subtree rooted at this object.
 AXObject::AXRange AXLayoutObject::selectionUnderObject() const {
   AXRange textSelection = textControlSelection();
   if (textSelection.isValid())
@@ skipping 15 matching lines @@
       ||
       !(parentNode &&
         selectionRange->comparePoint(parentNode, nodeIndex,
                                      IGNORE_EXCEPTION_FOR_TESTING) < 0 &&
         selectionRange->comparePoint(parentNode, nodeIndex + 1,
                                      IGNORE_EXCEPTION_FOR_TESTING) > 0)) {
     return AXRange();
   }
 
   int start = indexForVisiblePosition(selection.visibleStart());
-  ASSERT(start >= 0);
+  DCHECK(start >= 0);

[tkent, 2017/04/09 23:21:22]

Use DCHECK_GE

   int end = indexForVisiblePosition(selection.visibleEnd());
-  ASSERT(end >= 0);
+  DCHECK(end >= 0);

[tkent, 2017/04/09 23:21:22]

Use DCHECK_GE

 
   return AXRange(start, end);
 }
 
 AXObject::AXRange AXLayoutObject::textControlSelection() const {
   if (!getLayoutObject())
     return AXRange();
 
   LayoutObject* layout = nullptr;
   if (getLayoutObject()->isTextControl()) {
     layout = getLayoutObject();
   } else {
     Element* focusedElement = getDocument()->focusedElement();
     if (focusedElement && focusedElement->layoutObject() &&
         focusedElement->layoutObject()->isTextControl())
       layout = focusedElement->layoutObject();
   }
 
   if (!layout)
     return AXRange();
 
   AXObject* axObject = axObjectCache().getOrCreate(layout);
   if (!axObject || !axObject->isAXLayoutObject())
     return AXRange();
 
   VisibleSelection selection =
       layout->frame()->selection().computeVisibleSelectionInDOMTreeDeprecated();
   TextControlElement* textControl =
       toLayoutTextControl(layout)->textControlElement();
-  ASSERT(textControl);
+  DCHECK(textControl);
   int start = textControl->selectionStart();
   int end = textControl->selectionEnd();
 
   return AXRange(axObject, start, selection.visibleStart().affinity(), axObject,
                  end, selection.visibleEnd().affinity());
 }
 
 int AXLayoutObject::indexForVisiblePosition(
     const VisiblePosition& position) const {
   if (getLayoutObject() && getLayoutObject()->isTextControl()) {
@@ skipping 589 matching lines @@
   if (!map)
     return;
 
   for (HTMLAreaElement& area :
        Traversal<HTMLAreaElement>::descendantsOf(*map)) {
     // add an <area> element for this child if it has a link
     AXObject* obj = axObjectCache().getOrCreate(&area);
     if (obj) {
       AXImageMapLink* areaObject = toAXImageMapLink(obj);
       areaObject->setParent(this);
-      ASSERT(areaObject->axObjectID() != 0);
+      DCHECK(areaObject->axObjectID() != 0);

[tkent, 2017/04/09 23:21:22]

Use DCHECK_NE

       if (!areaObject->accessibilityIsIgnored())
         m_children.push_back(areaObject);
       else
         axObjectCache().remove(areaObject->axObjectID());
     }
   }
 }
 
 void AXLayoutObject::addCanvasChildren() {
   if (!isHTMLCanvasElement(getNode()))
     return;
 
   // If it's a canvas, it won't have laid out children, but it might have
   // accessible fallback content.  Clear m_haveChildren because
   // AXNodeObject::addChildren will expect it to be false.
-  ASSERT(!m_children.size());
+  DCHECK(!m_children.size());
   m_haveChildren = false;
   AXNodeObject::addChildren();
 }
 
 void AXLayoutObject::addPopupChildren() {
   if (!isHTMLInputElement(getNode()))
     return;
   if (AXObject* axPopup = toHTMLInputElement(getNode())->popupRootAXObject())
     m_children.push_back(axPopup);
 }
@@ skipping 15 matching lines @@
 
 bool AXLayoutObject::elementAttributeValue(
     const QualifiedName& attributeName) const {
   if (!m_layoutObject)
     return false;
 
   return equalIgnoringASCIICase(getAttribute(attributeName), "true");
 }
 
 }  // namespace blink