Replace ASSERT with DCHECK in modules/accessibility

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

 /*
  * Copyright (C) 2012, 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 209 matching lines @@
       m_childrenDirty(false),
       m_node(node) {
 }
 
 AXNodeObject* AXNodeObject::create(Node* node,
                                    AXObjectCacheImpl& axObjectCache) {
   return new AXNodeObject(node, axObjectCache);
 }
 
 AXNodeObject::~AXNodeObject() {
-  ASSERT(!m_node);
+  DCHECK(!m_node);
 }
 
 void AXNodeObject::alterSliderValue(bool increase) {
   if (roleValue() != SliderRole)
     return;
 
   float value = valueForRange();
   float step = stepValueForRange();
 
   value += increase ? step : -step;
@@ skipping 20 matching lines @@
 
   AXObject* axDescendant = axObjectCache().getOrCreate(descendant);
   return axDescendant;
 }
 
 bool AXNodeObject::computeAccessibilityIsIgnored(
     IgnoredReasons* ignoredReasons) const {
 #if DCHECK_IS_ON()
   // Double-check that an AXObject is never accessed before
   // it's been initialized.
-  ASSERT(m_initialized);
+  DCHECK(m_initialized);
 #endif
 
   // If this element is within a parent that cannot have children, it should not
   // be exposed.
   if (isDescendantOfLeafNode()) {
     if (ignoredReasons)
       ignoredReasons->push_back(
           IgnoredReason(AXAncestorIsLeafNode, leafNodeAncestor()));
     return true;
   }
@@ skipping 615 matching lines @@
     // searching up the chain.
     if (parentAriaRole)
       break;
   }
 
   return role;
 }
 
 void AXNodeObject::init() {
 #if DCHECK_IS_ON()
-  ASSERT(!m_initialized);
+  DCHECK(!m_initialized);
   m_initialized = true;
 #endif
   m_role = determineAccessibilityRole();
 }
 
 void AXNodeObject::detach() {
   AXObject::detach();
   m_node = nullptr;
 }
 
@@ skipping 951 matching lines @@
 
 String AXNodeObject::textAlternative(bool recursive,
                                      bool inAriaLabelledByTraversal,
                                      AXObjectSet& visited,
                                      AXNameFrom& nameFrom,
                                      AXRelatedObjectVector* relatedObjects,
                                      NameSources* nameSources) const {
   // If nameSources is non-null, relatedObjects is used in filling it in, so it
   // must be non-null as well.
   if (nameSources)
-    ASSERT(relatedObjects);
+    DCHECK(relatedObjects);
 
   bool foundTextAlternative = false;
 
   if (!getNode() && !getLayoutObject())
     return String();
 
   String textAlternative = ariaTextAlternative(
       recursive, inAriaLabelledByTraversal, visited, nameFrom, relatedObjects,
       nameSources, &foundTextAlternative);
   if (foundTextAlternative && !nameSources)
@@ skipping 266 matching lines @@
   if (isHTMLOptionElement(node))
     parentNode = toHTMLOptionElement(node)->ownerSelectElement();
 
   if (!parentNode)
     parentNode = node->parentNode();
 
   return parentNode;
 }
 
 AXObject* AXNodeObject::computeParent() const {
-  ASSERT(!isDetached());
+  DCHECK(!isDetached());
   if (Node* parentNode = getParentNodeForComputeParent(getNode()))
     return axObjectCache().getOrCreate(parentNode);
 
   return nullptr;
 }
 
 AXObject* AXNodeObject::computeParentIfExists() const {
   if (Node* parentNode = getParentNodeForComputeParent(getNode()))
     return axObjectCache().get(parentNode);
 
@@ skipping 17 matching lines @@
     return 0;
 
   Node* nextSibling = getNode()->nextSibling();
   if (!nextSibling)
     return 0;
 
   return axObjectCache().getOrCreate(nextSibling);
 }
 
 void AXNodeObject::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);
 
   if (!m_node)
     return;
 
   m_haveChildren = true;
 
   // The only time we add children from the DOM tree to a node with a
   // layoutObject is when it's a canvas.
   if (getLayoutObject() && !isHTMLCanvasElement(*m_node))
     return;
@@ skipping 28 matching lines @@
   // aria-hidden changes from working correctly. Hence, whenever a parent is
   // getting children, ensure data is not stale.
   child->clearChildren();
 
   if (child->accessibilityIsIgnored()) {
     const auto& children = child->children();
     size_t length = children.size();
     for (size_t i = 0; i < length; ++i)
       m_children.insert(index + i, children[i]);
   } else {
-    ASSERT(child->parentObject() == this);
+    DCHECK(child->parentObject() == this);

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

Use DCHECK_EQ

     m_children.insert(index, child);
   }
 }
 
 bool AXNodeObject::canHaveChildren() const {
   // If this is an AXLayoutObject, then it's okay if this object
   // doesn't have a node - there are some layoutObjects that don't have
   // associated nodes, like scroll areas and css-generated text.
   if (!getNode() && !isAXLayoutObject())
     return false;
@@ skipping 296 matching lines @@
     AXNameFrom& nameFrom,
     AXRelatedObjectVector* relatedObjects,
     NameSources* nameSources,
     bool* foundTextAlternative) const {
   if (!getNode())
     return String();
 
   // If nameSources is non-null, relatedObjects is used in filling it in, so it
   // must be non-null as well.
   if (nameSources)
-    ASSERT(relatedObjects);
+    DCHECK(relatedObjects);
 
   String textAlternative;
   AXRelatedObjectVector localRelatedObjects;
 
   const HTMLInputElement* inputElement = nullptr;
   if (isHTMLInputElement(getNode()))
     inputElement = toHTMLInputElement(getNode());
 
   // 5.1/5.5 Text inputs, Other labelable Elements
   // If you change this logic, update AXNodeObject::nameFromLabelElement, too.
@@ skipping 315 matching lines @@
   }
 
   // Per SVG AAM 1.0's modifications to 2D of this algorithm.
   if (getNode()->isSVGElement()) {
     nameFrom = AXNameFromRelatedElement;
     if (nameSources) {
       nameSources->push_back(NameSource(*foundTextAlternative));
       nameSources->back().type = nameFrom;
       nameSources->back().nativeSource = AXTextFromNativeHTMLTitleElement;
     }
-    ASSERT(getNode()->isContainerNode());
+    DCHECK(getNode()->isContainerNode());
     Element* title = ElementTraversal::firstChild(
         toContainerNode(*(getNode())), HasTagName(SVGNames::titleTag));
 
     if (title) {
       AXObject* titleAXObject = axObjectCache().getOrCreate(title);
       if (titleAXObject && !visited.contains(titleAXObject)) {
         textAlternative =
             recursiveTextAlternative(*titleAXObject, false, visited);
         if (relatedObjects) {
           localRelatedObjects.push_back(
@@ skipping 126 matching lines @@
 
 // Based on
 // http://rawgit.com/w3c/aria/master/html-aam/html-aam.html#accessible-name-and-description-calculation
 String AXNodeObject::description(AXNameFrom nameFrom,
                                  AXDescriptionFrom& descriptionFrom,
                                  DescriptionSources* descriptionSources,
                                  AXRelatedObjectVector* relatedObjects) const {
   // If descriptionSources is non-null, relatedObjects is used in filling it in,
   // so it must be non-null as well.
   if (descriptionSources)
-    ASSERT(relatedObjects);
+    DCHECK(relatedObjects);
 
   if (!getNode())
     return String();
 
   String description;
   bool foundDescription = false;
 
   descriptionFrom = AXDescriptionFromRelatedElement;
   if (descriptionSources) {
     descriptionSources->push_back(
@@ skipping 193 matching lines @@
     return String();
   return toTextControlElement(node)->strippedPlaceholder();
 }
 
 DEFINE_TRACE(AXNodeObject) {
   visitor->trace(m_node);
   AXObject::trace(visitor);
 }
 
 }  // namespace blink