Replace NULL with nullptr or null in webrtc/base/.

webrtc/base/base64.cc

 
 //*********************************************************************
 //* Base64 - a simple base64 encoder and decoder.
 //*
 //*     Copyright (c) 1999, Bob Withers - bwit@pobox.com
 //*
 //* This code may be freely used for any purpose, either personal
 //* or commercial, provided the authors copyright notice remains
 //* intact.
 //*
@@ skipping 56 matching lines @@
     il, il, il, il, il, il, il, il, il, il,  // 240 - 249
     il, il, il, il, il, il                   // 250 - 255
 };
 
 bool Base64::IsBase64Char(char ch) {
   return (('A' <= ch) && (ch <= 'Z')) || (('a' <= ch) && (ch <= 'z')) ||
          (('0' <= ch) && (ch <= '9')) || (ch == '+') || (ch == '/');
 }
 
 bool Base64::GetNextBase64Char(char ch, char* next_ch) {
-  if (next_ch == NULL) {
+  if (next_ch == nullptr) {
     return false;
   }
   const char* p = strchr(Base64Table, ch);
   if (!p)
     return false;
   ++p;
   *next_ch = (*p) ? *p : Base64Table[0];
   return true;
 }
 
 bool Base64::IsBase64Encoded(const std::string& str) {
   for (size_t i = 0; i < str.size(); ++i) {
     if (!IsBase64Char(str.at(i)))
       return false;
   }
   return true;
 }
 
 void Base64::EncodeFromArray(const void* data,
                              size_t len,
                              std::string* result) {
-  RTC_DCHECK(NULL != result);
+  RTC_DCHECK(nullptr != result);
   result->clear();
   result->resize(((len + 2) / 3) * 4);
   const unsigned char* byte_data = static_cast<const unsigned char*>(data);
 
   unsigned char c;
   size_t i = 0;
   size_t dest_ix = 0;
   while (i < len) {
     c = (byte_data[i] >> 2) & 0x3f;
     (*result)[dest_ix++] = Base64Table[c];
@@ skipping 107 matching lines @@
   return DecodeFromArrayTemplate<vector<uint8_t>>(data, len, flags, result,
                                                   data_used);
 }
 
 template <typename T>
 bool Base64::DecodeFromArrayTemplate(const char* data,
                                      size_t len,
                                      DecodeFlags flags,
                                      T* result,
                                      size_t* data_used) {
-  RTC_DCHECK(NULL != result);
+  RTC_DCHECK(nullptr != result);
   RTC_DCHECK(flags <= (DO_PARSE_MASK | DO_PAD_MASK | DO_TERM_MASK));
 
   const DecodeFlags parse_flags = flags & DO_PARSE_MASK;
   const DecodeFlags pad_flags = flags & DO_PAD_MASK;
   const DecodeFlags term_flags = flags & DO_TERM_MASK;
   RTC_DCHECK(0 != parse_flags);
   RTC_DCHECK(0 != pad_flags);
   RTC_DCHECK(0 != term_flags);
 
   result->clear();
@@ skipping 31 matching lines @@
   if ((DO_TERM_BUFFER == term_flags) && (dpos != len)) {
     success = false;  // unused chars
   }
   if (data_used) {
     *data_used = dpos;
   }
   return success;
 }
 
 }  // namespace rtc