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

third_party/WebKit/Source/core/layout/shapes/ShapeOutsideInfo.cpp

 /*
  * Copyright (C) 2012 Adobe Systems Incorporated. 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.
@@ skipping 79 matching lines @@
     return;
   markShapeAsDirty();
   m_referenceBoxLogicalSize = newReferenceBoxLogicalSize;
 }
 
 static bool checkShapeImageOrigin(Document& document,
                                   const StyleImage& styleImage) {
   if (styleImage.isGeneratedImage())
     return true;
 
-  ASSERT(styleImage.cachedImage());
+  DCHECK(styleImage.cachedImage());
   ImageResourceContent& imageResource = *(styleImage.cachedImage());
   if (imageResource.isAccessAllowed(document.getSecurityOrigin()))
     return true;
 
   const KURL& url = imageResource.url();
   String urlString = url.isNull() ? "''" : url.elidedString();
   document.addConsoleMessage(
       ConsoleMessage::create(SecurityMessageSource, ErrorMessageLevel,
                              "Unsafe attempt to load URL " + urlString + "."));
 
@@ skipping 45 matching lines @@
           : LayoutRect(LayoutPoint(), imageSize);
 
   if (!isValidRasterShapeRect(marginRect) ||
       !isValidRasterShapeRect(imageRect)) {
     m_layoutBox.document().addConsoleMessage(
         ConsoleMessage::create(RenderingMessageSource, ErrorMessageLevel,
                                "The shape-outside image is too large."));
     return Shape::createEmptyRasterShape(writingMode, margin);
   }
 
-  ASSERT(!styleImage->isPendingImage());
+  DCHECK(!styleImage->isPendingImage());
   RefPtr<Image> image =
       styleImage->image(m_layoutBox, flooredIntSize(imageSize),
                         m_layoutBox.style()->effectiveZoom());
 
   return Shape::createRasterShape(image.get(), shapeImageThreshold, imageRect,
                                   marginRect, writingMode, margin);
 }
 
 const Shape& ShapeOutsideInfo::computedShape() const {
   if (Shape* shape = m_shape.get())
     return *shape;
 
   AutoReset<bool> isInComputingShape(&m_isComputingShape, true);
 
   const ComputedStyle& style = *m_layoutBox.style();
-  ASSERT(m_layoutBox.containingBlock());
+  DCHECK(m_layoutBox.containingBlock());
   const ComputedStyle& containingBlockStyle =
       *m_layoutBox.containingBlock()->style();
 
   WritingMode writingMode = containingBlockStyle.getWritingMode();
   // Make sure contentWidth is not negative. This can happen when containing
   // block has a vertical scrollbar and its content is smaller than the
   // scrollbar width.
   LayoutUnit maximumValue =
       m_layoutBox.containingBlock()
           ? std::max(LayoutUnit(),
                      m_layoutBox.containingBlock()->contentWidth())
           : LayoutUnit();
   float margin = floatValueForLength(m_layoutBox.style()->shapeMargin(),
                                      maximumValue.toFloat());
 
   float shapeImageThreshold = style.shapeImageThreshold();
-  ASSERT(style.shapeOutside());
+  DCHECK(style.shapeOutside());
   const ShapeValue& shapeValue = *style.shapeOutside();
 
   switch (shapeValue.type()) {
     case ShapeValue::Shape:
-      ASSERT(shapeValue.shape());
+      DCHECK(shapeValue.shape());
       m_shape = Shape::createShape(
           shapeValue.shape(), m_referenceBoxLogicalSize, writingMode, margin);
       break;
     case ShapeValue::Image:
-      ASSERT(shapeValue.isImageValid());
+      DCHECK(shapeValue.isImageValid());
       m_shape = createShapeForImage(shapeValue.image(), shapeImageThreshold,
                                     writingMode, margin);
       break;
     case ShapeValue::Box: {
       const FloatRoundedRect& shapeRect = style.getRoundedBorderFor(
           LayoutRect(LayoutPoint(), m_referenceBoxLogicalSize),
           m_layoutBox.view());
       m_shape = Shape::createLayoutBoxShape(shapeRect, writingMode, margin);
       break;
     }
   }
 
-  ASSERT(m_shape);
+  DCHECK(m_shape);
   return *m_shape;
 }
 
 inline LayoutUnit borderBeforeInWritingMode(const LayoutBox& layoutBox,
                                             WritingMode writingMode) {
   switch (writingMode) {
     case WritingMode::kHorizontalTb:
       return LayoutUnit(layoutBox.borderTop());
     case WritingMode::kVerticalLr:
       return LayoutUnit(layoutBox.borderLeft());
@@ skipping 109 matching lines @@
   }
 
   return false;
 }
 
 ShapeOutsideDeltas ShapeOutsideInfo::computeDeltasForContainingBlockLine(
     const LineLayoutBlockFlow& containingBlock,
     const FloatingObject& floatingObject,
     LayoutUnit lineTop,
     LayoutUnit lineHeight) {
-  ASSERT(lineHeight >= 0);
+  DCHECK_GE(lineHeight, 0);
 
   LayoutUnit borderBoxTop = containingBlock.logicalTopForFloat(floatingObject) +
                             containingBlock.marginBeforeForChild(m_layoutBox);
   LayoutUnit borderBoxLineTop = lineTop - borderBoxTop;
 
   if (isShapeDirty() ||
       !m_shapeOutsideDeltas.isForLine(borderBoxLineTop, lineHeight)) {
     LayoutUnit referenceBoxLineTop = borderBoxLineTop - logicalTopOffset();
     LayoutUnit floatMarginBoxWidth = std::max(
         containingBlock.logicalWidthForFloat(floatingObject), LayoutUnit());
@@ skipping 71 matching lines @@
   return result;
 }
 
 FloatSize ShapeOutsideInfo::shapeToLayoutObjectSize(FloatSize size) const {
   if (!m_layoutBox.style()->isHorizontalWritingMode())
     return size.transposedSize();
   return size;
 }
 
 }  // namespace blink