Add a DebugVisitor to QuicConnection to facilitate logging the activity on a QUIC connection.

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 80 matching lines @@
       random_generator_(helper->GetRandomGenerator()),
       guid_(guid),
       peer_address_(address),
       should_send_ack_(false),
       should_send_congestion_feedback_(false),
       largest_seen_packet_with_ack_(0),
       peer_largest_observed_packet_(0),
       peer_least_packet_awaiting_ack_(0),
       handling_retransmission_timeout_(false),
       write_blocked_(false),
+      debug_visitor_(NULL),
       packet_creator_(guid_, &framer_),
       timeout_(QuicTime::Delta::FromMicroseconds(kDefaultTimeoutUs)),
       time_of_last_packet_(clock_->Now()),
       congestion_manager_(clock_, kTCP),
       connected_(true),
       received_truncated_ack_(false),
       send_ack_in_response_to_packet_(false) {
   helper_->SetConnection(this);
   helper_->SetTimeoutAlarm(timeout_);
   framer_.set_visitor(this);
@@ skipping 65 matching lines @@
   time_of_last_packet_ = clock_->Now();
   DVLOG(1) << "last packet: " << time_of_last_packet_.ToMicroseconds();
 
   // TODO(alyssar, rch) handle migration!
   self_address_ = last_self_address_;
   peer_address_ = last_peer_address_;
 }
 
 void QuicConnection::OnPublicResetPacket(
     const QuicPublicResetPacket& packet) {
+  if (debug_visitor_) {
+    debug_visitor_->OnPublicResetPacket(packet);
+  }
   CloseConnection(QUIC_PUBLIC_RESET, true);
 }
 
 void QuicConnection::OnRevivedPacket() {
 }
 
 bool QuicConnection::OnPacketHeader(const QuicPacketHeader& header) {
+  if (debug_visitor_) {
+    debug_visitor_->OnPacketHeader(header);
+  }
   if (header.public_header.guid != guid_) {
     DLOG(INFO) << "Ignoring packet from unexpected GUID: "
                << header.public_header.guid << " instead of " << guid_;
     return false;
   }
 
   if (!Near(header.packet_sequence_number,
             last_header_.packet_sequence_number)) {
     DLOG(INFO) << "Packet " << header.packet_sequence_number
                << " out of bounds.  Discarding";
@@ skipping 12 matching lines @@
   return true;
 }
 
 void QuicConnection::OnFecProtectedPayload(StringPiece payload) {
   DCHECK_NE(0u, last_header_.fec_group);
   QuicFecGroup* group = GetFecGroup();
   group->Update(last_header_, payload);
 }
 
 void QuicConnection::OnStreamFrame(const QuicStreamFrame& frame) {
+  if (debug_visitor_) {
+    debug_visitor_->OnStreamFrame(frame);
+  }
   last_stream_frames_.push_back(frame);
 }
 
 void QuicConnection::OnAckFrame(const QuicAckFrame& incoming_ack) {
+  if (debug_visitor_) {
+    debug_visitor_->OnAckFrame(incoming_ack);
+  }
   DVLOG(1) << "Ack packet: " << incoming_ack;
 
   if (last_header_.packet_sequence_number <= largest_seen_packet_with_ack_) {
     DLOG(INFO) << "Received an old ack frame: ignoring";
     return;
   }
   largest_seen_packet_with_ack_ = last_header_.packet_sequence_number;
 
   if (!ValidateAckFrame(incoming_ack)) {
     SendConnectionClose(QUIC_INVALID_ACK_DATA);
@@ skipping 18 matching lines @@
     if (!write_blocked_) {
       OnCanWrite();
     }
   } else {
     helper_->SetSendAlarm(delay);
   }
 }
 
 void QuicConnection::OnCongestionFeedbackFrame(
     const QuicCongestionFeedbackFrame& feedback) {
+  if (debug_visitor_) {
+    debug_visitor_->OnCongestionFeedbackFrame(feedback);
+  }
   congestion_manager_.OnIncomingQuicCongestionFeedbackFrame(feedback);
 }
 
 bool QuicConnection::ValidateAckFrame(const QuicAckFrame& incoming_ack) {
   if (incoming_ack.received_info.largest_observed >
       packet_creator_.sequence_number()) {
     DLOG(ERROR) << "Client observed unsent packet:"
                 << incoming_ack.received_info.largest_observed << " vs "
                 << packet_creator_.sequence_number();
     // We got an error for data we have not sent.  Error out.
@@ skipping 154 matching lines @@
   CloseFecGroupsBefore(incoming_ack.sent_info.least_unacked + 1);
 }
 
 void QuicConnection::OnFecData(const QuicFecData& fec) {
   DCHECK_NE(0u, last_header_.fec_group);
   QuicFecGroup* group = GetFecGroup();
   group->UpdateFec(last_header_.packet_sequence_number, fec);
 }
 
 void QuicConnection::OnRstStreamFrame(const QuicRstStreamFrame& frame) {
+  if (debug_visitor_) {
+    debug_visitor_->OnRstStreamFrame(frame);
+  }
   DLOG(INFO) << "Stream reset with error "
              << QuicUtils::ErrorToString(frame.error_code);
   visitor_->OnRstStream(frame);
 }
 
 void QuicConnection::OnConnectionCloseFrame(
     const QuicConnectionCloseFrame& frame) {
+  if (debug_visitor_) {
+    debug_visitor_->OnConnectionCloseFrame(frame);
+  }
   DLOG(INFO) << "Connection closed with error "
              << QuicUtils::ErrorToString(frame.error_code);
   CloseConnection(frame.error_code, true);
 }
 
 void QuicConnection::OnPacketComplete() {
   if (!last_packet_revived_) {
     DLOG(INFO) << "Got packet " << last_header_.packet_sequence_number
                << " with " << last_stream_frames_.size()
                << " stream frames for " << last_header_.public_header.guid;
@@ skipping 81 matching lines @@
 
   // Try to write immediately if possible.
   if (CanWrite(!kIsRetransmission)) {
     WriteQueuedData(kFlush);
   }
 }
 
 void QuicConnection::ProcessUdpPacket(const IPEndPoint& self_address,
                                       const IPEndPoint& peer_address,
                                       const QuicEncryptedPacket& packet) {
+  if (debug_visitor_) {
+    debug_visitor_->OnPacketReceived(self_address, peer_address, packet);

[jar (doing other things), 2013/02/14 17:13:19]

nit/comment: It is IMO common for the observer to want to be reminded which
instance is reporting this event.  As a result, for many of these interfaces, it
is tempting to pass a const ref to |*this|.   This method is a good example,
where you could have probably called after line 578, and then the instance would
have most of the parameters that you're handing off. [...but perhaps you wanted
to know what the "old" values were??].

I guess it could be that you'd only have one connection being "debuged" at a
time... or you could store a pointer to  |*this| inside a slot in your specific
|debug_visitor_|. 

Was the "typical" plan one of those... or something else?

[Ryan Hamilton, 2013/02/14 17:46:19]

*nod*  Definitely something to consider.  At the moment, I expect there to be a
1:1 mapping between the observer (as you call it) and the connection.  As such,
storing connection_ would work well.  In the follow up CL I create a
QuicConnectionLogger class which is a subclass of the observer.  This doesn't
store a pointer to the connection, but instead it stores a BoundNetLog whose
source in the Session (which owns the connection).  So it's basically doing the
same thing.  If we ever decided that we wanted to have an N:1 mapping, I would
definitely add |this| to these methods.

+  }
   last_packet_revived_ = false;
   last_size_ = packet.length();
   last_self_address_ = self_address;
   last_peer_address_ = peer_address;
   framer_.ProcessPacket(packet);
   MaybeProcessRevivedPacket();
 }
 
 bool QuicConnection::OnCanWrite() {
   write_blocked_ = false;
@@ skipping 376 matching lines @@
   char revived_payload[kMaxPacketSize];
   size_t len = group->Revive(&revived_header, revived_payload, kMaxPacketSize);
   revived_header.public_header.guid = guid_;
   revived_header.public_header.flags = PACKET_PUBLIC_FLAGS_NONE;
   revived_header.private_flags = PACKET_PRIVATE_FLAGS_NONE;
   revived_header.fec_group = kNoFecOffset;
   group_map_.erase(last_header_.fec_group);
   delete group;
 
   last_packet_revived_ = true;
+  if (debug_visitor_) {
+    debug_visitor_->OnRevivedPacket(revived_header,
+                                    StringPiece(revived_payload, len));
+  }
   framer_.ProcessRevivedPacket(revived_header,
                                StringPiece(revived_payload, len));
 }
 
 QuicFecGroup* QuicConnection::GetFecGroup() {
   QuicFecGroupNumber fec_group_num = last_header_.fec_group;
   if (fec_group_num == 0) {
     return NULL;
   }
   if (group_map_.count(fec_group_num) == 0) {
@@ skipping 64 matching lines @@
            << " delta:" << delta.ToMicroseconds();
   if (delta >= timeout_) {
     SendConnectionClose(QUIC_CONNECTION_TIMED_OUT);
     return true;
   }
   helper_->SetTimeoutAlarm(timeout_.Subtract(delta));
   return false;
 }
 
 }  // namespace net