C++11 declares a type safe null pointer

content/common/gpu/gpu_channel_manager.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/gpu_channel_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/gpu_memory_buffer_factory.h"
@@ skipping 11 matching lines @@
 #include "ui/gl/gl_share_group.h"
 
 namespace content {
 
 namespace {
 
 class GpuChannelManagerMessageFilter : public IPC::MessageFilter {
  public:
   GpuChannelManagerMessageFilter(
       GpuMemoryBufferFactory* gpu_memory_buffer_factory)
-      : sender_(NULL), gpu_memory_buffer_factory_(gpu_memory_buffer_factory) {}
+      : sender_(nullptr),
+        gpu_memory_buffer_factory_(gpu_memory_buffer_factory) {}
 
   virtual void OnFilterAdded(IPC::Sender* sender) override {
     DCHECK(!sender_);
     sender_ = sender;
   }
 
   virtual void OnFilterRemoved() override {
     DCHECK(sender_);
-    sender_ = NULL;
+    sender_ = nullptr;
   }
 
   virtual bool OnMessageReceived(const IPC::Message& message) override {
     DCHECK(sender_);
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(GpuChannelManagerMessageFilter, message)
       IPC_MESSAGE_HANDLER(GpuMsg_CreateGpuMemoryBuffer, OnCreateGpuMemoryBuffer)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
     return handled;
@@ skipping 44 matching lines @@
   DCHECK(router_);
   DCHECK(io_message_loop);
   DCHECK(shutdown_event);
   channel_->AddFilter(filter_.get());
 }
 
 GpuChannelManager::~GpuChannelManager() {
   gpu_channels_.clear();
   if (default_offscreen_surface_.get()) {
     default_offscreen_surface_->Destroy();
-    default_offscreen_surface_ = NULL;
+    default_offscreen_surface_ = nullptr;
   }
 }
 
 gpu::gles2::ProgramCache* GpuChannelManager::program_cache() {
   if (!program_cache_.get() &&
       (gfx::g_driver_gl.ext.b_GL_ARB_get_program_binary ||
        gfx::g_driver_gl.ext.b_GL_OES_get_program_binary) &&
       !CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableGpuProgramCache)) {
     program_cache_.reset(new gpu::gles2::MemoryProgramCache());
@@ skipping 22 matching lines @@
   router_->AddRoute(routing_id, listener);
 }
 
 void GpuChannelManager::RemoveRoute(int32 routing_id) {
   router_->RemoveRoute(routing_id);
 }
 
 GpuChannel* GpuChannelManager::LookupChannel(int32 client_id) {
   GpuChannelMap::const_iterator iter = gpu_channels_.find(client_id);
   if (iter == gpu_channels_.end())
-    return NULL;
+    return nullptr;
   else
     return iter->second;
 }
 
 bool GpuChannelManager::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuChannelManager, msg)
     IPC_MESSAGE_HANDLER(GpuMsg_EstablishChannel, OnEstablishChannel)
     IPC_MESSAGE_HANDLER(GpuMsg_CloseChannel, OnCloseChannel)
     IPC_MESSAGE_HANDLER(GpuMsg_CreateViewCommandBuffer,
                         OnCreateViewCommandBuffer)
     IPC_MESSAGE_HANDLER(GpuMsg_DestroyGpuMemoryBuffer, OnDestroyGpuMemoryBuffer)
     IPC_MESSAGE_HANDLER(GpuMsg_LoadedShader, OnLoadedShader)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 bool GpuChannelManager::Send(IPC::Message* msg) { return router_->Send(msg); }
 
 void GpuChannelManager::OnEstablishChannel(int client_id,
                                            bool share_context,
                                            bool allow_future_sync_points) {
   IPC::ChannelHandle channel_handle;
 
-  gfx::GLShareGroup* share_group = NULL;
-  gpu::gles2::MailboxManager* mailbox_manager = NULL;
+  gfx::GLShareGroup* share_group = nullptr;
+  gpu::gles2::MailboxManager* mailbox_manager = nullptr;
   if (share_context) {
     if (!share_group_.get()) {
       share_group_ = new gfx::GLShareGroup;
       DCHECK(!mailbox_manager_.get());
       mailbox_manager_ = new gpu::gles2::MailboxManager;
     }
     share_group = share_group_.get();
     mailbox_manager = mailbox_manager_.get();
   }
 
@@ skipping 117 matching lines @@
 
 gfx::GLSurface* GpuChannelManager::GetDefaultOffscreenSurface() {
   if (!default_offscreen_surface_.get()) {
     default_offscreen_surface_ =
         gfx::GLSurface::CreateOffscreenGLSurface(gfx::Size());
   }
   return default_offscreen_surface_.get();
 }
 
 }  // namespace content