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() {
     num_midpoints_ = 0;
     current_midpoint_ = 0;
     between_midpoints_ = false;
   }
 
   void StartIgnoringSpaces(const Iterator& midpoint) {
-    ASSERT(!(num_midpoints_ % 2));
+    DCHECK(!(num_midpoints_ % 2));
     AddMidpoint(midpoint);
   }
 
   void StopIgnoringSpaces(const Iterator& midpoint) {
-    ASSERT(num_midpoints_ % 2);
+    DCHECK(num_midpoints_ % 2);
     AddMidpoint(midpoint);
   }
 
   // Adding a pair of midpoints before a character will split it out into a new
   // line box.
   void EnsureCharacterGetsLineBox(Iterator& text_paragraph_separator) {
     StartIgnoringSpaces(Iterator(0,
                                  text_paragraph_separator.GetLineLayoutItem(),
                                  text_paragraph_separator.Offset() - 1));
     StopIgnoringSpaces(Iterator(0, text_paragraph_separator.GetLineLayoutItem(),
@@ skipping 182 matching lines @@
   void SetLastStrongDir(WTF::Unicode::CharDirection last_strong_dir) {
     status_.last_strong = last_strong_dir;
   }
   void SetEorDir(WTF::Unicode::CharDirection eor_dir) { status_.eor = eor_dir; }
 
   WTF::Unicode::CharDirection Dir() const { return direction_; }
   void SetDir(WTF::Unicode::CharDirection d) { direction_ = d; }
 
   const BidiStatus& Status() const { return status_; }
   void SetStatus(const BidiStatus s) {
-    ASSERT(s.context);
+    DCHECK(s.context);
     status_ = s;
     paragraph_directionality_ = s.context->Dir() == WTF::Unicode::kLeftToRight
                                     ? TextDirection::kLtr
                                     : TextDirection::kRtl;
   }
 
   MidpointState<Iterator>& GetMidpointState() { return midpoint_state_; }
 
   // 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() { nested_isolate_count_++; }
   void ExitIsolate() {
-    ASSERT(nested_isolate_count_ >= 1);
+    DCHECK_GE(nested_isolate_count_, 1u);
     nested_isolate_count_--;
   }
   bool InIsolate() const { return nested_isolate_count_; }
 
   void Embed(WTF::Unicode::CharDirection, BidiEmbeddingSource);
   bool CommitExplicitEmbedding(BidiRunList<Run>&);
 
   void CreateBidiRunsForLine(const Iterator& end,
                              VisualDirectionOverride = kNoVisualOverride,
                              bool hard_line_break = false,
@@ skipping 94 matching lines @@
       bool* has_strong_directionality);
 
   Vector<BidiEmbedding, 8> current_explicit_embedding_sequence_;
   HashMap<Run*, MidpointState<Iterator>> midpoint_state_for_isolated_run_;
 };
 
 #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(isolated_runs_.IsEmpty());
-  ASSERT(!runs_.RunCount());
+  DCHECK(isolated_runs_.IsEmpty());
+  DCHECK(!runs_.RunCount());
 }
 #endif
 
 template <class Iterator, class Run, class IsolatedRun>
 void BidiResolver<Iterator, Run, IsolatedRun>::AppendRun(
     BidiRunList<Run>& runs) {
   if (!empty_run_ && !eor_.AtEnd()) {
     unsigned start_offset = sor_.Offset();
     unsigned end_offset = eor_.Offset();
 
@@ skipping 27 matching lines @@
   direction_ = WTF::Unicode::kOtherNeutral;
   status_.eor = WTF::Unicode::kOtherNeutral;
 }
 
 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 == kPopDirectionalFormat || dir == kLeftToRightEmbedding ||
+  DCHECK(dir == kPopDirectionalFormat || dir == kLeftToRightEmbedding ||
          dir == kLeftToRightOverride || dir == kRightToLeftEmbedding ||
          dir == kRightToLeftOverride);
   current_explicit_embedding_sequence_.push_back(BidiEmbedding(dir, source));
 }
 
 template <class Iterator, class Run, class IsolatedRun>
 void BidiResolver<Iterator, Run, IsolatedRun>::
     CheckDirectionInLowerRaiseEmbeddingLevel() {
   using namespace WTF::Unicode;
 
-  ASSERT(status_.eor != kOtherNeutral || eor_.AtEnd());
-  ASSERT(status_.last != kNonSpacingMark && status_.last != kBoundaryNeutral &&
-         status_.last != kRightToLeftEmbedding &&
-         status_.last != kLeftToRightEmbedding &&
-         status_.last != kRightToLeftOverride &&
-         status_.last != kLeftToRightOverride &&
-         status_.last != kPopDirectionalFormat);
+  DCHECK(status_.eor != kOtherNeutral || eor_.AtEnd());
+  DCHECK_NE(status_.last, kNonSpacingMark);
+  DCHECK_NE(status_.last, kBoundaryNeutral);
+  DCHECK_NE(status_.last, kRightToLeftEmbedding);
+  DCHECK_NE(status_.last, kLeftToRightEmbedding);
+  DCHECK_NE(status_.last, kRightToLeftOverride);
+  DCHECK_NE(status_.last, kLeftToRightOverride);
+  DCHECK_NE(status_.last, kPopDirectionalFormat);
   if (direction_ == kOtherNeutral)
     direction_ =
         status_.last_strong == kLeftToRight ? kLeftToRight : kRightToLeft;
 }
 
 template <class Iterator, class Run, class IsolatedRun>
 void BidiResolver<Iterator, Run, IsolatedRun>::LowerExplicitEmbeddingLevel(
     BidiRunList<Run>& runs,
     WTF::Unicode::CharDirection from) {
   using namespace WTF::Unicode;
@@ skipping 74 matching lines @@
   empty_run_ = true;
 
   SetLastDir(to);
   SetLastStrongDir(to);
   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* trailing_space_run = runs.LogicallyLastRun();
 
   int first_space = FindFirstTrailingSpaceAtRun(trailing_space_run);
   if (first_space == trailing_space_run->Stop())
     return;
 
   bool should_reorder =
       trailing_space_run != (paragraph_directionality_ == TextDirection::kLtr
                                  ? runs.LastRun()
                                  : runs.FirstRun());
   if (first_space != trailing_space_run->Start()) {
     BidiContext* base_context = Context();
     while (BidiContext* parent = base_context->Parent())
       base_context = parent;
 
     trailing_space_run_ = AddTrailingRun(
         runs, first_space, trailing_space_run->stop_, trailing_space_run,
         base_context, paragraph_directionality_);
-    ASSERT(trailing_space_run_);
+    DCHECK(trailing_space_run_);
     trailing_space_run->stop_ = first_space;
     return;
   }
   if (!should_reorder) {
     trailing_space_run_ = trailing_space_run;
     return;
   }
 
   // Apply L1 rule.
   if (paragraph_directionality_ == TextDirection::kLtr) {
     runs.MoveRunToEnd(trailing_space_run);
     trailing_space_run->level_ = 0;
   } else {
     runs.MoveRunToBeginning(trailing_space_run);
     trailing_space_run->level_ = 1;
   }
   trailing_space_run_ = trailing_space_run;
 }
 
 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() || current_explicit_embedding_sequence_.IsEmpty());
