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

webrtc/base/logging.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.
  */
 
@@ skipping 92 matching lines @@
 bool LogMessage::log_to_stderr_ = true;
 
 namespace {
 // Global lock for log subsystem, only needed to serialize access to streams_.
 CriticalSection g_log_crit;
 }  // namespace
 
 // The list of logging streams currently configured.
 // Note: we explicitly do not clean this up, because of the uncertain ordering
 // of destructors at program exit.  Let the person who sets the stream trigger
-// cleanup by setting to NULL, or let it leak (safe at program exit).
+// cleanup by setting to null, or let it leak (safe at program exit).
 LogMessage::StreamList LogMessage::streams_ GUARDED_BY(g_log_crit);
 
 // Boolean options default to false (0)
 bool LogMessage::thread_, LogMessage::timestamp_;
 
 LogMessage::LogMessage(const char* file,
                        int line,
                        LoggingSeverity sev,
                        LogErrorContext err_ctx,
                        int err,
                        const char* module)
     : severity_(sev), tag_(kLibjingle) {
   if (timestamp_) {
     // Use SystemTimeMillis so that even if tests use fake clocks, the timestamp
     // in log messages represents the real system time.
     int64_t time = TimeDiff(SystemTimeMillis(), LogStartTime());
     // Also ensure WallClockStartTime is initialized, so that it matches
     // LogStartTime.
     WallClockStartTime();
     print_stream_ << "[" << std::setfill('0') << std::setw(3) << (time / 1000)
                   << ":" << std::setw(3) << (time % 1000) << std::setfill(' ')
                   << "] ";
   }
 
   if (thread_) {
     PlatformThreadId id = CurrentThreadId();
     print_stream_ << "[" << std::dec << id << "] ";
   }
 
-  if (file != NULL)
+  if (file != nullptr)
     print_stream_ << "(" << FilenameFromPath(file)  << ":" << line << "): ";
 
   if (err_ctx != ERRCTX_NONE) {
     std::ostringstream tmp;
     tmp << "[0x" << std::setfill('0') << std::hex << std::setw(8) << err << "]";
     switch (err_ctx) {
       case ERRCTX_ERRNO:
         tmp << " " << strerror(err);
         break;
 #ifdef WEBRTC_WIN
       case ERRCTX_HRESULT: {
         char msgbuf[256];
         DWORD flags = FORMAT_MESSAGE_FROM_SYSTEM;
         HMODULE hmod = GetModuleHandleA(module);
         if (hmod)
           flags |= FORMAT_MESSAGE_FROM_HMODULE;
         if (DWORD len = FormatMessageA(
-            flags, hmod, err,
-            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-            msgbuf, sizeof(msgbuf) / sizeof(msgbuf[0]), NULL)) {
+                flags, hmod, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                msgbuf, sizeof(msgbuf) / sizeof(msgbuf[0]), nullptr)) {
           while ((len > 0) &&
               isspace(static_cast<unsigned char>(msgbuf[len-1]))) {
             msgbuf[--len] = 0;
           }
           tmp << " " << msgbuf;
         }
         break;
       }
 #endif  // WEBRTC_WIN
 #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
       case ERRCTX_OSSTATUS: {
         std::string desc(DescriptionFromOSStatus(err));
         tmp << " " << (desc.empty() ? "Unknown error" : desc.c_str());
         break;
       }
 #endif  // WEBRTC_MAC && !defined(WEBRTC_IOS)
       default:
         break;
     }
     extra_ = tmp.str();
   }
 }
 
 LogMessage::LogMessage(const char* file,
                        int line,
                        LoggingSeverity sev,
                        const std::string& tag)
-    : LogMessage(file, line, sev, ERRCTX_NONE, 0 /* err */, NULL /* module */) {
+    : LogMessage(file,
+                 line,
+                 sev,
+                 ERRCTX_NONE,
+                 0 /* err */,
+                 nullptr /* module */) {
   tag_ = tag;
   print_stream_ << tag << ": ";
 }
 
 LogMessage::~LogMessage() {
   if (!extra_.empty())
     print_stream_ << " : " << extra_;
   print_stream_ << std::endl;
 
   const std::string& str = print_stream_.str();
   if (severity_ >= dbg_sev_) {
     OutputToDebug(str, severity_, tag_);
   }
 
   CritScope cs(&g_log_crit);
   for (auto& kv : streams_) {
     if (severity_ >= kv.second) {
       kv.first->OnLogMessage(str);
     }
   }
 }
 
 int64_t LogMessage::LogStartTime() {
   static const int64_t g_start = SystemTimeMillis();
   return g_start;
 }
 
 uint32_t LogMessage::WallClockStartTime() {
-  static const uint32_t g_start_wallclock = time(NULL);
+  static const uint32_t g_start_wallclock = time(nullptr);
   return g_start_wallclock;
 }
 
 void LogMessage::LogThreads(bool on) {
   thread_ = on;
 }
 
 void LogMessage::LogTimestamps(bool on) {
   timestamp_ = on;
 }
@@ skipping 111 matching lines @@
                                const std::string& tag) {
   bool log_to_stderr = log_to_stderr_;
 #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS) && defined(NDEBUG)
   // On the Mac, all stderr output goes to the Console log and causes clutter.
   // So in opt builds, don't log to stderr unless the user specifically sets
   // a preference to do so.
   CFStringRef key = CFStringCreateWithCString(kCFAllocatorDefault,
                                               "logToStdErr",
                                               kCFStringEncodingUTF8);
   CFStringRef domain = CFBundleGetIdentifier(CFBundleGetMainBundle());
-  if (key != NULL && domain != NULL) {
+  if (key != nullptr && domain != nullptr) {
     Boolean exists_and_is_valid;
     Boolean should_log =
         CFPreferencesGetAppBooleanValue(key, domain, &exists_and_is_valid);
     // If the key doesn't exist or is invalid or is false, we will not log to
     // stderr.
     log_to_stderr = exists_and_is_valid && should_log;
   }
-  if (key != NULL) {
+  if (key != nullptr) {
     CFRelease(key);
   }
 #endif
 #if defined(WEBRTC_WIN)
   // Always log to the debugger.
   // Perhaps stderr should be controlled by a preference, as on Mac?
   OutputDebugStringA(str.c_str());
   if (log_to_stderr) {
     // This handles dynamically allocated consoles, too.
     if (HANDLE error_handle = ::GetStdHandle(STD_ERROR_HANDLE)) {
@@ skipping 65 matching lines @@
 //////////////////////////////////////////////////////////////////////
 
 void LogMultiline(LoggingSeverity level, const char* label, bool input,
                   const void* data, size_t len, bool hex_mode,
                   LogMultilineState* state) {
   if (!LOG_CHECK_LEVEL_V(level))
     return;
 
   const char * direction = (input ? " << " : " >> ");
 
-  // NULL data means to flush our count of unprintable characters.
+  // null data means to flush our count of unprintable characters.
   if (!data) {
     if (state && state->unprintable_count_[input]) {
       LOG_V(level) << label << direction << "## "
                    << state->unprintable_count_[input]
                    << " consecutive unprintable ##";
       state->unprintable_count_[input] = 0;
     }
     return;
   }
 
@@ skipping 91 matching lines @@
   }
 
   if (state) {
     state->unprintable_count_[input] = consecutive_unprintable;
   }
 }
 
 //////////////////////////////////////////////////////////////////////
 
 }  // namespace rtc