C++11 declares a type safe null pointer

content/common/gpu/media/v4l2_video_decode_accelerator.cc

 // Copyright 2014 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 <dlfcn.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <sys/eventfd.h>
@@ skipping 109 matching lines @@
 V4L2VideoDecodeAccelerator::EGLSyncKHRRef::~EGLSyncKHRRef() {
   // We don't check for eglDestroySyncKHR failures, because if we get here
   // with a valid sync object, something went wrong and we are getting
   // destroyed anyway.
   if (egl_sync != EGL_NO_SYNC_KHR)
     eglDestroySyncKHR(egl_display, egl_sync);
 }
 
 V4L2VideoDecodeAccelerator::InputRecord::InputRecord()
     : at_device(false),
-      address(NULL),
+      address(nullptr),
       length(0),
       bytes_used(0),
       input_id(-1) {
 }
 
 V4L2VideoDecodeAccelerator::InputRecord::~InputRecord() {
 }
 
 V4L2VideoDecodeAccelerator::OutputRecord::OutputRecord()
     : at_device(false),
@@ skipping 247 matching lines @@
   // Must be run on child thread, as we'll insert a sync in the EGL context.
   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
 
   if (!make_context_current_.Run()) {
     LOG(ERROR) << "ReusePictureBuffer(): could not make context current";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
 
   EGLSyncKHR egl_sync =
-      eglCreateSyncKHR(egl_display_, EGL_SYNC_FENCE_KHR, NULL);
+      eglCreateSyncKHR(egl_display_, EGL_SYNC_FENCE_KHR, nullptr);
   if (egl_sync == EGL_NO_SYNC_KHR) {
     LOG(ERROR) << "ReusePictureBuffer(): eglCreateSyncKHR() failed";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
 
   scoped_ptr<EGLSyncKHRRef> egl_sync_ref(new EGLSyncKHRRef(
       egl_display_, egl_sync));
   decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
       &V4L2VideoDecodeAccelerator::ReusePictureBufferTask,
@@ skipping 92 matching lines @@
     DVLOG(2) << "DecodeBufferTask(): early out: kResetting state";
     return;
   } else if (decoder_state_ == kError) {
     DVLOG(2) << "DecodeBufferTask(): early out: kError state";
     return;
   } else if (decoder_state_ == kChangingResolution) {
     DVLOG(2) << "DecodeBufferTask(): early out: resolution change pending";
     return;
   }
 
-  if (decoder_current_bitstream_buffer_ == NULL) {
+  if (decoder_current_bitstream_buffer_ == nullptr) {
     if (decoder_input_queue_.empty()) {
       // We're waiting for a new buffer -- exit without scheduling a new task.
       return;
     }
     linked_ptr<BitstreamBufferRef>& buffer_ref = decoder_input_queue_.front();
     if (decoder_delay_bitstream_buffer_id_ == buffer_ref->input_id) {
       // We're asked to delay decoding on this and subsequent buffers.
       return;
     }
 
     // Setup to use the next buffer.
     decoder_current_bitstream_buffer_.reset(buffer_ref.release());
     decoder_input_queue_.pop();
     DVLOG(3) << "DecodeBufferTask(): reading input_id="
              << decoder_current_bitstream_buffer_->input_id
              << ", addr=" << (decoder_current_bitstream_buffer_->shm ?
                               decoder_current_bitstream_buffer_->shm->memory() :
-                              NULL)
+                              nullptr)
              << ", size=" << decoder_current_bitstream_buffer_->size;
   }
   bool schedule_task = false;
   const size_t size = decoder_current_bitstream_buffer_->size;
   size_t decoded_size = 0;
   if (size == 0) {
     const int32 input_id = decoder_current_bitstream_buffer_->input_id;
     if (input_id >= 0) {
       // This is a buffer queued from the client that has zero size.  Skip.
       schedule_task = true;
     } else {
       // This is a buffer of zero size, queued to flush the pipe.  Flush.
       DCHECK_EQ(decoder_current_bitstream_buffer_->shm.get(),
-                static_cast<base::SharedMemory*>(NULL));
+                static_cast<base::SharedMemory*>(nullptr));
       // Enqueue a buffer guaranteed to be empty.  To do that, we flush the
       // current input, enqueue no data to the next frame, then flush that down.
       schedule_task = true;
       if (decoder_current_input_buffer_ != -1 &&
           input_buffer_map_[decoder_current_input_buffer_].input_id !=
               kFlushBufferId)
         schedule_task = FlushInputFrame();
 
-      if (schedule_task && AppendToInputFrame(NULL, 0) && FlushInputFrame()) {
+      if (schedule_task && AppendToInputFrame(nullptr, 0) &&
+          FlushInputFrame()) {
         DVLOG(2) << "DecodeBufferTask(): enqueued flush buffer";
         decoder_partial_frame_pending_ = false;
         schedule_task = true;
       } else {
         // If we failed to enqueue the empty buffer (due to pipeline
         // backpressure), don't advance the bitstream buffer queue, and don't
         // schedule the next task.  This bitstream buffer queue entry will get
         // reprocessed when the pipeline frees up.
         schedule_task = false;
       }
@@ skipping 132 matching lines @@
     decoder_partial_frame_pending_ = false;
     return true;
   }
 }
 
 void V4L2VideoDecodeAccelerator::ScheduleDecodeBufferTaskIfNeeded() {
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
 
   // If we're behind on tasks, schedule another one.
   int buffers_to_decode = decoder_input_queue_.size();
-  if (decoder_current_bitstream_buffer_ != NULL)
+  if (decoder_current_bitstream_buffer_ != nullptr)
     buffers_to_decode++;
   if (decoder_decode_buffer_tasks_scheduled_ < buffers_to_decode) {
     decoder_decode_buffer_tasks_scheduled_++;
     decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
         &V4L2VideoDecodeAccelerator::DecodeBufferTask,
         base::Unretained(this)));
   }
 }
 
 bool V4L2VideoDecodeAccelerator::DecodeBufferInitial(
@@ skipping 64 matching lines @@
           (decoder_partial_frame_pending_ || FlushInputFrame()));
 }
 
 bool V4L2VideoDecodeAccelerator::AppendToInputFrame(
     const void* data, size_t size) {
   DVLOG(3) << "AppendToInputFrame()";
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
   DCHECK_NE(decoder_state_, kUninitialized);
   DCHECK_NE(decoder_state_, kResetting);
   DCHECK_NE(decoder_state_, kError);
-  // This routine can handle data == NULL and size == 0, which occurs when
+  // This routine can handle data == nullptr and size == 0, which occurs when
   // we queue an empty buffer for the purposes of flushing the pipe.
 
   // Flush if we're too big
   if (decoder_current_input_buffer_ != -1) {
     InputRecord& input_record =
         input_buffer_map_[decoder_current_input_buffer_];
     if (input_record.bytes_used + size > input_record.length) {
       if (!FlushInputFrame())
         return false;
       decoder_current_input_buffer_ = -1;
@@ skipping 10 matching lines @@
         DVLOG(2) << "AppendToInputFrame(): stalled for input buffers";
         return false;
       }
     }
     decoder_current_input_buffer_ = free_input_buffers_.back();
     free_input_buffers_.pop_back();
     InputRecord& input_record =
         input_buffer_map_[decoder_current_input_buffer_];
     DCHECK_EQ(input_record.bytes_used, 0);
     DCHECK_EQ(input_record.input_id, -1);
-    DCHECK(decoder_current_bitstream_buffer_ != NULL);
+    DCHECK(decoder_current_bitstream_buffer_ != nullptr);
     input_record.input_id = decoder_current_bitstream_buffer_->input_id;
   }
 
