C++11 declares a type safe null pointer

content/common/gpu/gpu_command_buffer_stub.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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/hash.h"
 #include "base/json/json_writer.h"
@@ skipping 174 matching lines @@
 
   if (share_group) {
     context_group_ = share_group->context_group_;
     DCHECK(context_group_->bind_generates_resource() ==
            attrib_parser.bind_generates_resource);
   } else {
     context_group_ = new gpu::gles2::ContextGroup(
         mailbox_manager,
         new GpuCommandBufferMemoryTracker(channel),
         channel_->gpu_channel_manager()->shader_translator_cache(),
-        NULL,
+        nullptr,
         attrib_parser.bind_generates_resource);
   }
 
   use_virtualized_gl_context_ |=
       context_group_->feature_info()->workarounds().use_virtualized_gl_contexts;
 }
 
 GpuCommandBufferStub::~GpuCommandBufferStub() {
   Destroy();
 
@@ skipping 202 matching lines @@
     gpu_channel_manager->Send(new GpuHostMsg_DidDestroyOffscreenContext(
         active_url_));
   }
 
   memory_manager_client_state_.reset();
 
   while (!sync_points_.empty())
     OnRetireSyncPoint(sync_points_.front());
 
   if (decoder_)
-    decoder_->set_engine(NULL);
+    decoder_->set_engine(nullptr);
 
   // The scheduler has raw references to the decoder and the command buffer so
   // destroy it before those.
   scheduler_.reset();
 
   bool have_context = false;
   if (decoder_ && command_buffer_ &&
       command_buffer_->GetLastState().error != gpu::error::kLostContext)
     have_context = decoder_->MakeCurrent();
   FOR_EACH_OBSERVER(DestructionObserver,
                     destruction_observers_,
                     OnWillDestroyStub());
 
   if (decoder_) {
     decoder_->Destroy(have_context);
     decoder_.reset();
   }
 
   command_buffer_.reset();
 
   // Remove this after crbug.com/248395 is sorted out.
-  surface_ = NULL;
+  surface_ = nullptr;
 }
 
 void GpuCommandBufferStub::OnInitializeFailed(IPC::Message* reply_message) {
   Destroy();
   GpuCommandBufferMsg_Initialize::WriteReplyParams(
       reply_message, false, gpu::Capabilities());
   Send(reply_message);
 }
 
 void GpuCommandBufferStub::OnInitialize(
@@ skipping 62 matching lines @@
     }
     // This should be a non-virtual GL context.
     DCHECK(context->GetHandle());
     context = new gpu::GLContextVirtual(
         channel_->share_group(), context.get(), decoder_->AsWeakPtr());
     if (!context->Initialize(surface_.get(), gpu_preference_)) {
       // TODO(sievers): The real context created above for the default
       // offscreen surface might not be compatible with this surface.
       // Need to adjust at least GLX to be able to create the initial context
       // with a config that is compatible with onscreen and offscreen surfaces.
-      context = NULL;
+      context = nullptr;
 
       DLOG(ERROR) << "Failed to initialize virtual GL context.";
       OnInitializeFailed(reply_message);
       return;
     }
   }
   if (!context.get()) {
     context = gfx::GLContext::CreateGLContext(
         channel_->share_group(), surface_.get(), gpu_preference_);
   }
@@ skipping 553 matching lines @@
 uint64 GpuCommandBufferStub::GetMemoryUsage() const {
   return GetMemoryManager()->GetClientMemoryUsage(this);
 }
 
 void GpuCommandBufferStub::SwapBuffersCompleted(
     const std::vector<ui::LatencyInfo>& latency_info) {
   Send(new GpuCommandBufferMsg_SwapBuffersCompleted(route_id_, latency_info));
 }
 
 }  // namespace content