Replace ASSERT with DCHECK in core/layout/ excluding subdirs

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

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 43 matching lines @@
   // The only place where a ruby base can be is in the last position
   // Note: As anonymous blocks, ruby runs do not have ':before' or ':after'
   // content themselves.
   return lastChild() && lastChild()->isRubyBase();
 }
 
 LayoutRubyText* LayoutRubyRun::rubyText() const {
   LayoutObject* child = firstChild();
   // If in future it becomes necessary to support floating or positioned ruby
   // text, layout will have to be changed to handle them properly.
-  ASSERT(!child || !child->isRubyText() ||
+  DCHECK(!child || !child->isRubyText() ||
          !child->isFloatingOrOutOfFlowPositioned());
   return child && child->isRubyText() ? static_cast<LayoutRubyText*>(child) : 0;
 }
 
 LayoutRubyBase* LayoutRubyRun::rubyBase() const {
   LayoutObject* child = lastChild();
   return child && child->isRubyBase() ? static_cast<LayoutRubyBase*>(child) : 0;
 }
 
 LayoutRubyBase* LayoutRubyRun::rubyBaseSafe() {
   LayoutRubyBase* base = rubyBase();
   if (!base) {
     base = createRubyBase();
     LayoutBlockFlow::addChild(base);
   }
   return base;
 }
 
 bool LayoutRubyRun::isChildAllowed(LayoutObject* child,
                                    const ComputedStyle&) const {
   return child->isRubyText() || child->isInline();
 }
 
 void LayoutRubyRun::addChild(LayoutObject* child, LayoutObject* beforeChild) {
-  ASSERT(child);
+  DCHECK(child);
 
   if (child->isRubyText()) {
     if (!beforeChild) {
       // LayoutRuby has already ascertained that we can add the child here.
-      ASSERT(!hasRubyText());
+      DCHECK(!hasRubyText());
       // prepend ruby texts as first child
       LayoutBlockFlow::addChild(child, firstChild());
     } else if (beforeChild->isRubyText()) {
       // New text is inserted just before another.
       // In this case the new text takes the place of the old one, and
       // the old text goes into a new run that is inserted as next sibling.
-      ASSERT(beforeChild->parent() == this);
+      DCHECK_EQ(beforeChild->parent(), this);
       LayoutObject* ruby = parent();
-      ASSERT(ruby->isRuby());
+      DCHECK(ruby->isRuby());
       LayoutBlock* newRun = staticCreateRubyRun(ruby);
       ruby->addChild(newRun, nextSibling());
       // Add the new ruby text and move the old one to the new run
       // Note: Doing it in this order and not using LayoutRubyRun's methods,
       // in order to avoid automatic removal of the ruby run in case there is no
       // other child besides the old ruby text.
       LayoutBlockFlow::addChild(child, beforeChild);
       LayoutBlockFlow::removeChild(beforeChild);
       newRun->addChild(beforeChild);
     } else if (hasRubyBase()) {
@@ skipping 12 matching lines @@
       rubyBaseSafe()->moveChildren(newRun->rubyBaseSafe(), beforeChild);
     }
   } else {
     // child is not a text -> insert it into the base
     // (append it instead if beforeChild is the ruby text)
     LayoutRubyBase* base = rubyBaseSafe();
     if (beforeChild == base)
       beforeChild = base->firstChild();
     if (beforeChild && beforeChild->isRubyText())
       beforeChild = 0;
-    ASSERT(!beforeChild || beforeChild->isDescendantOf(base));
+    DCHECK(!beforeChild || beforeChild->isDescendantOf(base));
     base->addChild(child, beforeChild);
   }
 }
 
 void LayoutRubyRun::removeChild(LayoutObject* child) {
   // If the child is a ruby text, then merge the ruby base with the base of
   // the right sibling run, if possible.
   if (!beingDestroyed() && !documentBeingDestroyed() && child->isRubyText()) {
     LayoutRubyBase* base = rubyBase();
     LayoutObject* rightNeighbour = nextSibling();
     if (base && rightNeighbour && rightNeighbour->isRubyRun()) {
       // Ruby run without a base can happen only at the first run.
       LayoutRubyRun* rightRun = toLayoutRubyRun(rightNeighbour);
       if (rightRun->hasRubyBase()) {
         LayoutRubyBase* rightBase = rightRun->rubyBaseSafe();
         // Collect all children in a single base, then swap the bases.
         rightBase->moveChildren(base);
         moveChildTo(rightRun, base);
         rightRun->moveChildTo(this, rightBase);
         // The now empty ruby base will be removed below.
-        ASSERT(!rubyBase()->firstChild());
+        DCHECK(!rubyBase()->firstChild());
       }
     }
   }
 
   LayoutBlockFlow::removeChild(child);
 
   if (!beingDestroyed() && !documentBeingDestroyed()) {
     // Check if our base (if any) is now empty. If so, destroy it.
     LayoutBlockFlow* base = rubyBase();
     if (base && !base->firstChild()) {
@@ skipping 15 matching lines @@
   RefPtr<ComputedStyle> newStyle =
       ComputedStyle::createAnonymousStyleWithDisplay(styleRef(),
                                                      EDisplay::kBlock);
   newStyle->setTextAlign(ETextAlign::kCenter);  // FIXME: use WEBKIT_CENTER?
   layoutObject->setStyle(std::move(newStyle));
   return layoutObject;
 }
 
 LayoutRubyRun* LayoutRubyRun::staticCreateRubyRun(
     const LayoutObject* parentRuby) {
-  ASSERT(parentRuby && parentRuby->isRuby());
+  DCHECK(parentRuby);
+  DCHECK(parentRuby->isRuby());
   LayoutRubyRun* rr = new LayoutRubyRun();
   rr->setDocumentForAnonymous(&parentRuby->document());
   RefPtr<ComputedStyle> newStyle =
       ComputedStyle::createAnonymousStyleWithDisplay(parentRuby->styleRef(),
                                                      EDisplay::kInlineBlock);
   rr->setStyle(std::move(newStyle));
   return rr;
 }
 
 LayoutObject* LayoutRubyRun::layoutSpecialExcludedChild(
@@ skipping 54 matching lines @@
 
   // Update our overflow to account for the new LayoutRubyText position.
   computeOverflow(clientLogicalBottom());
 }
 
 void LayoutRubyRun::getOverhang(bool firstLine,
                                 LayoutObject* startLayoutObject,
                                 LayoutObject* endLayoutObject,
                                 int& startOverhang,
                                 int& endOverhang) const {
-  ASSERT(!needsLayout());
+  DCHECK(!needsLayout());
 
   startOverhang = 0;
   endOverhang = 0;
 
   LayoutRubyBase* rubyBase = this->rubyBase();
   LayoutRubyText* rubyText = this->rubyText();
 
   if (!rubyBase || !rubyText)
     return;
 
@@ skipping 64 matching lines @@
     case U_LB_GLUE:
     case U_LB_OPEN_PUNCTUATION:
       return false;
     default:
       break;
   }
   return true;
 }
 
 }  // namespace blink