Cache the value of GetMaxPlaintextSize in QuicPacketCreator. No 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 "base/basictypes.h"
 #include "base/logging.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_ack_notifier.h"
@@ skipping 58 matching lines @@
                                      QuicFramer* framer,
                                      QuicRandom* random_generator)
     : connection_id_(connection_id),
       encryption_level_(ENCRYPTION_NONE),
       framer_(framer),
       random_bool_source_(new QuicRandomBoolSource(random_generator)),
       sequence_number_(0),
       should_fec_protect_(false),
       fec_group_number_(0),
       send_version_in_packet_(framer->perspective() == Perspective::IS_CLIENT),
-      max_packet_length_(kDefaultMaxPacketSize),
       max_packets_per_fec_group_(kDefaultMaxPacketsPerFecGroup),
       connection_id_length_(PACKET_8BYTE_CONNECTION_ID),
       next_sequence_number_length_(PACKET_1BYTE_SEQUENCE_NUMBER),
       sequence_number_length_(next_sequence_number_length_),
       packet_size_(0) {
+  SetMaxPacketLength(kDefaultMaxPacketSize);
   framer_->set_fec_builder(this);
 }
 
 QuicPacketCreator::~QuicPacketCreator() {
 }
 
 void QuicPacketCreator::OnBuiltFecProtectedPayload(
     const QuicPacketHeader& header, StringPiece payload) {
   if (fec_group_.get()) {
     DCHECK_NE(0u, header.fec_group);
     fec_group_->Update(encryption_level_, header, payload);
   }
 }
 
+void QuicPacketCreator::SetEncrypter(EncryptionLevel level,
+                                     QuicEncrypter* encrypter) {
+  framer_->SetEncrypter(level, encrypter);
+  max_plaintext_size_ = framer_->GetMaxPlaintextSize(max_packet_length_);
+}
+
+void QuicPacketCreator::SetMaxPacketLength(QuicByteCount length) {
+  // |max_packet_length_| should not be changed mid-packet or mid-FEC group.
+  DCHECK(fec_group_.get() == nullptr && queued_frames_.empty());
+  max_packet_length_ = length;
+  max_plaintext_size_ = framer_->GetMaxPlaintextSize(max_packet_length_);
+}
+
 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() != nullptr && fec_group_->NumReceivedPackets() > 0 &&
@@ skipping 213 matching lines @@
       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());
+  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() == 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) {
   return AddFrame(frame, true);
 }
 
 SerializedPacket QuicPacketCreator::SerializePacket() {
   LOG_IF(DFATAL, queued_frames_.empty())
       << "Attempt to serialize empty packet";
   DCHECK_GE(sequence_number_ + 1, fec_group_number_);
   QuicPacketHeader header;
   FillPacketHeader(should_fec_protect_ ? fec_group_number_ : 0, false, &header);
 
   MaybeAddPadding();
 
-  size_t max_plaintext_size =
-      framer_->GetMaxPlaintextSize(max_packet_length_);
-  DCHECK_GE(max_plaintext_size, packet_size_);
+  DCHECK_GE(max_plaintext_size_, packet_size_);
   // ACK Frames will be truncated due to length only if they're the only frame
-  // in the packet, and if packet_size_ was set to max_plaintext_size. If
+  // in the packet, and if packet_size_ was set to max_plaintext_size_. If
   // truncation due to length occurred, then GetSerializedFrameLength will have
   // returned all bytes free.
-  bool possibly_truncated_by_length = packet_size_ == max_plaintext_size &&
+  bool possibly_truncated_by_length = packet_size_ == max_plaintext_size_ &&
       queued_frames_.size() == 1 &&
       queued_frames_.back().type == ACK_FRAME;
   char buffer[kMaxPacketSize];
   scoped_ptr<QuicPacket> packet;
   // Use the packet_size_ instead of the buffer size to ensure smaller
   // packet sizes are properly used.
   scoped_ptr<char[]> large_buffer;
   if (packet_size_ <= kMaxPacketSize) {
     packet.reset(
         framer_->BuildDataPacket(header, queued_frames_, buffer, packet_size_));
@@ skipping 162 matching lines @@
   if (!is_handshake) {
     return;
   }
 
   QuicPaddingFrame padding;
   bool success = AddFrame(QuicFrame(&padding), false);
   DCHECK(success);
 }
 
 }  // namespace net