Add methods to the QuicConnectionDebug visitor for tracking various

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 <string.h>
 #include <sys/types.h>
 #include <algorithm>
 #include <iterator>
@@ skipping 425 matching lines @@
     return false;
   }
 
   // Will be decrement below if we fall through to return true;
   ++stats_.packets_dropped;
 
   if (header.public_header.connection_id != connection_id_) {
     DVLOG(1) << ENDPOINT << "Ignoring packet from unexpected ConnectionId: "
              << header.public_header.connection_id << " instead of "
              << connection_id_;
+    if (debug_visitor_.get() != NULL) {
+      debug_visitor_->OnIncorrectConnectionId(
+          header.public_header.connection_id);
+    }
     return false;
   }
 
   if (!Near(header.packet_sequence_number,
             last_header_.packet_sequence_number)) {
     DVLOG(1) << ENDPOINT << "Packet " << header.packet_sequence_number
              << " out of bounds.  Discarding";
     SendConnectionCloseWithDetails(QUIC_INVALID_PACKET_HEADER,
                                    "Packet sequence number out of bounds");
     return false;
   }
 
   // If this packet has already been seen, or that the sender
   // has told us will not be retransmitted, then stop processing the packet.
   if (!received_packet_manager_.IsAwaitingPacket(
           header.packet_sequence_number)) {
     DVLOG(1) << ENDPOINT << "Packet " << header.packet_sequence_number
              << " no longer being waited for.  Discarding.";
-    // TODO(jri): Log reception of duplicate packets or packets the peer has
-    // told us to stop waiting for.
+    if (debug_visitor_.get() != NULL) {
+      debug_visitor_->OnDuplicatePacket(header.packet_sequence_number);
+    }
     return false;
   }
 
   if (version_negotiation_state_ != NEGOTIATED_VERSION) {
     if (is_server_) {
       if (!header.public_header.version_flag) {
         DLOG(WARNING) << ENDPOINT << "Packet " << header.packet_sequence_number
                       << " without version flag before version negotiated.";
         // Packets should have the version flag till version negotiation is
         // done.
@@ skipping 604 matching lines @@
   last_size_ = packet.length();
 
   CheckForAddressMigration(self_address, peer_address);
 
   stats_.bytes_received += packet.length();
   ++stats_.packets_received;
 
   if (!framer_.ProcessPacket(packet)) {
     // If we are unable to decrypt this packet, it might be
     // because the CHLO or SHLO packet was lost.
-    if (encryption_level_ != ENCRYPTION_FORWARD_SECURE &&
-        framer_.error() == QUIC_DECRYPTION_FAILURE &&
-        undecryptable_packets_.size() < kMaxUndecryptablePackets) {
-      QueueUndecryptablePacket(packet);
+    if (framer_.error() == QUIC_DECRYPTION_FAILURE) {
+      if (encryption_level_ != ENCRYPTION_FORWARD_SECURE &&
+          undecryptable_packets_.size() < kMaxUndecryptablePackets) {
+        QueueUndecryptablePacket(packet);
+      } else if (debug_visitor_ != NULL) {
+        debug_visitor_->OnUndecryptablePacket();
+      }
     }
     DVLOG(1) << ENDPOINT << "Unable to process packet.  Last packet processed: "
              << last_header_.packet_sequence_number;
     return;
   }
 
   ++stats_.packets_processed;
   MaybeProcessUndecryptablePackets();
   MaybeProcessRevivedPacket();
   MaybeSendInResponseToPacket();
@@ skipping 576 matching lines @@
     DVLOG(1) << ENDPOINT << "Processed undecryptable packet!";
     ++stats_.packets_processed;
     delete packet;
     undecryptable_packets_.pop_front();
   }
 
   // Once forward secure encryption is in use, there will be no
   // new keys installed and hence any undecryptable packets will
   // never be able to be decrypted.
   if (encryption_level_ == ENCRYPTION_FORWARD_SECURE) {
+    if (debug_visitor_ != NULL) {
+      for (size_t i = 0; i < undecryptable_packets_.size(); ++i) {
+        debug_visitor_->OnUndecryptablePacket();
+      }
+    }
     STLDeleteElements(&undecryptable_packets_);
   }
 }
 
 void QuicConnection::MaybeProcessRevivedPacket() {
   QuicFecGroup* group = GetFecGroup();
   if (!connected_ || group == NULL || !group->CanRevive()) {
     return;
   }
   QuicPacketHeader revived_header;
@@ skipping 270 matching lines @@
   // If we changed the generator's batch state, restore original batch state.
   if (!already_in_batch_mode_) {
     DVLOG(1) << "Leaving Batch Mode.";
     connection_->packet_generator_.FinishBatchOperations();
   }
   DCHECK_EQ(already_in_batch_mode_,
             connection_->packet_generator_.InBatchMode());
 }
 
 }  // namespace net