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

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

 /*
  * Copyright (C) 2006 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  * Copyright 2014 The Chromium Authors. 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.
  *
@@ skipping 43 matching lines @@
 void LayoutSVGResourcePattern::removeAllClientsFromCache(
     bool markForInvalidation) {
   m_patternMap.clear();
   m_shouldCollectPatternAttributes = true;
   markAllClientsForInvalidation(markForInvalidation ? PaintInvalidation
                                                     : ParentOnlyInvalidation);
 }
 
 void LayoutSVGResourcePattern::removeClientFromCache(LayoutObject* client,
                                                      bool markForInvalidation) {
-  ASSERT(client);
+  DCHECK(client);
   m_patternMap.erase(client);
   markClientForInvalidation(
       client, markForInvalidation ? PaintInvalidation : ParentOnlyInvalidation);
 }
 
 PatternData* LayoutSVGResourcePattern::patternForLayoutObject(
     const LayoutObject& object) {
-  ASSERT(!m_shouldCollectPatternAttributes);
+  DCHECK(!m_shouldCollectPatternAttributes);
 
   // FIXME: the double hash lookup is needed to guard against paint-time
   // invalidation (painting animated images may trigger layout invals which
   // delete our map entry). Hopefully that will be addressed at some point, and
   // then we can optimize the lookup.
   if (PatternData* currentData = m_patternMap.at(&object))
     return currentData;
 
   return m_patternMap.set(&object, buildPatternData(object))
       .storedValue->value.get();
 }
 
 std::unique_ptr<PatternData> LayoutSVGResourcePattern::buildPatternData(
     const LayoutObject& object) {
   // If we couldn't determine the pattern content element root, stop here.
   const PatternAttributes& attributes = this->attributes();
   if (!attributes.patternContentElement())
     return nullptr;
 
   // An empty viewBox disables layout.
   if (attributes.hasViewBox() && attributes.viewBox().isEmpty())
     return nullptr;
 
-  ASSERT(element());
+  DCHECK(element());
   // Compute tile metrics.
   FloatRect clientBoundingBox = object.objectBoundingBox();
   FloatRect tileBounds = SVGLengthContext::resolveRectangle(
       element(), attributes.patternUnits(), clientBoundingBox, *attributes.x(),
       *attributes.y(), *attributes.width(), *attributes.height());
   if (tileBounds.isEmpty())
     return nullptr;
 
   AffineTransform tileTransform;
   if (attributes.hasViewBox()) {
@@ skipping 52 matching lines @@
 
   PatternData* patternData = patternForLayoutObject(object);
   if (!patternData || !patternData->pattern)
     return SVGPaintServer::invalid();
 
   return SVGPaintServer(patternData->pattern, patternData->transform);
 }
 
 const LayoutSVGResourceContainer*
 LayoutSVGResourcePattern::resolveContentElement() const {
-  ASSERT(attributes().patternContentElement());
+  DCHECK(attributes().patternContentElement());
   LayoutSVGResourceContainer* expectedLayoutObject =
       toLayoutSVGResourceContainer(
           attributes().patternContentElement()->layoutObject());
   // No content inheritance - avoid walking the inheritance chain.
   if (this == expectedLayoutObject)
     return this;
   // Walk the inheritance chain on the LayoutObject-side. If we reach the
   // expected LayoutObject, all is fine. If we don't, there's a cycle that
   // the cycle resolver did break, and the resource will be content-less.
   const LayoutSVGResourceContainer* contentLayoutObject = this;
   while (SVGResources* resources =
              SVGResourcesCache::cachedResourcesForLayoutObject(
                  contentLayoutObject)) {
     LayoutSVGResourceContainer* linkedResource = resources->linkedResource();
     if (!linkedResource)
       break;
     if (linkedResource == expectedLayoutObject)
       return expectedLayoutObject;
     contentLayoutObject = linkedResource;
   }
   // There was a cycle, just use this resource as the "content resource" even
   // though it will be empty (have no children).
   return this;
 }
 
 sk_sp<PaintRecord> LayoutSVGResourcePattern::asPaintRecord(
     const FloatRect& tileBounds,
     const AffineTransform& tileTransform) const {
-  ASSERT(!m_shouldCollectPatternAttributes);
+  DCHECK(!m_shouldCollectPatternAttributes);
 
   AffineTransform contentTransform;
   if (attributes().patternContentUnits() ==
       SVGUnitTypes::kSvgUnitTypeObjectboundingbox)
     contentTransform = tileTransform;
 
   FloatRect bounds(FloatPoint(), tileBounds.size());
   PaintRecordBuilder builder(bounds);
 
   const LayoutSVGResourceContainer* patternLayoutObject =
       resolveContentElement();
-  ASSERT(patternLayoutObject && !patternLayoutObject->needsLayout());
+  DCHECK(patternLayoutObject);
+  DCHECK(!patternLayoutObject->needsLayout());
 
   SubtreeContentTransformScope contentTransformScope(contentTransform);
 
   {
     TransformRecorder transformRecorder(builder.context(), *patternLayoutObject,
                                         tileTransform);
     for (LayoutObject* child = patternLayoutObject->firstChild(); child;
          child = child->nextSibling())
       SVGPaintContext::paintResourceSubtree(builder.context(), child);
   }
 
   return builder.endRecording();
 }
 
 }  // namespace blink