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

net/quic/quic_packet_creator.h

 // 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.
 //
 // Accumulates frames for the next packet until more frames no longer fit or
 // it's time to create a packet from them.  Also provides packet creation of
 // FEC packets based on previously created packets.
 
 #ifndef NET_QUIC_QUIC_PACKET_CREATOR_H_
 #define NET_QUIC_QUIC_PACKET_CREATOR_H_
@@ skipping 107 matching lines @@
   // Returns true if there are retransmittable frames pending to be serialized.
   bool HasPendingRetransmittableFrames() const;
 
   // Returns whether FEC protection is currently enabled. Note: Enabled does not
   // mean that an FEC group is currently active; i.e., IsFecProtected() may
   // still return false.
   bool IsFecEnabled() const;
 
   // Returns true if subsequent packets will be FEC protected. Note: True does
   // not mean that an FEC packet is currently under construction; i.e.,
-  // fec_group_.get() may still be NULL, until MaybeStartFec() is called.
+  // fec_group_.get() may still be nullptr, until MaybeStartFec() is called.
   bool IsFecProtected() const;
 
   // Returns the number of bytes which are available to be used by additional
   // frames in the packet.  Since stream frames are slightly smaller when they
   // are the last frame in a packet, this method will return a different
   // value than max_packet_size - PacketSize(), in this case.
   size_t BytesFree() const;
 
   // Returns the number of bytes that the packet will expand by if a new frame
   // is added to the packet. If the last frame was a stream frame, it will
   // expand slightly when a new frame is added, and this method returns the
   // amount of expected expansion. If the packet is in an FEC group, no
   // expansion happens and this method always returns zero.
   size_t ExpansionOnNewFrame() const;
 
   // Returns the number of bytes in the current packet, including the header,
   // if serialized with the current frames.  Adding a frame to the packet
   // may change the serialized length of existing frames, as per the comment
   // in BytesFree.
   size_t PacketSize() const;
 
   // TODO(jri): AddSavedFrame calls AddFrame, which only saves the frame
   // if it is a stream frame, not other types of frames. Fix this API;
   // add a AddNonSavedFrame method.
   // Adds |frame| to the packet creator's list of frames to be serialized.
   // Returns false if the frame doesn't fit into the current packet.
   bool AddSavedFrame(const QuicFrame& frame);
 
   // Serializes all frames which have been added and adds any which should be
-  // retransmitted to |retransmittable_frames| if it's not NULL. All frames must
-  // fit into a single packet. Sets the entropy hash of the serialized
+  // retransmitted to |retransmittable_frames| if it's not nullptr. All frames
+  // must fit into a single packet. Sets the entropy hash of the serialized
   // packet to a random bool and returns that value as a member of
-  // SerializedPacket. Also, sets |serialized_frames| in the SerializedPacket
-  // to the corresponding RetransmittableFrames if any frames are to be
+  // SerializedPacket. Also, sets |serialized_frames| in the SerializedPacket to
+  // the corresponding RetransmittableFrames if any frames are to be
   // retransmitted.
   SerializedPacket SerializePacket();
 
   // Packetize FEC data. All frames must fit into a single packet. Also, sets
   // the entropy hash of the serialized packet to a random bool and returns
   // that value as a member of SerializedPacket.
   SerializedPacket SerializeFec();
 
   // Creates a packet with connection close frame. Caller owns the created
   // packet. Also, sets the entropy hash of the serialized packet to a random
@@ skipping 34 matching lines @@
   void set_next_sequence_number_length(QuicSequenceNumberLength length) {
     next_sequence_number_length_ = length;
   }
 
   size_t max_packet_length() const {
     return max_packet_length_;
   }
 
   void set_max_packet_length(size_t length) {
     // |max_packet_length_| should not be changed mid-packet or mid-FEC group.
-    DCHECK(fec_group_.get() == NULL && queued_frames_.empty());
+    DCHECK(fec_group_.get() == nullptr && queued_frames_.empty());
     max_packet_length_ = length;
   }
 
   // Returns current max number of packets covered by an FEC group.
   size_t max_packets_per_fec_group() const {
       return max_packets_per_fec_group_;
   }
 
   // Sets creator's max number of packets covered by an FEC group.
   // Note: While there are no constraints on |max_packets_per_fec_group|,
@@ skipping 59 matching lines @@
   mutable size_t packet_size_;
   QuicFrames queued_frames_;
   scoped_ptr<RetransmittableFrames> queued_retransmittable_frames_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicPacketCreator);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PACKET_CREATOR_H_