Run clang-modernize -use-nullptr over src/extensions/.

extensions/browser/api/socket/udp_socket.cc

 // Copyright 2014 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 "extensions/browser/api/socket/udp_socket.h"
 
 #include <algorithm>
 
 #include "base/lazy_instance.h"
 #include "extensions/browser/api/api_resource.h"
@@ skipping 12 matching lines @@
 template <>
 BrowserContextKeyedAPIFactory<ApiResourceManager<ResumableUDPSocket> >*
 ApiResourceManager<ResumableUDPSocket>::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 UDPSocket::UDPSocket(const std::string& owner_extension_id)
     : Socket(owner_extension_id),
       socket_(net::DatagramSocket::DEFAULT_BIND,
               net::RandIntCallback(),
-              NULL,
-              net::NetLog::Source()) {}
+              nullptr,
+              net::NetLog::Source()) {
+}
 
 UDPSocket::~UDPSocket() { Disconnect(); }
 
 void UDPSocket::Connect(const std::string& address,
                         int port,
                         const CompletionCallback& callback) {
   int result = net::ERR_CONNECTION_FAILED;
   do {
     if (is_connected_)
       break;
@@ skipping 28 matching lines @@
   read_callback_.Reset();
   recv_from_callback_.Reset();
   send_to_callback_.Reset();
   multicast_groups_.clear();
 }
 
 void UDPSocket::Read(int count, const ReadCompletionCallback& callback) {
   DCHECK(!callback.is_null());
 
   if (!read_callback_.is_null()) {
-    callback.Run(net::ERR_IO_PENDING, NULL);
+    callback.Run(net::ERR_IO_PENDING, nullptr);
     return;
   } else {
     read_callback_ = callback;
   }
 
   int result = net::ERR_FAILED;
   scoped_refptr<net::IOBuffer> io_buffer;
   do {
     if (count < 0) {
       result = net::ERR_INVALID_ARGUMENT;
@@ skipping 24 matching lines @@
     return net::ERR_SOCKET_NOT_CONNECTED;
   else
     return socket_.Write(io_buffer, io_buffer_size, callback);
 }
 
 void UDPSocket::RecvFrom(int count,
                          const RecvFromCompletionCallback& callback) {
   DCHECK(!callback.is_null());
 
   if (!recv_from_callback_.is_null()) {
-    callback.Run(net::ERR_IO_PENDING, NULL, std::string(), 0);
+    callback.Run(net::ERR_IO_PENDING, nullptr, std::string(), 0);
     return;
   } else {
     recv_from_callback_ = callback;
   }
 
   int result = net::ERR_FAILED;
   scoped_refptr<net::IOBuffer> io_buffer;
   scoped_refptr<IPEndPoint> address;
   do {
     if (count < 0) {
@@ skipping 149 matching lines @@
 
 ResumableUDPSocket::ResumableUDPSocket(const std::string& owner_extension_id)
     : UDPSocket(owner_extension_id),
       persistent_(false),
       buffer_size_(0),
       paused_(false) {}
 
 bool ResumableUDPSocket::IsPersistent() const { return persistent(); }
 
 }  // namespace extensions