C++11 declares a type safe null pointer

content/common/gpu/media/android_video_encode_accelerator.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/common/gpu/media/android_video_encode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 269 matching lines @@
   bool is_key_frame = input.b;
   if (is_key_frame) {
     // Ideally MediaCodec would honor BUFFER_FLAG_SYNC_FRAME so we could
     // indicate this in the QueueInputBuffer() call below and guarantee _this_
     // frame be encoded as a key frame, but sadly that flag is ignored.
     // Instead, we request a key frame "soon".
     media_codec_->RequestKeyFrameSoon();
   }
   scoped_refptr<VideoFrame> frame = input.a;
 
-  uint8* buffer = NULL;
+  uint8* buffer = nullptr;
   size_t capacity = 0;
   media_codec_->GetInputBuffer(input_buf_index, &buffer, &capacity);
 
   size_t queued_size =
       VideoFrame::AllocationSize(VideoFrame::I420, frame->coded_size());
   RETURN_ON_FAILURE(capacity >= queued_size,
                     "Failed to get input buffer: " << input_buf_index,
                     kPlatformFailureError);
 
   uint8* dst_y = buffer;
@@ skipping 12 matching lines @@
                                        dst_y,
                                        dst_stride_y,
                                        dst_uv,
                                        dst_stride_uv,
                                        frame->coded_size().width(),
                                        frame->coded_size().height());
   RETURN_ON_FAILURE(converted, "Failed to I420ToNV12!", kPlatformFailureError);
 
   fake_input_timestamp_ += base::TimeDelta::FromMicroseconds(1);
   status = media_codec_->QueueInputBuffer(
-      input_buf_index, NULL, queued_size, fake_input_timestamp_);
+      input_buf_index, nullptr, queued_size, fake_input_timestamp_);
   UMA_HISTOGRAM_TIMES("Media.AVEA.InputQueueTime", base::Time::Now() - input.c);
   RETURN_ON_FAILURE(status == media::MEDIA_CODEC_OK,
                     "Failed to QueueInputBuffer: " << status,
                     kPlatformFailureError);
   ++num_buffers_at_codec_;
   pending_frames_.pop();
 }
 
 bool AndroidVideoEncodeAccelerator::DoOutputBuffersSuffice() {
   // If this returns false ever, then the VEA::Client interface will need to
@@ skipping 15 matching lines @@
       available_bitstream_buffers_.empty() || num_buffers_at_codec_ == 0) {
     return;
   }
 
   int32 buf_index = 0;
   size_t offset = 0;
   size_t size = 0;
   bool key_frame = false;
   do {
     media::MediaCodecStatus status = media_codec_->DequeueOutputBuffer(
-        NoWaitTimeOut(), &buf_index, &offset, &size, NULL, NULL, &key_frame);
+        NoWaitTimeOut(), &buf_index, &offset, &size, nullptr, nullptr,
+        &key_frame);
     switch (status) {
       case media::MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER:
         return;
 
       case media::MEDIA_CODEC_ERROR:
         RETURN_ON_FAILURE(false, "Codec error", kPlatformFailureError);
         // Unreachable because of previous statement, but included for clarity.
         return;
 
       case media::MEDIA_CODEC_OUTPUT_FORMAT_CHANGED:  // Fall-through.
@@ skipping 33 matching lines @@
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&VideoEncodeAccelerator::Client::BitstreamBufferReady,
                  client_ptr_factory_->GetWeakPtr(),
                  bitstream_buffer.id(),
                  size,
                  key_frame));
 }
 
 }  // namespace content