Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/text

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

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2006, 2007, 2008 Apple Inc.  All right reserved.
  * Copyright (C) 2011 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 63 matching lines @@
   if (!first_run_)
     first_run_ = run;
   else
     last_run_->next_ = run;
   last_run_ = run;
   run_count_++;
 }
 
 template <class Run>
 inline void BidiRunList<Run>::PrependRun(Run* run) {
-  ASSERT(!run->next_);
+  DCHECK(!run->next_);
 
   if (!last_run_)
     last_run_ = run;
   else
     run->next_ = first_run_;
   first_run_ = run;
   run_count_++;
 }
 
 template <class Run>
 inline void BidiRunList<Run>::MoveRunToEnd(Run* run) {
-  ASSERT(first_run_);
-  ASSERT(last_run_);
-  ASSERT(run->next_);
+  DCHECK(first_run_);
+  DCHECK(last_run_);
+  DCHECK(run->next_);
 
   Run* current = 0;
   Run* next = first_run_;
   while (next != run) {
     current = next;
     next = current->Next();
   }
 
   if (!current)
     first_run_ = run->Next();
   else
     current->next_ = run->next_;
 
   run->next_ = 0;
   last_run_->next_ = run;
   last_run_ = run;
 }
 
 template <class Run>
 inline void BidiRunList<Run>::MoveRunToBeginning(Run* run) {
-  ASSERT(first_run_);
-  ASSERT(last_run_);
-  ASSERT(run != first_run_);
+  DCHECK(first_run_);
+  DCHECK(last_run_);
+  DCHECK_NE(run, first_run_);
 
   Run* current = first_run_;
   Run* next = current->Next();
   while (next != run) {
     current = next;
     next = current->Next();
   }
 
   current->next_ = run->next_;
   if (run == last_run_)
     last_run_ = current;
 
   run->next_ = first_run_;
   first_run_ = run;
 }
 
 template <class Run>
 void BidiRunList<Run>::ReplaceRunWithRuns(Run* to_replace,
                                           BidiRunList<Run>& new_runs) {
-  ASSERT(new_runs.RunCount());
-  ASSERT(first_run_);
-  ASSERT(to_replace);
+  DCHECK(new_runs.RunCount());
+  DCHECK(first_run_);
+  DCHECK(to_replace);
 
   if (first_run_ == to_replace) {
     first_run_ = new_runs.FirstRun();
   } else {
     // Find the run just before "toReplace" in the list of runs.
     Run* previous_run = first_run_;
     while (previous_run->Next() != to_replace)
       previous_run = previous_run->Next();
-    ASSERT(previous_run);
+    DCHECK(previous_run);
     previous_run->SetNext(new_runs.FirstRun());
   }
 
   new_runs.LastRun()->SetNext(to_replace->Next());
 
   // Fix up any of other pointers which may now be stale.
   if (last_run_ == to_replace)
     last_run_ = new_runs.LastRun();
   if (logically_last_run_ == to_replace)
     logically_last_run_ = new_runs.LogicallyLastRun();
@@ skipping 22 matching lines @@
     Run* s = curr->Next();
     delete curr;
     curr = s;
   }
 
   ClearWithoutDestroyingRuns();
 }
 
 template <class Run>
 void BidiRunList<Run>::ReverseRuns(unsigned start, unsigned end) {
-  ASSERT(run_count_);
+  DCHECK(run_count_);
   if (start >= end)
     return;
 
-  ASSERT(end < run_count_);
+  DCHECK_LT(end, run_count_);
 
   // Get the item before the start of the runs to reverse and put it in
   // |beforeStart|. |curr| should point to the first run to reverse.
   Run* curr = first_run_;
   Run* before_start = 0;
   unsigned i = 0;
   while (i < start) {
     i++;
     before_start = curr;
     curr = curr->Next();
@@ skipping 26 matching lines @@
     first_run_ = end_run;
 
   start_run->next_ = after_end;
   if (!after_end)
     last_run_ = start_run;
 }
 
 }  // namespace blink
 
 #endif  // BidiRunList