C++11 declares a type safe null pointer

content/common/gpu/client/gpu_channel_host.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/client/gpu_channel_host.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 55 matching lines @@
                                const gpu::GPUInfo& gpu_info)
     : factory_(factory),
       gpu_info_(gpu_info) {
   next_transfer_buffer_id_.GetNext();
   next_gpu_memory_buffer_id_.GetNext();
   next_route_id_.GetNext();
 }
 
 void GpuChannelHost::Connect(const IPC::ChannelHandle& channel_handle,
                              base::WaitableEvent* shutdown_event) {
-  // Open a channel to the GPU process. We pass NULL as the main listener here
-  // since we need to filter everything to route it to the right thread.
+  // Open a channel to the GPU process. We pass nullptr as the main listener
+  // here since we need to filter everything to route it to the right thread.
   scoped_refptr<base::MessageLoopProxy> io_loop = factory_->GetIOLoopProxy();
   channel_ = IPC::SyncChannel::Create(channel_handle,
                                       IPC::Channel::MODE_CLIENT,
-                                      NULL,
+                                      nullptr,
                                       io_loop.get(),
                                       true,
                                       shutdown_event);
 
   sync_filter_ = new IPC::SyncMessageFilter(shutdown_event);
 
   channel_->AddFilter(sync_filter_.get());
 
   channel_filter_ = new MessageFilter();
 
@@ skipping 66 matching lines @@
       DCHECK(MessageLoopProxy::current().get());
 
       scoped_refptr<base::MessageLoopProxy> io_loop =
           factory_->GetIOLoopProxy();
       io_loop->PostTask(
           FROM_HERE,
           base::Bind(&GpuChannelHost::MessageFilter::OnChannelError,
                      channel_filter_.get()));
     }
 
-    return NULL;
+    return nullptr;
   }
 
   CommandBufferProxyImpl* command_buffer =
       new CommandBufferProxyImpl(this, route_id);
   AddRoute(route_id, command_buffer->AsWeakPtr());
 
   AutoLock lock(context_lock_);
   proxies_[route_id] = command_buffer;
   return command_buffer;
 }
@@ skipping 12 matching lines @@
   init_params.attribs = attribs;
   init_params.active_url = active_url;
   init_params.gpu_preference = gpu_preference;
   int32 route_id = GenerateRouteID();
   bool succeeded = false;
   if (!Send(new GpuChannelMsg_CreateOffscreenCommandBuffer(size,
                                                            init_params,
                                                            route_id,
                                                            &succeeded))) {
     LOG(ERROR) << "Failed to send GpuChannelMsg_CreateOffscreenCommandBuffer.";
-    return NULL;
+    return nullptr;
   }
 
   if (!succeeded) {
     LOG(ERROR)
         << "GpuChannelMsg_CreateOffscreenCommandBuffer returned failure.";
-    return NULL;
+    return nullptr;
   }
 
   CommandBufferProxyImpl* command_buffer =
       new CommandBufferProxyImpl(this, route_id);
   AddRoute(route_id, command_buffer->AsWeakPtr());
 
   AutoLock lock(context_lock_);
   proxies_[route_id] = command_buffer;
   return command_buffer;
 }
@@ skipping 188 matching lines @@
 
   listeners_.clear();
 }
 
 bool GpuChannelHost::MessageFilter::IsLost() const {
   AutoLock lock(lock_);
   return lost_;
 }
 
 }  // namespace content