Remove needs_padding from QuicPacketCreator AddFrame. Non functional change.

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 <algorithm>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 248 matching lines @@
                                     FecProtection fec_protection) {
   if (!HasRoomForStreamFrame(id, offset)) {
     Flush();
     return false;
   }
   if (fec_protection == MUST_FEC_PROTECT) {
     should_fec_protect_next_packet_ = true;
     MaybeStartFecProtection();
   }
   CreateStreamFrame(id, iov, iov_offset, offset, fin, frame);
-  bool success = AddFrame(*frame,
-                          /*save_retransmittable_frames=*/true, needs_padding);
+  bool success = AddFrame(*frame, /*save_retransmittable_frames=*/true);
+  if (needs_padding) {
+    needs_padding_ = true;
+  }
   DCHECK(success);
   return true;
 }
 
 bool QuicPacketCreator::HasRoomForStreamFrame(QuicStreamId id,
                                               QuicStreamOffset offset) const {
   // TODO(jri): This is a simple safe decision for now, but make
   // is_in_fec_group a parameter. Same as with all public methods in
   // QuicPacketCreator.
   return BytesFree() >
@@ skipping 145 matching lines @@
   return serialized_packet;
 }
 
 SerializedPacket QuicPacketCreator::SerializeAllFrames(const QuicFrames& frames,
                                                        char* buffer,
                                                        size_t buffer_len) {
   LOG_IF(DFATAL, !queued_frames_.empty()) << "Frames already queued.";
   LOG_IF(DFATAL, frames.empty())
       << "Attempt to serialize empty packet";
   for (const QuicFrame& frame : frames) {
-    bool success = AddFrame(frame, false, false);
+    bool success = AddFrame(frame, false);
     DCHECK(success);
   }
   SerializedPacket packet = SerializePacket(buffer, buffer_len);
   DCHECK(packet.retransmittable_frames == nullptr);
   return packet;
 }
 
 void QuicPacketCreator::Flush() {
   if (!HasPendingFrames()) {
     return;
@@ skipping 42 matching lines @@
     // Update packet number length on packet and FEC boundary.
     packet_number_length_ = next_packet_number_length_;
   }
   packet_size_ = GetPacketHeaderSize(
       connection_id_length_, send_version_in_packet_, /*include_path_id=*/false,
       packet_number_length_, fec_protect_ ? IN_FEC_GROUP : NOT_IN_FEC_GROUP);
   return packet_size_;
 }
 
 bool QuicPacketCreator::AddSavedFrame(const QuicFrame& frame) {
-  return AddFrame(frame,
-                  /*save_retransmittable_frames=*/true,
-                  /*needs_padding=*/false);
+  return AddFrame(frame, /*save_retransmittable_frames=*/true);
 }
 
 bool QuicPacketCreator::AddPaddedSavedFrame(const QuicFrame& frame) {
-  return AddFrame(frame,
-                  /*save_retransmittable_frames=*/true,
-                  /*needs_padding=*/true);
+  if (AddFrame(frame, /*save_retransmittable_frames=*/true)) {
+    needs_padding_ = true;
+    return true;
+  }
+  return false;
 }
 
 SerializedPacket QuicPacketCreator::SerializePacket(
     char* encrypted_buffer,
     size_t encrypted_buffer_len) {
   DCHECK_LT(0u, encrypted_buffer_len);
   LOG_IF(DFATAL, queued_frames_.empty())
       << "Attempt to serialize empty packet";
   if (fec_group_.get() != nullptr) {
     DCHECK_GE(packet_number_ + 1, fec_group_->FecGroupNumber());
@@ skipping 147 matching lines @@
     case PADDING_FRAME:
     case STOP_WAITING_FRAME:
     case MTU_DISCOVERY_FRAME:
       return false;
     default:
       return true;
   }
 }
 
 bool QuicPacketCreator::AddFrame(const QuicFrame& frame,
-                                 bool save_retransmittable_frames,
-                                 bool needs_padding) {
+                                 bool save_retransmittable_frames) {
   DVLOG(1) << "Adding frame: " << frame;
   InFecGroup is_in_fec_group = MaybeUpdateLengthsAndStartFec();
 
   size_t frame_len = framer_->GetSerializedFrameLength(
       frame, BytesFree(), queued_frames_.empty(), true, is_in_fec_group,
       packet_number_length_);
   if (frame_len == 0) {
     // Current open packet is full.
     Flush();
     return false;
   }
   DCHECK_LT(0u, packet_size_);
   packet_size_ += ExpansionOnNewFrame() + frame_len;
 
   if (save_retransmittable_frames && ShouldRetransmit(frame)) {
     if (queued_retransmittable_frames_.get() == nullptr) {
       queued_retransmittable_frames_.reset(new RetransmittableFrames());
     }
     queued_frames_.push_back(queued_retransmittable_frames_->AddFrame(frame));
   } else {
     queued_frames_.push_back(frame);
   }
 
   if (frame.type == ACK_FRAME) {
     has_ack_ = true;
   }
   if (frame.type == STOP_WAITING_FRAME) {
     has_stop_waiting_ = true;
   }
-  if (needs_padding) {
-    needs_padding_ = true;
-  }
   if (debug_delegate_ != nullptr) {
     debug_delegate_->OnFrameAddedToPacket(frame);
   }
 
   return true;
 }
 
 void QuicPacketCreator::MaybeAddPadding() {
   if (!needs_padding_) {
     return;
   }
 
   if (BytesFree() == 0) {
     // Don't pad full packets.
     return;
   }
 
-  bool success = AddFrame(QuicFrame(QuicPaddingFrame()), false, false);
+  bool success = AddFrame(QuicFrame(QuicPaddingFrame()), false);
   DCHECK(success);
 }
 
 void QuicPacketCreator::MaybeStartFecProtection() {
   if (max_packets_per_fec_group_ == 0 || fec_protect_) {
     // Do not start FEC protection when FEC protection is not enabled or FEC
     // protection is already on.
     return;
   }
   DVLOG(1) << "Turning FEC protection ON";
@@ skipping 69 matching lines @@
   hash_map<QuicPathId, QuicPacketNumber>::iterator it =
       multipath_packet_number_.find(path_id);
   // If path_id is not in the map, it's a new path. Set packet_number to 0.
   packet_number_ = it == multipath_packet_number_.end() ? 0 : it->second;
   current_path_ = path_id;
   // Switching path needs to update packet number length.
   UpdatePacketNumberLength(least_packet_awaited_by_peer, max_packets_in_flight);
 }
 
 }  // namespace net