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, mockScriptData,
                                     (new MockScriptData()));
 
     return &mockScriptData;
   }
 
   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::BracketTypeClose:
         return ch - kBracketDelta;
       case PairedBracketType::BracketTypeOpen:
         return ch + kBracketDelta;
       default:
         return ch;
     }
   }
 
   PairedBracketType getPairedBracketType(UChar32 ch) const override {
-    ASSERT(ch >= kMockCharMin && ch < kMockCharLimit);
+    DCHECK(ch >= kMockCharMin && ch < kMockCharLimit);

[tkent, 2017/04/09 23:13:23]

Split this into two DCHECKs

[Hwanseung Lee, 2017/04/11 22:25:09]

Done.

     int code = ch - kMockCharMin;
     if ((code & kCodeBracketBit) == 0) {
       return PairedBracketType::BracketTypeNone;
     }
     if (code & kCodeBracketCloseBit) {
       return PairedBracketType::BracketTypeClose;
     }
     return PairedBracketType::BracketTypeOpen;
   }
 
@@ skipping 11 matching lines @@
     String result(emptyString16Bit);
     bool inSet = false;
     int seen = 0;
     int code = 0;
     int list = 0;
     int currentShift = 0;
     for (char c : input) {
       if (inSet) {
         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(currentShift < 3);
+            DCHECK_EQ((seen & kSawLatin), 0);
+            DCHECK_LT(currentShift, 3);
             seen |= kSawLatin;
             list |= kLatin << (2 * currentShift++);
             break;
           case 'h':
-            ASSERT((seen & kSawHan) == 0);
-            ASSERT(currentShift < 3);
+            DCHECK_EQ((seen & kSawHan), 0);
+            DCHECK_LT(currentShift, 3);
             seen |= kSawHan;
             list |= kHan << (2 * currentShift++);
             break;
           case 'g':
-            ASSERT((seen & kSawGreek) == 0);
-            ASSERT(currentShift < 3);
+            DCHECK_EQ((seen & kSawGreek), 0);
+            DCHECK_LT(currentShift, 3);
             seen |= kSawGreek;
             list |= kGreek << (2 * currentShift++);
             break;
           case '>':
-            ASSERT(seen != 0);
+            DCHECK_NE(seen, 0);
             code |= TableLookup(list);
             result.append(static_cast<UChar>(kMockCharMin + code));
             inSet = false;
             break;
           default:
             DLOG(ERROR) << "Illegal mock string set char: '" << c << "'";
             break;
         }
         continue;
       }
@@ skipping 144 matching lines @@
     }
     ASSERT_EQ(expect.size(), runCount);
   }
 };
 
 TEST_F(ScriptRunIteratorTest, Empty) {
   String empty(emptyString16Bit);
   ScriptRunIterator scriptRunIterator(empty.characters16(), empty.length());
   unsigned limit = 0;
   UScriptCode code = USCRIPT_INVALID_CODE;
-  ASSERT(!scriptRunIterator.consume(limit, code));
+  DCHECK(!scriptRunIterator.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 runsArray[] = __VA_ARGS__; \
   Vector<TestRun> runs;                           \
   runs.append(runsArray, sizeof(runsArray) / sizeof(*runsArray));
 
@@ 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