Replace ASSERT, ENABLE(ASSERT), and ASSERT_NOT_REACHED in wtf

third_party/WebKit/Source/wtf/text/StringImpl.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller ( mueller@kde.org )
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2013 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 265 matching lines @@
   unsigned totalOverhead = m_totalNumberStrings * sizeof(StringImpl);
   double overheadPercent = (double)totalOverhead / (double)totalDataBytes * 100;
   dataLogF("         StringImpl overheader: %8u (%5.2f%%)\n", totalOverhead,
            overheadPercent);
 
   internal::callOnMainThread(&printLiveStringStats, nullptr);
 }
 #endif
 
 void* StringImpl::operator new(size_t size) {
-  ASSERT(size == sizeof(StringImpl));
+  DCHECK_EQ(size, sizeof(StringImpl));
   return Partitions::bufferMalloc(size, "WTF::StringImpl");
 }
 
 void StringImpl::operator delete(void* ptr) {
   Partitions::bufferFree(ptr);
 }
 
 inline StringImpl::~StringImpl() {
-  ASSERT(!isStatic());
+  DCHECK(!isStatic());
 
   STRING_STATS_REMOVE_STRING(this);
 
   if (isAtomic())
     AtomicStringTable::instance().remove(this);
 }
 
 void StringImpl::destroyIfNotStatic() {
   if (!isStatic())
     delete this;
@@ skipping 43 matching lines @@
 
   data = reinterpret_cast<UChar*>(string + 1);
   return adoptRef(new (string) StringImpl(length));
 }
 
 static StaticStringsTable& staticStrings() {
   DEFINE_STATIC_LOCAL(StaticStringsTable, staticStrings, ());
   return staticStrings;
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 static bool s_allowCreationOfStaticStrings = true;
 #endif
 
 const StaticStringsTable& StringImpl::allStaticStrings() {
   return staticStrings();
 }
 
 void StringImpl::freezeStaticStrings() {
-  ASSERT(isMainThread());
+  DCHECK(isMainThread());
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   s_allowCreationOfStaticStrings = false;
 #endif
 }
 
 unsigned StringImpl::m_highestStaticStringLength = 0;
 
 StringImpl* StringImpl::createStatic(const char* string,
                                      unsigned length,
                                      unsigned hash) {
-  ASSERT(s_allowCreationOfStaticStrings);
-  ASSERT(string);
-  ASSERT(length);
+#if DCHECK_IS_ON()
+  DCHECK(s_allowCreationOfStaticStrings);
+#endif
+  DCHECK(string);
+  DCHECK(length);
 
   StaticStringsTable::const_iterator it = staticStrings().find(hash);
   if (it != staticStrings().end()) {
-    ASSERT(!memcmp(string, it->value + 1, length * sizeof(LChar)));
+    DCHECK(!memcmp(string, it->value + 1, length * sizeof(LChar)));
     return it->value;
   }
 
   // Allocate a single buffer large enough to contain the StringImpl
   // struct as well as the data which it contains. This removes one
   // heap allocation from this call.
   RELEASE_ASSERT(length <=
                  ((std::numeric_limits<unsigned>::max() - sizeof(StringImpl)) /
                   sizeof(LChar)));
   size_t size = sizeof(StringImpl) + length * sizeof(LChar);
 
   WTF_INTERNAL_LEAK_SANITIZER_DISABLED_SCOPE;
   StringImpl* impl = static_cast<StringImpl*>(
       Partitions::bufferMalloc(size, "WTF::StringImpl"));
 
   LChar* data = reinterpret_cast<LChar*>(impl + 1);
   impl = new (impl) StringImpl(length, hash, StaticString);
   memcpy(data, string, length * sizeof(LChar));
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   impl->assertHashIsCorrect();
 #endif
 
-  ASSERT(isMainThread());
+  DCHECK(isMainThread());
   m_highestStaticStringLength = std::max(m_highestStaticStringLength, length);
   staticStrings().add(hash, impl);
   WTF_ANNOTATE_BENIGN_RACE(impl,
                            "Benign race on the reference counter of a static "
                            "string created by StringImpl::createStatic");
 
   return impl;
 }
 
 void StringImpl::reserveStaticStringsCapacityForSize(unsigned size) {
-  ASSERT(s_allowCreationOfStaticStrings);
+#if DCHECK_IS_ON()
+  DCHECK(s_allowCreationOfStaticStrings);
+#endif
   staticStrings().reserveCapacityForSize(size);
 }
 
 PassRefPtr<StringImpl> StringImpl::create(const UChar* characters,
                                           unsigned length) {
   if (!characters || !length)
     return empty();
 
   UChar* data;
   RefPtr<StringImpl> string = createUninitialized(length, data);
@@ skipping 1292 matching lines @@
   if (replacement.isNull())
     return this;
   if (replacement.is8Bit())
     return replace(pattern, replacement.characters8(), replacement.length());
   return replace(pattern, replacement.characters16(), replacement.length());
 }
 
 PassRefPtr<StringImpl> StringImpl::replace(UChar pattern,
                                            const LChar* replacement,
                                            unsigned repStrLength) {
-  ASSERT(replacement);
+  DCHECK(replacement);
 
   size_t srcSegmentStart = 0;
   unsigned matchCount = 0;
 
   // Count the matches.
   while ((srcSegmentStart = find(pattern, srcSegmentStart)) != kNotFound) {
     ++matchCount;
     ++srcSegmentStart;
   }
 
@@ skipping 27 matching lines @@
       dstOffset += srcSegmentLength;
       memcpy(data + dstOffset, replacement, repStrLength * sizeof(LChar));
       dstOffset += repStrLength;
       srcSegmentStart = srcSegmentEnd + 1;
     }
 
     srcSegmentLength = m_length - srcSegmentStart;
     memcpy(data + dstOffset, characters8() + srcSegmentStart,
            srcSegmentLength * sizeof(LChar));
 
-    ASSERT(dstOffset + srcSegmentLength == newImpl->length());
+    DCHECK_EQ(dstOffset + srcSegmentLength, newImpl->length());
 
     return newImpl.release();
   }
 
   UChar* data;
   RefPtr<StringImpl> newImpl = createUninitialized(newSize, data);
 
   while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != kNotFound) {
     srcSegmentLength = srcSegmentEnd - srcSegmentStart;
     memcpy(data + dstOffset, characters16() + srcSegmentStart,
            srcSegmentLength * sizeof(UChar));
 
     dstOffset += srcSegmentLength;
     for (unsigned i = 0; i < repStrLength; ++i)
       data[i + dstOffset] = replacement[i];
 
     dstOffset += repStrLength;
     srcSegmentStart = srcSegmentEnd + 1;
   }
 
   srcSegmentLength = m_length - srcSegmentStart;
   memcpy(data + dstOffset, characters16() + srcSegmentStart,
          srcSegmentLength * sizeof(UChar));
 
