DevTools: expose raw pointers in protocol collections, s/ASSERT/DCHECK/.

third_party/WebKit/Source/platform/inspector_protocol/String16STL.cpp

 // Copyright 2016 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/inspector_protocol/String16STL.h"
 
 #include <algorithm>
 #include <cctype>
 #include <functional>
 #include <locale>
@@ skipping 70 matching lines @@
     0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
     0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
     0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
     0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
     0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
     0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
 };
 
 template<typename CharType> inline int toASCIIHexValue(CharType c)
 {
-    ASSERT(isASCIIHexDigit(c));
+    DCHECK(isASCIIHexDigit(c));
     return c < 'A' ? c - '0' : (c - 'A' + 10) & 0xF;
 }
 
 template<typename CharType> inline int toASCIIHexValue(CharType upperValue, CharType lowerValue)
 {
-    ASSERT(isASCIIHexDigit(upperValue) && isASCIIHexDigit(lowerValue));
+    DCHECK(isASCIIHexDigit(upperValue) && isASCIIHexDigit(lowerValue));
     return ((toASCIIHexValue(upperValue) << 4) & 0xF0) | toASCIIHexValue(lowerValue);
 }
 
 inline char lowerNibbleToASCIIHexDigit(char c)
 {
     char nibble = c & 0xF;
     return nibble < 10 ? '0' + nibble : 'A' + nibble - 10;
 }
 
 inline char upperNibbleToASCIIHexDigit(char c)
 {
     char nibble = (c >> 4) & 0xF;
     return nibble < 10 ? '0' + nibble : 'A' + nibble - 10;
 }
 
 template<typename CharType> inline bool isASCIIAlphaCaselessEqual(CharType cssCharacter, char character)
 {
     // This function compares a (preferrably) constant ASCII
     // lowercase letter to any input character.
-    ASSERT(character >= 'a' && character <= 'z');
+    DCHECK(character >= 'a' && character <= 'z');
     return LIKELY(toASCIILowerUnchecked(cssCharacter) == character);
 }
 
 inline int inlineUTF8SequenceLengthNonASCII(char b0)
 {
     if ((b0 & 0xC0) != 0xC0)
         return 0;
     if ((b0 & 0xE0) == 0xC0)
         return 2;
     if ((b0 & 0xF0) == 0xE0)
@@ skipping 142 matching lines @@
         target += bytesToWrite;
     }
     *sourceStart = source;
     *targetStart = target;
     return result;
 }
 
 // Helper to write a three-byte UTF-8 code point to the buffer, caller must check room is available.
 static inline void putUTF8Triple(char*& buffer, UChar ch)
 {
-    ASSERT(ch >= 0x0800);
+    DCHECK_GE(ch, 0x0800);
     *buffer++ = static_cast<char>(((ch >> 12) & 0x0F) | 0xE0);
     *buffer++ = static_cast<char>(((ch >> 6) & 0x3F) | 0x80);
     *buffer++ = static_cast<char>((ch & 0x3F) | 0x80);
 }
 
 // trim from start
 static inline wstring &ltrim(wstring &s)
 {
     s.erase(s.begin(), std::find_if(s.begin(), s.end(), std::not1(std::ptr_fun<int, int>(std::isspace))));
         return s;
@@ skipping 30 matching lines @@
     //    have a good chance of being able to write the string into the
     //    buffer without reallocing (say, 1.5 x length).
     if (length > std::numeric_limits<unsigned>::max() / 3)
         return std::string();
     std::vector<char> bufferVector(length * 3);
     char* buffer = bufferVector.data();
     const UChar* characters = m_impl.data();
 
     bool strict = false;
     ConversionResult result = convertUTF16ToUTF8(&characters, characters + length, &buffer, buffer + bufferVector.size(), strict);
-    ASSERT(result != targetExhausted); // (length * 3) should be sufficient for any conversion
+    DCHECK(result != targetExhausted); // (length * 3) should be sufficient for any conversion
 
     // Only produced from strict conversion.
     if (result == sourceIllegal) {
-        ASSERT(strict);
+        DCHECK(strict);
         return std::string();
     }
 
     // Check for an unconverted high surrogate.
     if (result == sourceExhausted) {
         if (strict)
             return std::string();
         // This should be one unpaired high surrogate. Treat it the same
         // was as an unpaired high surrogate would have been handled in
         // the middle of a string with non-strict conversion - which is
         // to say, simply encode it to UTF-8.
-        ASSERT((characters + 1) == (m_impl.data() + length));
-        ASSERT((*characters >= 0xD800) && (*characters <= 0xDBFF));
+        DCHECK((characters + 1) == (m_impl.data() + length));
+        DCHECK((*characters >= 0xD800) && (*characters <= 0xDBFF));
         // There should be room left, since one UChar hasn't been
         // converted.
-        ASSERT((buffer + 3) <= (buffer + bufferVector.size()));
+        DCHECK((buffer + 3) <= (buffer + bufferVector.size()));
         putUTF8Triple(buffer, *characters);
     }
 
     return std::string(bufferVector.data(), buffer - bufferVector.data());
 }
 
 String16 String16::stripWhiteSpace() const
 {
     wstring result(m_impl);
     trim(result);
     return result;
 }
 
 } // namespace protocol
 } // namespace blink