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 (!m_firstRun)
     m_firstRun = run;
   else
     m_lastRun->m_next = run;
   m_lastRun = run;
   m_runCount++;
 }
 
 template <class Run>
 inline void BidiRunList<Run>::prependRun(Run* run) {
-  ASSERT(!run->m_next);
+  DCHECK(!run->m_next);
 
   if (!m_lastRun)
     m_lastRun = run;
   else
     run->m_next = m_firstRun;
   m_firstRun = run;
   m_runCount++;
 }
 
 template <class Run>
 inline void BidiRunList<Run>::moveRunToEnd(Run* run) {
-  ASSERT(m_firstRun);
-  ASSERT(m_lastRun);
-  ASSERT(run->m_next);
+  DCHECK(m_firstRun);
+  DCHECK(m_lastRun);
+  DCHECK(run->m_next);
 
   Run* current = 0;
   Run* next = m_firstRun;
   while (next != run) {
     current = next;
     next = current->next();
   }
 
   if (!current)
     m_firstRun = run->next();
   else
     current->m_next = run->m_next;
 
   run->m_next = 0;
   m_lastRun->m_next = run;
   m_lastRun = run;
 }
 
 template <class Run>
 inline void BidiRunList<Run>::moveRunToBeginning(Run* run) {
-  ASSERT(m_firstRun);
-  ASSERT(m_lastRun);
-  ASSERT(run != m_firstRun);
+  DCHECK(m_firstRun);
+  DCHECK(m_lastRun);
+  DCHECK_NE(run, m_firstRun);
 
   Run* current = m_firstRun;
   Run* next = current->next();
   while (next != run) {
     current = next;
     next = current->next();
   }
 
   current->m_next = run->m_next;
   if (run == m_lastRun)
     m_lastRun = current;
 
   run->m_next = m_firstRun;
   m_firstRun = run;
 }
 
 template <class Run>
 void BidiRunList<Run>::replaceRunWithRuns(Run* toReplace,
                                           BidiRunList<Run>& newRuns) {
-  ASSERT(newRuns.runCount());
-  ASSERT(m_firstRun);
-  ASSERT(toReplace);
+  DCHECK(newRuns.runCount());
+  DCHECK(m_firstRun);
+  DCHECK(toReplace);
 
   if (m_firstRun == toReplace) {
     m_firstRun = newRuns.firstRun();
   } else {
     // Find the run just before "toReplace" in the list of runs.
     Run* previousRun = m_firstRun;
     while (previousRun->next() != toReplace)
       previousRun = previousRun->next();
-    ASSERT(previousRun);
+    DCHECK(previousRun);
     previousRun->setNext(newRuns.firstRun());
   }
 
   newRuns.lastRun()->setNext(toReplace->next());
 
   // Fix up any of other pointers which may now be stale.
   if (m_lastRun == toReplace)
     m_lastRun = newRuns.lastRun();
   if (m_logicallyLastRun == toReplace)
     m_logicallyLastRun = newRuns.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(m_runCount);
+  DCHECK(m_runCount);
   if (start >= end)
     return;
 
-  ASSERT(end < m_runCount);
+  DCHECK_LT(end, m_runCount);
 
   // 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 = m_firstRun;
   Run* beforeStart = 0;
   unsigned i = 0;
   while (i < start) {
     i++;
     beforeStart = curr;
     curr = curr->next();
@@ skipping 26 matching lines @@
     m_firstRun = endRun;
 
   startRun->m_next = afterEnd;
   if (!afterEnd)
     m_lastRun = startRun;
 }
 
 }  // namespace blink
 
 #endif  // BidiRunList