Replace NULL with nullptr in webrtc/video.

webrtc/video/vie_encoder.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 148 matching lines @@
                                             uint8_t pl_type,
                                             bool internal_source) {
   if (vcm_->RegisterExternalEncoder(encoder, pl_type, internal_source) !=
       VCM_OK) {
     return -1;
   }
   return 0;
 }
 
 int32_t ViEEncoder::DeRegisterExternalEncoder(uint8_t pl_type) {
-  if (vcm_->RegisterExternalEncoder(NULL, pl_type) != VCM_OK) {
+  if (vcm_->RegisterExternalEncoder(nullptr, pl_type) != VCM_OK) {
     return -1;
   }
   return 0;
 }
 void ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec,
                             int min_transmit_bitrate_bps) {
-  RTC_DCHECK(send_payload_router_ != NULL);
+  RTC_DCHECK(send_payload_router_);
   // Setting target width and height for VPM.
   RTC_CHECK_EQ(VPM_OK,
                vp_->SetTargetResolution(video_codec.width, video_codec.height,
                                         video_codec.maxFramerate));
 
   // Cache codec before calling AddBitrateObserver (which calls OnBitrateUpdated
   // that makes use of the number of simulcast streams configured).
   {
     rtc::CritScope lock(&data_cs_);
     encoder_config_ = video_codec;
@@ skipping 140 matching lines @@
       return;
     }
     TraceFrameDropEnd();
     codec_type = encoder_config_.codecType;
   }
 
   TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", video_frame.render_time_ms(),
                           "Encode");
   const VideoFrame* frame_to_send = &video_frame;
   // TODO(wuchengli): support texture frames.
-  if (video_frame.native_handle() == NULL) {
+  if (!video_frame.native_handle()) {
     // Pass frame via preprocessor.
     frame_to_send = vp_->PreprocessFrame(video_frame);
     if (!frame_to_send) {
       // Drop this frame, or there was an error processing it.
       return;
     }
   }
 
   // If we haven't resampled the frame and we have a FrameCallback, we need to
   // make a deep copy of |video_frame|.
@@ skipping 57 matching lines @@
 
 void ViEEncoder::OnSetRates(uint32_t bitrate_bps, int framerate) {
   if (stats_proxy_)
     stats_proxy_->OnSetRates(bitrate_bps, framerate);
 }
 
 int32_t ViEEncoder::SendData(const uint8_t payload_type,
                              const EncodedImage& encoded_image,
                              const RTPFragmentationHeader* fragmentation_header,
                              const RTPVideoHeader* rtp_video_hdr) {
-  RTC_DCHECK(send_payload_router_ != NULL);
+  RTC_DCHECK(send_payload_router_);
 
   {
     rtc::CritScope lock(&data_cs_);
     time_of_last_frame_activity_ms_ = TickTime::MillisecondTimestamp();
   }
 
-  if (stats_proxy_ != NULL)
+  if (stats_proxy_)
     stats_proxy_->OnSendEncodedImage(encoded_image, rtp_video_hdr);
 
   bool success = send_payload_router_->RoutePayload(
       encoded_image._frameType, payload_type, encoded_image._timeStamp,
       encoded_image.capture_time_ms_, encoded_image._buffer,
       encoded_image._length, fragmentation_header, rtp_video_hdr);
   overuse_detector_->FrameSent(encoded_image._timeStamp);
   return success ? 0 : -1;
 }
 
@@ skipping 45 matching lines @@
   }
   RTC_NOTREACHED() << "Should not receive keyframe requests on unknown SSRCs.";
 }
 
 void ViEEncoder::OnBitrateUpdated(uint32_t bitrate_bps,
                                   uint8_t fraction_lost,
                                   int64_t round_trip_time_ms) {
   LOG(LS_VERBOSE) << "OnBitrateUpdated, bitrate" << bitrate_bps
                   << " packet loss " << static_cast<int>(fraction_lost)
                   << " rtt " << round_trip_time_ms;
-  RTC_DCHECK(send_payload_router_ != NULL);
+  RTC_DCHECK(send_payload_router_);
   vcm_->SetChannelParameters(bitrate_bps, fraction_lost, round_trip_time_ms);
   bool video_is_suspended = vcm_->VideoSuspended();
   bool video_suspension_changed;
   VideoCodec send_codec;
   {
     rtc::CritScope lock(&data_cs_);
     last_observed_bitrate_bps_ = bitrate_bps;
     video_suspension_changed = video_suspended_ != video_is_suspended;
     video_suspended_ = video_is_suspended;
     send_codec = encoder_config_;
@@ skipping 31 matching lines @@
     const uint32_t width,
     const uint32_t height) {
   return vp_->SetTargetResolution(width, height, frame_rate);
 }
 
 void QMVideoSettingsCallback::SetTargetFramerate(int frame_rate) {
   vp_->SetTargetFramerate(frame_rate);
 }
 
 }  // namespace webrtc