C++11 declares a type safe null pointer

content/common/gpu/media/dxva_video_decode_accelerator.cc

 // Copyright (c) 2012 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/dxva_video_decode_accelerator.h"
 
 #if !defined(OS_WIN)
 #error This file should only be built on Windows.
 #endif   // !defined(OS_WIN)
 
@@ skipping 53 matching lines @@
                                error_code, ret);
 
 // Maximum number of iterations we allow before aborting the attempt to flush
 // the batched queries to the driver and allow torn/corrupt frames to be
 // rendered.
 enum { kMaxIterationsForD3DFlush = 10 };
 
 static IMFSample* CreateEmptySample() {
   base::win::ScopedComPtr<IMFSample> sample;
   HRESULT hr = MFCreateSample(sample.Receive());
-  RETURN_ON_HR_FAILURE(hr, "MFCreateSample failed", NULL);
+  RETURN_ON_HR_FAILURE(hr, "MFCreateSample failed", nullptr);
   return sample.Detach();
 }
 
 // Creates a Media Foundation sample with one buffer of length |buffer_length|
 // on a |align|-byte boundary. Alignment must be a perfect power of 2 or 0.
 static IMFSample* CreateEmptySampleWithBuffer(int buffer_length, int align) {
   CHECK_GT(buffer_length, 0);
 
   base::win::ScopedComPtr<IMFSample> sample;
   sample.Attach(CreateEmptySample());
 
   base::win::ScopedComPtr<IMFMediaBuffer> buffer;
   HRESULT hr = E_FAIL;
   if (align == 0) {
     // Note that MFCreateMemoryBuffer is same as MFCreateAlignedMemoryBuffer
     // with the align argument being 0.
     hr = MFCreateMemoryBuffer(buffer_length, buffer.Receive());
   } else {
     hr = MFCreateAlignedMemoryBuffer(buffer_length,
                                      align - 1,
                                      buffer.Receive());
   }
-  RETURN_ON_HR_FAILURE(hr, "Failed to create memory buffer for sample", NULL);
+  RETURN_ON_HR_FAILURE(hr, "Failed to create memory buffer for sample",
+                       nullptr);
 
   hr = sample->AddBuffer(buffer);
-  RETURN_ON_HR_FAILURE(hr, "Failed to add buffer to sample", NULL);
+  RETURN_ON_HR_FAILURE(hr, "Failed to add buffer to sample", nullptr);
 
   return sample.Detach();
 }
 
 // Creates a Media Foundation sample with one buffer containing a copy of the
 // given Annex B stream data.
 // If duration and sample time are not known, provide 0.
 // |min_size| specifies the minimum size of the buffer (might be required by
 // the decoder for input). If no alignment is required, provide 0.
 static IMFSample* CreateInputSample(const uint8* stream, int size,
                                     int min_size, int alignment) {
   CHECK(stream);
   CHECK_GT(size, 0);
   base::win::ScopedComPtr<IMFSample> sample;
   sample.Attach(CreateEmptySampleWithBuffer(std::max(min_size, size),
                                             alignment));
-  RETURN_ON_FAILURE(sample, "Failed to create empty sample", NULL);
+  RETURN_ON_FAILURE(sample, "Failed to create empty sample", nullptr);
 
   base::win::ScopedComPtr<IMFMediaBuffer> buffer;
   HRESULT hr = sample->GetBufferByIndex(0, buffer.Receive());
-  RETURN_ON_HR_FAILURE(hr, "Failed to get buffer from sample", NULL);
+  RETURN_ON_HR_FAILURE(hr, "Failed to get buffer from sample", nullptr);
 
   DWORD max_length = 0;
   DWORD current_length = 0;
-  uint8* destination = NULL;
+  uint8* destination = nullptr;
   hr = buffer->Lock(&destination, &max_length, &current_length);
-  RETURN_ON_HR_FAILURE(hr, "Failed to lock buffer", NULL);
+  RETURN_ON_HR_FAILURE(hr, "Failed to lock buffer", nullptr);
 
   CHECK_EQ(current_length, 0u);
   CHECK_GE(static_cast<int>(max_length), size);
   memcpy(destination, stream, size);
 
   hr = buffer->Unlock();
-  RETURN_ON_HR_FAILURE(hr, "Failed to unlock buffer", NULL);
+  RETURN_ON_HR_FAILURE(hr, "Failed to unlock buffer", nullptr);
 
   hr = buffer->SetCurrentLength(size);
-  RETURN_ON_HR_FAILURE(hr, "Failed to set buffer length", NULL);
+  RETURN_ON_HR_FAILURE(hr, "Failed to set buffer length", nullptr);
 
   return sample.Detach();
 }
 
 static IMFSample* CreateSampleFromInputBuffer(
     const media::BitstreamBuffer& bitstream_buffer,
     DWORD stream_size,
     DWORD alignment) {
   base::SharedMemory shm(bitstream_buffer.handle(), true);
   RETURN_ON_FAILURE(shm.Map(bitstream_buffer.size()),
-                    "Failed in base::SharedMemory::Map", NULL);
+                    "Failed in base::SharedMemory::Map", nullptr);
 
   return CreateInputSample(reinterpret_cast<const uint8*>(shm.memory()),
                            bitstream_buffer.size(),
                            stream_size,
                            alignment);
 }
 
 // Maintains information about a DXVA picture buffer, i.e. whether it is
 // available for rendering, the texture information, etc.
 struct DXVAVideoDecodeAccelerator::DXVAPictureBuffer {
@@ skipping 63 matching lines @@
     EGL_TEXTURE_TARGET, EGL_TEXTURE_2D,
     EGL_NONE
   };
 
   picture_buffer->decoding_surface_ = eglCreatePbufferSurface(
       egl_display,
       egl_config,
       attrib_list);
   RETURN_ON_FAILURE(picture_buffer->decoding_surface_,
                     "Failed to create surface",
-                    linked_ptr<DXVAPictureBuffer>(NULL));
+                    linked_ptr<DXVAPictureBuffer>(nullptr));
 
