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

webrtc/base/stream.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 60 matching lines @@
   if (read)
     *read = total_read;
   return result;
 }
 
 StreamResult StreamInterface::ReadLine(std::string* line) {
   line->clear();
   StreamResult result = SR_SUCCESS;
   while (true) {
     char ch;
-    result = Read(&ch, sizeof(ch), NULL, NULL);
+    result = Read(&ch, sizeof(ch), nullptr, nullptr);
     if (result != SR_SUCCESS) {
       break;
     }
     if (ch == '\n') {
       break;
     }
     line->push_back(ch);
   }
   if (!line->empty()) {   // give back the line we've collected so far with
     result = SR_SUCCESS;  // a success code.  Otherwise return the last code
   }
   return result;
 }
 
 void StreamInterface::PostEvent(Thread* t, int events, int err) {
   t->Post(RTC_FROM_HERE, this, MSG_POST_EVENT,
           new StreamEventData(events, err));
 }
 
 void StreamInterface::PostEvent(int events, int err) {
   PostEvent(Thread::Current(), events, err);
 }
 
 const void* StreamInterface::GetReadData(size_t* data_len) {
-  return NULL;
+  return nullptr;
 }
 
 void* StreamInterface::GetWriteBuffer(size_t* buf_len) {
-  return NULL;
+  return nullptr;
 }
 
 bool StreamInterface::SetPosition(size_t position) {
   return false;
 }
 
 bool StreamInterface::GetPosition(size_t* position) const {
   return false;
 }
 
