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

third_party/WebKit/Source/core/layout/line/InlineIterator.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010 Apple Inc.
  *               All right reserved.
  * Copyright (C) 2010 Google Inc. 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 381 matching lines @@
   LineLayoutItem o = root.firstChild();
   // If either there are no children to walk, or the first one is correct
   // then just return it.
   if (!o || o.isLayoutInline() || isIteratorTarget(o))
     return o;
 
   return bidiNextIncludingEmptyInlines(root, o);
 }
 
 inline void InlineIterator::fastIncrementInTextNode() {
-  ASSERT(m_lineLayoutItem);
-  ASSERT(m_lineLayoutItem.isText());
-  ASSERT(m_pos <= LineLayoutText(m_lineLayoutItem).textLength());
+  DCHECK(m_lineLayoutItem);
+  DCHECK(m_lineLayoutItem.isText());
+  DCHECK_LE(m_pos, LineLayoutText(m_lineLayoutItem).textLength());
   if (m_pos < INT_MAX)
     m_pos++;
 }
 
 // FIXME: This is used by LayoutBlockFlow for simplified layout, and has nothing
 // to do with bidi it shouldn't use functions called bidiFirst and bidiNext.
 class InlineWalker {
   STACK_ALLOCATED();
 
  public:
@@ skipping 145 matching lines @@
     if (!isCollapsibleSpace(current, lastText))
       break;
     firstSpace--;
   }
 
   return firstSpace;
 }
 
 template <>
 inline int InlineBidiResolver::findFirstTrailingSpaceAtRun(BidiRun* run) {
-  ASSERT(run);
+  DCHECK(run);
   LineLayoutItem lastObject = LineLayoutItem(run->m_lineLayoutItem);
   if (!lastObject.isText())
     return run->m_stop;
 
   LineLayoutText lastText(lastObject);
   int firstSpace;
   if (lastText.is8Bit())
     firstSpace = findFirstTrailingSpace(lastText, lastText.characters8(),
                                         run->start(), run->stop());
   else
@@ skipping 26 matching lines @@
 inline bool InlineBidiResolver::needsToApplyL1Rule(BidiRunList<BidiRun>& runs) {
   if (!runs.logicallyLastRun()
            ->m_lineLayoutItem.style()
            ->breakOnlyAfterWhiteSpace() ||
       !runs.logicallyLastRun()->m_lineLayoutItem.style()->autoWrap())
     return false;
   return true;
 }
 
 static inline bool isIsolatedInline(LineLayoutItem object) {
-  ASSERT(object);
+  DCHECK(object);
   return object.isLayoutInline() && treatAsIsolated(object.styleRef());
 }
 
 static inline LineLayoutItem highestContainingIsolateWithinRoot(
     LineLayoutItem object,
     LineLayoutItem root) {
-  ASSERT(object);
+  DCHECK(object);
   LineLayoutItem containingIsolateObj(nullptr);
   while (object && object != root) {
     if (isIsolatedInline(object))
       containingIsolateObj = LineLayoutItem(object);
 
     object = object.parent();
-    ASSERT(object);
+    DCHECK(object);
   }
   return containingIsolateObj;
 }
 
 static inline unsigned numberOfIsolateAncestors(const InlineIterator& iter) {
   LineLayoutItem object = iter.getLineLayoutItem();
   if (!object)
     return 0;
   unsigned count = 0;
   while (object && object != iter.root()) {
     if (isIsolatedInline(object))
       count++;
     object = object.parent();
   }
   return count;
 }
 
 // FIXME: This belongs on InlineBidiResolver, except it's a template
 // specialization of BidiResolver which knows nothing about LayoutObjects.
 static inline BidiRun* addPlaceholderRunForIsolatedInline(
     InlineBidiResolver& resolver,
     LineLayoutItem obj,
     unsigned pos,
     LineLayoutItem root) {
-  ASSERT(obj);
+  DCHECK(obj);
   BidiRun* isolatedRun =
       new BidiRun(resolver.context()->override(), resolver.context()->level(),
                   pos, pos, obj, resolver.dir(), resolver.context()->dir());
   resolver.runs().addRun(isolatedRun);
   // FIXME: isolatedRuns() could be a hash of object->run and then we could
   // cheaply ASSERT here that we didn't create multiple objects for the same
   // inline.
   resolver.isolatedRuns().push_back(BidiIsolatedRun(
       obj, pos, root, *isolatedRun, resolver.context()->level()));
   return isolatedRun;
@@ skipping 19 matching lines @@
       : m_nestedIsolateCount(nestedIsolateCount),
         m_haveAddedFakeRunForRootIsolate(false),
         m_runs(runs) {}
 
   void setMidpointStateForRootIsolate(const LineMidpointState& midpointState) {
     m_midpointStateForRootIsolate = midpointState;
   }
 
   void enterIsolate() { m_nestedIsolateCount++; }
   void exitIsolate() {
-    ASSERT(m_nestedIsolateCount >= 1);
+    DCHECK_GE(m_nestedIsolateCount, 1u);
     m_nestedIsolateCount--;
     if (!inIsolate())
       m_haveAddedFakeRunForRootIsolate = false;
   }
   bool inIsolate() const { return m_nestedIsolateCount; }
 
   // We don't care if we encounter bidi directional overrides.
   void embed(WTF::Unicode::CharDirection, BidiEmbeddingSource) {}
   void commitExplicitEmbedding(BidiRunList<BidiRun>&) {}
   BidiRunList<BidiRun>& runs() { return m_runs; }
@@ skipping 188 matching lines @@
     m_sor = m_eor;
   }
 
   m_direction = WTF::Unicode::OtherNeutral;
   m_status.eor = WTF::Unicode::OtherNeutral;
 }
 
 }  // namespace blink
 
 #endif  // InlineIterator_h