+  DCHECK(!InIsolate() || current_explicit_embedding_sequence_.IsEmpty());
 
   using namespace WTF::Unicode;
 
   unsigned char from_level = Context()->Level();
   RefPtr<BidiContext> to_context = Context();
 
   for (size_t i = 0; i < current_explicit_embedding_sequence_.size(); ++i) {
     BidiEmbedding embedding = current_explicit_embedding_sequence_[i];
     if (embedding.Direction() == kPopDirectionalFormat) {
       if (BidiContext* parent_context = to_context->Parent())
@@ skipping 174 matching lines @@
 }
 
 template <class Iterator, class Run, class IsolatedRun>
 void BidiResolver<Iterator, Run, IsolatedRun>::CreateBidiRunsForLine(
     const Iterator& end,
     VisualDirectionOverride override,
     bool hard_line_break,
     bool reorder_runs) {
   using namespace WTF::Unicode;
 
-  ASSERT(direction_ == kOtherNeutral);
+  DCHECK_EQ(direction_, kOtherNeutral);
   trailing_space_run_ = 0;
 
   end_of_line_ = end;
 
   if (override != kNoVisualOverride) {
     empty_run_ = false;
     sor_ = current_;
     eor_ = Iterator();
     while (current_ != end && !current_.AtEnd()) {
       eor_ = current_;
@@ skipping 65 matching lines @@
         dir_current = Context()->Dir();
       else if (dir_current == kNonSpacingMark)
         dir_current = 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())
       dir_current = kOtherNeutral;
 
-    ASSERT(status_.eor != kOtherNeutral || eor_.AtEnd());
+    DCHECK(status_.eor != kOtherNeutral || eor_.AtEnd());
     switch (dir_current) {
       // embedding and overrides (X1-X9 in the Bidi specs)
       case kRightToLeftEmbedding:
       case kLeftToRightEmbedding:
       case kRightToLeftOverride:
       case kLeftToRightOverride:
       case kPopDirectionalFormat:
         Embed(dir_current, kFromUnicode);
         CommitExplicitEmbedding(runs_);
         break;
@@ skipping 262 matching lines @@
           case kLeftToRight:
           case kRightToLeft:
           case kArabicNumber:
             direction_ = status_.eor;
             break;
           case kEuropeanNumber:
             direction_ = status_.last_strong == kLeftToRight ? kLeftToRight
                                                              : kEuropeanNumber;
             break;
           default:
-            ASSERT_NOT_REACHED();
+            NOTREACHED();
         }
         AppendRun(runs_);
       }
       current_ = end;
       status_ = state_at_end.status_;
       sor_ = state_at_end.sor_;
       eor_ = state_at_end.eor_;
       last_ = state_at_end.last_;
       reached_end_of_line_ = state_at_end.reached_end_of_line_;
       last_before_et_ = state_at_end.last_before_et_;
@@ skipping 36 matching lines @@
 
   if (!hard_line_break && runs_.RunCount() && NeedsTrailingSpace(runs_)) {
     ComputeTrailingSpace(runs_);
   }
 }
 
 template <class Iterator, class Run, class IsolatedRun>
 void BidiResolver<Iterator, Run, IsolatedRun>::SetMidpointStateForIsolatedRun(
     Run& run,
     const MidpointState<Iterator>& midpoint) {
-  ASSERT(!midpoint_state_for_isolated_run_.Contains(&run));
+  DCHECK(!midpoint_state_for_isolated_run_.Contains(&run));
   midpoint_state_for_isolated_run_.insert(&run, midpoint);
 }
 
 template <class Iterator, class Run, class IsolatedRun>
 MidpointState<Iterator>
 BidiResolver<Iterator, Run, IsolatedRun>::MidpointStateForIsolatedRun(
     Run& run) {
   return midpoint_state_for_isolated_run_.Take(&run);
 }
 
 }  // namespace blink
 
 #endif  // BidiResolver_h