Add logging to the QUIC write path.

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"
 
 using base::StringPiece;
 
 namespace net {
 
 QuicPacketGenerator::QuicPacketGenerator(DelegateInterface* delegate,
+                                         DebugDelegateInterface* debug_delegate,
                                          QuicPacketCreator* creator)
     : delegate_(delegate),
+      debug_delegate_(debug_delegate),
       packet_creator_(creator),
       should_flush_(true),
       should_send_ack_(false),
       should_send_feedback_(false) {
 }
 
 QuicPacketGenerator::~QuicPacketGenerator() {
   for (QuicFrames::iterator it = queued_control_frames_.begin();
        it != queued_control_frames_.end(); ++it) {
     switch (it->type) {
@@ skipping 42 matching lines @@
                                                   bool fin) {
   SendQueuedFrames();
 
   size_t total_bytes_consumed = 0;
   bool fin_consumed = false;
 
   while (delegate_->CanWrite(NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA)) {
     QuicFrame frame;
     size_t bytes_consumed = packet_creator_->CreateStreamFrame(
         id, data, offset + total_bytes_consumed, fin, &frame);
-    bool success = packet_creator_->AddSavedFrame(frame);
+    bool success = AddFrame(frame);
     DCHECK(success);
 
     total_bytes_consumed += bytes_consumed;
     fin_consumed = fin && bytes_consumed == data.size();
     data.remove_prefix(bytes_consumed);
     DCHECK(data.empty() || packet_creator_->BytesFree() == 0u);
 
     // TODO(ianswett): Restore packet reordering.
     if (should_flush_ || !packet_creator_->HasRoomForStreamFrame()) {
       SerializeAndSendPacket();
@@ skipping 60 matching lines @@
 }
 
 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());
-    if (!packet_creator_->AddSavedFrame(QuicFrame(pending_ack_frame_.get()))) {
+    if (!AddFrame(QuicFrame(pending_ack_frame_.get()))) {
       // packet was full
       return false;
     }
     should_send_ack_ = false;
     return true;
   }
 
   if (should_send_feedback_) {
     pending_feedback_frame_.reset(delegate_->CreateFeedbackFrame());
-    if (!packet_creator_->AddSavedFrame(QuicFrame(
-            pending_feedback_frame_.get()))) {
+    if (!AddFrame(QuicFrame(pending_feedback_frame_.get()))) {
       // packet was full
       return false;
     }
     should_send_feedback_ = false;
     return true;
   }
 
   DCHECK(!queued_control_frames_.empty());
-  if (!packet_creator_->AddSavedFrame(queued_control_frames_.back())) {
+  if (!AddFrame(queued_control_frames_.back())) {
     // packet was full
     return false;
   }
   queued_control_frames_.pop_back();
   return true;
 }
 
+bool QuicPacketGenerator::AddFrame(const QuicFrame& frame) {
+  bool success = packet_creator_->AddSavedFrame(frame);
+  if (success && debug_delegate_) {
+    debug_delegate_->OnFrameAddedToPacket(frame);
+  }
+  return success;
+}
+
 void QuicPacketGenerator::SerializeAndSendPacket() {
   SerializedPacket serialized_packet = packet_creator_->SerializePacket();
   DCHECK(serialized_packet.packet);
   delegate_->OnSerializedPacket(serialized_packet);
 
   if (packet_creator_->ShouldSendFec(false)) {
     SerializedPacket serialized_fec = packet_creator_->SerializeFec();
     DCHECK(serialized_fec.packet);
     delegate_->OnSerializedPacket(serialized_fec);
     packet_creator_->MaybeStartFEC();
   }
 }
 
 }  // namespace net