@@ skipping 28 matching lines @@
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // StreamAdapterInterface
 ///////////////////////////////////////////////////////////////////////////////
 
 StreamAdapterInterface::StreamAdapterInterface(StreamInterface* stream,
                                                bool owned)
     : stream_(stream), owned_(owned) {
-  if (NULL != stream_)
+  if (nullptr != stream_)
     stream_->SignalEvent.connect(this, &StreamAdapterInterface::OnEvent);
 }
 
 StreamState StreamAdapterInterface::GetState() const {
   return stream_->GetState();
 }
 StreamResult StreamAdapterInterface::Read(void* buffer,
                                           size_t buffer_len,
                                           size_t* read,
                                           int* error) {
@@ skipping 31 matching lines @@
 
 bool StreamAdapterInterface::ReserveSize(size_t size) {
   return stream_->ReserveSize(size);
 }
 
 bool StreamAdapterInterface::Flush() {
   return stream_->Flush();
 }
 
 void StreamAdapterInterface::Attach(StreamInterface* stream, bool owned) {
-  if (NULL != stream_)
+  if (nullptr != stream_)
     stream_->SignalEvent.disconnect(this);
   if (owned_)
     delete stream_;
   stream_ = stream;
   owned_ = owned;
-  if (NULL != stream_)
+  if (nullptr != stream_)
     stream_->SignalEvent.connect(this, &StreamAdapterInterface::OnEvent);
 }
 
 StreamInterface* StreamAdapterInterface::Detach() {
-  if (NULL != stream_)
+  if (nullptr != stream_)
     stream_->SignalEvent.disconnect(this);
   StreamInterface* stream = stream_;
-  stream_ = NULL;
+  stream_ = nullptr;
   return stream;
 }
 
 StreamAdapterInterface::~StreamAdapterInterface() {
   if (owned_)
     delete stream_;
 }
 
 void StreamAdapterInterface::OnEvent(StreamInterface* stream,
                                      int events,
@@ skipping 30 matching lines @@
 
 StreamResult StreamTap::Read(void* buffer, size_t buffer_len,
                              size_t* read, int* error) {
   size_t backup_read;
   if (!read) {
     read = &backup_read;
   }
   StreamResult res = StreamAdapterInterface::Read(buffer, buffer_len,
                                                   read, error);
   if ((res == SR_SUCCESS) && (tap_result_ == SR_SUCCESS)) {
-    tap_result_ = tap_->WriteAll(buffer, *read, NULL, &tap_error_);
+    tap_result_ = tap_->WriteAll(buffer, *read, nullptr, &tap_error_);
   }
   return res;
 }
 
 StreamResult StreamTap::Write(const void* data, size_t data_len,
                               size_t* written, int* error) {
   size_t backup_written;
   if (!written) {
     written = &backup_written;
   }
   StreamResult res = StreamAdapterInterface::Write(data, data_len,
                                                    written, error);
   if ((res == SR_SUCCESS) && (tap_result_ == SR_SUCCESS)) {
-    tap_result_ = tap_->WriteAll(data, *written, NULL, &tap_error_);
+    tap_result_ = tap_->WriteAll(data, *written, nullptr, &tap_error_);
   }
   return res;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // NullStream
 ///////////////////////////////////////////////////////////////////////////////
 
 NullStream::NullStream() {
 }
@@ skipping 17 matching lines @@
   return SR_SUCCESS;
 }
 
 void NullStream::Close() {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // FileStream
 ///////////////////////////////////////////////////////////////////////////////
 
-FileStream::FileStream() : file_(NULL) {
-}
+FileStream::FileStream() : file_(nullptr) {}
 
 FileStream::~FileStream() {
   FileStream::Close();
 }
 
 bool FileStream::Open(const std::string& filename, const char* mode,
                       int* error) {
   Close();
 #if defined(WEBRTC_WIN)
   std::wstring wfilename;
   if (Utf8ToWindowsFilename(filename, &wfilename)) {
     file_ = _wfopen(wfilename.c_str(), ToUtf16(mode).c_str());
   } else {
     if (error) {
       *error = -1;
       return false;
     }
   }
 #else
   file_ = fopen(filename.c_str(), mode);
 #endif
   if (!file_ && error) {
     *error = errno;
   }
-  return (file_ != NULL);
+  return (file_ != nullptr);
 }
 
 bool FileStream::OpenShare(const std::string& filename, const char* mode,
                            int shflag, int* error) {
   Close();
 #if defined(WEBRTC_WIN)
   std::wstring wfilename;
   if (Utf8ToWindowsFilename(filename, &wfilename)) {
     file_ = _wfsopen(wfilename.c_str(), ToUtf16(mode).c_str(), shflag);
     if (!file_ && error) {
       *error = errno;
       return false;
     }
-    return file_ != NULL;
+    return file_ != nullptr;
   } else {
     if (error) {
       *error = -1;
     }
     return false;
   }
 #else
   return Open(filename, mode, error);
 #endif
 }
 
 bool FileStream::DisableBuffering() {
   if (!file_)
     return false;
-  return (setvbuf(file_, NULL, _IONBF, 0) == 0);
+  return (setvbuf(file_, nullptr, _IONBF, 0) == 0);
 }
 
 StreamState FileStream::GetState() const {
-  return (file_ == NULL) ? SS_CLOSED : SS_OPEN;
+  return (file_ == nullptr) ? SS_CLOSED : SS_OPEN;
 }
 
 StreamResult FileStream::Read(void* buffer, size_t buffer_len,
                               size_t* read, int* error) {
   if (!file_)
     return SR_EOS;
   size_t result = fread(buffer, 1, buffer_len, file_);
   if ((result == 0) && (buffer_len > 0)) {
     if (feof(file_))
       return SR_EOS;
@@ skipping 17 matching lines @@
     return SR_ERROR;
   }
   if (written)
     *written = result;
   return SR_SUCCESS;
 }
 
 void FileStream::Close() {
   if (file_) {
     DoClose();
-    file_ = NULL;
+    file_ = nullptr;
   }
 }
 
 bool FileStream::SetPosition(size_t position) {
   if (!file_)
     return false;
   return (fseek(file_, static_cast<int>(position), SEEK_SET) == 0);
 }
 
 bool FileStream::GetPosition(size_t* position) const {
-  RTC_DCHECK(NULL != position);
+  RTC_DCHECK(nullptr != position);
   if (!file_)
     return false;
   long result = ftell(file_);
   if (result < 0)
     return false;
   if (position)
     *position = result;
   return true;
 }
 
 bool FileStream::GetSize(size_t* size) const {
-  RTC_DCHECK(NULL != size);
+  RTC_DCHECK(nullptr != size);
   if (!file_)
     return false;
   struct stat file_stats;
   if (fstat(fileno(file_), &file_stats) != 0)
     return false;
   if (size)
     *size = file_stats.st_size;
   return true;
 }
 
 bool FileStream::GetAvailable(size_t* size) const {
-  RTC_DCHECK(NULL != size);
+  RTC_DCHECK(nullptr != size);
   if (!GetSize(size))
     return false;
   long result = ftell(file_);
   if (result < 0)
     return false;
   if (size)
     *size -= result;
   return true;
 }
 
@@ skipping 15 matching lines @@
     return (0 == fflush(file_));
   }
   // try to flush empty file?
   RTC_NOTREACHED();
   return false;
 }
 
 #if defined(WEBRTC_POSIX) && !defined(__native_client__)
 
 bool FileStream::TryLock() {
-  if (file_ == NULL) {
+  if (file_ == nullptr) {
     // Stream not open.
     RTC_NOTREACHED();
     return false;
   }
 
   return flock(fileno(file_), LOCK_EX|LOCK_NB) == 0;
 }
 
 bool FileStream::Unlock() {
-  if (file_ == NULL) {
+  if (file_ == nullptr) {
     // Stream not open.
     RTC_NOTREACHED();
     return false;
   }
 
   return flock(fileno(file_), LOCK_UN) == 0;
 }
 
 #endif
 
 void FileStream::DoClose() {
   fclose(file_);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // MemoryStream
 ///////////////////////////////////////////////////////////////////////////////
 
 MemoryStreamBase::MemoryStreamBase()
-  : buffer_(NULL), buffer_length_(0), data_length_(0),
-    seek_position_(0) {
-}
+    : buffer_(nullptr), buffer_length_(0), data_length_(0), seek_position_(0) {}
 
 StreamState MemoryStreamBase::GetState() const {
   return SS_OPEN;
 }
 
 StreamResult MemoryStreamBase::Read(void* buffer, size_t bytes,
                                     size_t* bytes_read, int* error) {
   if (seek_position_ >= data_length_) {
     return SR_EOS;
   }
@@ skipping 64 matching lines @@
   return true;
 }
 
 bool MemoryStreamBase::GetAvailable(size_t* size) const {
   if (size)
     *size = data_length_ - seek_position_;
   return true;
 }
 
 bool MemoryStreamBase::ReserveSize(size_t size) {
-  return (SR_SUCCESS == DoReserve(size, NULL));
+  return (SR_SUCCESS == DoReserve(size, nullptr));
 }
 
 StreamResult MemoryStreamBase::DoReserve(size_t size, int* error) {
   return (buffer_length_ >= size) ? SR_SUCCESS : SR_EOS;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-MemoryStream::MemoryStream()
-  : buffer_alloc_(NULL) {
-}
+MemoryStream::MemoryStream() : buffer_alloc_(nullptr) {}
 
-MemoryStream::MemoryStream(const char* data)
-  : buffer_alloc_(NULL) {
+MemoryStream::MemoryStream(const char* data) : buffer_alloc_(nullptr) {
   SetData(data, strlen(data));
 }
 
 MemoryStream::MemoryStream(const void* data, size_t length)
-  : buffer_alloc_(NULL) {
+    : buffer_alloc_(nullptr) {
   SetData(data, length);
 }
 
 MemoryStream::~MemoryStream() {
   delete [] buffer_alloc_;
 }
 
 void MemoryStream::SetData(const void* data, size_t length) {
   data_length_ = buffer_length_ = length;
   delete [] buffer_alloc_;
@@ skipping 169 matching lines @@
   read_position_ = (read_position_ + size) % buffer_length_;
   data_length_ -= size;
   if (!was_writable && size > 0) {
     PostEvent(owner_, SE_WRITE, 0);
   }
 }
 
 void* FifoBuffer::GetWriteBuffer(size_t* size) {
   CritScope cs(&crit_);
   if (state_ == SS_CLOSED) {
-    return NULL;
+    return nullptr;
   }
 
   // if empty, reset the write position to the beginning, so we can get
   // the biggest possible block
   if (data_length_ == 0) {
     read_position_ = 0;
   }
 
   const size_t write_position = (read_position_ + data_length_)
       % buffer_length_;
@@ skipping 103 matching lines @@
   StreamResult result = StreamAdapterInterface::Write(data, data_len, written,
                                                       error);
   if (result == SR_SUCCESS) {
     LogMultiline(level_, label_.c_str(), false, data, *written, hex_mode_,
                  &lms_);
   }
   return result;
 }
 
 void LoggingAdapter::Close() {
-  LogMultiline(level_, label_.c_str(), false, NULL, 0, hex_mode_, &lms_);
-  LogMultiline(level_, label_.c_str(), true, NULL, 0, hex_mode_, &lms_);
+  LogMultiline(level_, label_.c_str(), false, nullptr, 0, hex_mode_, &lms_);
+  LogMultiline(level_, label_.c_str(), true, nullptr, 0, hex_mode_, &lms_);
   LOG_V(level_) << label_ << " Closed locally";
   StreamAdapterInterface::Close();
 }
 
 void LoggingAdapter::OnEvent(StreamInterface* stream, int events, int err) {
   if (events & SE_OPEN) {
     LOG_V(level_) << label_ << " Open";
   } else if (events & SE_CLOSE) {
-    LogMultiline(level_, label_.c_str(), false, NULL, 0, hex_mode_, &lms_);
-    LogMultiline(level_, label_.c_str(), true, NULL, 0, hex_mode_, &lms_);
+    LogMultiline(level_, label_.c_str(), false, nullptr, 0, hex_mode_, &lms_);
+    LogMultiline(level_, label_.c_str(), true, nullptr, 0, hex_mode_, &lms_);
     LOG_V(level_) << label_ << " Closed with error: " << err;
   }
   StreamAdapterInterface::OnEvent(stream, events, err);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // StringStream - Reads/Writes to an external std::string
 ///////////////////////////////////////////////////////////////////////////////
 
 StringStream::StringStream(std::string* str)
@@ skipping 91 matching lines @@
 
 StreamReference::StreamReference(StreamRefCount* stream_ref_count,
                                  StreamInterface* stream)
     : StreamAdapterInterface(stream, false),
       stream_ref_count_(stream_ref_count) {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 StreamResult Flow(StreamInterface* source,
-                  char* buffer, size_t buffer_len,
+                  char* buffer,
+                  size_t buffer_len,
                   StreamInterface* sink,
-                  size_t* data_len /* = NULL */) {
+                  size_t* data_len /* = nullptr */) {
   RTC_DCHECK(buffer_len > 0);
 
   StreamResult result;
   size_t count, read_pos, write_pos;
   if (data_len) {
     read_pos = *data_len;
   } else {
     read_pos = 0;
   }
 
   bool end_of_stream = false;
   do {
     // Read until buffer is full, end of stream, or error
     while (!end_of_stream && (read_pos < buffer_len)) {
-      result = source->Read(buffer + read_pos, buffer_len - read_pos,
-                            &count, NULL);
+      result = source->Read(buffer + read_pos, buffer_len - read_pos, &count,
+                            nullptr);
       if (result == SR_EOS) {
         end_of_stream = true;
       } else if (result != SR_SUCCESS) {
         if (data_len) {
           *data_len = read_pos;
         }
         return result;
       } else {
         read_pos += count;
       }
     }
 
     // Write until buffer is empty, or error (including end of stream)
     write_pos = 0;
     while (write_pos < read_pos) {
-      result = sink->Write(buffer + write_pos, read_pos - write_pos,
-                           &count, NULL);
+      result = sink->Write(buffer + write_pos, read_pos - write_pos, &count,
+                           nullptr);
       if (result != SR_SUCCESS) {
         if (data_len) {
           *data_len = read_pos - write_pos;
           if (write_pos > 0) {
             memmove(buffer, buffer + write_pos, *data_len);
           }
         }
         return result;
       }
       write_pos += count;
     }
 
     read_pos = 0;
   } while (!end_of_stream);
 
   if (data_len) {
     *data_len = 0;
   }
   return SR_SUCCESS;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 }  // namespace rtc