Replace NULL with nullptr in webrtc/video.

webrtc/video/video_send_stream.cc

 /*
  *  Copyright (c) 2013 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 21 matching lines @@
 namespace webrtc {
 
 class RtcpIntraFrameObserver;
 class TransportFeedbackObserver;
 
 std::string
 VideoSendStream::Config::EncoderSettings::ToString() const {
   std::stringstream ss;
   ss << "{payload_name: " << payload_name;
   ss << ", payload_type: " << payload_type;
-  ss << ", encoder: " << (encoder != nullptr ? "(VideoEncoder)" : "nullptr");
+  ss << ", encoder: " << (encoder ? "(VideoEncoder)" : "nullptr");
   ss << '}';
   return ss.str();
 }
 
 std::string VideoSendStream::Config::Rtp::Rtx::ToString()
     const {
   std::stringstream ss;
   ss << "{ssrcs: [";
   for (size_t i = 0; i < ssrcs.size(); ++i) {
     ss << ssrcs[i];
@@ skipping 34 matching lines @@
   ss << ", c_name: " << c_name;
   ss << '}';
   return ss.str();
 }
 
 std::string VideoSendStream::Config::ToString() const {
   std::stringstream ss;
   ss << "{encoder_settings: " << encoder_settings.ToString();
   ss << ", rtp: " << rtp.ToString();
   ss << ", pre_encode_callback: "
-     << (pre_encode_callback != nullptr ? "(I420FrameCallback)" : "nullptr");
-  ss << ", post_encode_callback: " << (post_encode_callback != nullptr
-                                           ? "(EncodedFrameObserver)"
-                                           : "nullptr");
-  ss << ", local_renderer: " << (local_renderer != nullptr ? "(VideoRenderer)"
-                                                         : "nullptr");
+     << (pre_encode_callback ? "(I420FrameCallback)" : "nullptr");
+  ss << ", post_encode_callback: "
+     << (post_encode_callback ? "(EncodedFrameObserver)" : "nullptr");
+  ss << ", local_renderer: "
+     << (local_renderer ? "(VideoRenderer)" : "nullptr");
   ss << ", render_delay_ms: " << render_delay_ms;
   ss << ", target_delay_ms: " << target_delay_ms;
   ss << ", suspend_below_min_bitrate: " << (suspend_below_min_bitrate ? "on"
                                                                       : "off");
   ss << '}';
   return ss.str();
 }
 
 namespace {
 
@@ skipping 166 matching lines @@
                                              kRtpPacketSizeOverhead);
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     rtp_rtcp->RegisterRtcpStatisticsCallback(&stats_proxy_);
     rtp_rtcp->RegisterSendChannelRtpStatisticsCallback(&stats_proxy_);
     rtp_rtcp->SetMaxTransferUnit(mtu);
     rtp_rtcp->RegisterVideoSendPayload(
         config_.encoder_settings.payload_type,
         config_.encoder_settings.payload_name.c_str());
   }
 
-  RTC_DCHECK(config.encoder_settings.encoder != nullptr);
+  RTC_DCHECK(config.encoder_settings.encoder);
   RTC_DCHECK_GE(config.encoder_settings.payload_type, 0);
   RTC_DCHECK_LE(config.encoder_settings.payload_type, 127);
   RTC_CHECK_EQ(0, vie_encoder_.RegisterExternalEncoder(
                       config.encoder_settings.encoder,
                       config.encoder_settings.payload_type,
                       config.encoder_settings.internal_source));
 
   ReconfigureVideoEncoder(encoder_config);
 
   vie_channel_.RegisterSendSideDelayObserver(&stats_proxy_);
@@ skipping 121 matching lines @@
 
   if (video_codec.codecType == kVideoCodecVP8) {
     video_codec.codecSpecific.VP8 = VideoEncoder::GetDefaultVp8Settings();
   } else if (video_codec.codecType == kVideoCodecVP9) {
     video_codec.codecSpecific.VP9 = VideoEncoder::GetDefaultVp9Settings();
   } else if (video_codec.codecType == kVideoCodecH264) {
     video_codec.codecSpecific.H264 = VideoEncoder::GetDefaultH264Settings();
   }
 
   if (video_codec.codecType == kVideoCodecVP8) {
-    if (config.encoder_specific_settings != nullptr) {
+    if (config.encoder_specific_settings) {
       video_codec.codecSpecific.VP8 = *reinterpret_cast<const VideoCodecVP8*>(
                                           config.encoder_specific_settings);
     }
     video_codec.codecSpecific.VP8.numberOfTemporalLayers =
         static_cast<unsigned char>(
             streams.back().temporal_layer_thresholds_bps.size() + 1);
   } else if (video_codec.codecType == kVideoCodecVP9) {
-    if (config.encoder_specific_settings != nullptr) {
+    if (config.encoder_specific_settings) {
       video_codec.codecSpecific.VP9 = *reinterpret_cast<const VideoCodecVP9*>(
                                           config.encoder_specific_settings);
       if (video_codec.mode == kScreensharing) {
         video_codec.codecSpecific.VP9.flexibleMode = true;
         // For now VP9 screensharing use 1 temporal and 2 spatial layers.
         RTC_DCHECK_EQ(video_codec.codecSpecific.VP9.numberOfTemporalLayers, 1);
         RTC_DCHECK_EQ(video_codec.codecSpecific.VP9.numberOfSpatialLayers, 2);
       }
     }
     video_codec.codecSpecific.VP9.numberOfTemporalLayers =
         static_cast<unsigned char>(
             streams.back().temporal_layer_thresholds_bps.size() + 1);
   } else if (video_codec.codecType == kVideoCodecH264) {
-    if (config.encoder_specific_settings != nullptr) {
+    if (config.encoder_specific_settings) {
       video_codec.codecSpecific.H264 = *reinterpret_cast<const VideoCodecH264*>(
                                            config.encoder_specific_settings);
     }
   } else {
     // TODO(pbos): Support encoder_settings codec-agnostically.
-    RTC_DCHECK(config.encoder_specific_settings == nullptr)
+    RTC_DCHECK(!config.encoder_specific_settings)
         << "Encoder-specific settings for codec type not wired up.";
   }
 
   strncpy(video_codec.plName,
           config_.encoder_settings.payload_name.c_str(),
           kPayloadNameSize - 1);
   video_codec.plName[kPayloadNameSize - 1] = '\0';
   video_codec.plType = config_.encoder_settings.payload_type;
   video_codec.numberOfSimulcastStreams =
       static_cast<unsigned char>(streams.size());
@@ skipping 160 matching lines @@
 }
 
 void VideoSendStream::OnBitrateUpdated(uint32_t bitrate_bps,
                                        uint8_t fraction_loss,
                                        int64_t rtt) {
   vie_encoder_.OnBitrateUpdated(bitrate_bps, fraction_loss, rtt);
 }
 
 }  // namespace internal
 }  // namespace webrtc