Replace NULL with nullptr in all C++ files.

webrtc/modules/video_coding/generic_decoder.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.
  */
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/modules/video_coding/include/video_coding.h"
 #include "webrtc/modules/video_coding/generic_decoder.h"
 #include "webrtc/modules/video_coding/internal_defines.h"
 #include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
 
 VCMDecodedFrameCallback::VCMDecodedFrameCallback(VCMTiming* timing,
                                                  Clock* clock)
     : _critSect(CriticalSectionWrapper::CreateCriticalSection()),
       _clock(clock),
-      _receiveCallback(NULL),
+      _receiveCallback(nullptr),
       _timing(timing),
       _timestampMap(kDecoderFrameMemoryLength),
       _lastReceivedPictureID(0) {}
 
 VCMDecodedFrameCallback::~VCMDecodedFrameCallback() {
   delete _critSect;
 }
 
 void VCMDecodedFrameCallback::SetUserReceiveCallback(
     VCMReceiveCallback* receiveCallback) {
@@ skipping 27 matching lines @@
   // TODO(holmer): We should improve this so that we can handle multiple
   // callbacks from one call to Decode().
   VCMFrameInformation* frameInfo;
   VCMReceiveCallback* callback;
   {
     CriticalSectionScoped cs(_critSect);
     frameInfo = _timestampMap.Pop(decodedImage.timestamp());
     callback = _receiveCallback;
   }
 
-  if (frameInfo == NULL) {
+  if (frameInfo == nullptr) {
     LOG(LS_WARNING) << "Too many frames backed up in the decoder, dropping "
                        "this one.";
     return;
   }
 
   const int64_t now_ms = _clock->TimeInMilliseconds();
   if (!decode_time_ms) {
     decode_time_ms =
         rtc::Optional<int32_t>(now_ms - frameInfo->decodeStartTimeMs);
   }
   _timing->StopDecodeTimer(decodedImage.timestamp(), *decode_time_ms, now_ms,
                            frameInfo->renderTimeMs);
 
   decodedImage.set_timestamp_us(
       frameInfo->renderTimeMs * rtc::kNumMicrosecsPerMillisec);
   decodedImage.set_rotation(frameInfo->rotation);
-  // TODO(sakal): Investigate why callback is NULL sometimes and replace if
+  // TODO(sakal): Investigate why callback is null sometimes and replace if
   // statement with a DCHECK.
   if (callback) {
     callback->FrameToRender(decodedImage, qp);
   } else {
     LOG(LS_WARNING) << "No callback, dropping frame.";
   }
 }
 
 int32_t VCMDecodedFrameCallback::ReceivedDecodedReferenceFrame(
     const uint64_t pictureId) {
   CriticalSectionScoped cs(_critSect);
-  if (_receiveCallback != NULL) {
+  if (_receiveCallback != nullptr) {
     return _receiveCallback->ReceivedDecodedReferenceFrame(pictureId);
   }
   return -1;
 }
 
 int32_t VCMDecodedFrameCallback::ReceivedDecodedFrame(
     const uint64_t pictureId) {
   _lastReceivedPictureID = pictureId;
   return 0;
 }
@@ skipping 10 matching lines @@
 }
 
 void VCMDecodedFrameCallback::Map(uint32_t timestamp,
                                   VCMFrameInformation* frameInfo) {
   CriticalSectionScoped cs(_critSect);
   _timestampMap.Add(timestamp, frameInfo);
 }
 
 int32_t VCMDecodedFrameCallback::Pop(uint32_t timestamp) {
   CriticalSectionScoped cs(_critSect);
-  if (_timestampMap.Pop(timestamp) == NULL) {
+  if (_timestampMap.Pop(timestamp) == nullptr) {
     return VCM_GENERAL_ERROR;
   }
   return VCM_OK;
 }
 
 VCMGenericDecoder::VCMGenericDecoder(VideoDecoder* decoder, bool isExternal)
-    : _callback(NULL),
+    : _callback(nullptr),
       _frameInfos(),
       _nextFrameInfoIdx(0),
       _decoder(decoder),
       _codecType(kVideoCodecUnknown),
       _isExternal(isExternal),
       _keyFrameDecoded(false) {}
 
 VCMGenericDecoder::~VCMGenericDecoder() {}
 
 int32_t VCMGenericDecoder::InitDecode(const VideoCodec* settings,
@@ skipping 44 matching lines @@
 
 bool VCMGenericDecoder::External() const {
   return _isExternal;
 }
 
 bool VCMGenericDecoder::PrefersLateDecoding() const {
   return _decoder->PrefersLateDecoding();
 }
 
 }  // namespace webrtc