QUIC - (no behavior change) s/NULL/nullptr/g in .../quic/...

net/tools/quic/quic_socket_utils.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 "net/tools/quic/quic_socket_utils.h"
 
 #include <errno.h>
 #include <netinet/in.h>
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/uio.h>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "net/quic/quic_protocol.h"
 
 #ifndef SO_RXQ_OVFL
 #define SO_RXQ_OVFL 40
 #endif
 
 namespace net {
 namespace tools {
 
 // static
 IPAddressNumber QuicSocketUtils::GetAddressFromMsghdr(struct msghdr *hdr) {
   if (hdr->msg_controllen > 0) {
     for (cmsghdr* cmsg = CMSG_FIRSTHDR(hdr);
-         cmsg != NULL;
+         cmsg != nullptr;
          cmsg = CMSG_NXTHDR(hdr, cmsg)) {
-      const uint8* addr_data = NULL;
+      const uint8* addr_data = nullptr;
       int len = 0;
       if (cmsg->cmsg_type == IPV6_PKTINFO) {
         in6_pktinfo* info = reinterpret_cast<in6_pktinfo*>CMSG_DATA(cmsg);
         in6_addr addr = info->ipi6_addr;
         addr_data = reinterpret_cast<const uint8*>(&addr);
         len = sizeof(addr);
       } else if (cmsg->cmsg_type == IP_PKTINFO) {
         in_pktinfo* info = reinterpret_cast<in_pktinfo*>CMSG_DATA(cmsg);
         in_addr addr = info->ipi_addr;
         addr_data = reinterpret_cast<const uint8*>(&addr);
         len = sizeof(addr);
       } else {
         continue;
       }
       return IPAddressNumber(addr_data, addr_data + len);
     }
   }
   DCHECK(false) << "Unable to get address from msghdr";
   return IPAddressNumber();
 }
 
 // static
 bool QuicSocketUtils::GetOverflowFromMsghdr(struct msghdr *hdr,
                                             uint32 *dropped_packets) {
   if (hdr->msg_controllen > 0) {
     struct cmsghdr *cmsg;
     for (cmsg = CMSG_FIRSTHDR(hdr);
-         cmsg != NULL;
+         cmsg != nullptr;
          cmsg = CMSG_NXTHDR(hdr, cmsg)) {
       if (cmsg->cmsg_type == SO_RXQ_OVFL) {
         *dropped_packets = *(reinterpret_cast<int*>CMSG_DATA(cmsg));
         return true;
       }
     }
   }
   return false;
 }
 
@@ skipping 25 matching lines @@
     return false;
   }
   return true;
 }
 
 // static
 int QuicSocketUtils::ReadPacket(int fd, char* buffer, size_t buf_len,
                                 uint32* dropped_packets,
                                 IPAddressNumber* self_address,
                                 IPEndPoint* peer_address) {
-  CHECK(peer_address != NULL);
+  CHECK(peer_address != nullptr);
   const int kSpaceForOverflowAndIp =
       CMSG_SPACE(sizeof(int)) + CMSG_SPACE(sizeof(in6_pktinfo));
   char cbuf[kSpaceForOverflowAndIp];
   memset(cbuf, 0, arraysize(cbuf));
 
   iovec iov = {buffer, buf_len};
   struct sockaddr_storage raw_address;
   msghdr hdr;
 
   hdr.msg_name = &raw_address;
@@ skipping 11 matching lines @@
 
   // Return before setting dropped packets: if we get EAGAIN, it will
   // be 0.
   if (bytes_read < 0 && errno != 0) {
     if (errno != EAGAIN) {
       LOG(ERROR) << "Error reading " << strerror(errno);
     }
     return -1;
   }
 
-  if (dropped_packets != NULL) {
+  if (dropped_packets != nullptr) {
     GetOverflowFromMsghdr(&hdr, dropped_packets);
   }
-  if (self_address != NULL) {
+  if (self_address != nullptr) {
     *self_address = QuicSocketUtils::GetAddressFromMsghdr(&hdr);
   }
 
   if (raw_address.ss_family == AF_INET) {
     CHECK(peer_address->FromSockAddr(
         reinterpret_cast<const sockaddr*>(&raw_address),
         sizeof(struct sockaddr_in)));
   } else if (raw_address.ss_family == AF_INET6) {
     CHECK(peer_address->FromSockAddr(
         reinterpret_cast<const sockaddr*>(&raw_address),
@@ skipping 65 matching lines @@
   int rc = sendmsg(fd, &hdr, 0);
   if (rc >= 0) {
     return WriteResult(WRITE_STATUS_OK, rc);
   }
   return WriteResult((errno == EAGAIN || errno == EWOULDBLOCK) ?
       WRITE_STATUS_BLOCKED : WRITE_STATUS_ERROR, errno);
 }
 
 }  // namespace tools
 }  // namespace net