Replace NULL with nullptr in all C++ files.

webrtc/voice_engine/channel.cc

 /*
  *  Copyright (c) 2012 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 442 matching lines @@
 }
 
 bool Channel::SendRtp(const uint8_t* data,
                       size_t len,
                       const PacketOptions& options) {
   WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SendPacket(channel=%d, len=%" PRIuS ")", len);
 
   rtc::CritScope cs(&_callbackCritSect);
 
-  if (_transportPtr == NULL) {
+  if (_transportPtr == nullptr) {
     WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId, _channelId),
                  "Channel::SendPacket() failed to send RTP packet due to"
                  " invalid transport object");
     return false;
   }
 
   uint8_t* bufferToSendPtr = (uint8_t*)data;
   size_t bufferLength = len;
 
   if (!_transportPtr->SendRtp(bufferToSendPtr, bufferLength, options)) {
     std::string transport_name =
         _externalTransport ? "external transport" : "WebRtc sockets";
     WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId, _channelId),
                  "Channel::SendPacket() RTP transmission using %s failed",
                  transport_name.c_str());
     return false;
   }
   return true;
 }
 
 bool Channel::SendRtcp(const uint8_t* data, size_t len) {
   WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SendRtcp(len=%" PRIuS ")", len);
 
   rtc::CritScope cs(&_callbackCritSect);
-  if (_transportPtr == NULL) {
+  if (_transportPtr == nullptr) {
     WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId, _channelId),
                  "Channel::SendRtcp() failed to send RTCP packet"
                  " due to invalid transport object");
     return false;
   }
 
   uint8_t* bufferToSendPtr = (uint8_t*)data;
   size_t bufferLength = len;
 
   int n = _transportPtr->SendRtcp(bufferToSendPtr, bufferLength);
@@ skipping 82 matching lines @@
   // Push the incoming payload (parsed and ready for decoding) into the ACM
   if (audio_coding_->IncomingPacket(payloadData, payloadSize, *rtpHeader) !=
       0) {
     _engineStatisticsPtr->SetLastError(
         VE_AUDIO_CODING_MODULE_ERROR, kTraceWarning,
         "Channel::OnReceivedPayloadData() unable to push data to the ACM");
     return -1;
   }
 
   int64_t round_trip_time = 0;
-  _rtpRtcpModule->RTT(rtp_receiver_->SSRC(), &round_trip_time, NULL, NULL,
-                      NULL);
+  _rtpRtcpModule->RTT(rtp_receiver_->SSRC(), &round_trip_time, nullptr, nullptr,
+                      nullptr);
 
   std::vector<uint16_t> nack_list = audio_coding_->GetNackList(round_trip_time);
   if (!nack_list.empty()) {
     // Can't use nack_list.data() since it's not supported by all
     // compilers.
     ResendPackets(&(nack_list[0]), static_cast<int>(nack_list.size()));
   }
   return 0;
 }
 
@@ skipping 215 matching lines @@
 int32_t Channel::CreateChannel(
     Channel*& channel,
     int32_t channelId,
     uint32_t instanceId,
     const VoEBase::ChannelConfig& config) {
   WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(instanceId, channelId),
                "Channel::CreateChannel(channelId=%d, instanceId=%d)", channelId,
                instanceId);
 
   channel = new Channel(channelId, instanceId, config);
-  if (channel == NULL) {
+  if (channel == nullptr) {
     WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(instanceId, channelId),
                  "Channel::CreateChannel() unable to allocate memory for"
                  " channel");
     return -1;
   }
   return 0;
 }
 
 void Channel::PlayNotification(int32_t id, uint32_t durationMs) {
   WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, _channelId),
@@ skipping 61 matching lines @@
       telephone_event_handler_(rtp_receiver_->GetTelephoneEventHandler()),
       _outputAudioLevel(),
       _externalTransport(false),
       // Avoid conflict with other channels by adding 1024 - 1026,
       // won't use as much as 1024 channels.
       _inputFilePlayerId(VoEModuleId(instanceId, channelId) + 1024),
       _outputFilePlayerId(VoEModuleId(instanceId, channelId) + 1025),
       _outputFileRecorderId(VoEModuleId(instanceId, channelId) + 1026),
       _outputFileRecording(false),
       _outputExternalMedia(false),
-      _inputExternalMediaCallbackPtr(NULL),
-      _outputExternalMediaCallbackPtr(NULL),
+      _inputExternalMediaCallbackPtr(nullptr),
+      _outputExternalMediaCallbackPtr(nullptr),
       _timeStamp(0),  // This is just an offset, RTP module will add it's own
                       // random offset
       ntp_estimator_(Clock::GetRealTimeClock()),
       playout_timestamp_rtp_(0),
       playout_timestamp_rtcp_(0),
       playout_delay_ms_(0),
       _numberOfDiscardedPackets(0),
       send_sequence_number_(0),
       rtp_ts_wraparound_handler_(new rtc::TimestampWrapAroundHandler()),
       capture_start_rtp_time_stamp_(-1),
       capture_start_ntp_time_ms_(-1),
-      _engineStatisticsPtr(NULL),
-      _outputMixerPtr(NULL),
-      _transmitMixerPtr(NULL),
-      _moduleProcessThreadPtr(NULL),
-      _audioDeviceModulePtr(NULL),
-      _voiceEngineObserverPtr(NULL),
-      _callbackCritSectPtr(NULL),
-      _transportPtr(NULL),
+      _engineStatisticsPtr(nullptr),
+      _outputMixerPtr(nullptr),
+      _transmitMixerPtr(nullptr),
+      _moduleProcessThreadPtr(nullptr),
+      _audioDeviceModulePtr(nullptr),
+      _voiceEngineObserverPtr(nullptr),
+      _callbackCritSectPtr(nullptr),
+      _transportPtr(nullptr),
       _sendFrameType(0),
       _externalMixing(false),
       _mixFileWithMicrophone(false),
       input_mute_(false),
       previous_frame_muted_(false),
       _panLeft(1.0f),
       _panRight(1.0f),
       _outputGain(1.0f),
       _lastLocalTimeStamp(0),
       _lastPayloadType(0),
@@ skipping 39 matching lines @@
 
   _rtpRtcpModule.reset(RtpRtcp::CreateRtpRtcp(configuration));
   _rtpRtcpModule->SetSendingMediaStatus(false);
 
   statistics_proxy_.reset(new StatisticsProxy(_rtpRtcpModule->SSRC()));
   rtp_receive_statistics_->RegisterRtcpStatisticsCallback(
       statistics_proxy_.get());
 }
 
 Channel::~Channel() {
-  rtp_receive_statistics_->RegisterRtcpStatisticsCallback(NULL);
+  rtp_receive_statistics_->RegisterRtcpStatisticsCallback(nullptr);
   WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::~Channel() - dtor");
 
   if (_outputExternalMedia) {
     DeRegisterExternalMediaProcessing(kPlaybackPerChannel);
   }
   if (channel_state_.Get().input_external_media) {
     DeRegisterExternalMediaProcessing(kRecordingPerChannel);
   }
   StopSend();
   StopPlayout();
 
   {
     rtc::CritScope cs(&_fileCritSect);
     if (input_file_player_) {
-      input_file_player_->RegisterModuleFileCallback(NULL);
+      input_file_player_->RegisterModuleFileCallback(nullptr);
       input_file_player_->StopPlayingFile();
     }
     if (output_file_player_) {
-      output_file_player_->RegisterModuleFileCallback(NULL);
+      output_file_player_->RegisterModuleFileCallback(nullptr);
       output_file_player_->StopPlayingFile();
     }
     if (output_file_recorder_) {
-      output_file_recorder_->RegisterModuleFileCallback(NULL);
+      output_file_recorder_->RegisterModuleFileCallback(nullptr);
       output_file_recorder_->StopRecording();
     }
   }
 
   // The order to safely shutdown modules in a channel is:
   // 1. De-register callbacks in modules
   // 2. De-register modules in process thread
   // 3. Destroy modules
-  if (audio_coding_->RegisterTransportCallback(NULL) == -1) {
+  if (audio_coding_->RegisterTransportCallback(nullptr) == -1) {
     WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, _channelId),
                  "~Channel() failed to de-register transport callback"
                  " (Audio coding module)");
   }
-  if (audio_coding_->RegisterVADCallback(NULL) == -1) {
+  if (audio_coding_->RegisterVADCallback(nullptr) == -1) {
     WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, _channelId),
                  "~Channel() failed to de-register VAD callback"
                  " (Audio coding module)");
   }
   // De-register modules in process thread
   _moduleProcessThreadPtr->DeRegisterModule(_rtpRtcpModule.get());
 
   // End of modules shutdown
 }
 
 int32_t Channel::Init() {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::Init()");
 
   channel_state_.Reset();
 
   // --- Initial sanity
 
-  if ((_engineStatisticsPtr == NULL) || (_moduleProcessThreadPtr == NULL)) {
+  if ((_engineStatisticsPtr == nullptr) ||
+      (_moduleProcessThreadPtr == nullptr)) {
     WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId, _channelId),
                  "Channel::Init() must call SetEngineInformation() first");
     return -1;
   }
 
   // --- Add modules to process thread (for periodic schedulation)
 
   _moduleProcessThreadPtr->RegisterModule(_rtpRtcpModule.get());
 
   // --- ACM initialization
@@ skipping 245 matching lines @@
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::DeRegisterVoiceEngineObserver()");
   rtc::CritScope cs(&_callbackCritSect);
 
   if (!_voiceEngineObserverPtr) {
     _engineStatisticsPtr->SetLastError(
         VE_INVALID_OPERATION, kTraceWarning,
         "DeRegisterVoiceEngineObserver() observer already disabled");
     return 0;
   }
-  _voiceEngineObserverPtr = NULL;
+  _voiceEngineObserverPtr = nullptr;
   return 0;
 }
 
 int32_t Channel::GetSendCodec(CodecInst& codec) {
   auto send_codec = codec_manager_.GetCodecInst();
   if (send_codec) {
     codec = *send_codec;
     return 0;
   }
   return -1;
@@ skipping 298 matching lines @@
   if (_transportPtr) {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                  "DeRegisterExternalTransport() all transport is disabled");
   } else {
     _engineStatisticsPtr->SetLastError(
         VE_INVALID_OPERATION, kTraceWarning,
         "DeRegisterExternalTransport() external transport already "
         "disabled");
   }
   _externalTransport = false;
-  _transportPtr = NULL;
+  _transportPtr = nullptr;
   return 0;
 }
 
 int32_t Channel::ReceivedRTPPacket(const uint8_t* received_packet,
                                    size_t length,
                                    const PacketTime& packet_time) {
   WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::ReceivedRTPPacket()");
 
   // Store playout timestamp for the received RTP packet
@@ skipping 77 matching lines @@
                                     bool in_order) const {
   // Retransmissions are handled separately if RTX is enabled.
   if (rtp_payload_registry_->RtxEnabled())
     return false;
   StreamStatistician* statistician =
       rtp_receive_statistics_->GetStatistician(header.ssrc);
   if (!statistician)
     return false;
   // Check if this is a retransmission.
   int64_t min_rtt = 0;
-  _rtpRtcpModule->RTT(rtp_receiver_->SSRC(), NULL, NULL, &min_rtt, NULL);
+  _rtpRtcpModule->RTT(rtp_receiver_->SSRC(), nullptr, nullptr, &min_rtt,
+                      nullptr);
   return !in_order && statistician->IsRetransmitOfOldPacket(header, min_rtt);
 }
 
 int32_t Channel::ReceivedRTCPPacket(const uint8_t* data, size_t length) {
   WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::ReceivedRTCPPacket()");
   // Store playout timestamp for the received RTCP packet
   UpdatePlayoutTimestamp(true);
 
   // Deliver RTCP packet to RTP/RTCP module for parsing
@@ skipping 20 matching lines @@
   // Invoke audio encoders OnReceivedRtt().
   audio_coding_->ModifyEncoder([&](std::unique_ptr<AudioEncoder>* encoder) {
     if (*encoder)
       (*encoder)->OnReceivedRtt(rtt);
   });
 
   uint32_t ntp_secs = 0;
   uint32_t ntp_frac = 0;
   uint32_t rtp_timestamp = 0;
   if (0 !=
-      _rtpRtcpModule->RemoteNTP(&ntp_secs, &ntp_frac, NULL, NULL,
+      _rtpRtcpModule->RemoteNTP(&ntp_secs, &ntp_frac, nullptr, nullptr,
                                 &rtp_timestamp)) {
     // Waiting for RTCP.
     return 0;
   }
 
   {
     rtc::CritScope lock(&ts_stats_lock_);
     ntp_estimator_.UpdateRtcpTimestamp(rtt, ntp_secs, ntp_frac, rtp_timestamp);
   }
   return 0;
@@ skipping 17 matching lines @@
     _engineStatisticsPtr->SetLastError(
         VE_ALREADY_PLAYING, kTraceError,
         "StartPlayingFileLocally() is already playing");
     return -1;
   }
 
   {
     rtc::CritScope cs(&_fileCritSect);
 
     if (output_file_player_) {
-      output_file_player_->RegisterModuleFileCallback(NULL);
+      output_file_player_->RegisterModuleFileCallback(nullptr);
       output_file_player_.reset();
     }
 
     output_file_player_ = FilePlayer::CreateFilePlayer(
         _outputFilePlayerId, (const FileFormats)format);
 
     if (!output_file_player_) {
       _engineStatisticsPtr->SetLastError(
           VE_INVALID_ARGUMENT, kTraceError,
           "StartPlayingFileLocally() filePlayer format is not correct");
@@ skipping 26 matching lines @@
                                      FileFormats format,
                                      int startPosition,
                                      float volumeScaling,
                                      int stopPosition,
                                      const CodecInst* codecInst) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::StartPlayingFileLocally(format=%d,"
                " volumeScaling=%5.3f, startPosition=%d, stopPosition=%d)",
                format, volumeScaling, startPosition, stopPosition);
 
-  if (stream == NULL) {
+  if (stream == nullptr) {
     _engineStatisticsPtr->SetLastError(
         VE_BAD_FILE, kTraceError,
-        "StartPlayingFileLocally() NULL as input stream");
+        "StartPlayingFileLocally() null as input stream");
     return -1;
   }
 
   if (channel_state_.Get().output_file_playing) {
     _engineStatisticsPtr->SetLastError(
         VE_ALREADY_PLAYING, kTraceError,
         "StartPlayingFileLocally() is already playing");
     return -1;
   }
 
   {
     rtc::CritScope cs(&_fileCritSect);
 
     // Destroy the old instance
     if (output_file_player_) {
-      output_file_player_->RegisterModuleFileCallback(NULL);
+      output_file_player_->RegisterModuleFileCallback(nullptr);
       output_file_player_.reset();
     }
 
     // Create the instance
     output_file_player_ = FilePlayer::CreateFilePlayer(
         _outputFilePlayerId, (const FileFormats)format);
 
     if (!output_file_player_) {
       _engineStatisticsPtr->SetLastError(
           VE_INVALID_ARGUMENT, kTraceError,
@@ skipping 33 matching lines @@
 
   {
     rtc::CritScope cs(&_fileCritSect);
 
     if (output_file_player_->StopPlayingFile() != 0) {
       _engineStatisticsPtr->SetLastError(
           VE_STOP_RECORDING_FAILED, kTraceError,
           "StopPlayingFile() could not stop playing");
       return -1;
     }
-    output_file_player_->RegisterModuleFileCallback(NULL);
+    output_file_player_->RegisterModuleFileCallback(nullptr);
     output_file_player_.reset();
     channel_state_.SetOutputFilePlaying(false);
   }
   // _fileCritSect cannot be taken while calling
   // SetAnonymousMixibilityStatus. Refer to comments in
   // StartPlayingFileLocally(const char* ...) for more details.
   if (_outputMixerPtr->SetAnonymousMixabilityStatus(*this, false) != 0) {
     _engineStatisticsPtr->SetLastError(
         VE_AUDIO_CONF_MIX_MODULE_ERROR, kTraceError,
         "StopPlayingFile() failed to stop participant from playing as"
@@ skipping 53 matching lines @@
 
   if (channel_state_.Get().input_file_playing) {
     _engineStatisticsPtr->SetLastError(
         VE_ALREADY_PLAYING, kTraceWarning,
         "StartPlayingFileAsMicrophone() filePlayer is playing");
     return 0;
   }
 
   // Destroy the old instance
   if (input_file_player_) {
-    input_file_player_->RegisterModuleFileCallback(NULL);
+    input_file_player_->RegisterModuleFileCallback(nullptr);
     input_file_player_.reset();
   }
 
   // Create the instance
   input_file_player_ = FilePlayer::CreateFilePlayer(_inputFilePlayerId,
                                                     (const FileFormats)format);
 
   if (!input_file_player_) {
     _engineStatisticsPtr->SetLastError(
         VE_INVALID_ARGUMENT, kTraceError,
@@ skipping 23 matching lines @@
                                           FileFormats format,
                                           int startPosition,
                                           float volumeScaling,
                                           int stopPosition,
                                           const CodecInst* codecInst) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::StartPlayingFileAsMicrophone(format=%d, "
                "volumeScaling=%5.3f, startPosition=%d, stopPosition=%d)",
                format, volumeScaling, startPosition, stopPosition);
 
-  if (stream == NULL) {
+  if (stream == nullptr) {
     _engineStatisticsPtr->SetLastError(
         VE_BAD_FILE, kTraceError,
-        "StartPlayingFileAsMicrophone NULL as input stream");
+        "StartPlayingFileAsMicrophone null as input stream");
     return -1;
   }
 
   rtc::CritScope cs(&_fileCritSect);
 
   if (channel_state_.Get().input_file_playing) {
     _engineStatisticsPtr->SetLastError(
         VE_ALREADY_PLAYING, kTraceWarning,
         "StartPlayingFileAsMicrophone() is playing");
     return 0;
   }
 
   // Destroy the old instance
   if (input_file_player_) {
-    input_file_player_->RegisterModuleFileCallback(NULL);
+    input_file_player_->RegisterModuleFileCallback(nullptr);
     input_file_player_.reset();
   }
 
   // Create the instance
   input_file_player_ = FilePlayer::CreateFilePlayer(_inputFilePlayerId,
                                                     (const FileFormats)format);
 
   if (!input_file_player_) {
     _engineStatisticsPtr->SetLastError(
         VE_INVALID_ARGUMENT, kTraceError,
@@ skipping 29 matching lines @@
   if (!channel_state_.Get().input_file_playing) {
     return 0;
   }
 
   if (input_file_player_->StopPlayingFile() != 0) {
     _engineStatisticsPtr->SetLastError(
         VE_STOP_RECORDING_FAILED, kTraceError,
         "StopPlayingFile() could not stop playing");
     return -1;
   }
-  input_file_player_->RegisterModuleFileCallback(NULL);
+  input_file_player_->RegisterModuleFileCallback(nullptr);
   input_file_player_.reset();
   channel_state_.SetInputFilePlaying(false);
 
   return 0;
 }
 
 int Channel::IsPlayingFileAsMicrophone() const {
   return channel_state_.Get().input_file_playing;
 }
 
 int Channel::StartRecordingPlayout(const char* fileName,
                                    const CodecInst* codecInst) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::StartRecordingPlayout(fileName=%s)", fileName);
 
   if (_outputFileRecording) {
     WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
                  "StartRecordingPlayout() is already recording");
     return 0;
   }
 
   FileFormats format;
   const uint32_t notificationTime(0);  // Not supported in VoE
   CodecInst dummyCodec = {100, "L16", 16000, 320, 1, 320000};
 
-  if ((codecInst != NULL) &&
+  if ((codecInst != nullptr) &&
       ((codecInst->channels < 1) || (codecInst->channels > 2))) {
     _engineStatisticsPtr->SetLastError(
         VE_BAD_ARGUMENT, kTraceError,
         "StartRecordingPlayout() invalid compression");
     return (-1);
   }
-  if (codecInst == NULL) {
+  if (codecInst == nullptr) {
     format = kFileFormatPcm16kHzFile;
     codecInst = &dummyCodec;
   } else if ((STR_CASE_CMP(codecInst->plname, "L16") == 0) ||
              (STR_CASE_CMP(codecInst->plname, "PCMU") == 0) ||
              (STR_CASE_CMP(codecInst->plname, "PCMA") == 0)) {
     format = kFileFormatWavFile;
   } else {
     format = kFileFormatCompressedFile;
   }
 
   rtc::CritScope cs(&_fileCritSect);
 
   // Destroy the old instance
   if (output_file_recorder_) {
-    output_file_recorder_->RegisterModuleFileCallback(NULL);
+    output_file_recorder_->RegisterModuleFileCallback(nullptr);
     output_file_recorder_.reset();
   }
 
   output_file_recorder_ = FileRecorder::CreateFileRecorder(
       _outputFileRecorderId, (const FileFormats)format);
   if (!output_file_recorder_) {
     _engineStatisticsPtr->SetLastError(
         VE_INVALID_ARGUMENT, kTraceError,
         "StartRecordingPlayout() fileRecorder format isnot correct");
     return -1;
@@ skipping 22 matching lines @@
   if (_outputFileRecording) {
     WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
                  "StartRecordingPlayout() is already recording");
     return 0;
   }
 
   FileFormats format;
   const uint32_t notificationTime(0);  // Not supported in VoE
   CodecInst dummyCodec = {100, "L16", 16000, 320, 1, 320000};
 
-  if (codecInst != NULL && codecInst->channels != 1) {
+  if (codecInst != nullptr && codecInst->channels != 1) {
     _engineStatisticsPtr->SetLastError(
         VE_BAD_ARGUMENT, kTraceError,
         "StartRecordingPlayout() invalid compression");
     return (-1);
   }
-  if (codecInst == NULL) {
+  if (codecInst == nullptr) {
     format = kFileFormatPcm16kHzFile;
     codecInst = &dummyCodec;
   } else if ((STR_CASE_CMP(codecInst->plname, "L16") == 0) ||
              (STR_CASE_CMP(codecInst->plname, "PCMU") == 0) ||
              (STR_CASE_CMP(codecInst->plname, "PCMA") == 0)) {
     format = kFileFormatWavFile;
   } else {
     format = kFileFormatCompressedFile;
   }
 
   rtc::CritScope cs(&_fileCritSect);
 
   // Destroy the old instance
   if (output_file_recorder_) {
-    output_file_recorder_->RegisterModuleFileCallback(NULL);
+    output_file_recorder_->RegisterModuleFileCallback(nullptr);
     output_file_recorder_.reset();
   }
 
   output_file_recorder_ = FileRecorder::CreateFileRecorder(
       _outputFileRecorderId, (const FileFormats)format);
   if (!output_file_recorder_) {
     _engineStatisticsPtr->SetLastError(
         VE_INVALID_ARGUMENT, kTraceError,
         "StartRecordingPlayout() fileRecorder format isnot correct");
     return -1;
@@ skipping 26 matching lines @@
   }
 
   rtc::CritScope cs(&_fileCritSect);
 
   if (output_file_recorder_->StopRecording() != 0) {
     _engineStatisticsPtr->SetLastError(
         VE_STOP_RECORDING_FAILED, kTraceError,
         "StopRecording() could not stop recording");
     return (-1);
   }
-  output_file_recorder_->RegisterModuleFileCallback(NULL);
+  output_file_recorder_->RegisterModuleFileCallback(nullptr);
   output_file_recorder_.reset();
   _outputFileRecording = false;
 
   return 0;
 }
 
 void Channel::SetMixWithMicStatus(bool mix) {
   rtc::CritScope cs(&_fileCritSect);
   _mixFileWithMicrophone = mix;
 }
@@ skipping 207 matching lines @@
   if (_rtpRtcpModule->SetCNAME(cName) != 0) {
     _engineStatisticsPtr->SetLastError(
         VE_RTP_RTCP_MODULE_ERROR, kTraceError,
         "SetRTCP_CNAME() failed to set RTCP CNAME");
     return -1;
   }
   return 0;
 }
 
 int Channel::GetRemoteRTCP_CNAME(char cName[256]) {
-  if (cName == NULL) {
+  if (cName == nullptr) {
     _engineStatisticsPtr->SetLastError(
         VE_INVALID_ARGUMENT, kTraceError,
         "GetRemoteRTCP_CNAME() invalid CNAME input buffer");
     return -1;
   }
   char cname[RTCP_CNAME_SIZE];
   const uint32_t remoteSSRC = rtp_receiver_->SSRC();
   if (_rtpRtcpModule->RemoteCNAME(remoteSSRC, cname) != 0) {
     _engineStatisticsPtr->SetLastError(
         VE_CANNOT_RETRIEVE_CNAME, kTraceError,
@@ skipping 26 matching lines @@
   NTPHigh = senderInfo.NTPseconds;
   NTPLow = senderInfo.NTPfraction;
   timestamp = senderInfo.RTPtimeStamp;
 
   // --- Locally derived information
 
   // This value is updated on each incoming RTCP packet (0 when no packet
   // has been received)
   playoutTimestamp = playout_timestamp_rtcp_;
 
-  if (NULL != jitter || NULL != fractionLost) {
+  if (nullptr != jitter || nullptr != fractionLost) {
     // Get all RTCP receiver report blocks that have been received on this
     // channel. If we receive RTP packets from a remote source we know the
     // remote SSRC and use the report block from him.
     // Otherwise use the first report block.
     std::vector<RTCPReportBlock> remote_stats;
     if (_rtpRtcpModule->RemoteRTCPStat(&remote_stats) != 0 ||
         remote_stats.empty()) {
       WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, _channelId),
                    "GetRemoteRTCPData() failed to measure statistics due"
                    " to lack of received RTP and/or RTCP packets");
@@ skipping 32 matching lines @@
     const char* data,
     unsigned short dataLengthInBytes) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SendApplicationDefinedRTCPPacket()");
   if (!channel_state_.Get().sending) {
     _engineStatisticsPtr->SetLastError(
         VE_NOT_SENDING, kTraceError,
         "SendApplicationDefinedRTCPPacket() not sending");
     return -1;
   }
-  if (NULL == data) {
+  if (nullptr == data) {
     _engineStatisticsPtr->SetLastError(
         VE_INVALID_ARGUMENT, kTraceError,
         "SendApplicationDefinedRTCPPacket() invalid data value");
     return -1;
   }
   if (dataLengthInBytes % 4 != 0) {
     _engineStatisticsPtr->SetLastError(
         VE_INVALID_ARGUMENT, kTraceError,
         "SendApplicationDefinedRTCPPacket() invalid length value");
     return -1;
@@ skipping 43 matching lines @@
     averageJitterMs = stats.rtcp.jitter / (playoutFrequency / 1000);
   }
 
   discardedPackets = _numberOfDiscardedPackets;
 
   return 0;
 }
 
 int Channel::GetRemoteRTCPReportBlocks(
     std::vector<ReportBlock>* report_blocks) {
-  if (report_blocks == NULL) {
+  if (report_blocks == nullptr) {
     _engineStatisticsPtr->SetLastError(
         VE_INVALID_ARGUMENT, kTraceError,
         "GetRemoteRTCPReportBlock()s invalid report_blocks.");
     return -1;
   }
 
   // Get the report blocks from the latest received RTCP Sender or Receiver
   // Report. Each element in the vector contains the sender's SSRC and a
   // report block according to RFC 3550.
   std::vector<RTCPReportBlock> rtcp_report_blocks;
@@ skipping 209 matching lines @@
   rtc::CritScope lock(&assoc_send_channel_lock_);
   associate_send_channel_ = channel;
 }
 
 void Channel::DisassociateSendChannel(int channel_id) {
   rtc::CritScope lock(&assoc_send_channel_lock_);
   Channel* channel = associate_send_channel_.channel();
   if (channel && channel->ChannelId() == channel_id) {
     // If this channel is associated with a send channel of the specified
     // Channel ID, disassociate with it.
-    ChannelOwner ref(NULL);
+    ChannelOwner ref(nullptr);
     associate_send_channel_ = ref;
   }
 }
 
 void Channel::SetRtcEventLog(RtcEventLog* event_log) {
   event_log_proxy_->SetEventLog(event_log);
 }
 
 void Channel::SetRtcpRttStats(RtcpRttStats* rtcp_rtt_stats) {
   rtcp_rtt_stats_proxy_->SetRtcpRttStats(rtcp_rtt_stats);
@@ skipping 57 matching lines @@
 
   if (kPlaybackPerChannel == type) {
     if (!_outputExternalMediaCallbackPtr) {
       _engineStatisticsPtr->SetLastError(
           VE_INVALID_OPERATION, kTraceWarning,
           "Channel::DeRegisterExternalMediaProcessing() "
           "output external media already disabled");
       return 0;
     }
     _outputExternalMedia = false;
-    _outputExternalMediaCallbackPtr = NULL;
+    _outputExternalMediaCallbackPtr = nullptr;
   } else if (kRecordingPerChannel == type) {
     if (!_inputExternalMediaCallbackPtr) {
       _engineStatisticsPtr->SetLastError(
           VE_INVALID_OPERATION, kTraceWarning,
           "Channel::DeRegisterExternalMediaProcessing() "
           "input external media already disabled");
       return 0;
     }
     channel_state_.SetInputExternalMedia(false);
-    _inputExternalMediaCallbackPtr = NULL;
+    _inputExternalMediaCallbackPtr = nullptr;
   }
 
   return 0;
 }
 
 int Channel::SetExternalMixing(bool enabled) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SetExternalMixing(enabled=%d)", enabled);
 
   if (channel_state_.Get().playing) {
@@ skipping 328 matching lines @@
   int64_t min_rtt = 0;
   if (_rtpRtcpModule->RTT(remoteSSRC, &rtt, &avg_rtt, &min_rtt, &max_rtt) !=
       0) {
     return 0;
   }
   return rtt;
 }
 
 }  // namespace voe
 }  // namespace webrtc