Land Recent QUIC changes.

net/quic/quic_packet_generator.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_generator.h"
 
 #include "base/logging.h"
 #include "net/quic/quic_fec_group.h"
 #include "net/quic/quic_utils.h"
 
@@ skipping 52 matching lines @@
 }
 
 void QuicPacketGenerator::AddControlFrame(const QuicFrame& frame) {
   queued_control_frames_.push_back(frame);
   SendQueuedFrames();
 }
 
 QuicConsumedData QuicPacketGenerator::ConsumeData(QuicStreamId id,
                                                   StringPiece data,
                                                   QuicStreamOffset offset,
-                                                  bool fin) {
-  return ConsumeData(id, data, offset, fin, NULL);
-}
-
-QuicConsumedData QuicPacketGenerator::ConsumeData(QuicStreamId id,
-                                                  StringPiece data,
-                                                  QuicStreamOffset offset,
                                                   bool fin,
                                                   QuicAckNotifier* notifier) {
   IsHandshake handshake = id == kCryptoStreamId ? IS_HANDSHAKE : NOT_HANDSHAKE;
   // The caller should have flushed pending frames before sending handshake
   // messages.
   DCHECK(handshake == NOT_HANDSHAKE || !HasPendingFrames());
   SendQueuedFrames();
 
   size_t total_bytes_consumed = 0;
   bool fin_consumed = false;
@@ skipping 106 matching lines @@
   return packet_creator_->HasPendingFrames() || HasPendingFrames();
 }
 
 bool QuicPacketGenerator::HasPendingFrames() const {
   return should_send_ack_ || should_send_feedback_ ||
       !queued_control_frames_.empty();
 }
 
 bool QuicPacketGenerator::AddNextPendingFrame() {
   if (should_send_ack_) {
-    pending_ack_frame_.reset((delegate_->CreateAckFrame()));
+    pending_ack_frame_.reset(delegate_->CreateAckFrame());
     // If we can't this add the frame now, then we still need to do so later.
     should_send_ack_ = !AddFrame(QuicFrame(pending_ack_frame_.get()));
     // Return success if we have cleared out this flag (i.e., added the frame).
     // If we still need to send, then the frame is full, and we have failed.
     return !should_send_ack_;
   }
 
   if (should_send_feedback_) {
-    pending_feedback_frame_.reset((delegate_->CreateFeedbackFrame()));
+    pending_feedback_frame_.reset(delegate_->CreateFeedbackFrame());
     // If we can't this add the frame now, then we still need to do so later.
     should_send_feedback_ = !AddFrame(QuicFrame(pending_feedback_frame_.get()));
     // Return success if we have cleared out this flag (i.e., added the frame).
     // If we still need to send, then the frame is full, and we have failed.
     return !should_send_feedback_;
   }
 
   DCHECK(!queued_control_frames_.empty());
   if (!AddFrame(queued_control_frames_.back())) {
     // Packet was full.
@@ skipping 18 matching lines @@
 
   if (packet_creator_->ShouldSendFec(false)) {
     SerializedPacket serialized_fec = packet_creator_->SerializeFec();
     DCHECK(serialized_fec.packet);
     delegate_->OnSerializedPacket(serialized_fec);
     packet_creator_->MaybeStartFEC();
   }
 }
 
 }  // namespace net