-  DCHECK(data != NULL || size == 0);
+  DCHECK(data != nullptr || size == 0);
   if (size == 0) {
     // If we asked for an empty buffer, return now.  We return only after
     // getting the next input buffer, since we might actually want an empty
     // input buffer for flushing purposes.
     return true;
   }
 
   // Copy in to the buffer.
   InputRecord& input_record =
       input_buffer_map_[decoder_current_input_buffer_];
@@ skipping 415 matching lines @@
     DVLOG(2) << "FlushTask(): early out: kError state";
     return;
   }
 
   // We don't support stacked flushing.
   DCHECK(!decoder_flushing_);
 
   // Queue up an empty buffer -- this triggers the flush.
   decoder_input_queue_.push(
       linked_ptr<BitstreamBufferRef>(new BitstreamBufferRef(
-          io_client_, io_message_loop_proxy_, NULL, 0, kFlushBufferId)));
+          io_client_, io_message_loop_proxy_, nullptr, 0, kFlushBufferId)));
   decoder_flushing_ = true;
   SendPictureReady();  // Send all pending PictureReady.
 
   ScheduleDecodeBufferTaskIfNeeded();
 }
 
 void V4L2VideoDecodeAccelerator::NotifyFlushDoneIfNeeded() {
   if (!decoder_flushing_)
     return;
 
@@ skipping 330 matching lines @@
     client_->NotifyError(error);
     client_ptr_factory_.reset();
   }
 }
 
 void V4L2VideoDecodeAccelerator::SetDecoderState(State state) {
   DVLOG(3) << "SetDecoderState(): state=" << state;
 
   // We can touch decoder_state_ only if this is the decoder thread or the
   // decoder thread isn't running.
-  if (decoder_thread_.message_loop() != NULL &&
+  if (decoder_thread_.message_loop() != nullptr &&
       decoder_thread_.message_loop() != base::MessageLoop::current()) {
     decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
         &V4L2VideoDecodeAccelerator::SetDecoderState,
         base::Unretained(this), state));
   } else {
     decoder_state_ = state;
   }
 }
 
 bool V4L2VideoDecodeAccelerator::GetFormatInfo(struct v4l2_format* format,
@@ skipping 72 matching lines @@
     struct v4l2_plane planes[1];
     struct v4l2_buffer buffer;
     memset(&buffer, 0, sizeof(buffer));
     memset(planes, 0, sizeof(planes));
     buffer.index    = i;
     buffer.type     = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
     buffer.memory   = V4L2_MEMORY_MMAP;
     buffer.m.planes = planes;
     buffer.length   = 1;
     IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYBUF, &buffer);
