Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/text

third_party/WebKit/Source/platform/text/BidiResolver.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2006, 2007, 2008 Apple Inc.  All right 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.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 30 matching lines @@
  public:
   MidpointState() { reset(); }
 
   void reset() {
     m_numMidpoints = 0;
     m_currentMidpoint = 0;
     m_betweenMidpoints = false;
   }
 
   void startIgnoringSpaces(const Iterator& midpoint) {
-    ASSERT(!(m_numMidpoints % 2));
+    DCHECK(!(m_numMidpoints % 2));
     addMidpoint(midpoint);
   }
 
   void stopIgnoringSpaces(const Iterator& midpoint) {
-    ASSERT(m_numMidpoints % 2);
+    DCHECK(m_numMidpoints % 2);
     addMidpoint(midpoint);
   }
 
   // Adding a pair of midpoints before a character will split it out into a new
   // line box.
   void ensureCharacterGetsLineBox(Iterator& textParagraphSeparator) {
     startIgnoringSpaces(Iterator(0, textParagraphSeparator.getLineLayoutItem(),
                                  textParagraphSeparator.offset() - 1));
     stopIgnoringSpaces(Iterator(0, textParagraphSeparator.getLineLayoutItem(),
                                 textParagraphSeparator.offset()));
@@ skipping 182 matching lines @@
   void setLastStrongDir(WTF::Unicode::CharDirection lastStrongDir) {
     m_status.lastStrong = lastStrongDir;
   }
   void setEorDir(WTF::Unicode::CharDirection eorDir) { m_status.eor = eorDir; }
 
   WTF::Unicode::CharDirection dir() const { return m_direction; }
   void setDir(WTF::Unicode::CharDirection d) { m_direction = d; }
 
   const BidiStatus& status() const { return m_status; }
   void setStatus(const BidiStatus s) {
-    ASSERT(s.context);
+    DCHECK(s.context);
     m_status = s;
     m_paragraphDirectionality = s.context->dir() == WTF::Unicode::LeftToRight
                                     ? TextDirection::kLtr
                                     : TextDirection::kRtl;
   }
 
   MidpointState<Iterator>& midpointState() { return m_midpointState; }
 
   // The current algorithm handles nested isolates one layer of nesting at a
   // time.  But when we layout each isolated span, we will walk into (and
   // ignore) all child isolated spans.
   void enterIsolate() { m_nestedIsolateCount++; }
   void exitIsolate() {
-    ASSERT(m_nestedIsolateCount >= 1);
+    DCHECK_GE(m_nestedIsolateCount, 1u);
     m_nestedIsolateCount--;
   }
   bool inIsolate() const { return m_nestedIsolateCount; }
 
   void embed(WTF::Unicode::CharDirection, BidiEmbeddingSource);
   bool commitExplicitEmbedding(BidiRunList<Run>&);
 
   void createBidiRunsForLine(const Iterator& end,
                              VisualDirectionOverride = NoVisualOverride,
                              bool hardLineBreak = false,
@@ skipping 93 matching lines @@
                                                 bool* hasStrongDirectionality);
 
   Vector<BidiEmbedding, 8> m_currentExplicitEmbeddingSequence;
   HashMap<Run*, MidpointState<Iterator>> m_midpointStateForIsolatedRun;
 };
 
 #if DCHECK_IS_ON()
 template <class Iterator, class Run, class IsolatedRun>
 BidiResolver<Iterator, Run, IsolatedRun>::~BidiResolver() {
   // The owner of this resolver should have handled the isolated runs.
-  ASSERT(m_isolatedRuns.isEmpty());
-  ASSERT(!m_runs.runCount());
+  DCHECK(m_isolatedRuns.isEmpty());
+  DCHECK(!m_runs.runCount());
 }
 #endif
 
 template <class Iterator, class Run, class IsolatedRun>
 void BidiResolver<Iterator, Run, IsolatedRun>::appendRun(
     BidiRunList<Run>& runs) {
   if (!m_emptyRun && !m_eor.atEnd()) {
     unsigned startOffset = m_sor.offset();
     unsigned endOffset = m_eor.offset();
 
@@ skipping 27 matching lines @@
   m_direction = WTF::Unicode::OtherNeutral;
   m_status.eor = WTF::Unicode::OtherNeutral;
 }
 
 template <class Iterator, class Run, class IsolatedRun>
 void BidiResolver<Iterator, Run, IsolatedRun>::embed(
     WTF::Unicode::CharDirection dir,
     BidiEmbeddingSource source) {
   // Isolated spans compute base directionality during their own UBA run.
   // Do not insert fake embed characters once we enter an isolated span.
-  ASSERT(!inIsolate());
+  DCHECK(!inIsolate());
   using namespace WTF::Unicode;
 
-  ASSERT(dir == PopDirectionalFormat || dir == LeftToRightEmbedding ||
+  DCHECK(dir == PopDirectionalFormat || dir == LeftToRightEmbedding ||
          dir == LeftToRightOverride || dir == RightToLeftEmbedding ||
          dir == RightToLeftOverride);
   m_currentExplicitEmbeddingSequence.push_back(BidiEmbedding(dir, source));
 }
 
 template <class Iterator, class Run, class IsolatedRun>
 void BidiResolver<Iterator, Run, IsolatedRun>::
     checkDirectionInLowerRaiseEmbeddingLevel() {
   using namespace WTF::Unicode;
 
-  ASSERT(m_status.eor != OtherNeutral || m_eor.atEnd());
-  ASSERT(m_status.last != NonSpacingMark && m_status.last != BoundaryNeutral &&
+  DCHECK(m_status.eor != OtherNeutral || m_eor.atEnd());
+  DCHECK(m_status.last != NonSpacingMark && m_status.last != BoundaryNeutral &&

[tkent, 2017/04/09 23:07:01]

Split this into 7 DCHECKs.

[Hwanseung Lee, 2017/04/11 03:29:38]

Done.

          m_status.last != RightToLeftEmbedding &&
          m_status.last != LeftToRightEmbedding &&
          m_status.last != RightToLeftOverride &&
          m_status.last != LeftToRightOverride &&
          m_status.last != PopDirectionalFormat);
   if (m_direction == OtherNeutral)
     m_direction =
         m_status.lastStrong == LeftToRight ? LeftToRight : RightToLeft;
 }
 
@@ skipping 78 matching lines @@
   m_emptyRun = true;
 
   setLastDir(to);
   setLastStrongDir(to);
   m_eor = Iterator();
 }
 
 template <class Iterator, class Run, class IsolatedRun>
 void BidiResolver<Iterator, Run, IsolatedRun>::computeTrailingSpace(
     BidiRunList<Run>& runs) {
-  ASSERT(runs.runCount());
+  DCHECK(runs.runCount());
 
   Run* trailingSpaceRun = runs.logicallyLastRun();
 
   int firstSpace = findFirstTrailingSpaceAtRun(trailingSpaceRun);
   if (firstSpace == trailingSpaceRun->stop())
     return;
 
   bool shouldReorder =
       trailingSpaceRun != (m_paragraphDirectionality == TextDirection::kLtr
                                ? runs.lastRun()
                                : runs.firstRun());
   if (firstSpace != trailingSpaceRun->start()) {
     BidiContext* baseContext = context();
     while (BidiContext* parent = baseContext->parent())
       baseContext = parent;
 
     m_trailingSpaceRun = addTrailingRun(
         runs, firstSpace, trailingSpaceRun->m_stop, trailingSpaceRun,
         baseContext, m_paragraphDirectionality);
-    ASSERT(m_trailingSpaceRun);
+    DCHECK(m_trailingSpaceRun);
     trailingSpaceRun->m_stop = firstSpace;
     return;
   }
   if (!shouldReorder) {
     m_trailingSpaceRun = trailingSpaceRun;
     return;
   }
 
   // Apply L1 rule.
   if (m_paragraphDirectionality == TextDirection::kLtr) {
     runs.moveRunToEnd(trailingSpaceRun);
     trailingSpaceRun->m_level = 0;
   } else {
     runs.moveRunToBeginning(trailingSpaceRun);
     trailingSpaceRun->m_level = 1;
   }
   m_trailingSpaceRun = trailingSpaceRun;
 }
 
 template <class Iterator, class Run, class IsolatedRun>
 bool BidiResolver<Iterator, Run, IsolatedRun>::commitExplicitEmbedding(
     BidiRunList<Run>& runs) {
   // When we're "inIsolate()" we're resolving the parent context which
   // ignores (skips over) the isolated content, including embedding levels.
   // We should never accrue embedding levels while skipping over isolated
   // content.
-  ASSERT(!inIsolate() || m_currentExplicitEmbeddingSequence.isEmpty());
+  DCHECK(!inIsolate() || m_currentExplicitEmbeddingSequence.isEmpty());
 
   using namespace WTF::Unicode;
 
   unsigned char fromLevel = context()->level();
   RefPtr<BidiContext> toContext = context();
 
   for (size_t i = 0; i < m_currentExplicitEmbeddingSequence.size(); ++i) {
     BidiEmbedding embedding = m_currentExplicitEmbeddingSequence[i];
     if (embedding.direction() == PopDirectionalFormat) {
       if (BidiContext* parentContext = toContext->parent())
@@ skipping 173 matching lines @@
 }
 
 template <class Iterator, class Run, class IsolatedRun>
 void BidiResolver<Iterator, Run, IsolatedRun>::createBidiRunsForLine(
     const Iterator& end,
     VisualDirectionOverride override,
     bool hardLineBreak,
     bool reorderRuns) {
   using namespace WTF::Unicode;
 
-  ASSERT(m_direction == OtherNeutral);
+  DCHECK_EQ(m_direction, OtherNeutral);
   m_trailingSpaceRun = 0;
 
   m_endOfLine = end;
 
   if (override != NoVisualOverride) {
     m_emptyRun = false;
     m_sor = m_current;
     m_eor = Iterator();
     while (m_current != end && !m_current.atEnd()) {
       m_eor = m_current;
@@ skipping 65 matching lines @@
         dirCurrent = context()->dir();
       else if (dirCurrent == NonSpacingMark)
         dirCurrent = m_status.last;
     }
 
     // We ignore all character directionality while in unicode-bidi: isolate
     // spans.  We'll handle ordering the isolated characters in a second pass.
     if (inIsolate())
       dirCurrent = OtherNeutral;
 
-    ASSERT(m_status.eor != OtherNeutral || m_eor.atEnd());
+    DCHECK(m_status.eor != OtherNeutral || m_eor.atEnd());
     switch (dirCurrent) {
       // embedding and overrides (X1-X9 in the Bidi specs)
       case RightToLeftEmbedding:
       case LeftToRightEmbedding:
       case RightToLeftOverride:
       case LeftToRightOverride:
       case PopDirectionalFormat:
         embed(dirCurrent, FromUnicode);
         commitExplicitEmbedding(m_runs);
         break;
@@ skipping 262 matching lines @@
           case LeftToRight:
           case RightToLeft:
           case ArabicNumber:
             m_direction = m_status.eor;
             break;
           case EuropeanNumber:
             m_direction = m_status.lastStrong == LeftToRight ? LeftToRight
                                                              : EuropeanNumber;
             break;
           default:
-            ASSERT_NOT_REACHED();
+            NOTREACHED();
         }
         appendRun(m_runs);
       }
       m_current = end;
       m_status = stateAtEnd.m_status;
       m_sor = stateAtEnd.m_sor;
       m_eor = stateAtEnd.m_eor;
       m_last = stateAtEnd.m_last;
       m_reachedEndOfLine = stateAtEnd.m_reachedEndOfLine;
       m_lastBeforeET = stateAtEnd.m_lastBeforeET;
@@ skipping 36 matching lines @@
 
   if (!hardLineBreak && m_runs.runCount() && needsTrailingSpace(m_runs)) {
     computeTrailingSpace(m_runs);
   }
 }
 
 template <class Iterator, class Run, class IsolatedRun>
 void BidiResolver<Iterator, Run, IsolatedRun>::setMidpointStateForIsolatedRun(
     Run& run,
     const MidpointState<Iterator>& midpoint) {
-  ASSERT(!m_midpointStateForIsolatedRun.contains(&run));
+  DCHECK(!m_midpointStateForIsolatedRun.contains(&run));
   m_midpointStateForIsolatedRun.insert(&run, midpoint);
 }
 
 template <class Iterator, class Run, class IsolatedRun>
 MidpointState<Iterator>
 BidiResolver<Iterator, Run, IsolatedRun>::midpointStateForIsolatedRun(
     Run& run) {
   return m_midpointStateForIsolatedRun.take(&run);
 }
 
 }  // namespace blink
 
 #endif  // BidiResolver_h