C++11 declares a type safe null pointer

content/common/gpu/client/gpu_video_encode_accelerator_host.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/client/gpu_video_encode_accelerator_host.h"
 
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "content/common/gpu/client/gpu_channel_host.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/gpu/media/gpu_video_encode_accelerator.h"
 #include "media/base/video_frame.h"
 
 namespace content {
 
 #define NOTIFY_ERROR(error) \
   PostNotifyError(error);   \
   DLOG(ERROR)
 
 GpuVideoEncodeAcceleratorHost::GpuVideoEncodeAcceleratorHost(
     GpuChannelHost* channel,
     CommandBufferProxyImpl* impl)
     : channel_(channel),
       encoder_route_id_(MSG_ROUTING_NONE),
-      client_(NULL),
+      client_(nullptr),
       impl_(impl),
       next_frame_id_(0),
       weak_this_factory_(this) {
   DCHECK(channel_);
   DCHECK(impl_);
   impl_->AddDeletionObserver(this);
 }
 
 GpuVideoEncodeAcceleratorHost::~GpuVideoEncodeAcceleratorHost() {
   DCHECK(CalledOnValidThread());
@@ skipping 21 matching lines @@
   // See OnNotifyError for why |this| mustn't be used after OnNotifyError might
   // have been called above.
   return handled;
 }
 
 void GpuVideoEncodeAcceleratorHost::OnChannelError() {
   DCHECK(CalledOnValidThread());
   if (channel_) {
     if (encoder_route_id_ != MSG_ROUTING_NONE)
       channel_->RemoveRoute(encoder_route_id_);
-    channel_ = NULL;
+    channel_ = nullptr;
   }
   NOTIFY_ERROR(kPlatformFailureError) << "OnChannelError()";
 }
 
 std::vector<media::VideoEncodeAccelerator::SupportedProfile>
 GpuVideoEncodeAcceleratorHost::GetSupportedProfiles() {
   DCHECK(CalledOnValidThread());
   if (!channel_)
     return std::vector<media::VideoEncodeAccelerator::SupportedProfile>();
   return channel_->gpu_info().video_encode_accelerator_supported_profiles;
@@ skipping 97 matching lines @@
     return;
 
   Send(new AcceleratedVideoEncoderMsg_RequestEncodingParametersChange(
       encoder_route_id_, bitrate, framerate));
 }
 
 void GpuVideoEncodeAcceleratorHost::Destroy() {
   DCHECK(CalledOnValidThread());
   if (channel_)
     Send(new AcceleratedVideoEncoderMsg_Destroy(encoder_route_id_));
-  client_ = NULL;
+  client_ = nullptr;
   delete this;
 }
 
 void GpuVideoEncodeAcceleratorHost::OnWillDeleteImpl() {
   DCHECK(CalledOnValidThread());
-  impl_ = NULL;
+  impl_ = nullptr;
 
   // The CommandBufferProxyImpl is going away; error out this VEA.
   OnChannelError();
 }
 
 void GpuVideoEncodeAcceleratorHost::PostNotifyError(Error error) {
   DCHECK(CalledOnValidThread());
   DVLOG(2) << "PostNotifyError(): error=" << error;
   // Post the error notification back to this thread, to avoid re-entrancy.
   base::MessageLoopProxy::current()->PostTask(
@@ skipping 36 matching lines @@
   // theoretical" - Android's std::hash_map crashes if we don't do this.
   scoped_refptr<media::VideoFrame> frame = frame_map_[frame_id];
   if (!frame_map_.erase(frame_id)) {
     DLOG(ERROR) << "OnNotifyInputDone(): "
                    "invalid frame_id=" << frame_id;
     // See OnNotifyError for why this needs to be the last thing in this
     // function.
     OnNotifyError(kPlatformFailureError);
     return;
   }
-  frame = NULL;  // Not necessary but nice to be explicit; see fun-fact above.
+  frame = nullptr; // Not necessary but nice to be explicit; see fun-fact above.
 }
 
 void GpuVideoEncodeAcceleratorHost::OnBitstreamBufferReady(
     int32 bitstream_buffer_id,
     uint32 payload_size,
     bool key_frame) {
   DCHECK(CalledOnValidThread());
   DVLOG(3) << "OnBitstreamBufferReady(): "
               "bitstream_buffer_id=" << bitstream_buffer_id
            << ", payload_size=" << payload_size
            << ", key_frame=" << key_frame;
   if (client_)
     client_->BitstreamBufferReady(bitstream_buffer_id, payload_size, key_frame);
 }
 
 void GpuVideoEncodeAcceleratorHost::OnNotifyError(Error error) {
   DCHECK(CalledOnValidThread());
   DVLOG(2) << "OnNotifyError(): error=" << error;
   if (!client_)
     return;
   weak_this_factory_.InvalidateWeakPtrs();
 
   // Client::NotifyError() may Destroy() |this|, so calling it needs to be the
   // last thing done on this stack!
-  media::VideoEncodeAccelerator::Client* client = NULL;
+  media::VideoEncodeAccelerator::Client* client = nullptr;
   std::swap(client_, client);
   client->NotifyError(error);
 }
 
 }  // namespace content