-  ASSERT(dstOffset + srcSegmentLength == newImpl->length());
+  DCHECK_EQ(dstOffset + srcSegmentLength, newImpl->length());
 
   return newImpl.release();
 }
 
 PassRefPtr<StringImpl> StringImpl::replace(UChar pattern,
                                            const UChar* replacement,
                                            unsigned repStrLength) {
-  ASSERT(replacement);
+  DCHECK(replacement);
 
   size_t srcSegmentStart = 0;
   unsigned matchCount = 0;
 
   // Count the matches.
   while ((srcSegmentStart = find(pattern, srcSegmentStart)) != kNotFound) {
     ++matchCount;
     ++srcSegmentStart;
   }
 
@@ skipping 29 matching lines @@
       memcpy(data + dstOffset, replacement, repStrLength * sizeof(UChar));
 
       dstOffset += repStrLength;
       srcSegmentStart = srcSegmentEnd + 1;
     }
 
     srcSegmentLength = m_length - srcSegmentStart;
     for (unsigned i = 0; i < srcSegmentLength; ++i)
       data[i + dstOffset] = characters8()[i + srcSegmentStart];
 
-    ASSERT(dstOffset + srcSegmentLength == newImpl->length());
+    DCHECK_EQ(dstOffset + srcSegmentLength, newImpl->length());
 
     return newImpl.release();
   }
 
   UChar* data;
   RefPtr<StringImpl> newImpl = createUninitialized(newSize, data);
 
   while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != kNotFound) {
     srcSegmentLength = srcSegmentEnd - srcSegmentStart;
     memcpy(data + dstOffset, characters16() + srcSegmentStart,
            srcSegmentLength * sizeof(UChar));
 
     dstOffset += srcSegmentLength;
     memcpy(data + dstOffset, replacement, repStrLength * sizeof(UChar));
 
     dstOffset += repStrLength;
     srcSegmentStart = srcSegmentEnd + 1;
   }
 
   srcSegmentLength = m_length - srcSegmentStart;
   memcpy(data + dstOffset, characters16() + srcSegmentStart,
          srcSegmentLength * sizeof(UChar));
 
