Replace ASSERT with DCHECK in core/layout/<sub dirs>

third_party/WebKit/Source/core/layout/svg/SVGResources.cpp

 /*
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 165 matching lines @@
     std::unique_ptr<SVGResources>& resources) {
   if (!resources)
     resources = WTF::wrapUnique(new SVGResources);
 
   return *resources.get();
 }
 
 std::unique_ptr<SVGResources> SVGResources::buildResources(
     const LayoutObject* object,
     const ComputedStyle& computedStyle) {
-  ASSERT(object);
+  DCHECK(object);
 
   Node* node = object->node();
-  ASSERT(node);
+  DCHECK(node);
   SECURITY_DCHECK(node->isSVGElement());
 
   SVGElement& element = toSVGElement(*node);
 
   const AtomicString& tagName = element.localName();
-  ASSERT(!tagName.isNull());
+  DCHECK(!tagName.isNull());
 
   TreeScope& treeScope = element.treeScopeForIdResolution();
   SVGTreeScopeResources& treeScopeResources =
       treeScope.ensureSVGTreeScopedResources();
 
   const SVGComputedStyle& style = computedStyle.svgStyle();
 
   std::unique_ptr<SVGResources> resources;
   if (clipperFilterMaskerTags().contains(tagName)) {
     if (computedStyle.clipPath() && !object->isSVGRoot()) {
@@ skipping 115 matching lines @@
   if (LayoutSVGResourceMasker* masker = m_clipperFilterMaskerData->masker)
     masker->removeClientFromCache(object, markForInvalidation);
 }
 
 void SVGResources::removeClientFromCache(LayoutObject* object,
                                          bool markForInvalidation) const {
   if (!hasResourceData())
     return;
 
   if (m_linkedResource) {
-    ASSERT(!m_clipperFilterMaskerData);
-    ASSERT(!m_markerData);
-    ASSERT(!m_fillStrokeData);
+    DCHECK(!m_clipperFilterMaskerData);
+    DCHECK(!m_markerData);
+    DCHECK(!m_fillStrokeData);
     m_linkedResource->removeClientFromCache(object, markForInvalidation);
     return;
   }
 
   removeClientFromCacheAffectingObjectBounds(object, markForInvalidation);
 
   if (m_markerData) {
     if (m_markerData->markerStart)
       m_markerData->markerStart->removeClientFromCache(object,
                                                        markForInvalidation);
     if (m_markerData->markerMid)
       m_markerData->markerMid->removeClientFromCache(object,
                                                      markForInvalidation);
     if (m_markerData->markerEnd)
       m_markerData->markerEnd->removeClientFromCache(object,
                                                      markForInvalidation);
   }
 
   if (m_fillStrokeData) {
     if (m_fillStrokeData->fill)
       m_fillStrokeData->fill->removeClientFromCache(object,
                                                     markForInvalidation);
     if (m_fillStrokeData->stroke)
       m_fillStrokeData->stroke->removeClientFromCache(object,
                                                       markForInvalidation);
   }
 }
 
 void SVGResources::resourceDestroyed(LayoutSVGResourceContainer* resource) {
-  ASSERT(resource);
+  DCHECK(resource);
   if (!hasResourceData())
     return;
 
   if (m_linkedResource == resource) {
-    ASSERT(!m_clipperFilterMaskerData);
-    ASSERT(!m_markerData);
-    ASSERT(!m_fillStrokeData);
+    DCHECK(!m_clipperFilterMaskerData);
+    DCHECK(!m_markerData);
+    DCHECK(!m_fillStrokeData);
     m_linkedResource->removeAllClientsFromCache();
     m_linkedResource = nullptr;
     return;
   }
 
   switch (resource->resourceType()) {
     case MaskerResourceType:
       if (!m_clipperFilterMaskerData)
         break;
       if (m_clipperFilterMaskerData->masker == resource)
@@ skipping 35 matching lines @@
       NOTREACHED();
   }
 }
 
 void SVGResources::buildSetOfResources(
     HashSet<LayoutSVGResourceContainer*>& set) {
   if (!hasResourceData())
     return;
 
   if (m_linkedResource) {
-    ASSERT(!m_clipperFilterMaskerData);
-    ASSERT(!m_markerData);
-    ASSERT(!m_fillStrokeData);
+    DCHECK(!m_clipperFilterMaskerData);
+    DCHECK(!m_markerData);
+    DCHECK(!m_fillStrokeData);
     set.insert(m_linkedResource);
     return;
   }
 
   if (m_clipperFilterMaskerData) {
     if (m_clipperFilterMaskerData->clipper)
       set.insert(m_clipperFilterMaskerData->clipper);
     if (m_clipperFilterMaskerData->filter)
       set.insert(m_clipperFilterMaskerData->filter);
     if (m_clipperFilterMaskerData->masker)
@@ skipping 14 matching lines @@
       set.insert(m_fillStrokeData->fill);
     if (m_fillStrokeData->stroke)
       set.insert(m_fillStrokeData->stroke);
   }
 }
 
 void SVGResources::setClipper(LayoutSVGResourceClipper* clipper) {
   if (!clipper)
     return;
 
-  ASSERT(clipper->resourceType() == ClipperResourceType);
+  DCHECK_EQ(clipper->resourceType(), ClipperResourceType);
 
   if (!m_clipperFilterMaskerData)
     m_clipperFilterMaskerData = ClipperFilterMaskerData::create();
 
   m_clipperFilterMaskerData->clipper = clipper;
 }
 
 void SVGResources::resetClipper() {
-  ASSERT(m_clipperFilterMaskerData);
-  ASSERT(m_clipperFilterMaskerData->clipper);
+  DCHECK(m_clipperFilterMaskerData);
+  DCHECK(m_clipperFilterMaskerData->clipper);
   m_clipperFilterMaskerData->clipper = nullptr;
 }
 
 void SVGResources::setFilter(LayoutSVGResourceFilter* filter) {
   if (!filter)
     return;
 
-  ASSERT(filter->resourceType() == FilterResourceType);
+  DCHECK_EQ(filter->resourceType(), FilterResourceType);
 
   if (!m_clipperFilterMaskerData)
     m_clipperFilterMaskerData = ClipperFilterMaskerData::create();
 
   m_clipperFilterMaskerData->filter = filter;
 }
 
 void SVGResources::resetFilter() {
-  ASSERT(m_clipperFilterMaskerData);
-  ASSERT(m_clipperFilterMaskerData->filter);
+  DCHECK(m_clipperFilterMaskerData);
+  DCHECK(m_clipperFilterMaskerData->filter);
   m_clipperFilterMaskerData->filter = nullptr;
 }
 
 void SVGResources::setMarkerStart(LayoutSVGResourceMarker* markerStart) {
   if (!markerStart)
     return;
 
-  ASSERT(markerStart->resourceType() == MarkerResourceType);
+  DCHECK_EQ(markerStart->resourceType(), MarkerResourceType);
 
   if (!m_markerData)
     m_markerData = MarkerData::create();
 
   m_markerData->markerStart = markerStart;
 }
 
 void SVGResources::resetMarkerStart() {
-  ASSERT(m_markerData);
-  ASSERT(m_markerData->markerStart);
+  DCHECK(m_markerData);
+  DCHECK(m_markerData->markerStart);
   m_markerData->markerStart = nullptr;
 }
 
 void SVGResources::setMarkerMid(LayoutSVGResourceMarker* markerMid) {
   if (!markerMid)
     return;
 
-  ASSERT(markerMid->resourceType() == MarkerResourceType);
+  DCHECK_EQ(markerMid->resourceType(), MarkerResourceType);
 
   if (!m_markerData)
     m_markerData = MarkerData::create();
 
   m_markerData->markerMid = markerMid;
 }
 
 void SVGResources::resetMarkerMid() {
-  ASSERT(m_markerData);
-  ASSERT(m_markerData->markerMid);
+  DCHECK(m_markerData);
+  DCHECK(m_markerData->markerMid);
   m_markerData->markerMid = nullptr;
 }
 
 void SVGResources::setMarkerEnd(LayoutSVGResourceMarker* markerEnd) {
   if (!markerEnd)
     return;
 
-  ASSERT(markerEnd->resourceType() == MarkerResourceType);
+  DCHECK_EQ(markerEnd->resourceType(), MarkerResourceType);
 
   if (!m_markerData)
     m_markerData = MarkerData::create();
 
   m_markerData->markerEnd = markerEnd;
 }
 
 void SVGResources::resetMarkerEnd() {
-  ASSERT(m_markerData);
-  ASSERT(m_markerData->markerEnd);
+  DCHECK(m_markerData);
+  DCHECK(m_markerData->markerEnd);
   m_markerData->markerEnd = nullptr;
 }
 
 void SVGResources::setMasker(LayoutSVGResourceMasker* masker) {
   if (!masker)
     return;
 
-  ASSERT(masker->resourceType() == MaskerResourceType);
+  DCHECK_EQ(masker->resourceType(), MaskerResourceType);
 
   if (!m_clipperFilterMaskerData)
     m_clipperFilterMaskerData = ClipperFilterMaskerData::create();
 
   m_clipperFilterMaskerData->masker = masker;
 }
 
 void SVGResources::resetMasker() {
-  ASSERT(m_clipperFilterMaskerData);
-  ASSERT(m_clipperFilterMaskerData->masker);
+  DCHECK(m_clipperFilterMaskerData);
+  DCHECK(m_clipperFilterMaskerData->masker);
   m_clipperFilterMaskerData->masker = nullptr;
 }
 
 void SVGResources::setFill(LayoutSVGResourcePaintServer* fill) {
   if (!fill)
     return;
 
   if (!m_fillStrokeData)
     m_fillStrokeData = FillStrokeData::create();
 
   m_fillStrokeData->fill = fill;
 }
 
 void SVGResources::resetFill() {
-  ASSERT(m_fillStrokeData);
-  ASSERT(m_fillStrokeData->fill);
+  DCHECK(m_fillStrokeData);
+  DCHECK(m_fillStrokeData->fill);
   m_fillStrokeData->fill = nullptr;
 }
 
 void SVGResources::setStroke(LayoutSVGResourcePaintServer* stroke) {
   if (!stroke)
     return;
 
   if (!m_fillStrokeData)
     m_fillStrokeData = FillStrokeData::create();
 
   m_fillStrokeData->stroke = stroke;
 }
 
 void SVGResources::resetStroke() {
-  ASSERT(m_fillStrokeData);
-  ASSERT(m_fillStrokeData->stroke);
+  DCHECK(m_fillStrokeData);
+  DCHECK(m_fillStrokeData->stroke);
   m_fillStrokeData->stroke = nullptr;
 }
 
 void SVGResources::setLinkedResource(
     LayoutSVGResourceContainer* linkedResource) {
   if (!linkedResource)
     return;
 
   m_linkedResource = linkedResource;
 }
 
 void SVGResources::resetLinkedResource() {
-  ASSERT(m_linkedResource);
+  DCHECK(m_linkedResource);
   m_linkedResource = nullptr;
 }
 
 #ifndef NDEBUG
 void SVGResources::dump(const LayoutObject* object) {
-  ASSERT(object);
-  ASSERT(object->node());
+  DCHECK(object);
+  DCHECK(object->node());
 
   fprintf(stderr, "-> this=%p, SVGResources(layoutObject=%p, node=%p)\n", this,
           object, object->node());
   fprintf(stderr, " | DOM Tree:\n");
   fprintf(stderr, "%s", object->node()->toTreeStringForThis().utf8().data());
 
   fprintf(stderr, "\n | List of resources:\n");
   if (m_clipperFilterMaskerData) {
     if (LayoutSVGResourceClipper* clipper = m_clipperFilterMaskerData->clipper)
       fprintf(stderr, " |-> Clipper    : %p (node=%p)\n", clipper,
@@ skipping 27 matching lines @@
               stroke->element());
   }
 
   if (m_linkedResource)
     fprintf(stderr, " |-> xlink:href : %p (node=%p)\n", m_linkedResource,
             m_linkedResource->element());
 }
 #endif
 
 }  // namespace blink