C++11 declares a type safe null pointer

content/common/gpu/media/vaapi_wrapper.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/vaapi_wrapper.h"
 
 #include <dlfcn.h>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 115 matching lines @@
     : va_surface_id_(va_surface_id),
       release_cb_(release_cb) {
   DCHECK(!release_cb_.is_null());
 }
 
 VASurface::~VASurface() {
   release_cb_.Run(va_surface_id_);
 }
 
 VaapiWrapper::VaapiWrapper()
-    : va_display_(NULL),
+    : va_display_(nullptr),
       va_config_id_(VA_INVALID_ID),
       va_context_id_(VA_INVALID_ID) {
 }
 
 VaapiWrapper::~VaapiWrapper() {
   DestroyPendingBuffers();
   DestroyCodedBuffers();
   DestroySurfaces();
   Deinitialize();
 }
@@ skipping 202 matching lines @@
     VAStatus va_res = vaDestroyConfig(va_display_, va_config_id_);
     VA_LOG_ON_ERROR(va_res, "vaDestroyConfig failed");
   }
 
   if (va_display_) {
     VAStatus va_res = vaTerminate(va_display_);
     VA_LOG_ON_ERROR(va_res, "vaTerminate failed");
   }
 
   va_config_id_ = VA_INVALID_ID;
