C++11 declares a type safe null pointer

content/common/gpu/gpu_channel.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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/common/gpu/gpu_channel.h"
 
@@ skipping 58 matching lines @@
 //   into the channel's queue.
 // - it generates mailbox names for clients of the GPU process on the IO thread.
 class GpuChannelMessageFilter : public IPC::MessageFilter {
  public:
   GpuChannelMessageFilter(base::WeakPtr<GpuChannel> gpu_channel,
                           scoped_refptr<SyncPointManager> sync_point_manager,
                           scoped_refptr<base::MessageLoopProxy> message_loop,
                           bool future_sync_points)
       : preemption_state_(IDLE),
         gpu_channel_(gpu_channel),
-        sender_(NULL),
+        sender_(nullptr),
         sync_point_manager_(sync_point_manager),
         message_loop_(message_loop),
         messages_forwarded_to_channel_(0),
         a_stub_is_descheduled_(false),
         future_sync_points_(future_sync_points) {}
 
   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 = false;
     if ((message.type() == GpuCommandBufferMsg_RetireSyncPoint::ID) &&
         !future_sync_points_) {
       DLOG(ERROR) << "Untrusted client should not send "
                      "GpuCommandBufferMsg_RetireSyncPoint message";
@@ skipping 298 matching lines @@
                        bool software,
                        bool allow_future_sync_points)
     : gpu_channel_manager_(gpu_channel_manager),
       messages_processed_(0),
       client_id_(client_id),
       share_group_(share_group ? share_group : new gfx::GLShareGroup),
       mailbox_manager_(mailbox ? mailbox : new gpu::gles2::MailboxManager),
       watchdog_(watchdog),
       software_(software),
       handle_messages_scheduled_(false),
-      currently_processing_message_(NULL),
+      currently_processing_message_(nullptr),
       num_stubs_descheduled_(0),
       allow_future_sync_points_(allow_future_sync_points),
       weak_factory_(this) {
   DCHECK(gpu_channel_manager);
   DCHECK(client_id);
 
   channel_id_ = IPC::Channel::GenerateVerifiedChannelID("gpu");
   const base::CommandLine* command_line =
       base::CommandLine::ForCurrentProcess();
   log_messages_ = command_line->HasSwitch(switches::kLogPluginMessages);
@@ skipping 81 matching lines @@
   }
 
   return channel_->Send(message);
 }
 
 void GpuChannel::RequeueMessage() {
   DCHECK(currently_processing_message_);
   deferred_messages_.push_front(
       new IPC::Message(*currently_processing_message_));
   messages_processed_--;
-  currently_processing_message_ = NULL;
+  currently_processing_message_ = nullptr;
 }
 
 void GpuChannel::OnScheduled() {
   if (handle_messages_scheduled_)
     return;
   // Post a task to handle any deferred messages. The deferred message queue is
   // not emptied here, which ensures that OnMessageReceived will continue to
   // defer newly received messages until the ones in the queue have all been
   // handled by HandleMessage. HandleMessage is invoked as a
   // task to prevent reentrancy.
@@ skipping 135 matching lines @@
   IPC_END_MESSAGE_MAP()
   DCHECK(handled) << msg.type();
   return handled;
 }
 
 void GpuChannel::HandleMessage() {
   handle_messages_scheduled_ = false;
   if (deferred_messages_.empty())
     return;
 
-  IPC::Message* m = NULL;
-  GpuCommandBufferStub* stub = NULL;
+  IPC::Message* m = nullptr;
+  GpuCommandBufferStub* stub = nullptr;
 
   m = deferred_messages_.front();
   stub = stubs_.Lookup(m->routing_id());
   if (stub) {
     if (!stub->IsScheduled())
       return;
     if (stub->IsPreempted()) {
       OnScheduled();
       return;
     }
   }
 
   scoped_ptr<IPC::Message> message(m);
   deferred_messages_.pop_front();
   bool message_processed = true;
 
   currently_processing_message_ = message.get();
   bool result;
   if (message->routing_id() == MSG_ROUTING_CONTROL)
     result = OnControlMessageReceived(*message);
   else
     result = router_.RouteMessage(*message);
-  currently_processing_message_ = NULL;
+  currently_processing_message_ = nullptr;
 
   if (!result) {
     // Respond to sync messages even if router failed to route.
     if (message->is_sync()) {
       IPC::Message* reply = IPC::SyncMessage::GenerateReply(&*message);
       reply->set_reply_error();
       Send(reply);
     }
   } else {
     // If the command buffer becomes unscheduled as a result of handling the
@@ skipping 107 matching lines @@
 uint64 GpuChannel::GetMemoryUsage() {
   uint64 size = 0;
   for (StubMap::Iterator<GpuCommandBufferStub> it(&stubs_);
        !it.IsAtEnd(); it.Advance()) {
     size += it.GetCurrentValue()->GetMemoryUsage();
   }
   return size;
 }
 
 }  // namespace content