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

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

 /*
  * Copyright (C) 2007, 2008 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Google, Inc.  All rights reserved.
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) Research In Motion Limited 2009-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
@@ skipping 144 matching lines @@
 }
 
 void SVGLayoutSupport::mapAncestorToLocal(const LayoutObject& object,
                                           const LayoutBoxModelObject* ancestor,
                                           TransformState& transformState,
                                           MapCoordinatesFlags flags) {
   // |object| is either a LayoutSVGModelObject or a LayoutSVGBlock here. In
   // the former case, |object| can never be an ancestor while in the latter
   // the caller is responsible for doing the ancestor check. Because of this,
   // computing the transform to the SVG root is always what we want to do here.
-  ASSERT(ancestor != &object);
-  ASSERT(object.isSVGContainer() || object.isSVGShape() ||
+  DCHECK_NE(ancestor, &object);
+  DCHECK(object.isSVGContainer() || object.isSVGShape() ||
          object.isSVGImage() || object.isSVGText() ||
          object.isSVGForeignObject());
   AffineTransform localToSVGRoot;
   const LayoutSVGRoot& svgRoot =
       computeTransformToSVGRoot(object, localToSVGRoot);
 
   MapCoordinatesFlags mode = flags | UseTransforms | ApplyContainerFlip;
   svgRoot.mapAncestorToLocal(ancestor, transformState, mode);
 
   transformState.applyTransform(localToSVGRoot);
@@ skipping 83 matching lines @@
 
   localVisualRect = strokeBoundingBox;
   adjustVisualRectWithResources(container, localVisualRect);
 }
 
 const LayoutSVGRoot* SVGLayoutSupport::findTreeRootObject(
     const LayoutObject* start) {
   while (start && !start->isSVGRoot())
     start = start->parent();
 
-  ASSERT(start);
-  ASSERT(start->isSVGRoot());
+  DCHECK(start);
+  DCHECK(start->isSVGRoot());
   return toLayoutSVGRoot(start);
 }
 
 bool SVGLayoutSupport::layoutSizeOfNearestViewportChanged(
     const LayoutObject* start) {
   for (; start; start = start->parent()) {
     if (start->isSVGRoot())
       return toLayoutSVGRoot(start)->isLayoutSizeChanged();
     if (start->isSVGViewportContainer())
       return toLayoutSVGViewportContainer(start)->isLayoutSizeChanged();
@@ skipping 72 matching lines @@
         layoutScope.setNeedsLayout(child, LayoutInvalidationReason::SvgChanged);
 
       // Lay out any referenced resources before the child.
       layoutResourcesIfNeeded(child);
       child->layoutIfNeeded();
     }
   }
 }
 
 void SVGLayoutSupport::layoutResourcesIfNeeded(const LayoutObject* object) {
-  ASSERT(object);
+  DCHECK(object);
 
   SVGResources* resources =
       SVGResourcesCache::cachedResourcesForLayoutObject(object);
   if (resources)
     resources->layoutIfNeeded();
 }
 
 bool SVGLayoutSupport::isOverflowHidden(const LayoutObject* object) {
   // LayoutSVGRoot should never query for overflow state - it should always clip
   // itself to the initial viewport size.
-  ASSERT(!object->isDocumentElement());
+  DCHECK(!object->isDocumentElement());
 
   return object->style()->overflowX() == EOverflow::kHidden ||
          object->style()->overflowX() == EOverflow::kScroll;
 }
 
 void SVGLayoutSupport::adjustVisualRectWithResources(
     const LayoutObject* layoutObject,
     FloatRect& visualRect) {
-  ASSERT(layoutObject);
+  DCHECK(layoutObject);
 
   SVGResources* resources =
       SVGResourcesCache::cachedResourcesForLayoutObject(layoutObject);
   if (!resources)
     return;
 
   if (LayoutSVGResourceFilter* filter = resources->filter())
     visualRect = filter->resourceBoundingBox(layoutObject);
 
   if (LayoutSVGResourceClipper* clipper = resources->clipper())
@@ skipping 47 matching lines @@
   DashArray dashArray;
   for (const Length& dashLength : svgDashArray.vector())
     dashArray.push_back(lengthContext.valueForLength(dashLength, style));
   return dashArray;
 }
 
 void SVGLayoutSupport::applyStrokeStyleToStrokeData(StrokeData& strokeData,
                                                     const ComputedStyle& style,
                                                     const LayoutObject& object,
                                                     float dashScaleFactor) {
-  ASSERT(object.node());
-  ASSERT(object.node()->isSVGElement());
+  DCHECK(object.node());
+  DCHECK(object.node()->isSVGElement());
 
   const SVGComputedStyle& svgStyle = style.svgStyle();
 
   SVGLengthContext lengthContext(toSVGElement(object.node()));
   strokeData.setThickness(lengthContext.valueForLength(svgStyle.strokeWidth()));
   strokeData.setLineCap(svgStyle.capStyle());
   strokeData.setLineJoin(svgStyle.joinStyle());
   strokeData.setMiterLimit(svgStyle.strokeMiterLimit());
 
   DashArray dashArray =
       resolveSVGDashArray(*svgStyle.strokeDashArray(), style, lengthContext);
   float dashOffset =
       lengthContext.valueForLength(svgStyle.strokeDashOffset(), style);
   // Apply scaling from 'pathLength'.
   if (dashScaleFactor != 1) {
-    ASSERT(dashScaleFactor >= 0);
+    DCHECK_GE(dashScaleFactor, 0);
     dashOffset *= dashScaleFactor;
     for (auto& dashItem : dashArray)
       dashItem *= dashScaleFactor;
   }
   strokeData.setLineDash(dashArray, dashOffset);
 }
 
 bool SVGLayoutSupport::isLayoutableTextNode(const LayoutObject* object) {
-  ASSERT(object->isText());
+  DCHECK(object->isText());
   // <br> is marked as text, but is not handled by the SVG layout code-path.
   return object->isSVGInlineText() &&
          !toLayoutSVGInlineText(object)->hasEmptyText();
 }
 
 bool SVGLayoutSupport::willIsolateBlendingDescendantsForStyle(
     const ComputedStyle& style) {
   const SVGComputedStyle& svgStyle = style.svgStyle();
 
   return style.hasIsolation() || style.opacity() < 1 || style.hasBlendMode() ||
@@ skipping 120 matching lines @@
 }
 
 LayoutObject* SVGLayoutSupport::findClosestLayoutSVGText(
     LayoutObject* layoutObject,
     const FloatPoint& point) {
   return searchTreeForFindClosestLayoutSVGText(layoutObject, point)
       .candidateLayoutObject;
 }
 
 }  // namespace blink