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

net/quic/quic_packet_creator.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/quic/quic_packet_creator.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_ack_notifier.h"
@@ skipping 86 matching lines @@
 
 void QuicPacketCreator::set_max_packets_per_fec_group(
     size_t max_packets_per_fec_group) {
   max_packets_per_fec_group_ = max(kLowestMaxPacketsPerFecGroup,
                                    max_packets_per_fec_group);
   DCHECK_LT(0u, max_packets_per_fec_group_);
 }
 
 bool QuicPacketCreator::ShouldSendFec(bool force_close) const {
   DCHECK(!HasPendingFrames());
-  return fec_group_.get() != NULL && fec_group_->NumReceivedPackets() > 0 &&
-      (force_close || fec_group_->NumReceivedPackets() >=
-                      max_packets_per_fec_group_);
+  return fec_group_.get() != nullptr && fec_group_->NumReceivedPackets() > 0 &&
+         (force_close ||
+          fec_group_->NumReceivedPackets() >= max_packets_per_fec_group_);
 }
 
 bool QuicPacketCreator::IsFecGroupOpen() const {
-  return fec_group_.get() != NULL;
+  return fec_group_.get() != nullptr;
 }
 
 void QuicPacketCreator::StartFecProtectingPackets() {
   if (!IsFecEnabled()) {
     LOG(DFATAL) << "Cannot start FEC protection when FEC is not enabled.";
     return;
   }
   // TODO(jri): This currently requires that the generator flush out any
   // pending frames when FEC protection is turned on. If current packet can be
   // converted to an FEC protected packet, do it. This will require the
   // generator to check if the resulting expansion still allows the incoming
   // frame to be added to the packet.
   if (HasPendingFrames()) {
     LOG(DFATAL) << "Cannot start FEC protection with pending frames.";
     return;
   }
   DCHECK(!should_fec_protect_);
   should_fec_protect_ = true;
 }
 
 void QuicPacketCreator::StopFecProtectingPackets() {
-  if (fec_group_.get() != NULL) {
+  if (fec_group_.get() != nullptr) {
     LOG(DFATAL) << "Cannot stop FEC protection with open FEC group.";
     return;
   }
   DCHECK(should_fec_protect_);
   should_fec_protect_ = false;
   fec_group_number_ = 0;
 }
 
 bool QuicPacketCreator::IsFecProtected() const {
   return should_fec_protect_;
 }
 
 bool QuicPacketCreator::IsFecEnabled() const {
   return max_packets_per_fec_group_ > 0;
 }
 
 InFecGroup QuicPacketCreator::MaybeUpdateLengthsAndStartFec() {
-  if (fec_group_.get() != NULL) {
+  if (fec_group_.get() != nullptr) {
     // Don't update any lengths when an FEC group is open, to ensure same
     // packet header size in all packets within a group.
     return IN_FEC_GROUP;
   }
   if (!queued_frames_.empty()) {
     // Don't change creator state if there are frames queued.
-    return fec_group_.get() == NULL ? NOT_IN_FEC_GROUP : IN_FEC_GROUP;
+    return fec_group_.get() == nullptr ? NOT_IN_FEC_GROUP : IN_FEC_GROUP;
   }
 
   // Update sequence number length only on packet and FEC group boundaries.
   sequence_number_length_ = next_sequence_number_length_;
 
   if (!should_fec_protect_) {
     return NOT_IN_FEC_GROUP;
   }
   // Start a new FEC group since protection is on. Set the fec group number to
   // the sequence number of the next packet.
@@ skipping 105 matching lines @@
   // a packet. At that point the notifier is informed of the sequence number
   // of the packet that this frame was eventually sent in.
   frame->stream_frame->notifier = notifier;
 
   return bytes_consumed;
 }
 
 SerializedPacket QuicPacketCreator::ReserializeAllFrames(
     const QuicFrames& frames,
     QuicSequenceNumberLength original_length) {
-  DCHECK(fec_group_.get() == NULL);
+  DCHECK(fec_group_.get() == nullptr);
   const QuicSequenceNumberLength saved_length = sequence_number_length_;
   const QuicSequenceNumberLength saved_next_length =
       next_sequence_number_length_;
   const bool saved_should_fec_protect = should_fec_protect_;
 
   // Temporarily set the sequence number length and stop FEC protection.
   sequence_number_length_ = original_length;
   next_sequence_number_length_ = original_length;
   should_fec_protect_ = false;
 
@@ skipping 12 matching lines @@
   // frames from SendStreamData()[send_stream_should_flush_ == false &&
   // data.empty() == true] and retransmit due to RTO.
   DCHECK_EQ(0u, queued_frames_.size());
   LOG_IF(DFATAL, frames.empty())
       << "Attempt to serialize empty packet";
   for (size_t i = 0; i < frames.size(); ++i) {
     bool success = AddFrame(frames[i], false);
     DCHECK(success);
   }
   SerializedPacket packet = SerializePacket();
-  DCHECK(packet.retransmittable_frames == NULL);
+  DCHECK(packet.retransmittable_frames == nullptr);
   return packet;
 }
 
 bool QuicPacketCreator::HasPendingFrames() const {
   return !queued_frames_.empty();
 }
 
 bool QuicPacketCreator::HasPendingRetransmittableFrames() const {
-  return queued_retransmittable_frames_.get() != NULL &&
-      !queued_retransmittable_frames_->frames().empty();
+  return queued_retransmittable_frames_.get() != nullptr &&
+         !queued_retransmittable_frames_->frames().empty();
 }
 
 size_t QuicPacketCreator::ExpansionOnNewFrame() const {
   // If packet is FEC protected, there's no expansion.
   if (should_fec_protect_) {
       return 0;
   }
   // If the last frame in the packet is a stream frame, then it will expand to
   // include the stream_length field when a new frame is added.
   bool has_trailing_stream_frame =
       !queued_frames_.empty() && queued_frames_.back().type == STREAM_FRAME;
   return has_trailing_stream_frame ? kQuicStreamPayloadLengthSize : 0;
 }
 
 size_t QuicPacketCreator::BytesFree() const {
   const size_t max_plaintext_size =
       framer_->GetMaxPlaintextSize(max_packet_length_);
   DCHECK_GE(max_plaintext_size, PacketSize());
   return max_plaintext_size - min(max_plaintext_size, PacketSize()
                                   + ExpansionOnNewFrame());
 }
 
 size_t QuicPacketCreator::PacketSize() const {
   if (!queued_frames_.empty()) {
     return packet_size_;
   }
-  if (fec_group_.get() == NULL) {
+  if (fec_group_.get() == nullptr) {
     // Update sequence number length on packet and FEC boundary.
     sequence_number_length_ = next_sequence_number_length_;
   }
   packet_size_ = GetPacketHeaderSize(
       connection_id_length_, send_version_in_packet_, sequence_number_length_,
       should_fec_protect_ ? IN_FEC_GROUP : NOT_IN_FEC_GROUP);
   return packet_size_;
 }
 
 bool QuicPacketCreator::AddSavedFrame(const QuicFrame& frame) {
@@ skipping 28 matching lines @@
   if (!possibly_truncated_by_length) {
     DCHECK_EQ(packet_size_, serialized.packet->length());
   }
   packet_size_ = 0;
   queued_frames_.clear();
   serialized.retransmittable_frames = queued_retransmittable_frames_.release();
   return serialized;
 }
 
 SerializedPacket QuicPacketCreator::SerializeFec() {
-  if (fec_group_.get() == NULL || fec_group_->NumReceivedPackets() <= 0) {
+  if (fec_group_.get() == nullptr || fec_group_->NumReceivedPackets() <= 0) {
     LOG(DFATAL) << "SerializeFEC called but no group or zero packets in group.";
     // TODO(jri): Make this a public method of framer?
-    SerializedPacket kNoPacket(0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL);
+    SerializedPacket kNoPacket(0, PACKET_1BYTE_SEQUENCE_NUMBER, nullptr, 0,
+                               nullptr);
     return kNoPacket;
   }
   DCHECK_EQ(0u, queued_frames_.size());
   QuicPacketHeader header;
   FillPacketHeader(fec_group_number_, true, &header);
   QuicFecData fec_data;
   fec_data.fec_group = fec_group_->min_protected_packet();
   fec_data.redundancy = fec_group_->payload_parity();
   SerializedPacket serialized = framer_->BuildFecPacket(header, fec_data);
-  fec_group_.reset(NULL);
+  fec_group_.reset(nullptr);
   packet_size_ = 0;
   LOG_IF(DFATAL, !serialized.packet)
       << "Failed to serialize fec packet for group:" << fec_data.fec_group;
   DCHECK_GE(max_packet_length_, serialized.packet->length());
   return serialized;
 }
 
 SerializedPacket QuicPacketCreator::SerializeConnectionClose(
     QuicConnectionCloseFrame* close_frame) {
   QuicFrames frames;
@@ skipping 50 matching lines @@
   size_t frame_len = framer_->GetSerializedFrameLength(
       frame, BytesFree(), queued_frames_.empty(), true, is_in_fec_group,
       sequence_number_length_);
   if (frame_len == 0) {
     return false;
   }
   DCHECK_LT(0u, packet_size_);
   packet_size_ += ExpansionOnNewFrame() + frame_len;
 
   if (save_retransmittable_frames && ShouldRetransmit(frame)) {
-    if (queued_retransmittable_frames_.get() == NULL) {
+    if (queued_retransmittable_frames_.get() == nullptr) {
       queued_retransmittable_frames_.reset(new RetransmittableFrames());
     }
     if (frame.type == STREAM_FRAME) {
       queued_frames_.push_back(
           queued_retransmittable_frames_->AddStreamFrame(frame.stream_frame));
     } else {
       queued_frames_.push_back(
           queued_retransmittable_frames_->AddNonStreamFrame(frame));
     }
   } else {
     queued_frames_.push_back(frame);
   }
   return true;
 }
 
 void QuicPacketCreator::MaybeAddPadding() {
-  if (queued_retransmittable_frames_.get() == NULL) {
+  if (queued_retransmittable_frames_.get() == nullptr) {
     return;
   }
   if (!queued_retransmittable_frames_->HasCryptoHandshake()) {
     return;
   }
   if (BytesFree() == 0) {
     // Don't pad full packets.
     return;
   }
   QuicPaddingFrame padding;
   bool success = AddFrame(QuicFrame(&padding), false);
   DCHECK(success);
 }
 
 }  // namespace net