C++11 declares a type safe null pointer

content/common/gpu/media/v4l2_video_encode_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 <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <sys/eventfd.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
@@ skipping 42 matching lines @@
       : id(id), shm(shm.Pass()), size(size) {}
   const int32 id;
   const scoped_ptr<base::SharedMemory> shm;
   const size_t size;
 };
 
 V4L2VideoEncodeAccelerator::InputRecord::InputRecord() : at_device(false) {
 }
 
 V4L2VideoEncodeAccelerator::OutputRecord::OutputRecord()
-    : at_device(false), address(NULL), length(0) {
+    : at_device(false), address(nullptr), length(0) {
 }
 
 V4L2VideoEncodeAccelerator::V4L2VideoEncodeAccelerator(
     scoped_ptr<V4L2Device> device)
     : child_message_loop_proxy_(base::MessageLoopProxy::current()),
       output_buffer_byte_size_(0),
       device_input_format_(media::VideoFrame::UNKNOWN),
       input_planes_count_(0),
       output_format_fourcc_(0),
       encoder_state_(kUninitialized),
@@ skipping 426 matching lines @@
         break;
       }
       PLOG(ERROR) << "Dequeue(): ioctl() failed: VIDIOC_DQBUF";
       NOTIFY_ERROR(kPlatformFailureError);
       return;
     }
     InputRecord& input_record = input_buffer_map_[dqbuf.index];
     DCHECK(input_record.at_device);
     input_record.at_device = false;
 
-    input_record.frame = NULL;
+    input_record.frame = nullptr;
     free_input_buffers_.push_back(dqbuf.index);
     input_buffer_queued_count_--;
   }
 
   // Dequeue completed output (VIDEO_CAPTURE) buffers, and recycle to the
   // free list.  Notify the client that an output buffer is complete.
   while (output_buffer_queued_count_ > 0) {
     DCHECK(output_streamon_);
     memset(&dqbuf, 0, sizeof(dqbuf));
     memset(planes, 0, sizeof(planes));
@@ skipping 189 matching lines @@
     IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_STREAMOFF, &type);
   }
   output_streamon_ = false;
 
   // Reset all our accounting info.
   encoder_input_queue_.clear();
   free_input_buffers_.clear();
   for (size_t i = 0; i < input_buffer_map_.size(); ++i) {
     InputRecord& input_record = input_buffer_map_[i];
     input_record.at_device = false;
-    input_record.frame = NULL;
+    input_record.frame = nullptr;
     free_input_buffers_.push_back(i);
   }
   input_buffer_queued_count_ = 0;
 
   free_output_buffers_.clear();
   for (size_t i = 0; i < output_buffer_map_.size(); ++i) {
     OutputRecord& output_record = output_buffer_map_[i];
     output_record.at_device = false;
     output_record.buffer_ref.reset();
     free_output_buffers_.push_back(i);
@@ skipping 39 matching lines @@
     client_->NotifyError(error);
     client_ptr_factory_.reset();
   }
 }
 
 void V4L2VideoEncodeAccelerator::SetEncoderState(State state) {
   DVLOG(3) << "SetEncoderState(): state=" << state;
 
   // We can touch encoder_state_ only if this is the encoder thread or the
   // encoder thread isn't running.
-  if (encoder_thread_.message_loop() != NULL &&
+  if (encoder_thread_.message_loop() != nullptr &&
       encoder_thread_.message_loop() != base::MessageLoop::current()) {
     encoder_thread_.message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&V4L2VideoEncodeAccelerator::SetEncoderState,
                    base::Unretained(this),
                    state));
   } else {
     encoder_state_ = state;
   }
 }
@@ skipping 242 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_CAPTURE_MPLANE;
     buffer.memory = V4L2_MEMORY_MMAP;
     buffer.m.planes = planes;
     buffer.length = arraysize(planes);
     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) << "CreateOutputBuffers(): mmap() failed";
       return false;
     }
     output_buffer_map_[i].address = address;
     output_buffer_map_[i].length = buffer.m.planes[0].length;
@@ skipping 18 matching lines @@
   input_buffer_map_.clear();
   free_input_buffers_.clear();
 }
 
 void V4L2VideoEncodeAccelerator::DestroyOutputBuffers() {
   DVLOG(3) << "DestroyOutputBuffers()";
   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
   DCHECK(!output_streamon_);
 
   for (size_t i = 0; i < output_buffer_map_.size(); ++i) {
-    if (output_buffer_map_[i].address != NULL)
+    if (output_buffer_map_[i].address != nullptr)
       device_->Munmap(output_buffer_map_[i].address,
                       output_buffer_map_[i].length);
   }
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = 0;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
 
   output_buffer_map_.clear();
   free_output_buffers_.clear();
 }
 
 }  // namespace content