Replace NULL with nullptr in all C++ files.

webrtc/pc/webrtcsession.cc

 /*
  *  Copyright 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 216 matching lines @@
       LOG(LS_ERROR) << "Session description must have ice ufrag and pwd.";
       return false;
     }
   }
   return true;
 }
 
 static bool GetTrackIdBySsrc(const SessionDescription* session_description,
                              uint32_t ssrc,
                              std::string* track_id) {
-  RTC_DCHECK(track_id != NULL);
+  RTC_DCHECK(track_id != nullptr);
 
   const cricket::ContentInfo* audio_info =
       cricket::GetFirstAudioContent(session_description);
   if (audio_info) {
     const cricket::MediaContentDescription* audio_content =
         static_cast<const cricket::MediaContentDescription*>(
             audio_info->description);
 
     const auto* found =
         cricket::GetStreamBySsrc(audio_content->streams(), ssrc);
@@ skipping 200 matching lines @@
       worker_thread_(worker_thread),
       signaling_thread_(signaling_thread),
       // RFC 3264: The numeric value of the session id and version in the
       // o line MUST be representable with a "64 bit signed integer".
       // Due to this constraint session id |sid_| is max limited to LLONG_MAX.
       sid_(rtc::ToString(rtc::CreateRandomId64() & LLONG_MAX)),
       transport_controller_(std::move(transport_controller)),
       sctp_factory_(std::move(sctp_factory)),
       media_controller_(media_controller),
       channel_manager_(media_controller_->channel_manager()),
-      ice_observer_(NULL),
+      ice_observer_(nullptr),
       ice_connection_state_(PeerConnectionInterface::kIceConnectionNew),
       ice_connection_receiving_(true),
       older_version_remote_peer_(false),
       dtls_enabled_(false),
       data_channel_type_(cricket::DCT_NONE),
-      metrics_observer_(NULL) {
+      metrics_observer_(nullptr) {
   transport_controller_->SetIceRole(cricket::ICEROLE_CONTROLLED);
   transport_controller_->SignalConnectionState.connect(
       this, &WebRtcSession::OnTransportControllerConnectionState);
   transport_controller_->SignalReceiving.connect(
       this, &WebRtcSession::OnTransportControllerReceiving);
   transport_controller_->SignalGatheringState.connect(
       this, &WebRtcSession::OnTransportControllerGatheringState);
   transport_controller_->SignalCandidatesGathered.connect(
       this, &WebRtcSession::OnTransportControllerCandidatesGathered);
   transport_controller_->SignalCandidatesRemoved.connect(
@@ skipping 628 matching lines @@
 }
 
 bool WebRtcSession::ProcessIceMessage(const IceCandidateInterface* candidate) {
   if (!remote_description()) {
     LOG(LS_ERROR) << "ProcessIceMessage: ICE candidates can't be added "
                   << "without any remote session description.";
     return false;
   }
 
   if (!candidate) {
-    LOG(LS_ERROR) << "ProcessIceMessage: Candidate is NULL.";
+    LOG(LS_ERROR) << "ProcessIceMessage: Candidate is null.";
     return false;
   }
 
   bool valid = false;
-  bool ready = ReadyToUseRemoteCandidate(candidate, NULL, &valid);
+  bool ready = ReadyToUseRemoteCandidate(candidate, nullptr, &valid);
   if (!valid) {
     return false;
   }
 
   // Add this candidate to the remote session description.
   if (!mutable_remote_description()->AddCandidate(candidate)) {
     LOG(LS_ERROR) << "ProcessIceMessage: Candidate cannot be used.";
     return false;
   }
 
@@ skipping 94 matching lines @@
   std::ostringstream desc;
   desc << "Called in wrong state: " << GetStateString(state);
   return desc.str();
 }
 
 bool WebRtcSession::SendData(const cricket::SendDataParams& params,
                              const rtc::CopyOnWriteBuffer& payload,
                              cricket::SendDataResult* result) {
   if (!rtp_data_channel_ && !sctp_transport_) {
     LOG(LS_ERROR) << "SendData called when rtp_data_channel_ "
-                  << "and sctp_transport_ are NULL.";
+                  << "and sctp_transport_ are null.";
     return false;
   }
   return rtp_data_channel_
              ? rtp_data_channel_->SendData(params, payload, result)
              : network_thread_->Invoke<bool>(
                    RTC_FROM_HERE,
                    Bind(&cricket::SctpTransportInternal::SendData,
                         sctp_transport_.get(), params, payload, result));
 }
 
@@ skipping 16 matching lines @@
                                    &DataChannel::OnDataReceived);
     SignalSctpStreamClosedRemotely.connect(
         webrtc_data_channel, &DataChannel::OnStreamClosedRemotely);
   }
   return true;
 }
 
 void WebRtcSession::DisconnectDataChannel(DataChannel* webrtc_data_channel) {
   if (!rtp_data_channel_ && !sctp_transport_) {
     LOG(LS_ERROR) << "DisconnectDataChannel called when rtp_data_channel_ and "
-                     "sctp_transport_ are NULL.";
+                     "sctp_transport_ are null.";
     return;
   }
   if (rtp_data_channel_) {
     rtp_data_channel_->SignalReadyToSendData.disconnect(webrtc_data_channel);
     rtp_data_channel_->SignalDataReceived.disconnect(webrtc_data_channel);
   } else {
     SignalSctpReadyToSendData.disconnect(webrtc_data_channel);
     SignalSctpDataReceived.disconnect(webrtc_data_channel);
     SignalSctpStreamClosedRemotely.disconnect(webrtc_data_channel);
   }
 }
 
 void WebRtcSession::AddSctpDataStream(int sid) {
   if (!sctp_transport_) {
-    LOG(LS_ERROR) << "AddSctpDataStream called when sctp_transport_ is NULL.";
+    LOG(LS_ERROR) << "AddSctpDataStream called when sctp_transport_ is null.";
     return;
   }
   network_thread_->Invoke<void>(
       RTC_FROM_HERE, rtc::Bind(&cricket::SctpTransportInternal::OpenStream,
                                sctp_transport_.get(), sid));
 }
 
 void WebRtcSession::RemoveSctpDataStream(int sid) {
   if (!sctp_transport_) {
     LOG(LS_ERROR) << "RemoveSctpDataStream called when sctp_transport_ is "
-                  << "NULL.";
+                  << "null.";
     return;
   }
   network_thread_->Invoke<void>(
       RTC_FROM_HERE, rtc::Bind(&cricket::SctpTransportInternal::ResetStream,
                                sctp_transport_.get(), sid));
 }
 
 bool WebRtcSession::ReadyToSendData() const {
   return (rtp_data_channel_ && rtp_data_channel_->ready_to_send_data()) ||
          sctp_ready_to_send_data_;
@@ skipping 683 matching lines @@
 }
 
 // Returns false if bundle is enabled and rtcp_mux is disabled.
 bool WebRtcSession::ValidateBundleSettings(const SessionDescription* desc) {
   bool bundle_enabled = desc->HasGroup(cricket::GROUP_TYPE_BUNDLE);
   if (!bundle_enabled)
     return true;
 
   const cricket::ContentGroup* bundle_group =
       desc->GetGroupByName(cricket::GROUP_TYPE_BUNDLE);
-  RTC_DCHECK(bundle_group != NULL);
+  RTC_DCHECK(bundle_group != nullptr);
 
   const cricket::ContentInfos& contents = desc->contents();
   for (cricket::ContentInfos::const_iterator citer = contents.begin();
        citer != contents.end(); ++citer) {
     const cricket::ContentInfo* content = (&*citer);
-    RTC_DCHECK(content != NULL);
+    RTC_DCHECK(content != nullptr);
     if (bundle_group->HasContentName(content->name) &&
         !content->rejected && content->type == cricket::NS_JINGLE_RTP) {
       if (!HasRtcpMuxEnabled(content))
         return false;
     }
   }
   // RTCP-MUX is enabled in all the contents.
   return true;
 }
 
@@ skipping 174 matching lines @@
     if (transport_controller_->GetStats(name, &stats)) {
       ReportBestConnectionState(stats);
       ReportNegotiatedCiphers(stats);
     }
   }
 }
 // Walk through the ConnectionInfos to gather best connection usage
 // for IPv4 and IPv6.
 void WebRtcSession::ReportBestConnectionState(
     const cricket::TransportStats& stats) {
-  RTC_DCHECK(metrics_observer_ != NULL);
+  RTC_DCHECK(metrics_observer_ != nullptr);
   for (cricket::TransportChannelStatsList::const_iterator it =
          stats.channel_stats.begin();
        it != stats.channel_stats.end(); ++it) {
     for (cricket::ConnectionInfos::const_iterator it_info =
            it->connection_infos.begin();
          it_info != it->connection_infos.end(); ++it_info) {
       if (!it_info->best_connection) {
         continue;
       }
 
@@ skipping 29 matching lines @@
         RTC_CHECK(0);
       }
 
       return;
     }
   }
 }
 
 void WebRtcSession::ReportNegotiatedCiphers(
     const cricket::TransportStats& stats) {
-  RTC_DCHECK(metrics_observer_ != NULL);
+  RTC_DCHECK(metrics_observer_ != nullptr);
   if (!dtls_enabled_ || stats.channel_stats.empty()) {
     return;
   }
 
   int srtp_crypto_suite = stats.channel_stats[0].srtp_crypto_suite;
   int ssl_cipher_suite = stats.channel_stats[0].ssl_cipher_suite;
   if (srtp_crypto_suite == rtc::SRTP_INVALID_CRYPTO_SUITE &&
       ssl_cipher_suite == rtc::TLS_NULL_WITH_NULL_NULL) {
     return;
   }
@@ skipping 97 matching lines @@
       (rtp_data_channel_->rtcp_dtls_transport() != nullptr);
   channel_manager_->DestroyRtpDataChannel(rtp_data_channel_.release());
   transport_controller_->DestroyDtlsTransport(
       transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
   if (need_to_delete_rtcp) {
     transport_controller_->DestroyDtlsTransport(
         transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTCP);
   }
 }
 }  // namespace webrtc