-  HANDLE share_handle = NULL;
+  HANDLE share_handle = nullptr;
   EGLBoolean ret = eglQuerySurfacePointerANGLE(
       egl_display,
       picture_buffer->decoding_surface_,
       EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE,
       &share_handle);
 
   RETURN_ON_FAILURE(share_handle && ret == EGL_TRUE,
                     "Failed to query ANGLE surface pointer",
-                    linked_ptr<DXVAPictureBuffer>(NULL));
+                    linked_ptr<DXVAPictureBuffer>(nullptr));
 
   HRESULT hr = decoder.device_->CreateTexture(
       buffer.size().width(),
       buffer.size().height(),
       1,
       D3DUSAGE_RENDERTARGET,
       use_rgb ? D3DFMT_X8R8G8B8 : D3DFMT_A8R8G8B8,
       D3DPOOL_DEFAULT,
       picture_buffer->decoding_texture_.Receive(),
       &share_handle);
 
   RETURN_ON_HR_FAILURE(hr, "Failed to create texture",
-                       linked_ptr<DXVAPictureBuffer>(NULL));
+                       linked_ptr<DXVAPictureBuffer>(nullptr));
   picture_buffer->use_rgb_ = !!use_rgb;
   return picture_buffer;
 }
 
 DXVAVideoDecodeAccelerator::DXVAPictureBuffer::DXVAPictureBuffer(
     const media::PictureBuffer& buffer)
     : available_(true),
       picture_buffer_(buffer),
-      decoding_surface_(NULL),
+      decoding_surface_(nullptr),
       use_rgb_(true) {
 }
 
 DXVAVideoDecodeAccelerator::DXVAPictureBuffer::~DXVAPictureBuffer() {
   if (decoding_surface_) {
     EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
 
     eglReleaseTexImage(
         egl_display,
         decoding_surface_,
         EGL_BACK_BUFFER);
 
     eglDestroySurface(
         egl_display,
         decoding_surface_);
-    decoding_surface_ = NULL;
+    decoding_surface_ = nullptr;
   }
 }
 
 void DXVAVideoDecodeAccelerator::DXVAPictureBuffer::ReusePictureBuffer() {
   DCHECK(decoding_surface_);
   EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
   eglReleaseTexImage(
     egl_display,
     decoding_surface_,
     EGL_BACK_BUFFER);
@@ skipping 31 matching lines @@
 
   glBindTexture(GL_TEXTURE_2D, picture_buffer_.texture_id());
 
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 
   base::win::ScopedComPtr<IDirect3DSurface9> d3d_surface;
   hr = decoding_texture_->GetSurfaceLevel(0, d3d_surface.Receive());
   RETURN_ON_HR_FAILURE(hr, "Failed to get surface from texture", false);
 
   hr = decoder.device_->StretchRect(
-      dest_surface, NULL, d3d_surface, NULL, D3DTEXF_NONE);
+      dest_surface, nullptr, d3d_surface, nullptr, D3DTEXF_NONE);
   RETURN_ON_HR_FAILURE(hr, "Colorspace conversion via StretchRect failed",
                         false);
 
   // Ideally, this should be done immediately before the draw call that uses
   // the texture. Flush it once here though.
   hr = decoder.query_->Issue(D3DISSUE_END);
   RETURN_ON_HR_FAILURE(hr, "Failed to issue END", false);
 
   // The DXVA decoder has its own device which it uses for decoding. ANGLE
   // has its own device which we don't have access to.
   // The above code attempts to copy the decoded picture into a surface
   // which is owned by ANGLE. As there are multiple devices involved in
   // this, the StretchRect call above is not synchronous.
   // We attempt to flush the batched operations to ensure that the picture is
   // copied to the surface owned by ANGLE.
   // We need to do this in a loop and call flush multiple times.
   // We have seen the GetData call for flushing the command buffer fail to
   // return success occassionally on multi core machines, leading to an
   // infinite loop.
   // Workaround is to have an upper limit of 10 on the number of iterations to
   // wait for the Flush to finish.
   int iterations = 0;
