Land Recent QUIC Changes.

net/quic/quic_connection.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_connection.h"
 
 #include <string.h>
 #include <sys/types.h>
 #include <algorithm>
 #include <iterator>
@@ skipping 1223 matching lines @@
         sent_packet_manager_.NextPendingRetransmission();
     if (GetPacketType(&pending.retransmittable_frames) == NORMAL &&
         !CanWrite(HAS_RETRANSMITTABLE_DATA)) {
       break;
     }
 
     // Re-packetize the frames with a new sequence number for retransmission.
     // Retransmitted data packets do not use FEC, even when it's enabled.
     // Retransmitted packets use the same sequence number length as the
     // original.
-    // Flush the packet creator before making a new packet.
+    // Flush the packet generator before making a new packet.
     // TODO(ianswett): Implement ReserializeAllFrames as a separate path that
     // does not require the creator to be flushed.
-    Flush();
+    packet_generator_.FlushAllQueuedFrames();
     SerializedPacket serialized_packet = packet_generator_.ReserializeAllFrames(
         pending.retransmittable_frames.frames(),
         pending.sequence_number_length);
 
     DVLOG(1) << ENDPOINT << "Retransmitting " << pending.sequence_number
              << " as " << serialized_packet.sequence_number;
     if (debug_visitor_) {
       debug_visitor_->OnPacketRetransmitted(
           pending.sequence_number, serialized_packet.sequence_number);
     }
@@ skipping 515 matching lines @@
 void QuicConnection::SendConnectionClosePacket(QuicErrorCode error,
                                                const string& details) {
   DVLOG(1) << ENDPOINT << "Force closing " << connection_id()
            << " with error " << QuicUtils::ErrorToString(error)
            << " (" << error << ") " << details;
   ScopedPacketBundler ack_bundler(this, SEND_ACK);
   QuicConnectionCloseFrame* frame = new QuicConnectionCloseFrame();
   frame->error_code = error;
   frame->error_details = details;
   packet_generator_.AddControlFrame(QuicFrame(frame));
-  Flush();
+  packet_generator_.FlushAllQueuedFrames();
 }
 
 void QuicConnection::CloseConnection(QuicErrorCode error, bool from_peer) {
   if (!connected_) {
     DLOG(DFATAL) << "Error: attempt to close an already closed connection"
                  << base::debug::StackTrace().ToString();
     return;
   }
   connected_ = false;
   visitor_->OnConnectionClosed(error, from_peer);
@@ skipping 41 matching lines @@
 }
 
 size_t QuicConnection::max_packet_length() const {
   return packet_generator_.max_packet_length();
 }
 
 void QuicConnection::set_max_packet_length(size_t length) {
   return packet_generator_.set_max_packet_length(length);
 }
 
-void QuicConnection::Flush() {
-  packet_generator_.FlushAllQueuedFrames();
-}
-
 bool QuicConnection::HasQueuedData() const {
   return pending_version_negotiation_packet_ ||
       !queued_packets_.empty() || packet_generator_.HasQueuedFrames();
 }
 
 bool QuicConnection::CanWriteStreamData() {
   // Don't write stream data if there are negotiation or queued data packets
   // to send. Otherwise, continue and bundle as many frames as possible.
   if (pending_version_negotiation_packet_ || !queued_packets_.empty()) {
     return false;
@@ skipping 122 matching lines @@
   // If we changed the generator's batch state, restore original batch state.
   if (!already_in_batch_mode_) {
     DVLOG(1) << "Leaving Batch Mode.";
     connection_->packet_generator_.FinishBatchOperations();
   }
   DCHECK_EQ(already_in_batch_mode_,
             connection_->packet_generator_.InBatchMode());
 }
 
 }  // namespace net