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

webrtc/base/win32.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 17 matching lines @@
 static int inet_pton_v4(const char* src, void* dst);
 static int inet_pton_v6(const char* src, void* dst);
 
 // Implementation of inet_ntop (create a printable representation of an
 // ip address). XP doesn't have its own inet_ntop, and
 // WSAAddressToString requires both IPv6 to be  installed and for Winsock
 // to be initialized.
 const char* win32_inet_ntop(int af, const void *src,
                             char* dst, socklen_t size) {
   if (!src || !dst) {
-    return NULL;
+    return nullptr;
   }
   switch (af) {
     case AF_INET: {
       return inet_ntop_v4(src, dst, size);
     }
     case AF_INET6: {
       return inet_ntop_v6(src, dst, size);
     }
   }
-  return NULL;
+  return nullptr;
 }
 
 // As above, but for inet_pton. Implements inet_pton for v4 and v6.
 // Note that our inet_ntop will output normal 'dotted' v4 addresses only.
 int win32_inet_pton(int af, const char* src, void* dst) {
   if (!src || !dst) {
     return 0;
   }
   if (af == AF_INET) {
     return inet_pton_v4(src, dst);
   } else if (af == AF_INET6) {
     return inet_pton_v6(src, dst);
   }
   return -1;
 }
 
 // Helper function for inet_ntop for IPv4 addresses.
 // Outputs "dotted-quad" decimal notation.
 const char* inet_ntop_v4(const void* src, char* dst, socklen_t size) {
   if (size < INET_ADDRSTRLEN) {
-    return NULL;
+    return nullptr;
   }
   const struct in_addr* as_in_addr =
       reinterpret_cast<const struct in_addr*>(src);
   rtc::sprintfn(dst, size, "%d.%d.%d.%d",
                       as_in_addr->S_un.S_un_b.s_b1,
                       as_in_addr->S_un.S_un_b.s_b2,
                       as_in_addr->S_un.S_un_b.s_b3,
                       as_in_addr->S_un.S_un_b.s_b4);
   return dst;
 }
 
 // Helper function for inet_ntop for IPv6 addresses.
 const char* inet_ntop_v6(const void* src, char* dst, socklen_t size) {
   if (size < INET6_ADDRSTRLEN) {
-    return NULL;
+    return nullptr;
   }
   const uint16_t* as_shorts = reinterpret_cast<const uint16_t*>(src);
   int runpos[8];
   int current = 1;
   int max = 0;
   int maxpos = -1;
   int run_array_size = arraysize(runpos);
   // Run over the address marking runs of 0s.
   for (int i = 0; i < run_array_size; ++i) {
     if (as_shorts[i] == 0) {
@@ skipping 216 matching lines @@
 // FILETIME of that time/date, then we add/subtract in appropriate units to
 // convert to/from unix time.
 // The units of FILETIME are 100ns intervals, so by multiplying by or dividing
 // by 10000000, we can convert to/from seconds.
 //
 // FileTime = UnixTime*10000000 + FileTime(1970)
 // UnixTime = (FileTime-FileTime(1970))/10000000
 //
 
 void FileTimeToUnixTime(const FILETIME& ft, time_t* ut) {
-  RTC_DCHECK(NULL != ut);
+  RTC_DCHECK(nullptr != ut);
 
   // FILETIME has an earlier date base than time_t (1/1/1970), so subtract off
   // the difference.
   SYSTEMTIME base_st;
   memset(&base_st, 0, sizeof(base_st));
   base_st.wDay = 1;
   base_st.wMonth = 1;
   base_st.wYear = 1970;
 
   FILETIME base_ft;
   SystemTimeToFileTime(&base_st, &base_ft);
 
   ULARGE_INTEGER base_ul, current_ul;
   memcpy(&base_ul, &base_ft, sizeof(FILETIME));
   memcpy(&current_ul, &ft, sizeof(FILETIME));
 
   // Divide by big number to convert to seconds, then subtract out the 1970
   // base date value.
   const ULONGLONG RATIO = 10000000;
   *ut = static_cast<time_t>((current_ul.QuadPart - base_ul.QuadPart) / RATIO);
 }
 
 void UnixTimeToFileTime(const time_t& ut, FILETIME* ft) {
-  RTC_DCHECK(NULL != ft);
+  RTC_DCHECK(nullptr != ft);
 
   // FILETIME has an earlier date base than time_t (1/1/1970), so add in
   // the difference.
   SYSTEMTIME base_st;
   memset(&base_st, 0, sizeof(base_st));
   base_st.wDay = 1;
   base_st.wMonth = 1;
   base_st.wYear = 1970;
 
   FILETIME base_ft;
@@ skipping 10 matching lines @@
   memcpy(ft, &current_ul, sizeof(FILETIME));
 }
 
 bool Utf8ToWindowsFilename(const std::string& utf8, std::wstring* filename) {
   // TODO: Integrate into fileutils.h
   // TODO: Handle wide and non-wide cases via TCHAR?
   // TODO: Skip \\?\ processing if the length is not > MAX_PATH?
   // TODO: Write unittests
 
   // Convert to Utf16
-  int wlen = ::MultiByteToWideChar(CP_UTF8, 0, utf8.c_str(),
-                                   static_cast<int>(utf8.length() + 1), NULL,
-                                   0);
+  int wlen =
+      ::MultiByteToWideChar(CP_UTF8, 0, utf8.c_str(),
+                            static_cast<int>(utf8.length() + 1), nullptr, 0);
   if (0 == wlen) {
     return false;
   }
   wchar_t* wfilename = STACK_ARRAY(wchar_t, wlen);
   if (0 == ::MultiByteToWideChar(CP_UTF8, 0, utf8.c_str(),
                                  static_cast<int>(utf8.length() + 1),
                                  wfilename, wlen)) {
     return false;
   }
   // Replace forward slashes with backslashes
   std::replace(wfilename, wfilename + wlen, L'/', L'\\');
   // Convert to complete filename
-  DWORD full_len = ::GetFullPathName(wfilename, 0, NULL, NULL);
+  DWORD full_len = ::GetFullPathName(wfilename, 0, nullptr, nullptr);
   if (0 == full_len) {
     return false;
   }
-  wchar_t* filepart = NULL;
+  wchar_t* filepart = nullptr;
   wchar_t* full_filename = STACK_ARRAY(wchar_t, full_len + 6);
   wchar_t* start = full_filename + 6;
   if (0 == ::GetFullPathName(wfilename, full_len, start, &filepart)) {
     return false;
   }
   // Add long-path prefix
   const wchar_t kLongPathPrefix[] = L"\\\\?\\UNC";
   if ((start[0] != L'\\') || (start[1] != L'\\')) {
     // Non-unc path:     <pathname>
     //      Becomes: \\?\<pathname>
@@ skipping 23 matching lines @@
     return true;
   }
   return false;
 }
 
 bool GetCurrentProcessIntegrityLevel(int* level) {
   bool ret = false;
   HANDLE process = ::GetCurrentProcess(), token;
   if (OpenProcessToken(process, TOKEN_QUERY | TOKEN_QUERY_SOURCE, &token)) {
     DWORD size;
-    if (!GetTokenInformation(token, TokenIntegrityLevel, NULL, 0, &size) &&
+    if (!GetTokenInformation(token, TokenIntegrityLevel, nullptr, 0, &size) &&
         GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
-
       char* buf = STACK_ARRAY(char, size);
       TOKEN_MANDATORY_LABEL* til =
           reinterpret_cast<TOKEN_MANDATORY_LABEL*>(buf);
       if (GetTokenInformation(token, TokenIntegrityLevel, til, size, &size)) {
 
         DWORD count = *GetSidSubAuthorityCount(til->Label.Sid);
         *level = *GetSidSubAuthority(til->Label.Sid, count - 1);
         ret = true;
       }
     }
     CloseHandle(token);
   }
   return ret;
 }
 
 }  // namespace rtc