-  while ((decoder.query_->GetData(NULL, 0, D3DGETDATA_FLUSH) == S_FALSE) &&
+  while ((decoder.query_->GetData(nullptr, 0, D3DGETDATA_FLUSH) == S_FALSE) &&
          ++iterations < kMaxIterationsForD3DFlush) {
     Sleep(1);  // Poor-man's Yield().
   }
   EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
   eglBindTexImage(
       egl_display,
       decoding_surface_,
       EGL_BACK_BUFFER);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glBindTexture(GL_TEXTURE_2D, current_texture);
@@ skipping 28 matching lines @@
   present_params.PresentationInterval = 0;
 
   hr = d3d9_->CreateDeviceEx(D3DADAPTER_DEFAULT,
                              D3DDEVTYPE_HAL,
                              ::GetShellWindow(),
                              D3DCREATE_FPU_PRESERVE |
                              D3DCREATE_SOFTWARE_VERTEXPROCESSING |
                              D3DCREATE_DISABLE_PSGP_THREADING |
                              D3DCREATE_MULTITHREADED,
                              &present_params,
-                             NULL,
+                             nullptr,
                              device_.Receive());
   RETURN_ON_HR_FAILURE(hr, "Failed to create D3D device", false);
 
   hr = DXVA2CreateDirect3DDeviceManager9(&dev_manager_reset_token_,
                                          device_manager_.Receive());
   RETURN_ON_HR_FAILURE(hr, "DXVA2CreateDirect3DDeviceManager9 failed", false);
 
   hr = device_manager_->ResetDevice(device_, dev_manager_reset_token_);
   RETURN_ON_HR_FAILURE(hr, "Failed to reset device", false);
 
   hr = device_->CreateQuery(D3DQUERYTYPE_EVENT, query_.Receive());
   RETURN_ON_HR_FAILURE(hr, "Failed to create D3D device query", false);
   // Ensure query_ API works (to avoid an infinite loop later in
   // CopyOutputSampleDataToPictureBuffer).
   hr = query_->Issue(D3DISSUE_END);
   RETURN_ON_HR_FAILURE(hr, "Failed to issue END test query", false);
   return true;
 }
 
 DXVAVideoDecodeAccelerator::DXVAVideoDecodeAccelerator(
     const base::Callback<bool(void)>& make_context_current)
-    : client_(NULL),
+    : client_(nullptr),
       dev_manager_reset_token_(0),
-      egl_config_(NULL),
+      egl_config_(nullptr),
       state_(kUninitialized),
       pictures_requested_(false),
       inputs_before_decode_(0),
       make_context_current_(make_context_current),
       weak_this_factory_(this) {
   memset(&input_stream_info_, 0, sizeof(input_stream_info_));
   memset(&output_stream_info_, 0, sizeof(output_stream_info_));
 }
 
 DXVAVideoDecodeAccelerator::~DXVAVideoDecodeAccelerator() {
-  client_ = NULL;
+  client_ = nullptr;
 }
 
 bool DXVAVideoDecodeAccelerator::Initialize(media::VideoCodecProfile profile,
                                             Client* client) {
   DCHECK(CalledOnValidThread());
 
   client_ = client;
 
   // Not all versions of Windows 7 and later include Media Foundation DLLs.
   // Instead of crashing while delay loading the DLL when calling MFStartup()
@@ skipping 221 matching lines @@
       GetProcAddress(decoder_dll, "DllGetClassObject"));
   RETURN_ON_FAILURE(
       get_class_object, "Failed to get DllGetClassObject pointer", false);
 
   base::win::ScopedComPtr<IClassFactory> factory;
   HRESULT hr = get_class_object(__uuidof(CMSH264DecoderMFT),
                                 __uuidof(IClassFactory),
                                 reinterpret_cast<void**>(factory.Receive()));
   RETURN_ON_HR_FAILURE(hr, "DllGetClassObject for decoder failed", false);
 
