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

webrtc/base/unixfilesystem.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 45 matching lines @@
 // elsewhere; other places should use GetApp{Data,Temp}Folder() in
 // this file.  Don't copy/paste.  I mean it.
 char* AppleDataDirectory();
 char* AppleTempDirectory();
 void AppleAppName(rtc::Pathname* path);
 #endif
 
 namespace rtc {
 
 #if !defined(WEBRTC_ANDROID) && !defined(WEBRTC_MAC)
-char* UnixFilesystem::app_temp_path_ = NULL;
+char* UnixFilesystem::app_temp_path_ = nullptr;
 #else
-char* UnixFilesystem::provided_app_data_folder_ = NULL;
-char* UnixFilesystem::provided_app_temp_folder_ = NULL;
+char* UnixFilesystem::provided_app_data_folder_ = nullptr;
+char* UnixFilesystem::provided_app_temp_folder_ = nullptr;
 
 void UnixFilesystem::SetAppDataFolder(const std::string& folder) {
   delete [] provided_app_data_folder_;
   provided_app_data_folder_ = CopyString(folder);
 }
 
 void UnixFilesystem::SetAppTempFolder(const std::string& folder) {
   delete [] provided_app_temp_folder_;
   provided_app_temp_folder_ = CopyString(folder);
 }
@@ skipping 39 matching lines @@
   return (0 == ::mkdir(pathname.c_str(), mode));
 }
 
 bool UnixFilesystem::CreateFolder(const Pathname &path) {
   return CreateFolder(path, 0755);
 }
 
 FileStream *UnixFilesystem::OpenFile(const Pathname &filename,
                                      const std::string &mode) {
   FileStream *fs = new FileStream();
-  if (fs && !fs->Open(filename.pathname().c_str(), mode.c_str(), NULL)) {
+  if (fs && !fs->Open(filename.pathname().c_str(), mode.c_str(), nullptr)) {
     delete fs;
-    fs = NULL;
+    fs = nullptr;
   }
   return fs;
 }
 
 bool UnixFilesystem::DeleteFile(const Pathname &filename) {
   LOG(LS_INFO) << "Deleting file:" << filename.pathname();
 
   if (!IsFile(filename)) {
     RTC_DCHECK(IsFile(filename));
     return false;
   }
   return ::unlink(filename.pathname().c_str()) == 0;
 }
 
 bool UnixFilesystem::DeleteEmptyFolder(const Pathname &folder) {
   LOG(LS_INFO) << "Deleting folder" << folder.pathname();
 
   if (!IsFolder(folder)) {
     RTC_DCHECK(IsFolder(folder));
     return false;
   }
   std::string no_slash(folder.pathname(), 0, folder.pathname().length()-1);
   return ::rmdir(no_slash.c_str()) == 0;
 }
 
 bool UnixFilesystem::GetTemporaryFolder(Pathname &pathname, bool create,
                                         const std::string *append) {
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_MAC)
-  RTC_DCHECK(provided_app_temp_folder_ != NULL);
+  RTC_DCHECK(provided_app_temp_folder_ != nullptr);
   pathname.SetPathname(provided_app_temp_folder_, "");
 #else
   if (const char* tmpdir = getenv("TMPDIR")) {
     pathname.SetPathname(tmpdir, "");
   } else if (const char* tmp = getenv("TMP")) {
     pathname.SetPathname(tmp, "");
   } else {
 #ifdef P_tmpdir
     pathname.SetPathname(P_tmpdir, "");
 #else  // !P_tmpdir
@@ skipping 60 matching lines @@
   StreamInterface *source = OpenFile(old_path, "rb");
   if (!source)
     return false;
 
   StreamInterface *dest = OpenFile(new_path, "wb");
   if (!dest) {
     delete source;
     return false;
   }
 
-  while (source->Read(buf, sizeof(buf), &len, NULL) == SR_SUCCESS)
-    dest->Write(buf, len, NULL, NULL);
+  while (source->Read(buf, sizeof(buf), &len, nullptr) == SR_SUCCESS)
+    dest->Write(buf, len, nullptr, nullptr);
 
   delete source;
   delete dest;
   return true;
 }
 
 bool UnixFilesystem::IsTemporaryPath(const Pathname& pathname) {
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_MAC)
-  RTC_DCHECK(provided_app_temp_folder_ != NULL);
+  RTC_DCHECK(provided_app_temp_folder_ != nullptr);
 #endif
 
   const char* const kTempPrefixes[] = {
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_MAC)
     provided_app_temp_folder_,
 #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
     "/private/tmp/", "/private/var/tmp/", "/private/var/folders/",
 #endif  // WEBRTC_MAC && !defined(WEBRTC_IOS)
 #else
     "/tmp/", "/var/tmp/",
@@ skipping 46 matching lines @@
     *time = st.st_atime;
     break;
   default:
     return false;
   }
   return true;
 }
 
 bool UnixFilesystem::GetAppTempFolder(Pathname* path) {
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_MAC)
-  RTC_DCHECK(provided_app_temp_folder_ != NULL);
+  RTC_DCHECK(provided_app_temp_folder_ != nullptr);
   path->SetPathname(provided_app_temp_folder_);
   return true;
 #else
   RTC_DCHECK(!application_name_.empty());
   // TODO: Consider whether we are worried about thread safety.
-  if (app_temp_path_ != NULL && strlen(app_temp_path_) > 0) {
+  if (app_temp_path_ != nullptr && strlen(app_temp_path_) > 0) {
     path->SetPathname(app_temp_path_);
     return true;
   }
 
   // Create a random directory as /tmp/<appname>-<pid>-<timestamp>
   char buffer[128];
   sprintfn(buffer, arraysize(buffer), "-%d-%d",
            static_cast<int>(getpid()),
            static_cast<int>(time(0)));
   std::string folder(application_name_);
   folder.append(buffer);
   if (!GetTemporaryFolder(*path, true, &folder))
     return false;
 
   delete [] app_temp_path_;
   app_temp_path_ = CopyString(path->pathname());
   // TODO: atexit(DeleteFolderAndContents(app_temp_path_));
   return true;
 #endif
 }
 
 char* UnixFilesystem::CopyString(const std::string& str) {
   size_t size = str.length() + 1;
 
   char* buf = new char[size];
   if (!buf) {
-    return NULL;
+    return nullptr;
   }
 
   strcpyn(buf, size, str.c_str());
   return buf;
 }
 
 }  // namespace rtc
 
 #if defined(__native_client__)
 extern "C" int __attribute__((weak))
 link(const char* oldpath, const char* newpath) {
   errno = EACCES;
   return -1;
 }
 #endif