Replace ASSERT with DCHECK in core/layout/ excluding subdirs

third_party/WebKit/Source/core/layout/LayoutReplaced.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011-2012. 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 59 matching lines @@
   LayoutBox::styleDidChange(diff, oldStyle);
 
   bool hadStyle = (oldStyle != 0);
   float oldZoom =
       hadStyle ? oldStyle->effectiveZoom() : ComputedStyle::initialZoom();
   if (style() && style()->effectiveZoom() != oldZoom)
     intrinsicSizeChanged();
 }
 
 void LayoutReplaced::layout() {
-  ASSERT(needsLayout());
+  DCHECK(needsLayout());
   LayoutAnalyzer::Scope analyzer(*this);
 
   LayoutRect oldContentRect = replacedContentRect();
 
   setHeight(minimumReplacedHeight());
 
   updateLogicalWidth();
   updateLogicalHeight();
 
   m_overflow.reset();
@@ skipping 39 matching lines @@
 
 bool LayoutReplaced::needsPreferredWidthsRecalculation() const {
   // If the height is a percentage and the width is auto, then the
   // containingBlocks's height changing can cause this node to change it's
   // preferred width because it maintains aspect ratio.
   return hasRelativeLogicalHeight() && style()->logicalWidth().isAuto();
 }
 
 static inline bool layoutObjectHasAspectRatio(
     const LayoutObject* layoutObject) {
-  ASSERT(layoutObject);
+  DCHECK(layoutObject);
   return layoutObject->isImage() || layoutObject->isCanvas() ||
          layoutObject->isVideo();
 }
 
 void LayoutReplaced::computeIntrinsicSizingInfoForReplacedContent(
     LayoutReplaced* contentLayoutObject,
     IntrinsicSizingInfo& intrinsicSizingInfo) const {
   if (contentLayoutObject) {
     contentLayoutObject->computeIntrinsicSizingInfo(intrinsicSizingInfo);
 
@@ skipping 127 matching lines @@
   //    get equal values, unless this would make them negative, in which case
   //    when the direction of the containing block is 'ltr' ('rtl'), set
   //    'margin-left' ('margin-right') to zero and solve for 'margin-right'
   //    ('margin-left').
   // ---------------------------------------------------------------------------
   LayoutUnit logicalLeftValue;
   LayoutUnit logicalRightValue;
 
   if (marginLogicalLeft.isAuto() && marginLogicalRight.isAuto()) {
     // 'left' and 'right' cannot be 'auto' due to step 3
-    ASSERT(!(logicalLeft.isAuto() && logicalRight.isAuto()));
+    DCHECK(!(logicalLeft.isAuto() && logicalRight.isAuto()));
 
     logicalLeftValue = valueForLength(logicalLeft, containerLogicalWidth);
     logicalRightValue = valueForLength(logicalRight, containerLogicalWidth);
 
     LayoutUnit difference =
         availableSpace - (logicalLeftValue + logicalRightValue);
     if (difference > LayoutUnit()) {
       marginLogicalLeftAlias = difference / 2;  // split the difference
       marginLogicalRightAlias =
           difference -
@@ skipping 179 matching lines @@
   // ---------------------------------------------------------------------------
   // 4. If at this point both 'margin-top' and 'margin-bottom' are still 'auto',
   //    solve the equation under the extra constraint that the two margins must
   //    get equal values.
   // ---------------------------------------------------------------------------
   LayoutUnit logicalTopValue;
   LayoutUnit logicalBottomValue;
 
   if (marginBefore.isAuto() && marginAfter.isAuto()) {
     // 'top' and 'bottom' cannot be 'auto' due to step 2 and 3 combined.
-    ASSERT(!(logicalTop.isAuto() || logicalBottom.isAuto()));
+    DCHECK(!(logicalTop.isAuto() || logicalBottom.isAuto()));
 
     logicalTopValue = valueForLength(logicalTop, containerLogicalHeight);
     logicalBottomValue = valueForLength(logicalBottom, containerLogicalHeight);
 
     LayoutUnit difference =
         availableSpace - (logicalTopValue + logicalBottomValue);
     // NOTE: This may result in negative values.
     marginBeforeAlias = difference / 2;  // split the difference
     marginAfterAlias =
         difference - marginBeforeAlias;  // account for odd valued differences
@@ skipping 118 matching lines @@
 }
 
 LayoutRect LayoutReplaced::replacedContentRect() const {
   return computeObjectFit();
 }
 
 void LayoutReplaced::computeIntrinsicSizingInfo(
     IntrinsicSizingInfo& intrinsicSizingInfo) const {
   // If there's an embeddedReplacedContent() of a remote, referenced document
   // available, this code-path should never be used.
-  ASSERT(!embeddedReplacedContent());
+  DCHECK(!embeddedReplacedContent());
   intrinsicSizingInfo.size = FloatSize(intrinsicLogicalWidth().toFloat(),
                                        intrinsicLogicalHeight().toFloat());
 
   // Figure out if we need to compute an intrinsic ratio.
   if (intrinsicSizingInfo.size.isEmpty() || !layoutObjectHasAspectRatio(this))
     return;
 
   intrinsicSizingInfo.aspectRatio = intrinsicSizingInfo.size;
 }
 
@@ skipping 171 matching lines @@
       intrinsicLogicalHeight());
 }
 
 void LayoutReplaced::computeIntrinsicLogicalWidths(
     LayoutUnit& minLogicalWidth,
     LayoutUnit& maxLogicalWidth) const {
   minLogicalWidth = maxLogicalWidth = intrinsicLogicalWidth();
 }
 
 void LayoutReplaced::computePreferredLogicalWidths() {
-  ASSERT(preferredLogicalWidthsDirty());
+  DCHECK(preferredLogicalWidthsDirty());
 
   // We cannot resolve some logical width here (i.e. percent, fill-available or
   // fit-content) as the available logical width may not be set on our
   // containing block.
   const Length& logicalWidth = style()->logicalWidth();
   if (logicalWidth.isPercentOrCalc() || logicalWidth.isFillAvailable() ||
       logicalWidth.isFitContent())
     computeIntrinsicLogicalWidths(m_minPreferredLogicalWidth,
                                   m_maxPreferredLogicalWidth);
   else
@@ skipping 97 matching lines @@
     inlineBoxWrapper()->root().setHasSelectedChildren(state != SelectionNone);
 }
 
 void LayoutReplaced::IntrinsicSizingInfo::transpose() {
   size = size.transposedSize();
   aspectRatio = aspectRatio.transposedSize();
   std::swap(hasWidth, hasHeight);
 }
 
 }  // namespace blink