Add logging to the QUIC write path.

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 <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 69 matching lines @@
       guid_(guid),
       peer_address_(address),
       largest_seen_packet_with_ack_(0),
       peer_largest_observed_packet_(0),
       least_packet_awaited_by_peer_(1),
       peer_least_packet_awaiting_ack_(0),
       handling_retransmission_timeout_(false),
       write_blocked_(false),
       debug_visitor_(NULL),
       packet_creator_(guid_, &framer_, random_generator_, is_server),
-      packet_generator_(this, &packet_creator_),
+      packet_generator_(this, NULL, &packet_creator_),
       idle_network_timeout_(
           QuicTime::Delta::FromSeconds(kDefaultInitialTimeoutSecs)),
       overall_connection_timeout_(QuicTime::Delta::Infinite()),
       creation_time_(clock_->ApproximateNow()),
       time_of_last_received_packet_(clock_->ApproximateNow()),
       time_of_last_sent_packet_(clock_->ApproximateNow()),
       time_largest_observed_(QuicTime::Zero()),
       congestion_manager_(clock_, kTCP),
       version_negotiation_state_(START_NEGOTIATION),
       quic_version_(kQuicVersion1),
@@ skipping 1003 matching lines @@
   DVLOG(2) << ENDPOINT << "packet(" << sequence_number << "): " << std::endl
            << QuicUtils::StringToHexASCIIDump(packet->AsStringPiece());
 
   DCHECK(encrypted->length() <= kMaxPacketSize)
       << "Packet " << sequence_number << " will not be read; too large: "
       << packet->length() << " " << encrypted->length() << " "
       << outgoing_ack_ << " forced: " << (forced == FORCE ? "yes" : "no");
 
   int error;
   QuicTime now = clock_->Now();
-  if (helper_->WritePacketToWire(*encrypted, &error) == -1) {
+  if (WritePacketToWire(sequence_number, level, *encrypted, &error) == -1) {
     if (helper_->IsWriteBlocked(error)) {
       // TODO(satyashekhar): It might be more efficient (fewer system calls), if
       // all connections share this variable i.e this becomes a part of
       // PacketWriterInterface.
       write_blocked_ = true;
       // If the socket buffers the the data, then the packet should not
       // be queued and sent again, which would result in an unnecessary
       // duplicate packet being sent.
       return helper_->IsWriteBlockedDataBuffered();
     }
@@ skipping 24 matching lines @@
 
   if (retransmission == IS_RETRANSMISSION) {
     stats_.bytes_retransmitted += encrypted->length();
     ++stats_.packets_retransmitted;
   }
 
   delete packet;
   return true;
 }
 
+int QuicConnection::WritePacketToWire(QuicPacketSequenceNumber sequence_number,
+                                      EncryptionLevel level,
+                                      const QuicEncryptedPacket& packet,
+                                      int* error) {
+  int bytes_written = helper_->WritePacketToWire(packet, error);
+  if (debug_visitor_) {
+    // WritePacketToWire returned -1, then |error| will be populated with
+    // a NetErrorCode, which we want to pass along to the visitor.
+    debug_visitor_->OnPacketSent(sequence_number, level, packet,
+                                 bytes_written == -1 ? *error : bytes_written);
+  }
+  return bytes_written;
+}
+
 bool QuicConnection::OnSerializedPacket(
     const SerializedPacket& serialized_packet) {
   if (serialized_packet.retransmittable_frames != NULL) {
     DCHECK(unacked_packets_.empty() ||
            unacked_packets_.rbegin()->first <
                serialized_packet.sequence_number);
     // Retransmitted frames will be sent with the same encryption level as the
     // original.
     serialized_packet.retransmittable_frames->set_encryption_level(
         encryption_level_);
@@ skipping 384 matching lines @@
     if (connection_timeout < timeout) {
       timeout = connection_timeout;
     }
   }
 
   helper_->SetTimeoutAlarm(timeout);
   return false;
 }
 
 }  // namespace net