Replace ASSERT with DCHECK in core/svg/

third_party/WebKit/Source/core/svg/SVGUseElement.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Nikolas Zimmermann
  * <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007 Rob Buis <buis@kde.org>
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
  * Copyright (C) 2011 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  * Copyright (C) 2012 University of Szeged
  * Copyright (C) 2012 Renata Hodovan <reni@webkit.org>
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 51 matching lines @@
           SVGAnimatedLength::create(this,
                                     SVGNames::widthAttr,
                                     SVGLength::create(SVGLengthMode::Width))),
       m_height(
           SVGAnimatedLength::create(this,
                                     SVGNames::heightAttr,
                                     SVGLength::create(SVGLengthMode::Height))),
       m_elementIdentifierIsLocal(true),
       m_haveFiredLoadEvent(false),
       m_needsShadowTreeRecreation(false) {
-  ASSERT(hasCustomStyleCallbacks());
+  DCHECK(hasCustomStyleCallbacks());
 
   addToPropertyMap(m_x);
   addToPropertyMap(m_y);
   addToPropertyMap(m_width);
   addToPropertyMap(m_height);
 }
 
 SVGUseElement* SVGUseElement::create(Document& document) {
   // Always build a user agent #shadow-root for SVGUseElement.
   SVGUseElement* use = new SVGUseElement(document);
@@ skipping 28 matching lines @@
 }
 #endif
 
 Node::InsertionNotificationRequest SVGUseElement::insertedInto(
     ContainerNode* rootParent) {
   // This functions exists to assure assumptions made in the code regarding
   // SVGElementInstance creation/destruction are satisfied.
   SVGGraphicsElement::insertedInto(rootParent);
   if (!rootParent->isConnected())
     return InsertionDone;
-  ASSERT(!m_targetElementInstance || !isWellFormedDocument(&document()));
-  ASSERT(!hasPendingResources() || !isWellFormedDocument(&document()));
+#if DCHECK_IS_ON()
+  DCHECK(!m_targetElementInstance || !isWellFormedDocument(&document()));
+  DCHECK(!hasPendingResources() || !isWellFormedDocument(&document()));
+#endif
   invalidateShadowTree();
   return InsertionDone;
 }
 
 void SVGUseElement::removedFrom(ContainerNode* rootParent) {
   SVGGraphicsElement::removedFrom(rootParent);
   if (rootParent->isConnected()) {
     clearResourceReference();
     cancelShadowTreeRecreation();
   }
@@ skipping 85 matching lines @@
     SVGElement::InvalidationGuard invalidationGuard(this);
 
     if (attrName == SVGNames::xAttr || attrName == SVGNames::yAttr) {
       invalidateSVGPresentationAttributeStyle();
       setNeedsStyleRecalc(LocalStyleChange,
                           StyleChangeReasonForTracing::fromAttribute(attrName));
     }
 
     updateRelativeLengthsInformation();
     if (m_targetElementInstance) {
-      ASSERT(m_targetElementInstance->correspondingElement());
+      DCHECK(m_targetElementInstance->correspondingElement());
       transferUseWidthAndHeightIfNeeded(
           *this, *m_targetElementInstance,
           *m_targetElementInstance->correspondingElement());
     }
 
     LayoutObject* object = this->layoutObject();
     if (object)
       markForLayoutAndParentResourceInvalidation(object);
     return;
   }
@@ skipping 77 matching lines @@
   cancelShadowTreeRecreation();
   if (!isConnected())
     return;
   Element* target = resolveTargetElement();
   // TODO(fs): Why would the Element not be "connected" at this point?
   if (target && target->isConnected() && target->isSVGElement()) {
     buildShadowAndInstanceTree(toSVGElement(*target));
     invalidateDependentShadowTrees();
   }
 
