Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/fonts

third_party/WebKit/Source/platform/fonts/ScriptRunIteratorTest.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/fonts/ScriptRunIterator.h"
 
 #include <string>
 #include "platform/wtf/Assertions.h"
 #include "platform/wtf/Threading.h"
 #include "platform/wtf/text/WTFString.h"
@@ skipping 19 matching lines @@
   ~MockScriptData() override {}
 
   static const MockScriptData* Instance() {
     DEFINE_THREAD_SAFE_STATIC_LOCAL(const MockScriptData, mock_script_data,
                                     (new MockScriptData()));
 
     return &mock_script_data;
   }
 
   void GetScripts(UChar32 ch, Vector<UScriptCode>& dst) const override {
-    ASSERT(ch >= kMockCharMin);
-    ASSERT(ch < kMockCharLimit);
+    DCHECK_GE(ch, kMockCharMin);
+    DCHECK_LT(ch, kMockCharLimit);
 
     int code = ch - kMockCharMin;
     dst.Clear();
     switch (code & kCodeSpecialMask) {
       case kCodeSpecialCommon:
         dst.push_back(USCRIPT_COMMON);
         break;
       case kCodeSpecialInherited:
         dst.push_back(USCRIPT_INHERITED);
         break;
@@ skipping 28 matching lines @@
       case PairedBracketType::kBracketTypeClose:
         return ch - kBracketDelta;
       case PairedBracketType::kBracketTypeOpen:
         return ch + kBracketDelta;
       default:
         return ch;
     }
   }
 
   PairedBracketType GetPairedBracketType(UChar32 ch) const override {
-    ASSERT(ch >= kMockCharMin && ch < kMockCharLimit);
+    DCHECK_GE(ch, kMockCharMin);
+    DCHECK_LT(ch, kMockCharLimit);
     int code = ch - kMockCharMin;
     if ((code & kCodeBracketBit) == 0) {
       return PairedBracketType::kBracketTypeNone;
     }
     if (code & kCodeBracketCloseBit) {
       return PairedBracketType::kBracketTypeClose;
     }
     return PairedBracketType::kBracketTypeOpen;
   }
 
@@ skipping 11 matching lines @@
     String result(g_empty_string16_bit);
     bool in_set = false;
     int seen = 0;
     int code = 0;
     int list = 0;
     int current_shift = 0;
     for (char c : input) {
       if (in_set) {
         switch (c) {
           case '(':
-            ASSERT(seen == 0);
+            DCHECK_EQ(seen, 0);
             seen |= kSawBracket;
             code |= kCodeBracketBit;
             break;
           case '[':
-            ASSERT(seen == 0);
+            DCHECK_EQ(seen, 0);
             seen |= kSawBracket;
             code |= kCodeBracketBit | kCodeSquareBracketBit;
             break;
           case ')':
-            ASSERT(seen == 0);
+            DCHECK_EQ(seen, 0);
             seen |= kSawBracket;
             code |= kCodeBracketBit | kCodeBracketCloseBit;
             break;
           case ']':
-            ASSERT(seen == 0);
+            DCHECK_EQ(seen, 0);
             seen |= kSawBracket;
             code |=
                 kCodeBracketBit | kCodeSquareBracketBit | kCodeBracketCloseBit;
             break;
           case 'i':
-            ASSERT(seen == 0);  // brackets can't be inherited
+            DCHECK_EQ(seen, 0);  // brackets can't be inherited
             seen |= kSawSpecial;
             code |= kCodeSpecialInherited;
             break;
           case 'c':
-            ASSERT((seen & ~kSawBracket) == 0);
+            DCHECK_EQ((seen & ~kSawBracket), 0);
             seen |= kSawSpecial;
             code |= kCodeSpecialCommon;
             break;
           case 'l':
-            ASSERT((seen & kSawLatin) == 0);
-            ASSERT(current_shift < 3);
+            DCHECK_EQ((seen & kSawLatin), 0);
+            DCHECK_LT(current_shift, 3);
             seen |= kSawLatin;
             list |= kLatin << (2 * current_shift++);
             break;
           case 'h':
-            ASSERT((seen & kSawHan) == 0);
-            ASSERT(current_shift < 3);
+            DCHECK_EQ((seen & kSawHan), 0);
+            DCHECK_LT(current_shift, 3);
             seen |= kSawHan;
             list |= kHan << (2 * current_shift++);
             break;
           case 'g':
-            ASSERT((seen & kSawGreek) == 0);
-            ASSERT(current_shift < 3);
+            DCHECK_EQ((seen & kSawGreek), 0);
+            DCHECK_LT(current_shift, 3);
             seen |= kSawGreek;
             list |= kGreek << (2 * current_shift++);
             break;
           case '>':
-            ASSERT(seen != 0);
+            DCHECK_NE(seen, 0);
             code |= TableLookup(list);
             result.Append(static_cast<UChar>(kMockCharMin + code));
             in_set = false;
             break;
           default:
             DLOG(ERROR) << "Illegal mock string set char: '" << c << "'";
             break;
         }
         continue;
       }
@@ skipping 144 matching lines @@
     }
     ASSERT_EQ(expect.size(), run_count);
   }
 };
 
 TEST_F(ScriptRunIteratorTest, Empty) {
   String empty(g_empty_string16_bit);
   ScriptRunIterator script_run_iterator(empty.Characters16(), empty.length());
   unsigned limit = 0;
   UScriptCode code = USCRIPT_INVALID_CODE;
-  ASSERT(!script_run_iterator.Consume(limit, code));
+  DCHECK(!script_run_iterator.Consume(limit, code));
   ASSERT_EQ(limit, 0u);
   ASSERT_EQ(code, USCRIPT_INVALID_CODE);
 }
 
 // Some of our compilers cannot initialize a vector from an array yet.
 #define DECLARE_RUNSVECTOR(...)                    \
   static const TestRun kRunsArray[] = __VA_ARGS__; \
   Vector<TestRun> runs;                            \
   runs.Append(kRunsArray, sizeof(kRunsArray) / sizeof(*kRunsArray));
 
@@ skipping 332 matching lines @@
     }
   }
 }
 
 // ZWJ is \u200D Cf (Format, other) and its script is inherited.  I'm going to
 // ignore this for now, as I think it shouldn't matter which run it ends up
 // in. HarfBuzz needs to be able to use it as context and shape each
 // neighboring character appropriately no matter what run it got assigned to.
 
 }  // namespace blink