Replace NULL with nullptr in webrtc/video.

webrtc/video/video_receive_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 23 matching lines @@
     return false;
   for (const auto& extension : config.rtp.extensions) {
     if (extension.name == RtpExtension::kTransportSequenceNumber)
       return true;
   }
   return false;
 }
 
 std::string VideoReceiveStream::Decoder::ToString() const {
   std::stringstream ss;
-  ss << "{decoder: " << (decoder != nullptr ? "(VideoDecoder)" : "nullptr");
+  ss << "{decoder: " << (decoder ? "(VideoDecoder)" : "nullptr");
   ss << ", payload_type: " << payload_type;
   ss << ", payload_name: " << payload_name;
   ss << '}';
 
   return ss.str();
 }
 
 std::string VideoReceiveStream::Config::ToString() const {
   std::stringstream ss;
   ss << "{decoders: [";
   for (size_t i = 0; i < decoders.size(); ++i) {
     ss << decoders[i].ToString();
     if (i != decoders.size() - 1)
       ss << ", ";
   }
   ss << ']';
   ss << ", rtp: " << rtp.ToString();
-  ss << ", renderer: " << (renderer != nullptr ? "(renderer)" : "nullptr");
+  ss << ", renderer: " << (renderer ? "(renderer)" : "nullptr");
   ss << ", render_delay_ms: " << render_delay_ms;
   if (!sync_group.empty())
     ss << ", sync_group: " << sync_group;
   ss << ", pre_decode_callback: "
-     << (pre_decode_callback != nullptr ? "(EncodedFrameObserver)" : "nullptr");
+     << (pre_decode_callback ? "(EncodedFrameObserver)" : "nullptr");
   ss << ", pre_render_callback: "
-     << (pre_render_callback != nullptr ? "(I420FrameCallback)" : "nullptr");
+     << (pre_render_callback ? "(I420FrameCallback)" : "nullptr");
   ss << ", target_delay_ms: " << target_delay_ms;
   ss << '}';
 
   return ss.str();
 }
 
 std::string VideoReceiveStream::Config::Rtp::ToString() const {
   std::stringstream ss;
   ss << "{remote_ssrc: " << remote_ssrc;
   ss << ", local_ssrc: " << local_ssrc;
@@ skipping 258 matching lines @@
 void VideoReceiveStream::Stop() {
   incoming_video_stream_.Stop();
   vie_receiver_->StopReceive();
   vcm_->TriggerDecoderShutdown();
   decode_thread_.Stop();
   transport_adapter_.Disable();
 }
 
 void VideoReceiveStream::SetSyncChannel(VoiceEngine* voice_engine,
                                         int audio_channel_id) {
-  if (voice_engine != nullptr && audio_channel_id != -1) {
+  if (voice_engine && audio_channel_id != -1) {
     VoEVideoSync* voe_sync_interface = VoEVideoSync::GetInterface(voice_engine);
     vie_sync_.ConfigureSync(audio_channel_id, voe_sync_interface, rtp_rtcp_,
                             vie_receiver_->GetRtpReceiver());
     voe_sync_interface->Release();
     return;
   }
   vie_sync_.ConfigureSync(-1, nullptr, rtp_rtcp_,
                           vie_receiver_->GetRtpReceiver());
 }
 
 VideoReceiveStream::Stats VideoReceiveStream::GetStats() const {
   return stats_proxy_.GetStats();
 }
 
 bool VideoReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) {
   return vie_receiver_->DeliverRtcp(packet, length);
 }
 
 bool VideoReceiveStream::DeliverRtp(const uint8_t* packet,
                                     size_t length,
                                     const PacketTime& packet_time) {
   return vie_receiver_->DeliverRtp(packet, length, packet_time);
 }
 
 void VideoReceiveStream::FrameCallback(VideoFrame* video_frame) {
   stats_proxy_.OnDecodedFrame();
 
   // Post processing is not supported if the frame is backed by a texture.
-  if (video_frame->native_handle() == NULL) {
+  if (!video_frame->native_handle()) {
     if (config_.pre_render_callback)
       config_.pre_render_callback->FrameCallback(video_frame);
   }
 }
 
 int VideoReceiveStream::RenderFrame(const uint32_t /*stream_id*/,
                                     const VideoFrame& video_frame) {
   int64_t sync_offset_ms;
   if (vie_sync_.GetStreamSyncOffsetInMs(video_frame, &sync_offset_ms))
     stats_proxy_.OnSyncOffsetUpdated(sync_offset_ms);
 
-  if (config_.renderer != nullptr)
+  if (config_.renderer)
     config_.renderer->OnFrame(video_frame);
 
   stats_proxy_.OnRenderedFrame(video_frame);
 
   return 0;
 }
 
 // TODO(asapersson): Consider moving callback from video_encoder.h or
 // creating a different callback.
 int32_t VideoReceiveStream::Encoded(
@@ skipping 28 matching lines @@
     const std::vector<uint16_t>& sequence_numbers) {
   rtp_rtcp_->SendNack(sequence_numbers);
 }
 
 void VideoReceiveStream::RequestKeyFrame() {
   rtp_rtcp_->RequestKeyFrame();
 }
 
 }  // namespace internal
 }  // namespace webrtc