-  ASSERT(!m_needsShadowTreeRecreation);
+  DCHECK(!m_needsShadowTreeRecreation);
 }
 
 String SVGUseElement::title() const {
   // Find the first <title> child in <use> which doesn't cover shadow tree.
   if (Element* titleElement = Traversal<SVGTitleElement>::firstChild(*this))
     return titleElement->innerText();
 
   // If there is no <title> child in <use>, we lookup first <title> child in
   // shadow tree.
   if (m_targetElementInstance) {
     if (Element* titleElement =
             Traversal<SVGTitleElement>::firstChild(*m_targetElementInstance))
       return titleElement->innerText();
   }
   // Otherwise return a null string.
   return String();
 }
 
 static void associateCorrespondingElements(SVGElement& targetRoot,
                                            SVGElement& instanceRoot) {
   auto targetRange = Traversal<SVGElement>::inclusiveDescendantsOf(targetRoot);
   auto targetIterator = targetRange.begin();
   for (SVGElement& instance :
        Traversal<SVGElement>::inclusiveDescendantsOf(instanceRoot)) {
-    ASSERT(!instance.correspondingElement());
+    DCHECK(!instance.correspondingElement());
     instance.setCorrespondingElement(&*targetIterator);
     ++targetIterator;
   }
-  ASSERT(!(targetIterator != targetRange.end()));
+  DCHECK(!(targetIterator != targetRange.end()));

[tkent, 2017/03/14 22:33:14]

Use DCHECK_EQ if possible.

[mrunal, 2017/03/14 23:52:14]

It throws an error,
../../base/logging.h:703:26: error: invalid operands to binary expression
('const
blink::TraversalInclusiveDescendantIterator<blink::Traversal<blink::SVGElement>
>' and 'const
blink::TraversalInclusiveDescendantIterator<blink::Traversal<blink::SVGElement>
>')
DEFINE_CHECK_OP_IMPL(EQ, ==)
~~~~~~~~~~~~~~~~~~~~~~~~~^~~
../../base/logging.h:692:12: note: expanded from macro 'DEFINE_CHECK_OP_IMPL'
    if (v1 op v2)                                                            \
        ~~ ^  ~~
../../third_party/WebKit/Source/core/svg/SVGUseElement.cpp:357:3: note: in
instantiation of function template specialization
'logging::CheckEQImpl<blink::TraversalInclusiveDescendantIterator<blink::Traversal<blink::SVGElement>
>,
blink::TraversalInclusiveDescendantIterator<blink::Traversal<blink::SVGElement>
> >' requested here
  DCHECK_EQ(targetIterator, targetRange.end());
  ^
../../base/logging.h:899:31: note: expanded from macro 'DCHECK_EQ'
#define DCHECK_EQ(val1, val2) DCHECK_OP(EQ, ==, val1, val2)
                              ^
../../base/logging.h:853:18: note: expanded from macro 'DCHECK_OP'
      ::logging::Check##name##Impl((val1), (val2),                     \
                 ^

 }
 
 // We don't walk the target tree element-by-element, and clone each element,
 // but instead use cloneNode(deep=true). This is an optimization for the common
 // case where <use> doesn't contain disallowed elements (ie. <foreignObject>).
 // Though if there are disallowed elements in the subtree, we have to remove
 // them.  For instance: <use> on <g> containing <foreignObject> (indirect
 // case).
 static inline void removeDisallowedElementsFromSubtree(SVGElement& subtree) {
-  ASSERT(!subtree.isConnected());
+  DCHECK(!subtree.isConnected());
   Element* element = ElementTraversal::firstWithin(subtree);
   while (element) {
     if (isDisallowedElement(*element)) {
       Element* next =
           ElementTraversal::nextSkippingChildren(*element, &subtree);
       // The subtree is not in document so this won't generate events that could
       // mutate the tree.
       element->parentNode()->removeChild(element);
       element = next;
     } else {
       element = ElementTraversal::next(*element, &subtree);
     }
   }
 }
 
 static void moveChildrenToReplacementElement(ContainerNode& sourceRoot,
                                              ContainerNode& destinationRoot) {
   for (Node* child = sourceRoot.firstChild(); child;) {
     Node* nextChild = child->nextSibling();
     destinationRoot.appendChild(child);
     child = nextChild;
   }
 }
 
 Element* SVGUseElement::createInstanceTree(SVGElement& targetRoot) const {
   Element* instanceRoot = targetRoot.cloneElementWithChildren();
-  ASSERT(instanceRoot->isSVGElement());
+  DCHECK(instanceRoot->isSVGElement());
   if (isSVGSymbolElement(targetRoot)) {
     // Spec: The referenced 'symbol' and its contents are deep-cloned into
     // the generated tree, with the exception that the 'symbol' is replaced
     // by an 'svg'. This generated 'svg' will always have explicit values
     // for attributes width and height. If attributes width and/or height
     // are provided on the 'use' element, then these attributes will be
     // transferred to the generated 'svg'. If attributes width and/or
     // height are not specified, the generated 'svg' element will use
     // values of 100% for these attributes.
     SVGSVGElement* svgElement = SVGSVGElement::create(targetRoot.document());
     // Transfer all data (attributes, etc.) from the <symbol> to the new
     // <svg> element.
     svgElement->cloneDataFromElement(*instanceRoot);
     // Move already cloned elements to the new <svg> element.
     moveChildrenToReplacementElement(*instanceRoot, *svgElement);
     instanceRoot = svgElement;
   }
   transferUseWidthAndHeightIfNeeded(*this, toSVGElement(*instanceRoot),
                                     targetRoot);
   associateCorrespondingElements(targetRoot, toSVGElement(*instanceRoot));
   removeDisallowedElementsFromSubtree(toSVGElement(*instanceRoot));
   return instanceRoot;
 }
 
 void SVGUseElement::buildShadowAndInstanceTree(SVGElement& target) {
-  ASSERT(!m_targetElementInstance);
-  ASSERT(!m_needsShadowTreeRecreation);
+  DCHECK(!m_targetElementInstance);
+  DCHECK(!m_needsShadowTreeRecreation);
 
   // <use> creates a "user agent" shadow root. Do not build the shadow/instance
   // tree for <use> elements living in a user agent shadow tree because they
   // will get expanded in a second pass -- see expandUseElementsInShadowTree().
   if (inUseShadowTree())
     return;
 
   // Do not allow self-referencing.
   if (&target == this || isDisallowedElement(target))
     return;
 
   // Set up root SVG element in shadow tree.
   // Clone the target subtree into the shadow tree, not handling <use> and
   // <symbol> yet.
   Element* instanceRoot = createInstanceTree(target);
   m_targetElementInstance = toSVGElement(instanceRoot);
   ShadowRoot* shadowTreeRootElement = userAgentShadowRoot();
   shadowTreeRootElement->appendChild(instanceRoot);
 
   addReferencesToFirstDegreeNestedUseElements(target);
 
   if (instanceTreeIsLoading())
     return;
 
   // Assure shadow tree building was successful.
-  ASSERT(m_targetElementInstance);
-  ASSERT(m_targetElementInstance->correspondingUseElement() == this);
-  ASSERT(m_targetElementInstance->correspondingElement() == &target);
+  DCHECK(m_targetElementInstance);
+  DCHECK_EQ(m_targetElementInstance->correspondingUseElement(), this);
+  DCHECK_EQ(m_targetElementInstance->correspondingElement(), &target);
 
   // Expand all <use> elements in the shadow tree.
   // Expand means: replace the actual <use> element by what it references.
   if (!expandUseElementsInShadowTree()) {
     shadowTreeRootElement->removeChildren(OmitSubtreeModifiedEvent);
     clearResourceReference();
     return;
   }
 
   // If the instance root was a <use>, it could have been replaced now, so
   // reset |m_targetElementInstance|.
   m_targetElementInstance =
       toSVGElementOrDie(shadowTreeRootElement->firstChild());
-  ASSERT(m_targetElementInstance->parentNode() == shadowTreeRootElement);
+  DCHECK_EQ(m_targetElementInstance->parentNode(), shadowTreeRootElement);
 
   // Update relative length information.
   updateRelativeLengthsInformation();
 }
 
 LayoutObject* SVGUseElement::createLayoutObject(const ComputedStyle&) {
   return new LayoutSVGTransformableContainer(this);
 }
 
 static bool isDirectReference(const SVGElement& element) {
   return isSVGPathElement(element) || isSVGRectElement(element) ||
          isSVGCircleElement(element) || isSVGEllipseElement(element) ||
          isSVGPolygonElement(element) || isSVGPolylineElement(element) ||
          isSVGTextElement(element);
 }
 
 void SVGUseElement::toClipPath(Path& path) const {
-  ASSERT(path.isEmpty());
+  DCHECK(path.isEmpty());
 
   const SVGGraphicsElement* element = visibleTargetGraphicsElementForClipping();
 
   if (!element)
     return;
 
   if (element->isSVGGeometryElement()) {
     toSVGGeometryElement(*element).toClipPath(path);
     // FIXME: Avoid manual resolution of x/y here. Its potentially harmful.
     SVGLengthContext lengthContext(this);
@@ skipping 89 matching lines @@
   // Why expand the <use> elements in the shadow tree here, and not just
   // do this directly in buildShadowTree, if we encounter a <use> element?
   //
   // Short answer: Because we may miss to expand some elements. For example, if
   // a <symbol> contains <use> tags, we'd miss them. So once we're done with
   // setting up the actual shadow tree (after the special case modification for
   // svg/symbol) we have to walk it completely and expand all <use> elements.
   ShadowRoot* shadowRoot = userAgentShadowRoot();
   for (SVGUseElement* use = Traversal<SVGUseElement>::firstWithin(*shadowRoot);
        use;) {
-    ASSERT(!use->resourceIsStillLoading());
+    DCHECK(!use->resourceIsStillLoading());
 
     SVGUseElement& originalUse = toSVGUseElement(*use->correspondingElement());
     SVGElement* target = nullptr;
     if (hasCycleUseReferencing(originalUse, *use, target))
       return false;
 
     if (target && isDisallowedElement(*target))
       return false;
-    // Don't ASSERT(target) here, it may be "pending", too.
+    // Don't DCHECK(target) here, it may be "pending", too.
     // Setup sub-shadow tree root node
     SVGGElement* cloneParent = SVGGElement::create(originalUse.document());
     // Transfer all data (attributes, etc.) from <use> to the new <g> element.
     cloneParent->cloneDataFromElement(*use);
     cloneParent->setCorrespondingElement(&originalUse);
 
     removeAttributesFromReplacementElement(*cloneParent);
 
     // Move already cloned elements to the new <g> element.
     moveChildrenToReplacementElement(*use, *cloneParent);
@@ skipping 20 matching lines @@
 }
 
 void SVGUseElement::invalidateDependentShadowTrees() {
   // Recursively invalidate dependent <use> shadow trees
   const HeapHashSet<WeakMember<SVGElement>>& rawInstances =
       instancesForElement();
   HeapVector<Member<SVGElement>> instances;
   instances.appendRange(rawInstances.begin(), rawInstances.end());
   for (auto& instance : instances) {
     if (SVGUseElement* element = instance->correspondingUseElement()) {
-      ASSERT(element->isConnected());
+      DCHECK(element->isConnected());
       element->invalidateShadowTree();
     }
   }
 }
 
 bool SVGUseElement::selfHasRelativeLengths() const {
   if (m_x->currentValue()->isRelative() || m_y->currentValue()->isRelative() ||
       m_width->currentValue()->isRelative() ||
       m_height->currentValue()->isRelative())
     return true;
@@ skipping 21 matching lines @@
   // correct without additional work. That will not work out ATM without
   // additional quirks. The problem stems from including the additional
   // translation directly on the LayoutObject corresponding to the
   // SVGUseElement.
   FloatRect bbox = transformableContainer.objectBoundingBox();
   bbox.move(transformableContainer.additionalTranslation());
   return bbox;
 }
 
 void SVGUseElement::dispatchPendingEvent() {
-  ASSERT(isStructurallyExternal() && m_haveFiredLoadEvent);
+  DCHECK(isStructurallyExternal() && m_haveFiredLoadEvent);

[tkent, 2017/03/14 22:33:14]

Split it to two DCHECKs
  DCHECK((isStructurallyExternal());
  DCHECK(m_haveFiredLoadEvent);

[mrunal, 2017/03/14 23:52:14]

Done.

   dispatchEvent(Event::create(EventTypeNames::load));
 }
 
 void SVGUseElement::notifyFinished(Resource* resource) {
-  ASSERT(m_resource == resource);
+  DCHECK_EQ(m_resource, resource);
   if (!isConnected())
     return;
 
   invalidateShadowTree();
   if (!resourceIsValid()) {
     dispatchEvent(Event::create(EventTypeNames::error));
   } else if (!resource->wasCanceled()) {
     if (m_haveFiredLoadEvent)
       return;
     if (!isStructurallyExternal())
       return;
-    ASSERT(!m_haveFiredLoadEvent);
+    DCHECK(!m_haveFiredLoadEvent);
     m_haveFiredLoadEvent = true;
     TaskRunnerHelper::get(TaskType::DOMManipulation, &document())
         ->postTask(BLINK_FROM_HERE,
                    WTF::bind(&SVGUseElement::dispatchPendingEvent,
                              wrapPersistent(this)));
   }
 }
 
 bool SVGUseElement::resourceIsStillLoading() const {
   return m_resource && m_resource->isLoading();
@@ skipping 19 matching lines @@
 
   if (m_resource)
     m_resource->removeClient(this);
 
   m_resource = resource;
   if (m_resource)
     m_resource->addClient(this);
 }
 
 }  // namespace blink