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

net/quic/quic_unacked_packet_map.cc

Index: net/quic/quic_unacked_packet_map.cc
diff --git a/net/quic/quic_unacked_packet_map.cc b/net/quic/quic_unacked_packet_map.cc
index 2580654b82b64fa6ce16012925d1add33580c384..ab46dfb7d538929404d21e7fc2d13ad0a8c11c8a 100644
--- a/net/quic/quic_unacked_packet_map.cc
+++ b/net/quic/quic_unacked_packet_map.cc
@@ -27,7 +27,7 @@ QuicUnackedPacketMap::~QuicUnackedPacketMap() {
        it != unacked_packets_.end(); ++it, ++index) {
     delete it->retransmittable_frames;
     // Only delete all_transmissions once, for the newest packet.
-    if (it->all_transmissions != NULL &&
+    if (it->all_transmissions != nullptr &&
         index == *it->all_transmissions->rbegin()) {
       delete it->all_transmissions;
     }
@@ -48,9 +48,9 @@ void QuicUnackedPacketMap::AddPacket(
   unacked_packets_.push_back(
       TransmissionInfo(serialized_packet.retransmittable_frames,
                        serialized_packet.sequence_number_length));
-  if (serialized_packet.retransmittable_frames != NULL &&
-      serialized_packet.retransmittable_frames->HasCryptoHandshake()
-          == IS_HANDSHAKE) {
+  if (serialized_packet.retransmittable_frames != nullptr &&
+      serialized_packet.retransmittable_frames->HasCryptoHandshake() ==
+          IS_HANDSHAKE) {
     ++pending_crypto_packet_count_;
   }
 }
@@ -81,19 +81,19 @@ void QuicUnackedPacketMap::OnRetransmittedPacket(
   TransmissionInfo* transmission_info =
       &unacked_packets_.at(old_sequence_number - least_unacked_);
   RetransmittableFrames* frames = transmission_info->retransmittable_frames;
-  LOG_IF(DFATAL, frames == NULL) << "Attempt to retransmit packet with no "
-                                 << "retransmittable frames: "
-                                 << old_sequence_number;
+  LOG_IF(DFATAL, frames == nullptr)
+      << "Attempt to retransmit packet with no "
+      << "retransmittable frames: " << old_sequence_number;
 
   // We keep the old packet in the unacked packet list until it, or one of
   // the retransmissions of it are acked.
-  transmission_info->retransmittable_frames = NULL;
+  transmission_info->retransmittable_frames = nullptr;
   // Only keep one transmission older than largest observed, because only the
   // most recent is expected to possibly be a spurious retransmission.
-  while (transmission_info->all_transmissions != NULL &&
+  while (transmission_info->all_transmissions != nullptr &&
          transmission_info->all_transmissions->size() > 1 &&
-         *(++transmission_info->all_transmissions->begin())
-             < largest_observed_) {
+         *(++transmission_info->all_transmissions->begin()) <
+             largest_observed_) {
     QuicPacketSequenceNumber old_transmission =
         *transmission_info->all_transmissions->begin();
     TransmissionInfo* old_info =
@@ -104,7 +104,7 @@ void QuicUnackedPacketMap::OnRetransmittedPacket(
     }
     old_info->all_transmissions->pop_front();
     // This will cause the packet be removed in RemoveObsoletePackets.
-    old_info->all_transmissions = NULL;
+    old_info->all_transmissions = nullptr;
   }
   // Don't link old transmissions to new ones when version or
   // encryption changes.
@@ -112,7 +112,7 @@ void QuicUnackedPacketMap::OnRetransmittedPacket(
       transmission_type == ALL_UNACKED_RETRANSMISSION) {
     RemoveAckability(transmission_info);
   } else {
-    if (transmission_info->all_transmissions == NULL) {
+    if (transmission_info->all_transmissions == nullptr) {
       transmission_info->all_transmissions = new SequenceNumberList();
       transmission_info->all_transmissions->push_back(old_sequence_number);
     }
@@ -132,25 +132,25 @@ void QuicUnackedPacketMap::ClearAllPreviousRetransmissions() {
     // no point in clearing out any further packets, because they would not
     // affect the high water mark.
     TransmissionInfo* info = &unacked_packets_.front();
-    if (info->in_flight || info->retransmittable_frames != NULL) {
+    if (info->in_flight || info->retransmittable_frames != nullptr) {
       break;
     }
 
-    if (info->all_transmissions != NULL) {
+    if (info->all_transmissions != nullptr) {
       if (info->all_transmissions->size() < 2) {
-        LOG(DFATAL) << "all_transmissions must be NULL or have multiple "
+        LOG(DFATAL) << "all_transmissions must be nullptr or have multiple "
                     << "elements.  size:" << info->all_transmissions->size();
         delete info->all_transmissions;
       } else {
         info->all_transmissions->pop_front();
         if (info->all_transmissions->size() == 1) {
-          // Set the newer transmission's 'all_transmissions' entry to NULL.
+          // Set the newer transmission's 'all_transmissions' entry to nullptr.
           QuicPacketSequenceNumber new_transmission =
               info->all_transmissions->front();
           TransmissionInfo* new_info =
               &unacked_packets_.at(new_transmission - least_unacked_);
           delete new_info->all_transmissions;
-          new_info->all_transmissions = NULL;
+          new_info->all_transmissions = nullptr;
         }
       }
     }
@@ -163,8 +163,8 @@ bool QuicUnackedPacketMap::HasRetransmittableFrames(
     QuicPacketSequenceNumber sequence_number) const {
   DCHECK_GE(sequence_number, least_unacked_);
   DCHECK_LT(sequence_number, least_unacked_ + unacked_packets_.size());
-  return unacked_packets_[
-      sequence_number - least_unacked_].retransmittable_frames != NULL;
+  return unacked_packets_[sequence_number - least_unacked_]
+             .retransmittable_frames != nullptr;
 }
 
 void QuicUnackedPacketMap::NackPacket(QuicPacketSequenceNumber sequence_number,
@@ -182,7 +182,7 @@ void QuicUnackedPacketMap::RemoveRetransmittability(
   DCHECK_LT(sequence_number, least_unacked_ + unacked_packets_.size());
   TransmissionInfo* info = &unacked_packets_[sequence_number - least_unacked_];
   SequenceNumberList* all_transmissions = info->all_transmissions;
-  if (all_transmissions == NULL) {
+  if (all_transmissions == nullptr) {
     MaybeRemoveRetransmittableFrames(info);
     return;
   }
@@ -193,23 +193,23 @@ void QuicUnackedPacketMap::RemoveRetransmittability(
     TransmissionInfo* transmission_info =
         &unacked_packets_[*it - least_unacked_];
     MaybeRemoveRetransmittableFrames(transmission_info);
-    transmission_info->all_transmissions = NULL;
+    transmission_info->all_transmissions = nullptr;
   }
   delete all_transmissions;
 }
 
 void QuicUnackedPacketMap::RemoveAckability(TransmissionInfo* info) {
-  DCHECK(info->retransmittable_frames == NULL);
+  DCHECK(info->retransmittable_frames == nullptr);
   info->is_unackable = true;
   SequenceNumberList* all_transmissions = info->all_transmissions;
-  if (all_transmissions == NULL) {
+  if (all_transmissions == nullptr) {
     return;
   }
   for (SequenceNumberList::const_iterator it = all_transmissions->begin();
        it != all_transmissions->end(); ++it) {
     TransmissionInfo* transmission_info =
         &unacked_packets_[*it - least_unacked_];
-    transmission_info->all_transmissions = NULL;
+    transmission_info->all_transmissions = nullptr;
     transmission_info->is_unackable = true;
   }
   delete all_transmissions;
@@ -217,13 +217,13 @@ void QuicUnackedPacketMap::RemoveAckability(TransmissionInfo* info) {
 
 void QuicUnackedPacketMap::MaybeRemoveRetransmittableFrames(
     TransmissionInfo* transmission_info) {
-  if (transmission_info->retransmittable_frames != NULL) {
+  if (transmission_info->retransmittable_frames != nullptr) {
     if (transmission_info->retransmittable_frames->HasCryptoHandshake()
             == IS_HANDSHAKE) {
       --pending_crypto_packet_count_;
     }
     delete transmission_info->retransmittable_frames;
-    transmission_info->retransmittable_frames = NULL;
+    transmission_info->retransmittable_frames = nullptr;
   }
 }
 
@@ -237,20 +237,17 @@ bool QuicUnackedPacketMap::IsPacketUseless(
     QuicPacketSequenceNumber sequence_number,
     const TransmissionInfo& info) const {
   return (info.is_unackable || sequence_number <= largest_observed_) &&
-      !info.in_flight &&
-      info.retransmittable_frames == NULL &&
-      info.all_transmissions == NULL;
+         !info.in_flight && info.retransmittable_frames == nullptr &&
+         info.all_transmissions == nullptr;
 }
 
 bool QuicUnackedPacketMap::IsPacketRemovable(
     QuicPacketSequenceNumber sequence_number,
     const TransmissionInfo& info) const {
-  return (info.is_unackable ||
-          sequence_number <= largest_observed_ ||
+  return (info.is_unackable || sequence_number <= largest_observed_ ||
           unacked_packets_.size() > kMaxTcpCongestionWindow) &&
-      !info.in_flight &&
-      info.retransmittable_frames == NULL &&
-      info.all_transmissions == NULL;
+         !info.in_flight && info.retransmittable_frames == nullptr &&
+         info.all_transmissions == nullptr;
 }
 
 bool QuicUnackedPacketMap::IsUnacked(