Replace NULL with nullptr in all C++ files.

webrtc/pc/channel.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 107 matching lines @@
 static bool IsReceiveContentDirection(MediaContentDirection direction) {
   return direction == MD_SENDRECV || direction == MD_RECVONLY;
 }
 
 static bool IsSendContentDirection(MediaContentDirection direction) {
   return direction == MD_SENDRECV || direction == MD_SENDONLY;
 }
 
 static const MediaContentDescription* GetContentDescription(
     const ContentInfo* cinfo) {
-  if (cinfo == NULL)
-    return NULL;
+  if (cinfo == nullptr)
+    return nullptr;
   return static_cast<const MediaContentDescription*>(cinfo->description);
 }
 
 template <class Codec>
 void RtpParametersFromMediaDescription(
     const MediaContentDescriptionImpl<Codec>* desc,
     RtpParameters<Codec>* params) {
   // TODO(pthatcher): Remove this once we're sure no one will give us
   // a description without codecs (currently a CA_UPDATE with just
   // streams can).
@@ skipping 37 matching lines @@
 
 BaseChannel::~BaseChannel() {
   TRACE_EVENT0("webrtc", "BaseChannel::~BaseChannel");
   RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
   Deinit();
   StopConnectionMonitor();
   // Eats any outstanding messages or packets.
   worker_thread_->Clear(&invoker_);
   worker_thread_->Clear(this);
   // We must destroy the media channel before the transport channel, otherwise
-  // the media channel may try to send on the dead transport channel. NULLing
+  // the media channel may try to send on the dead transport channel. nulling
   // is not an effective strategy since the sends will come on another thread.
   delete media_channel_;
   LOG(LS_INFO) << "Destroyed channel: " << content_name_;
 }
 
 void BaseChannel::DisconnectTransportChannels_n() {
   // Send any outstanding RTCP packets.
   FlushRtcpMessages_n();
 
   // Stop signals from transport channels, but keep them alive because
@@ skipping 49 matching lines @@
     return false;
   }
   if (rtcp_mux_required_) {
     rtcp_mux_filter_.SetActive();
   }
   return true;
 }
 
 void BaseChannel::Deinit() {
   RTC_DCHECK(worker_thread_->IsCurrent());
-  media_channel_->SetInterface(NULL);
+  media_channel_->SetInterface(nullptr);
   // Packets arrive on the network thread, processing packets calls virtual
   // functions, so need to stop this process in Deinit that is called in
   // derived classes destructor.
   network_thread_->Invoke<void>(
       RTC_FROM_HERE, Bind(&BaseChannel::DisconnectTransportChannels_n, this));
 }
 
 void BaseChannel::SetTransports(DtlsTransportInternal* rtp_dtls_transport,
                                 DtlsTransportInternal* rtcp_dtls_transport) {
   network_thread_->Invoke<void>(
@@ skipping 472 matching lines @@
       res = srtp_filter_.ProtectRtp(
           data, len, static_cast<int>(packet->capacity()), &len);
 #else
       updated_options.packet_time_params.rtp_sendtime_extension_id =
           rtp_abs_sendtime_extn_id_;
       res = srtp_filter_.ProtectRtp(
           data, len, static_cast<int>(packet->capacity()), &len,
           &updated_options.packet_time_params.srtp_packet_index);
       // If protection succeeds, let's get auth params from srtp.
       if (res) {
-        uint8_t* auth_key = NULL;
+        uint8_t* auth_key = nullptr;
         int key_len;
         res = srtp_filter_.GetRtpAuthParams(
             &auth_key, &key_len,
             &updated_options.packet_time_params.srtp_auth_tag_len);
         if (res) {
           updated_options.packet_time_params.srtp_auth_key.resize(key_len);
           updated_options.packet_time_params.srtp_auth_key.assign(
               auth_key, auth_key + key_len);
         }
       }
@@ skipping 283 matching lines @@
   if (!rtc::GetSrtpKeyAndSaltLengths(selected_crypto_suite, &key_len,
       &salt_len)) {
     LOG(LS_ERROR) << "Unknown DTLS-SRTP crypto suite" << selected_crypto_suite;
     return false;
   }
 
   // OK, we're now doing DTLS (RFC 5764)
   std::vector<unsigned char> dtls_buffer(key_len * 2 + salt_len * 2);
 
   // RFC 5705 exporter using the RFC 5764 parameters
-  if (!transport->ExportKeyingMaterial(kDtlsSrtpExporterLabel, NULL, 0, false,
-                                       &dtls_buffer[0], dtls_buffer.size())) {
+  if (!transport->ExportKeyingMaterial(kDtlsSrtpExporterLabel, nullptr, 0,
+                                       false, &dtls_buffer[0],
+                                       dtls_buffer.size())) {
     LOG(LS_WARNING) << "DTLS-SRTP key export failed";
     RTC_NOTREACHED();  // This should never happen
     return false;
   }
 
   // Sync up the keys with the DTLS-SRTP interface
   std::vector<unsigned char> client_write_key(key_len + salt_len);
   std::vector<unsigned char> server_write_key(key_len + salt_len);
   size_t offset = 0;
   memcpy(&client_write_key[0], &dtls_buffer[offset], key_len);
@@ skipping 609 matching lines @@
 }
 
 void VoiceChannel::StopAudioMonitor() {
   if (audio_monitor_) {
     audio_monitor_->Stop();
     audio_monitor_.reset();
   }
 }
 
 bool VoiceChannel::IsAudioMonitorRunning() const {
-  return (audio_monitor_.get() != NULL);
+  return (audio_monitor_.get() != nullptr);
 }
 
 int VoiceChannel::GetInputLevel_w() {
   return media_engine_->GetInputLevel();
 }
 
 int VoiceChannel::GetOutputLevel_w() {
   return media_channel()->GetOutputLevel();
 }
 
@@ skipping 83 matching lines @@
 
 bool VoiceChannel::SetLocalContent_w(const MediaContentDescription* content,
                                      ContentAction action,
                                      std::string* error_desc) {
   TRACE_EVENT0("webrtc", "VoiceChannel::SetLocalContent_w");
   RTC_DCHECK(worker_thread() == rtc::Thread::Current());
   LOG(LS_INFO) << "Setting local voice description";
 
   const AudioContentDescription* audio =
       static_cast<const AudioContentDescription*>(content);
-  RTC_DCHECK(audio != NULL);
+  RTC_DCHECK(audio != nullptr);
   if (!audio) {
     SafeSetError("Can't find audio content in local description.", error_desc);
     return false;
   }
 
   if (!SetRtpTransportParameters(content, action, CS_LOCAL, error_desc)) {
     return false;
   }
 
   AudioRecvParameters recv_params = last_recv_params_;
@@ skipping 24 matching lines @@
 
 bool VoiceChannel::SetRemoteContent_w(const MediaContentDescription* content,
                                       ContentAction action,
                                       std::string* error_desc) {
   TRACE_EVENT0("webrtc", "VoiceChannel::SetRemoteContent_w");
   RTC_DCHECK(worker_thread() == rtc::Thread::Current());
   LOG(LS_INFO) << "Setting remote voice description";
 
   const AudioContentDescription* audio =
       static_cast<const AudioContentDescription*>(content);
-  RTC_DCHECK(audio != NULL);
+  RTC_DCHECK(audio != nullptr);
   if (!audio) {
     SafeSetError("Can't find audio content in remote description.", error_desc);
     return false;
   }
 
   if (!SetRtpTransportParameters(content, action, CS_REMOTE, error_desc)) {
     return false;
   }
 
   AudioSendParameters send_params = last_send_params_;
@@ skipping 212 matching lines @@
 
 bool VideoChannel::SetLocalContent_w(const MediaContentDescription* content,
                                      ContentAction action,
                                      std::string* error_desc) {
   TRACE_EVENT0("webrtc", "VideoChannel::SetLocalContent_w");
   RTC_DCHECK(worker_thread() == rtc::Thread::Current());
   LOG(LS_INFO) << "Setting local video description";
 
   const VideoContentDescription* video =
       static_cast<const VideoContentDescription*>(content);
-  RTC_DCHECK(video != NULL);
+  RTC_DCHECK(video != nullptr);
   if (!video) {
     SafeSetError("Can't find video content in local description.", error_desc);
     return false;
   }
 
   if (!SetRtpTransportParameters(content, action, CS_LOCAL, error_desc)) {
     return false;
   }
 
   VideoRecvParameters recv_params = last_recv_params_;
@@ skipping 24 matching lines @@
 
 bool VideoChannel::SetRemoteContent_w(const MediaContentDescription* content,
                                       ContentAction action,
                                       std::string* error_desc) {
   TRACE_EVENT0("webrtc", "VideoChannel::SetRemoteContent_w");
   RTC_DCHECK(worker_thread() == rtc::Thread::Current());
   LOG(LS_INFO) << "Setting remote video description";
 
   const VideoContentDescription* video =
       static_cast<const VideoContentDescription*>(content);
-  RTC_DCHECK(video != NULL);
+  RTC_DCHECK(video != nullptr);
   if (!video) {
     SafeSetError("Can't find video content in remote description.", error_desc);
     return false;
   }
 
   if (!SetRtpTransportParameters(content, action, CS_REMOTE, error_desc)) {
     return false;
   }
 
   VideoSendParameters send_params = last_send_params_;
@@ skipping 130 matching lines @@
 
 bool RtpDataChannel::SetLocalContent_w(const MediaContentDescription* content,
                                        ContentAction action,
                                        std::string* error_desc) {
   TRACE_EVENT0("webrtc", "RtpDataChannel::SetLocalContent_w");
   RTC_DCHECK(worker_thread() == rtc::Thread::Current());
   LOG(LS_INFO) << "Setting local data description";
 
   const DataContentDescription* data =
       static_cast<const DataContentDescription*>(content);
-  RTC_DCHECK(data != NULL);
+  RTC_DCHECK(data != nullptr);
   if (!data) {
     SafeSetError("Can't find data content in local description.", error_desc);
     return false;
   }
 
   if (!CheckDataChannelTypeFromContent(data, error_desc)) {
     return false;
   }
 
   if (!SetRtpTransportParameters(content, action, CS_LOCAL, error_desc)) {
@@ skipping 27 matching lines @@
 }
 
 bool RtpDataChannel::SetRemoteContent_w(const MediaContentDescription* content,
                                         ContentAction action,
                                         std::string* error_desc) {
   TRACE_EVENT0("webrtc", "RtpDataChannel::SetRemoteContent_w");
   RTC_DCHECK(worker_thread() == rtc::Thread::Current());
 
   const DataContentDescription* data =
       static_cast<const DataContentDescription*>(content);
-  RTC_DCHECK(data != NULL);
+  RTC_DCHECK(data != nullptr);
   if (!data) {
     SafeSetError("Can't find data content in remote description.", error_desc);
     return false;
   }
 
   // If the remote data doesn't have codecs and isn't an update, it
   // must be empty, so ignore it.
   if (!data->has_codecs() && action != CA_UPDATE) {
     return true;
   }
@@ skipping 131 matching lines @@
   signaling_thread()->Post(RTC_FROM_HERE, this, MSG_READYTOSENDDATA,
                            new DataChannelReadyToSendMessageData(writable));
 }
 
 void RtpDataChannel::GetSrtpCryptoSuites_n(
     std::vector<int>* crypto_suites) const {
   GetSupportedDataCryptoSuites(crypto_options(), crypto_suites);
 }
 
 }  // namespace cricket