-    void* address = device_->Mmap(NULL,
+    void* address = device_->Mmap(nullptr,
                                   buffer.m.planes[0].length,
                                   PROT_READ | PROT_WRITE,
                                   MAP_SHARED,
                                   buffer.m.planes[0].m.mem_offset);
     if (address == MAP_FAILED) {
       PLOG(ERROR) << "CreateInputBuffers(): mmap() failed";
       return false;
     }
     input_buffer_map_[i].address = address;
     input_buffer_map_[i].length = buffer.m.planes[0].length;
@@ skipping 57 matching lines @@
   Enqueue();
   return true;
 }
 
 void V4L2VideoDecodeAccelerator::DestroyInputBuffers() {
   DVLOG(3) << "DestroyInputBuffers()";
   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
   DCHECK(!input_streamon_);
 
   for (size_t i = 0; i < input_buffer_map_.size(); ++i) {
-    if (input_buffer_map_[i].address != NULL) {
+    if (input_buffer_map_[i].address != nullptr) {
       device_->Munmap(input_buffer_map_[i].address,
                       input_buffer_map_[i].length);
     }
   }
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = 0;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
@@ skipping 140 matching lines @@
   gfx::Size new_size(base::checked_cast<int>(format.fmt.pix_mp.width),
                      base::checked_cast<int>(format.fmt.pix_mp.height));
   if (frame_buffer_size_ != new_size) {
     DVLOG(3) << "IsResolutionChangeNecessary(): Resolution change detected";
     return true;
   }
   return false;
 }
 
 }  // namespace content