Add RTC_ prefix to (D)CHECKs and related macros.

webrtc/base/stringencode.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/base/stringencode.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/stringutils.h"
 
 namespace rtc {
 
 /////////////////////////////////////////////////////////////////////////////
 // String Encoding Utilities
 /////////////////////////////////////////////////////////////////////////////
 
 size_t escape(char * buffer, size_t buflen,
               const char * source, size_t srclen,
               const char * illegal, char escape) {
-  DCHECK(buffer);  // TODO: estimate output size
+  RTC_DCHECK(buffer);  // TODO(grunell): estimate output size
   if (buflen <= 0)
     return 0;
 
   size_t srcpos = 0, bufpos = 0;
   while ((srcpos < srclen) && (bufpos + 1 < buflen)) {
     char ch = source[srcpos++];
     if ((ch == escape) || ::strchr(illegal, ch)) {
       if (bufpos + 2 >= buflen)
         break;
       buffer[bufpos++] = escape;
     }
     buffer[bufpos++] = ch;
   }
 
   buffer[bufpos] = '\0';
   return bufpos;
 }
 
 size_t unescape(char * buffer, size_t buflen,
                 const char * source, size_t srclen,
                 char escape) {
-  DCHECK(buffer);  // TODO: estimate output size
+  RTC_DCHECK(buffer);  // TODO(grunell): estimate output size
   if (buflen <= 0)
     return 0;
 
   size_t srcpos = 0, bufpos = 0;
   while ((srcpos < srclen) && (bufpos + 1 < buflen)) {
     char ch = source[srcpos++];
     if ((ch == escape) && (srcpos < srclen)) {
       ch = source[srcpos++];
     }
     buffer[bufpos++] = ch;
   }
   buffer[bufpos] = '\0';
   return bufpos;
 }
 
 size_t encode(char * buffer, size_t buflen,
               const char * source, size_t srclen,
               const char * illegal, char escape) {
-  DCHECK(buffer);  // TODO: estimate output size
+  RTC_DCHECK(buffer);  // TODO(grunell): estimate output size
   if (buflen <= 0)
     return 0;
 
   size_t srcpos = 0, bufpos = 0;
   while ((srcpos < srclen) && (bufpos + 1 < buflen)) {
     char ch = source[srcpos++];
     if ((ch != escape) && !::strchr(illegal, ch)) {
       buffer[bufpos++] = ch;
     } else if (bufpos + 3 >= buflen) {
       break;
@@ skipping 31 matching lines @@
   buffer[bufpos] = '\0';
   return bufpos;
 }
 
 const char* unsafe_filename_characters() {
   // It might be better to have a single specification which is the union of
   // all operating systems, unless one system is overly restrictive.
 #if defined(WEBRTC_WIN)
   return "\\/:*?\"<>|";
 #else  // !WEBRTC_WIN
-  // TODO
-  DCHECK(false);
+  // TODO(grunell): Should this never be reached?
+  RTC_DCHECK(false);
   return "";
 #endif  // !WEBRTC_WIN
 }
 
 const unsigned char URL_UNSAFE  = 0x1; // 0-33 "#$%&+,/:;<=>?@[\]^`{|} 127
 const unsigned char XML_UNSAFE  = 0x2; // "&'<>
 const unsigned char HTML_UNSAFE = 0x2; // "&'<>
 
 //  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 6 5 7 8 9 : ; < = > ?
 //@ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _
@@ skipping 116 matching lines @@
     buffer[1] = 0x80 | static_cast<unsigned char>((value >> 12) & 0x3F);
     buffer[2] = 0x80 | static_cast<unsigned char>((value >> 6) & 0x3F);
     buffer[3] = 0x80 | static_cast<unsigned char>(value & 0x3F);
     return 4;
   }
   return 0;
 }
 
 size_t html_encode(char * buffer, size_t buflen,
                    const char * source, size_t srclen) {
-  DCHECK(buffer);  // TODO: estimate output size
+  RTC_DCHECK(buffer);  // TODO(grunell): estimate output size
   if (buflen <= 0)
     return 0;
 
   size_t srcpos = 0, bufpos = 0;
   while ((srcpos < srclen) && (bufpos + 1 < buflen)) {
     unsigned char ch = source[srcpos];
     if (ch < 128) {
       srcpos += 1;
       if (ASCII_CLASS[ch] & HTML_UNSAFE) {
         const char * escseq = 0;
         size_t esclen = 0;
         switch (ch) {
           case '<':  escseq = "&lt;";   esclen = 4; break;
           case '>':  escseq = "&gt;";   esclen = 4; break;
           case '\'': escseq = "&#39;";  esclen = 5; break;
           case '\"': escseq = "&quot;"; esclen = 6; break;
           case '&':  escseq = "&amp;";  esclen = 5; break;
-          default: DCHECK(false);
+          default: RTC_DCHECK(false);
         }
         if (bufpos + esclen >= buflen) {
           break;
         }
         memcpy(buffer + bufpos, escseq, esclen);
         bufpos += esclen;
       } else {
         buffer[bufpos++] = ch;
       }
     } else {
@@ skipping 14 matching lines @@
       memcpy(buffer + bufpos, escseq, esclen);
       bufpos += esclen;
     }
   }
   buffer[bufpos] = '\0';
   return bufpos;
 }
 
 size_t html_decode(char * buffer, size_t buflen,
                    const char * source, size_t srclen) {
-  DCHECK(buffer);  // TODO: estimate output size
+  RTC_DCHECK(buffer);  // TODO(grunell): estimate output size
   return xml_decode(buffer, buflen, source, srclen);
 }
 
 size_t xml_encode(char * buffer, size_t buflen,
                   const char * source, size_t srclen) {
-  DCHECK(buffer);  // TODO: estimate output size
+  RTC_DCHECK(buffer);  // TODO(grunell): estimate output size
   if (buflen <= 0)
     return 0;
 
   size_t srcpos = 0, bufpos = 0;
   while ((srcpos < srclen) && (bufpos + 1 < buflen)) {
     unsigned char ch = source[srcpos++];
     if ((ch < 128) && (ASCII_CLASS[ch] & XML_UNSAFE)) {
       const char * escseq = 0;
       size_t esclen = 0;
       switch (ch) {
         case '<':  escseq = "&lt;";   esclen = 4; break;
         case '>':  escseq = "&gt;";   esclen = 4; break;
         case '\'': escseq = "&apos;"; esclen = 6; break;
         case '\"': escseq = "&quot;"; esclen = 6; break;
         case '&':  escseq = "&amp;";  esclen = 5; break;
-        default: DCHECK(false);
+        default: RTC_DCHECK(false);
       }
       if (bufpos + esclen >= buflen) {
         break;
       }
       memcpy(buffer + bufpos, escseq, esclen);
       bufpos += esclen;
     } else {
       buffer[bufpos++] = ch;
     }
   }
   buffer[bufpos] = '\0';
   return bufpos;
 }
 
 size_t xml_decode(char * buffer, size_t buflen,
                   const char * source, size_t srclen) {
-  DCHECK(buffer);  // TODO: estimate output size
+  RTC_DCHECK(buffer);  // TODO(grunell): estimate output size
   if (buflen <= 0)
     return 0;
 
   size_t srcpos = 0, bufpos = 0;
   while ((srcpos < srclen) && (bufpos + 1 < buflen)) {
     unsigned char ch = source[srcpos++];
     if (ch != '&') {
       buffer[bufpos++] = ch;
     } else if ((srcpos + 2 < srclen)
                && (memcmp(source + srcpos, "lt;", 3) == 0)) {
@@ skipping 15 matching lines @@
                && (memcmp(source + srcpos, "amp;", 4) == 0)) {
       buffer[bufpos++] = '&';
       srcpos += 4;
     } else if ((srcpos < srclen) && (source[srcpos] == '#')) {
       int int_base = 10;
       if ((srcpos + 1 < srclen) && (source[srcpos+1] == 'x')) {
         int_base = 16;
         srcpos += 1;
       }
       char * ptr;
-      // TODO: Fix hack (ptr may go past end of data)
+      // TODO(grunell): Fix hack (ptr may go past end of data)
       unsigned long val = strtoul(source + srcpos + 1, &ptr, int_base);
       if ((static_cast<size_t>(ptr - source) < srclen) && (*ptr == ';')) {
         srcpos = ptr - source + 1;
       } else {
         // Not a valid escape sequence.
         break;
       }
       if (size_t esclen = utf8_encode(buffer + bufpos, buflen - bufpos, val)) {
         bufpos += esclen;
       } else {
         // Not enough room to encode the character, or illegal character
         break;
       }
     } else {
       // Unrecognized escape sequence.
       break;
     }
   }
   buffer[bufpos] = '\0';
   return bufpos;
 }
 
 static const char HEX[] = "0123456789abcdef";
 
 char hex_encode(unsigned char val) {
-  DCHECK_LT(val, 16);
+  RTC_DCHECK_LT(val, 16);
   return (val < 16) ? HEX[val] : '!';
 }
 
 bool hex_decode(char ch, unsigned char* val) {
   if ((ch >= '0') && (ch <= '9')) {
     *val = ch - '0';
   } else if ((ch >= 'A') && (ch <= 'Z')) {
     *val = (ch - 'A') + 10;
   } else if ((ch >= 'a') && (ch <= 'z')) {
     *val = (ch - 'a') + 10;
   } else {
     return false;
   }
   return true;
 }
 
 size_t hex_encode(char* buffer, size_t buflen,
                   const char* csource, size_t srclen) {
   return hex_encode_with_delimiter(buffer, buflen, csource, srclen, 0);
 }
 
 size_t hex_encode_with_delimiter(char* buffer, size_t buflen,
                                  const char* csource, size_t srclen,
                                  char delimiter) {
-  DCHECK(buffer);  // TODO: estimate output size
+  RTC_DCHECK(buffer);  // TODO(grunell): estimate output size
   if (buflen == 0)
     return 0;
 
   // Init and check bounds.
   const unsigned char* bsource =
       reinterpret_cast<const unsigned char*>(csource);
   size_t srcpos = 0, bufpos = 0;
   size_t needed = delimiter ? (srclen * 3) : (srclen * 2 + 1);
   if (buflen < needed)
     return 0;
@@ skipping 23 matching lines @@
 std::string hex_encode(const char* source, size_t srclen) {
   return hex_encode_with_delimiter(source, srclen, 0);
 }
 
 std::string hex_encode_with_delimiter(const char* source, size_t srclen,
                                       char delimiter) {
   const size_t kBufferSize = srclen * 3;
   char* buffer = STACK_ARRAY(char, kBufferSize);
   size_t length = hex_encode_with_delimiter(buffer, kBufferSize,
                                             source, srclen, delimiter);
-  DCHECK(srclen == 0 || length > 0);
+  RTC_DCHECK(srclen == 0 || length > 0);
   return std::string(buffer, length);
 }
 
 size_t hex_decode(char * cbuffer, size_t buflen,
                   const char * source, size_t srclen) {
   return hex_decode_with_delimiter(cbuffer, buflen, source, srclen, 0);
 }
 
 size_t hex_decode_with_delimiter(char* cbuffer, size_t buflen,
                                  const char* source, size_t srclen,
                                  char delimiter) {
-  DCHECK(cbuffer);  // TODO: estimate output size
+  RTC_DCHECK(cbuffer);  // TODO(grunell): estimate output size
   if (buflen == 0)
     return 0;
 
   // Init and bounds check.
   unsigned char* bbuffer = reinterpret_cast<unsigned char*>(cbuffer);
   size_t srcpos = 0, bufpos = 0;
   size_t needed = (delimiter) ? (srclen + 1) / 3 : srclen / 2;
   if (buflen < needed)
     return 0;
 
@@ skipping 43 matching lines @@
   // Ask transformation function to approximate the destination size (returns upper bound)
   size_t maxlen = t(NULL, 0, source.data(), source.length());
   char * buffer = STACK_ARRAY(char, maxlen);
   size_t len = t(buffer, maxlen, source.data(), source.length());
   std::string result(buffer, len);
   return result;
 }
 
 size_t tokenize(const std::string& source, char delimiter,
                 std::vector<std::string>* fields) {
-  DCHECK(fields);
+  RTC_DCHECK(fields);
   fields->clear();
   size_t last = 0;
   for (size_t i = 0; i < source.length(); ++i) {
     if (source[i] == delimiter) {
       if (i != last) {
         fields->push_back(source.substr(last, i - last));
       }
       last = i + 1;
     }
   }
@@ skipping 57 matching lines @@
     right_pos++;
   }
 
   *token = source.substr(0, left_pos);
   *rest = source.substr(right_pos);
   return true;
 }
 
 size_t split(const std::string& source, char delimiter,
              std::vector<std::string>* fields) {
-  DCHECK(fields);
+  RTC_DCHECK(fields);
   fields->clear();
   size_t last = 0;
   for (size_t i = 0; i < source.length(); ++i) {
     if (source[i] == delimiter) {
       fields->push_back(source.substr(last, i - last));
       last = i + 1;
     }
   }
   fields->push_back(source.substr(last, source.length() - last));
   return fields->size();
@@ skipping 26 matching lines @@
   va_list args;
   va_start(args, format);
   value.assign(buffer, vsprintfn(buffer, maxlen + 1, format, args));
   va_end(args);
 }
 */
 
 /////////////////////////////////////////////////////////////////////////////
 
 }  // namespace rtc