-  va_display_ = NULL;
+  va_display_ = nullptr;
 }
 
 bool VaapiWrapper::VAAPIVersionLessThan(int major, int minor) {
   return (major_version_ < major) ||
       (major_version_ == major && minor_version_ < minor);
 }
 
 bool VaapiWrapper::CreateSurfaces(gfx::Size size,
                                   size_t num_surfaces,
                                   std::vector<VASurfaceID>* va_surfaces) {
   base::AutoLock auto_lock(va_lock_);
   DVLOG(2) << "Creating " << num_surfaces << " surfaces";
 
   DCHECK(va_surfaces->empty());
   DCHECK(va_surface_ids_.empty());
   va_surface_ids_.resize(num_surfaces);
 
   // Allocate surfaces in driver.
   VAStatus va_res = vaCreateSurfaces(va_display_,
                                      VA_RT_FORMAT_YUV420,
                                      size.width(), size.height(),
                                      &va_surface_ids_[0],
                                      va_surface_ids_.size(),
-                                     NULL, 0);
+                                     nullptr, 0);
 
   VA_LOG_ON_ERROR(va_res, "vaCreateSurfaces failed");
   if (va_res != VA_STATUS_SUCCESS) {
     va_surface_ids_.clear();
     return false;
   }
 
   // And create a context associated with them.
   va_res = vaCreateContext(va_display_, va_config_id_,
                            size.width(), size.height(), VA_PROGRESSIVE,
@@ skipping 60 matching lines @@
     size_t size,
     void* buffer) {
   base::AutoLock auto_lock(va_lock_);
 
   VABufferID buffer_id;
   VAStatus va_res = vaCreateBuffer(va_display_,
                                    va_context_id_,
                                    VAEncMiscParameterBufferType,
                                    sizeof(VAEncMiscParameterBuffer) + size,
                                    1,
-                                   NULL,
+                                   nullptr,
                                    &buffer_id);
   VA_SUCCESS_OR_RETURN(va_res, "Failed to create a VA buffer", false);
 
-  void* data_ptr = NULL;
+  void* data_ptr = nullptr;
   va_res = vaMapBuffer(va_display_, buffer_id, &data_ptr);
   VA_LOG_ON_ERROR(va_res, "vaMapBuffer failed");
   if (va_res != VA_STATUS_SUCCESS) {
     vaDestroyBuffer(va_display_, buffer_id);
     return false;
   }
 
   DCHECK(data_ptr);
 
   VAEncMiscParameterBuffer* misc_param =
@@ skipping 24 matching lines @@
   pending_slice_bufs_.clear();
 }
 
 bool VaapiWrapper::CreateCodedBuffer(size_t size, VABufferID* buffer_id) {
   base::AutoLock auto_lock(va_lock_);
   VAStatus va_res = vaCreateBuffer(va_display_,
                                    va_context_id_,
                                    VAEncCodedBufferType,
                                    size,
                                    1,
-                                   NULL,
+                                   nullptr,
                                    buffer_id);
   VA_SUCCESS_OR_RETURN(va_res, "Failed to create a coded buffer", false);
 
   DCHECK(coded_buffers_.insert(*buffer_id).second);
   return true;
 }
 
 void VaapiWrapper::DestroyCodedBuffers() {
   base::AutoLock auto_lock(va_lock_);
 
@@ skipping 57 matching lines @@
 
   VAStatus va_res = vaSyncSurface(va_display_, va_surface_id);
   VA_SUCCESS_OR_RETURN(va_res, "Failed syncing surface", false);
 
   // Put the data into an X Pixmap.
   va_res = vaPutSurface(va_display_,
                         va_surface_id,
                         x_pixmap,
                         0, 0, dest_size.width(), dest_size.height(),
                         0, 0, dest_size.width(), dest_size.height(),
-                        NULL, 0, 0);
+                        nullptr, 0, 0);
   VA_SUCCESS_OR_RETURN(va_res, "Failed putting surface to pixmap", false);
   return true;
 }
 
 bool VaapiWrapper::GetVaImageForTesting(VASurfaceID va_surface_id,
                                         VAImage* image,
                                         void** mem) {
   base::AutoLock auto_lock(va_lock_);
 
   VAStatus va_res = vaSyncSurface(va_display_, va_surface_id);
@@ skipping 46 matching lines @@
   if (image.format.fourcc != VA_FOURCC_NV12) {
     LOG(ERROR) << "Unsupported image format: " << image.format.fourcc;
     return false;
   }
 
   if (gfx::Rect(image.width, image.height) < gfx::Rect(frame->coded_size())) {
     LOG(ERROR) << "Buffer too small to fit the frame.";
     return false;
   }
 
-  void* image_ptr = NULL;
+  void* image_ptr = nullptr;
   va_res = vaMapBuffer(va_display_, image.buf, &image_ptr);
   VA_SUCCESS_OR_RETURN(va_res, "vaMapBuffer failed", false);
   DCHECK(image_ptr);
 
   int ret = 0;
   {
     base::AutoUnlock auto_unlock(va_lock_);
     ret = libyuv::I420ToNV12(frame->data(media::VideoFrame::kYPlane),
                              frame->stride(media::VideoFrame::kYPlane),
                              frame->data(media::VideoFrame::kUPlane),
@@ skipping 17 matching lines @@
 bool VaapiWrapper::DownloadAndDestroyCodedBuffer(VABufferID buffer_id,
                                                  VASurfaceID sync_surface_id,
                                                  uint8* target_ptr,
                                                  size_t target_size,
                                                  size_t* coded_data_size) {
   base::AutoLock auto_lock(va_lock_);
 
   VAStatus va_res = vaSyncSurface(va_display_, sync_surface_id);
   VA_SUCCESS_OR_RETURN(va_res, "Failed syncing surface", false);
 
-  VACodedBufferSegment* buffer_segment = NULL;
+  VACodedBufferSegment* buffer_segment = nullptr;
   va_res = vaMapBuffer(
       va_display_, buffer_id, reinterpret_cast<void**>(&buffer_segment));
   VA_SUCCESS_OR_RETURN(va_res, "vaMapBuffer failed", false);
   DCHECK(target_ptr);
 
   {
     base::AutoUnlock auto_unlock(va_lock_);
     *coded_data_size = 0;
 
     while (buffer_segment) {
@@ skipping 16 matching lines @@
   }
 
   va_res = vaUnmapBuffer(va_display_, buffer_id);
   VA_LOG_ON_ERROR(va_res, "vaUnmapBuffer failed");
 
   va_res = vaDestroyBuffer(va_display_, buffer_id);
   VA_LOG_ON_ERROR(va_res, "vaDestroyBuffer failed");
 
   DCHECK(coded_buffers_.erase(buffer_id));
 
-  return buffer_segment == NULL;
+  return buffer_segment == nullptr;
 }
 
 // static
 bool VaapiWrapper::PostSandboxInitialization() {
   StubPathMap paths;
   paths[kModuleVa].push_back(kVaLib);
 
   return InitializeStubs(paths);
 }
 
 }  // namespace content