C++11 declares a type safe null pointer

content/common/gpu/media/vt_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 <CoreVideo/CoreVideo.h>
 #include <OpenGL/CGLIOSurface.h>
 #include <OpenGL/gl.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 50 matching lines @@
     int32_t bitstream_id)
     : action(action),
       bitstream_id(bitstream_id) {
 }
 
 VTVideoDecodeAccelerator::PendingAction::~PendingAction() {
 }
 
 VTVideoDecodeAccelerator::VTVideoDecodeAccelerator(CGLContextObj cgl_context)
     : cgl_context_(cgl_context),
-      client_(NULL),
-      format_(NULL),
-      session_(NULL),
+      client_(nullptr),
+      format_(nullptr),
+      session_(nullptr),
       gpu_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       weak_this_factory_(this),
       decoder_thread_("VTDecoderThread") {
   callback_.decompressionOutputCallback = OutputThunk;
   callback_.decompressionOutputRefCon = this;
 }
 
 VTVideoDecodeAccelerator::~VTVideoDecodeAccelerator() {
 }
 
@@ skipping 162 matching lines @@
   if (!session_)
     ConfigureDecoder(config_nalu_data_ptrs, config_nalu_data_sizes);
 
   // If there are no non-configuration units, immediately return an empty
   // (ie. dropped) frame. It is an error to create a MemoryBlock with zero
   // size.
   if (!data_size) {
     gpu_task_runner_->PostTask(FROM_HERE, base::Bind(
         &VTVideoDecodeAccelerator::OutputTask,
         weak_this_factory_.GetWeakPtr(),
-        DecodedFrame(bitstream.id(), NULL)));
+        DecodedFrame(bitstream.id(), nullptr)));
     return;
   }
 
   // 3. Allocate a memory-backed CMBlockBuffer for the translated data.
   base::ScopedCFTypeRef<CMBlockBufferRef> data;
   CHECK(!CMBlockBufferCreateWithMemoryBlock(
       kCFAllocatorDefault,
-      NULL,                 // &memory_block
+      nullptr,                 // &memory_block
       data_size,            // block_length
       kCFAllocatorDefault,  // block_allocator
-      NULL,                 // &custom_block_source
+      nullptr,                 // &custom_block_source
       0,                    // offset_to_data
       data_size,            // data_length
       0,                    // flags
       data.InitializeInto()));
 
   // 4. Copy NALU data, inserting length headers.
   size_t offset = 0;
   for (size_t i = 0; i < nalus.size(); i++) {
     media::H264NALU& nalu = nalus[i];
     uint32_t header = base::HostToNet32(static_cast<uint32_t>(nalu.size));
     CHECK(!CMBlockBufferReplaceDataBytes(
         &header, data, offset, kNALUHeaderLength));
     offset += kNALUHeaderLength;
     CHECK(!CMBlockBufferReplaceDataBytes(nalu.data, data, offset, nalu.size));
     offset += nalu.size;
   }
 
   // 5. Package the data for VideoToolbox and request decoding.
   base::ScopedCFTypeRef<CMSampleBufferRef> frame;
   CHECK(!CMSampleBufferCreate(
       kCFAllocatorDefault,
       data,                 // data_buffer
       true,                 // data_ready
-      NULL,                 // make_data_ready_callback
-      NULL,                 // make_data_ready_refcon
+      nullptr,                 // make_data_ready_callback
+      nullptr,                 // make_data_ready_refcon
       format_,              // format_description
       1,                    // num_samples
       0,                    // num_sample_timing_entries
-      NULL,                 // &sample_timing_array
+      nullptr,                 // &sample_timing_array
       0,                    // num_sample_size_entries
-      NULL,                 // &sample_size_array
+      nullptr,                 // &sample_size_array
       frame.InitializeInto()));
 
   // Asynchronous Decompression allows for parallel submission of frames
   // (without it, DecodeFrame() does not return until the frame has been
   // decoded). We don't enable Temporal Processing so that frames are always
   // returned in decode order; this makes it easier to avoid deadlock.
   VTDecodeFrameFlags decode_flags =
       kVTDecodeFrame_EnableAsynchronousDecompression;
 
   intptr_t bitstream_id = bitstream.id();
   CHECK(!VTDecompressionSessionDecodeFrame(
       session_,
       frame,                                  // sample_buffer
       decode_flags,                           // decode_flags
       reinterpret_cast<void*>(bitstream_id),  // source_frame_refcon
-      NULL));                                 // &info_flags_out
+      nullptr));                                 // &info_flags_out
 }
 
 // This method may be called on any VideoToolbox thread.
 // TODO(sandersd): Proper error reporting instead of CHECKs.
 void VTVideoDecodeAccelerator::Output(
     int32_t bitstream_id,
     OSStatus status,
     CVImageBufferRef image_buffer) {
   CHECK(!status);
   CHECK_EQ(CFGetTypeID(image_buffer), CVPixelBufferGetTypeID());
@@ skipping 221 matching lines @@
     pending_bitstream_ids_.pop();
   }
   QueueAction(ACTION_DESTROY);
 }
 
 bool VTVideoDecodeAccelerator::CanDecodeOnIOThread() {
   return false;
 }
 
 }  // namespace content