-  hr = factory->CreateInstance(NULL,
+  hr = factory->CreateInstance(nullptr,
                                __uuidof(IMFTransform),
                                reinterpret_cast<void**>(decoder_.Receive()));
   RETURN_ON_HR_FAILURE(hr, "Failed to create decoder instance", false);
 
   RETURN_ON_FAILURE(CheckDecoderDxvaSupport(),
                     "Failed to check decoder DXVA support", false);
 
   hr = decoder_->ProcessMessage(
             MFT_MESSAGE_SET_D3D_MANAGER,
             reinterpret_cast<ULONG_PTR>(device_manager_.get()));
@@ skipping 135 matching lines @@
       "DoDecode: not in normal/flushing/stopped state", ILLEGAL_STATE,);
 
   MFT_OUTPUT_DATA_BUFFER output_data_buffer = {0};
   DWORD status = 0;
 
   HRESULT hr = decoder_->ProcessOutput(0,  // No flags
                                        1,  // # of out streams to pull from
                                        &output_data_buffer,
                                        &status);
   IMFCollection* events = output_data_buffer.pEvents;
-  if (events != NULL) {
+  if (events != nullptr) {
     VLOG(1) << "Got events from ProcessOuput, but discarding";
     events->Release();
   }
   if (FAILED(hr)) {
     // A stream change needs further ProcessInput calls to get back decoder
     // output which is why we need to set the state to stopped.
     if (hr == MF_E_TRANSFORM_STREAM_CHANGE) {
       if (!SetDecoderOutputMediaType(MFVideoFormat_NV12)) {
         // Decoder didn't let us set NV12 output format. Not sure as to why
         // this can happen. Give up in disgust.
@@ skipping 19 matching lines @@
   TRACE_COUNTER1("DXVA Decoding", "TotalPacketsBeforeDecode",
                  inputs_before_decode_);
 
   inputs_before_decode_ = 0;
 
   RETURN_AND_NOTIFY_ON_FAILURE(ProcessOutputSample(output_data_buffer.pSample),
       "Failed to process output sample.", PLATFORM_FAILURE,);
 }
 
 bool DXVAVideoDecodeAccelerator::ProcessOutputSample(IMFSample* sample) {
-  RETURN_ON_FAILURE(sample, "Decode succeeded with NULL output sample", false);
+  RETURN_ON_FAILURE(sample, "Decode succeeded with nullptr output sample",
+                    false);
 
   base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
   HRESULT hr = sample->GetBufferByIndex(0, output_buffer.Receive());
   RETURN_ON_HR_FAILURE(hr, "Failed to get buffer from output sample", false);
 
   base::win::ScopedComPtr<IDirect3DSurface9> surface;
   hr = MFGetService(output_buffer, MR_BUFFER_SERVICE,
                     IID_PPV_ARGS(surface.Receive()));
   RETURN_ON_HR_FAILURE(hr, "Failed to get D3D surface from output sample",
                        false);
@@ skipping 101 matching lines @@
                    weak_this_factory_.GetWeakPtr()));
   }
 }
 
 void DXVAVideoDecodeAccelerator::StopOnError(
   media::VideoDecodeAccelerator::Error error) {
   DCHECK(CalledOnValidThread());
 
   if (client_)
     client_->NotifyError(error);
-  client_ = NULL;
+  client_ = nullptr;
 
   if (state_ != kUninitialized) {
     Invalidate();
   }
 }
 
 void DXVAVideoDecodeAccelerator::Invalidate() {
   if (state_ == kUninitialized)
     return;
   weak_this_factory_.InvalidateWeakPtrs();
@@ skipping 208 matching lines @@
     int32 picture_buffer_id) {
   OutputBuffers::iterator it = stale_output_picture_buffers_.find(
       picture_buffer_id);
   DCHECK(it != stale_output_picture_buffers_.end());
   DVLOG(1) << "Dismissing picture id: " << it->second->id();
   client_->DismissPictureBuffer(it->second->id());
   stale_output_picture_buffers_.erase(it);
 }
 
 }  // namespace content