Add logging to the QUIC write path.

net/quic/quic_connection.h

 // 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.
 //
 // The entity that handles framing writes for a Quic client or server.
 // Each QuicSession will have a connection associated with it.
 //
 // On the server side, the Dispatcher handles the raw reads, and hands off
 // packets via ProcessUdpPacket for framing and processing.
 //
@@ skipping 64 matching lines @@
 
   // Called when a blocked socket becomes writable.  If all pending bytes for
   // this visitor are consumed by the connection successfully this should
   // return true, otherwise it should return false.
   virtual bool OnCanWrite() = 0;
 };
 
 // Interface which gets callbacks from the QuicConnection at interesting
 // points.  Implementations must not mutate the state of the connection
 // as a result of these callbacks.
-class NET_EXPORT_PRIVATE QuicConnectionDebugVisitorInterface {
+class NET_EXPORT_PRIVATE QuicConnectionDebugVisitorInterface
+    : public QuicPacketGenerator::DebugDelegateInterface {
  public:
   virtual ~QuicConnectionDebugVisitorInterface() {}
 
+  // Called when a packet has been sent.
+  virtual void OnPacketSent(QuicPacketSequenceNumber sequence_number,
+                            EncryptionLevel level,
+                            const QuicEncryptedPacket& packet,
+                            int rv) = 0;
+
   // Called when a packet has been received, but before it is
   // validated or parsed.
   virtual void OnPacketReceived(const IPEndPoint& self_address,
                                 const IPEndPoint& peer_address,
                                 const QuicEncryptedPacket& packet) = 0;
 
   // Called when the protocol version on the received packet doensn't match
   // current protocol version of the connection.
   virtual void OnProtocolVersionMismatch(QuicTag version) = 0;
 
@@ skipping 200 matching lines @@
   virtual QuicAckFrame* CreateAckFrame() OVERRIDE;
   virtual QuicCongestionFeedbackFrame* CreateFeedbackFrame() OVERRIDE;
   virtual bool OnSerializedPacket(const SerializedPacket& packet) OVERRIDE;
 
   // Accessors
   void set_visitor(QuicConnectionVisitorInterface* visitor) {
     visitor_ = visitor;
   }
   void set_debug_visitor(QuicConnectionDebugVisitorInterface* debug_visitor) {
     debug_visitor_ = debug_visitor;
+    packet_generator_.set_debug_delegate(debug_visitor);
   }
   const IPEndPoint& self_address() const { return self_address_; }
   const IPEndPoint& peer_address() const { return peer_address_; }
   QuicGuid guid() const { return guid_; }
   const QuicClock* clock() const { return clock_; }
   QuicRandom* random_generator() const { return random_generator_; }
 
   // Updates the internal state concerning which packets have been acked.
   void RecordPacketReceived(const QuicPacketHeader& header);
 
@@ skipping 103 matching lines @@
   // deleted and should not be accessed. If |sequence_number| is present in
   // |retransmission_map_| it also sets up retransmission of the given packet
   // in case of successful write. If |force| is FORCE, then the packet will be
   // sent immediately and the send scheduler will not be consulted.
   bool WritePacket(EncryptionLevel level,
                    QuicPacketSequenceNumber sequence_number,
                    QuicPacket* packet,
                    HasRetransmittableData retransmittable,
                    Force force);
 
+  int WritePacketToWire(QuicPacketSequenceNumber sequence_number,
+                        EncryptionLevel level,
+                        const QuicEncryptedPacket& packet,
+                        int* error);
+
   // Make sure an ack we got from our peer is sane.
   bool ValidateAckFrame(const QuicAckFrame& incoming_ack);
 
   QuicConnectionHelperInterface* helper() { return helper_.get(); }
 
  protected:
   QuicFramer framer_;
 
  private:
   friend class test::QuicConnectionPeer;
@@ skipping 249 matching lines @@
   // Set to true if the udp packet headers have a new self or peer address.
   // This is checked later on validating a data or version negotiation packet.
   bool address_migrating_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicConnection);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CONNECTION_H_