-  ASSERT(dstOffset + srcSegmentLength == newImpl->length());
+  DCHECK_EQ(dstOffset + srcSegmentLength, newImpl->length());
 
   return newImpl.release();
 }
 
 PassRefPtr<StringImpl> StringImpl::replace(const StringView& pattern,
                                            const StringView& replacement) {
   if (pattern.isNull() || replacement.isNull())
     return this;
 
   unsigned patternLength = pattern.length();
@@ skipping 48 matching lines @@
       memcpy(data + dstOffset, replacement.characters8(),
              repStrLength * sizeof(LChar));
       dstOffset += repStrLength;
       srcSegmentStart = srcSegmentEnd + patternLength;
     }
 
     srcSegmentLength = m_length - srcSegmentStart;
     memcpy(data + dstOffset, characters8() + srcSegmentStart,
            srcSegmentLength * sizeof(LChar));
 
-    ASSERT(dstOffset + srcSegmentLength == newImpl->length());
+    DCHECK_EQ(dstOffset + srcSegmentLength, newImpl->length());
 
     return newImpl.release();
   }
 
   UChar* data;
   RefPtr<StringImpl> newImpl = createUninitialized(newSize, data);
   while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != kNotFound) {
     srcSegmentLength = srcSegmentEnd - srcSegmentStart;
     if (srcIs8Bit) {
       // Case 3.
@@ skipping 22 matching lines @@
   if (srcIs8Bit) {
     // Case 3.
     for (unsigned i = 0; i < srcSegmentLength; ++i)
       data[i + dstOffset] = characters8()[i + srcSegmentStart];
   } else {
     // Cases 2 & 4.
     memcpy(data + dstOffset, characters16() + srcSegmentStart,
            srcSegmentLength * sizeof(UChar));
   }
 
-  ASSERT(dstOffset + srcSegmentLength == newImpl->length());
+  DCHECK_EQ(dstOffset + srcSegmentLength, newImpl->length());
 
   return newImpl.release();
 }
 
 PassRefPtr<StringImpl> StringImpl::upconvertedString() {
   if (is8Bit())
     return String::make16BitFrom8BitSource(characters8(), m_length)
         .releaseImpl();
   return this;
 }
@@ skipping 81 matching lines @@
     if (!bc)
       return false;
     if (aPtr[i] != bc)
       return false;
   }
 
   return !b[length];
 }
 
 bool equalNonNull(const StringImpl* a, const StringImpl* b) {
-  ASSERT(a && b);
+  DCHECK(a);
+  DCHECK(b);
   if (a == b)
     return true;
 
   return stringImplContentEqual(a, b);
 }
 
 bool equalIgnoringNullity(StringImpl* a, StringImpl* b) {
   if (!a && b && !b->length())
     return true;
   if (!b && a && !a->length())
@@ skipping 52 matching lines @@
     } else if (localeIdMatchesLang(localeIdentifier, "lt")) {
       // TODO(rob.buis) implement upper-casing rules for lt
       // like in StringImpl::upper(locale).
     }
   }
 
   return toUpper(c);
 }
 
 }  // namespace WTF