C++11 declares a type safe null pointer

content/common/gpu/media/vaapi_h264_decoder.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 <algorithm>
 #include <limits>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/numerics/safe_conversions.h"
@@ skipping 163 matching lines @@
       FillVAPicture(&va_pics[i++], *rit);
   }
 
   return i;
 }
 
 VaapiH264Decoder::DecodeSurface* VaapiH264Decoder::DecodeSurfaceByPoC(int poc) {
   DecSurfacesInUse::iterator iter = decode_surfaces_in_use_.find(poc);
   if (iter == decode_surfaces_in_use_.end()) {
     DVLOG(1) << "Could not find surface assigned to POC: " << poc;
-    return NULL;
+    return nullptr;
   }
 
   return iter->second.get();
 }
 
 bool VaapiH264Decoder::AssignSurfaceToPoC(int32 input_id, int poc) {
   if (available_va_surfaces_.empty()) {
     DVLOG(1) << "No VA Surfaces available";
     return false;
   }
@@ skipping 1063 matching lines @@
             std::max<int>(parser_.GetSPS(curr_sps_id_)->max_num_ref_frames,
                           1));
         if (dpb_.CountRefPics() ==
             std::max<int>(parser_.GetSPS(curr_sps_id_)->max_num_ref_frames,
                           1)) {
           // Max number of reference pics reached,
           // need to remove one of the short term ones.
           // Find smallest frame_num_wrap short reference picture and mark
           // it as unused.
           H264Picture* to_unmark = dpb_.GetLowestFrameNumWrapShortRefPic();
-          if (to_unmark == NULL) {
+          if (to_unmark == nullptr) {
             DVLOG(1) << "Couldn't find a short ref picture to unmark";
             return;
           }
           to_unmark->ref = false;
         }
       } else {
         // Shouldn't get here.
         DVLOG(1) << "Interlaced video not supported.";
         report_error_to_uma_cb_.Run(INTERLACED_STREAM);
       }
@@ skipping 232 matching lines @@
   const media::H264PPS* pps = parser_.GetPPS(pps_id);
   DCHECK(pps);
 
   curr_pps_id_ = pps->pic_parameter_set_id;
 
   return true;
 }
 
 bool VaapiH264Decoder::FinishPrevFrameIfPresent() {
   // If we already have a frame waiting to be decoded, decode it and finish.
-  if (curr_pic_ != NULL) {
+  if (curr_pic_ != nullptr) {
     if (!DecodePicture())
       return false;
     return FinishPicture();
   }
 
   return true;
 }
 
 bool VaapiH264Decoder::ProcessSlice(media::H264SliceHeader* slice_hdr) {
   prev_frame_num_ = frame_num_;
   frame_num_ = slice_hdr->frame_num;
 
   if (prev_frame_num_ > 0 && prev_frame_num_ < frame_num_ - 1) {
     DVLOG(1) << "Gap in frame_num!";
     report_error_to_uma_cb_.Run(GAPS_IN_FRAME_NUM);
     return false;
   }
 
   if (slice_hdr->field_pic_flag == 0)
     max_pic_num_ = max_frame_num_;
   else
     max_pic_num_ = 2 * max_frame_num_;
 
   // TODO posciak: switch to new picture detection per 7.4.1.2.4.
-  if (curr_pic_ != NULL && slice_hdr->first_mb_in_slice != 0) {
+  if (curr_pic_ != nullptr && slice_hdr->first_mb_in_slice != 0) {
     // This is just some more slice data of the current picture, so
     // just queue it and return.
     QueueSlice(slice_hdr);
     return true;
   } else {
     // A new frame, so first finish the previous one before processing it...
     if (!FinishPrevFrameIfPresent())
       return false;
 
     // and then start a new one.
@@ skipping 124 matching lines @@
         break;
     }
   }
 }
 
 size_t VaapiH264Decoder::GetRequiredNumOfPictures() {
   return dpb_.max_num_pics() + kPicsInPipeline;
 }
 
 }  // namespace content