Land Recent QUIC Changes.

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 202 matching lines @@
       pending_version_negotiation_packet_(false),
       received_packet_manager_(kTCP, &stats_),
       ack_queued_(false),
       stop_waiting_count_(0),
       ack_alarm_(helper->CreateAlarm(new AckAlarm(this))),
       retransmission_alarm_(helper->CreateAlarm(new RetransmissionAlarm(this))),
       send_alarm_(helper->CreateAlarm(new SendAlarm(this))),
       resume_writes_alarm_(helper->CreateAlarm(new SendAlarm(this))),
       timeout_alarm_(helper->CreateAlarm(new TimeoutAlarm(this))),
       ping_alarm_(helper->CreateAlarm(new PingAlarm(this))),
-      debug_visitor_(NULL),
       packet_generator_(connection_id_, &framer_, random_generator_, this),
       idle_network_timeout_(
           QuicTime::Delta::FromSeconds(kDefaultInitialTimeoutSecs)),
       overall_connection_timeout_(QuicTime::Delta::Infinite()),
       time_of_last_received_packet_(clock_->ApproximateNow()),
       time_of_last_sent_new_packet_(clock_->ApproximateNow()),
       sequence_number_of_last_sent_packet_(0),
       sent_packet_manager_(
           is_server, clock_, &stats_, kCubic,
           FLAGS_quic_use_time_loss_detection ? kTime : kNack),
@@ skipping 68 matching lines @@
          last_window_update_frames_.empty() &&
          last_blocked_frames_.empty() &&
          last_rst_frames_.empty() &&
          last_ack_frames_.empty() &&
          last_congestion_frames_.empty() &&
          last_stop_waiting_frames_.empty());
 }
 
 void QuicConnection::OnPublicResetPacket(
     const QuicPublicResetPacket& packet) {
-  if (debug_visitor_) {
+  if (debug_visitor_.get() != NULL) {
     debug_visitor_->OnPublicResetPacket(packet);
   }
   CloseConnection(QUIC_PUBLIC_RESET, true);
 
   DVLOG(1) << ENDPOINT << "Connection " << connection_id()
            << " closed via QUIC_PUBLIC_RESET from peer.";
 }
 
 bool QuicConnection::OnProtocolVersionMismatch(QuicVersion received_version) {
   DVLOG(1) << ENDPOINT << "Received packet with mismatched version "
            << received_version;
   // TODO(satyamshekhar): Implement no server state in this mode.
   if (!is_server_) {
     LOG(DFATAL) << ENDPOINT << "Framer called OnProtocolVersionMismatch. "
                 << "Closing connection.";
     CloseConnection(QUIC_INTERNAL_ERROR, false);
     return false;
   }
   DCHECK_NE(version(), received_version);
 
-  if (debug_visitor_) {
+  if (debug_visitor_.get() != NULL) {
     debug_visitor_->OnProtocolVersionMismatch(received_version);
   }
 
   switch (version_negotiation_state_) {
     case START_NEGOTIATION:
       if (!framer_.IsSupportedVersion(received_version)) {
         SendVersionNegotiationPacket();
         version_negotiation_state_ = NEGOTIATION_IN_PROGRESS;
         return false;
       }
@@ skipping 30 matching lines @@
 
 // Handles version negotiation for client connection.
 void QuicConnection::OnVersionNegotiationPacket(
     const QuicVersionNegotiationPacket& packet) {
   if (is_server_) {
     LOG(DFATAL) << ENDPOINT << "Framer parsed VersionNegotiationPacket."
                 << " Closing connection.";
     CloseConnection(QUIC_INTERNAL_ERROR, false);
     return;
   }
-  if (debug_visitor_) {
+  if (debug_visitor_.get() != NULL) {
     debug_visitor_->OnVersionNegotiationPacket(packet);
   }
 
   if (version_negotiation_state_ != START_NEGOTIATION) {
     // Possibly a duplicate version negotiation packet.
     return;
   }
 
   if (std::find(packet.versions.begin(),
                 packet.versions.end(), version()) !=
@@ skipping 27 matching lines @@
 
 bool QuicConnection::OnUnauthenticatedHeader(const QuicPacketHeader& header) {
   return true;
 }
 
 void QuicConnection::OnDecryptedPacket(EncryptionLevel level) {
   last_decrypted_packet_level_ = level;
 }
 
 bool QuicConnection::OnPacketHeader(const QuicPacketHeader& header) {
-  if (debug_visitor_) {
+  if (debug_visitor_.get() != NULL) {
     debug_visitor_->OnPacketHeader(header);
   }
 
   if (!ProcessValidatedPacket()) {
     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 28 matching lines @@
   DCHECK_EQ(IN_FEC_GROUP, last_header_.is_in_fec_group);
   DCHECK_NE(0u, last_header_.fec_group);
   QuicFecGroup* group = GetFecGroup();
   if (group != NULL) {
     group->Update(last_decrypted_packet_level_, last_header_, payload);
   }
 }
 
 bool QuicConnection::OnStreamFrame(const QuicStreamFrame& frame) {
   DCHECK(connected_);
-  if (debug_visitor_) {
+  if (debug_visitor_.get() != NULL) {
     debug_visitor_->OnStreamFrame(frame);
   }
   if (frame.stream_id != kCryptoStreamId &&
       last_decrypted_packet_level_ == ENCRYPTION_NONE) {
     DLOG(WARNING) << ENDPOINT
                   << "Received an unencrypted data frame: closing connection";
     SendConnectionClose(QUIC_UNENCRYPTED_STREAM_DATA);
     return false;
   }
   last_stream_frames_.push_back(frame);
   return true;
 }
 
 bool QuicConnection::OnAckFrame(const QuicAckFrame& incoming_ack) {
   DCHECK(connected_);
-  if (debug_visitor_) {
+  if (debug_visitor_.get() != NULL) {
     debug_visitor_->OnAckFrame(incoming_ack);
   }
   DVLOG(1) << ENDPOINT << "OnAckFrame: " << incoming_ack;
 
   if (last_header_.packet_sequence_number <= largest_seen_packet_with_ack_) {
     DVLOG(1) << ENDPOINT << "Received an old ack frame: ignoring";
     return true;
   }
 
   if (!ValidateAckFrame(incoming_ack)) {
     SendConnectionClose(QUIC_INVALID_ACK_DATA);
     return false;
   }
 
   last_ack_frames_.push_back(incoming_ack);
   return connected_;
 }
 
 void QuicConnection::ProcessAckFrame(const QuicAckFrame& incoming_ack) {
   largest_seen_packet_with_ack_ = last_header_.packet_sequence_number;
-  received_packet_manager_.UpdatePacketInformationReceivedByPeer(
-      incoming_ack.received_info);
-  if (version() <= QUIC_VERSION_15) {
-    ProcessStopWaitingFrame(incoming_ack.sent_info);
-  }
+  received_packet_manager_.UpdatePacketInformationReceivedByPeer(incoming_ack);
 
   sent_entropy_manager_.ClearEntropyBefore(
       received_packet_manager_.least_packet_awaited_by_peer() - 1);
 
-  sent_packet_manager_.OnIncomingAck(incoming_ack.received_info,
+  sent_packet_manager_.OnIncomingAck(incoming_ack,
                                      time_of_last_received_packet_);
   if (sent_packet_manager_.HasPendingRetransmissions()) {
     WriteIfNotBlocked();
   }
 
   // Always reset the retransmission alarm when an ack comes in, since we now
   // have a better estimate of the current rtt than when it was set.
   retransmission_alarm_->Cancel();
   QuicTime retransmission_time =
       sent_packet_manager_.GetRetransmissionTime();
   if (retransmission_time != QuicTime::Zero()) {
     retransmission_alarm_->Set(retransmission_time);
   }
 }
 
 void QuicConnection::ProcessStopWaitingFrame(
     const QuicStopWaitingFrame& stop_waiting) {
   largest_seen_packet_with_stop_waiting_ = last_header_.packet_sequence_number;
   received_packet_manager_.UpdatePacketInformationSentByPeer(stop_waiting);
   // Possibly close any FecGroups which are now irrelevant.
   CloseFecGroupsBefore(stop_waiting.least_unacked + 1);
 }
 
 bool QuicConnection::OnCongestionFeedbackFrame(
     const QuicCongestionFeedbackFrame& feedback) {
   DCHECK(connected_);
-  if (debug_visitor_) {
+  if (debug_visitor_.get() != NULL) {
     debug_visitor_->OnCongestionFeedbackFrame(feedback);
   }
   last_congestion_frames_.push_back(feedback);
   return connected_;
 }
 
 bool QuicConnection::OnStopWaitingFrame(const QuicStopWaitingFrame& frame) {
   DCHECK(connected_);
 
   if (last_header_.packet_sequence_number <=
       largest_seen_packet_with_stop_waiting_) {
     DVLOG(1) << ENDPOINT << "Received an old stop waiting frame: ignoring";
     return true;
   }
 
   if (!ValidateStopWaitingFrame(frame)) {
     SendConnectionClose(QUIC_INVALID_STOP_WAITING_DATA);
     return false;
   }
 
-  if (debug_visitor_) {
+  if (debug_visitor_.get() != NULL) {
     debug_visitor_->OnStopWaitingFrame(frame);
   }
 
   last_stop_waiting_frames_.push_back(frame);
   return connected_;
 }
 
 bool QuicConnection::OnPingFrame(const QuicPingFrame& frame) {
   DCHECK(connected_);
-  if (debug_visitor_) {
+  if (debug_visitor_.get() != NULL) {
     debug_visitor_->OnPingFrame(frame);
   }
   return true;
 }
 
 bool QuicConnection::ValidateAckFrame(const QuicAckFrame& incoming_ack) {
-  if (incoming_ack.received_info.largest_observed >
-      packet_generator_.sequence_number()) {
+  if (incoming_ack.largest_observed > packet_generator_.sequence_number()) {
     DLOG(ERROR) << ENDPOINT << "Peer's observed unsent packet:"
-                << incoming_ack.received_info.largest_observed << " vs "
+                << incoming_ack.largest_observed << " vs "
                 << packet_generator_.sequence_number();
     // We got an error for data we have not sent.  Error out.
     return false;
   }
 
-  if (incoming_ack.received_info.largest_observed <
+  if (incoming_ack.largest_observed <
           received_packet_manager_.peer_largest_observed_packet()) {
     DLOG(ERROR) << ENDPOINT << "Peer's largest_observed packet decreased:"
-                << incoming_ack.received_info.largest_observed << " vs "
+                << incoming_ack.largest_observed << " vs "
                 << received_packet_manager_.peer_largest_observed_packet();
     // A new ack has a diminished largest_observed value.  Error out.
     // If this was an old packet, we wouldn't even have checked.
     return false;
   }
 
-  if (version() <= QUIC_VERSION_15) {
-    if (!ValidateStopWaitingFrame(incoming_ack.sent_info)) {
-      return false;
-    }
-  }
-
-  if (!incoming_ack.received_info.missing_packets.empty() &&
-      *incoming_ack.received_info.missing_packets.rbegin() >
-      incoming_ack.received_info.largest_observed) {
+  if (!incoming_ack.missing_packets.empty() &&
+      *incoming_ack.missing_packets.rbegin() > incoming_ack.largest_observed) {
     DLOG(ERROR) << ENDPOINT << "Peer sent missing packet: "
-                << *incoming_ack.received_info.missing_packets.rbegin()
+                << *incoming_ack.missing_packets.rbegin()
                 << " which is greater than largest observed: "
-                << incoming_ack.received_info.largest_observed;
+                << incoming_ack.largest_observed;
     return false;
   }
 
-  if (!incoming_ack.received_info.missing_packets.empty() &&
-      *incoming_ack.received_info.missing_packets.begin() <
+  if (!incoming_ack.missing_packets.empty() &&
+      *incoming_ack.missing_packets.begin() <
       received_packet_manager_.least_packet_awaited_by_peer()) {
     DLOG(ERROR) << ENDPOINT << "Peer sent missing packet: "
-                << *incoming_ack.received_info.missing_packets.begin()
+                << *incoming_ack.missing_packets.begin()
                 << " which is smaller than least_packet_awaited_by_peer_: "
                 << received_packet_manager_.least_packet_awaited_by_peer();
     return false;
   }
 
   if (!sent_entropy_manager_.IsValidEntropy(
-          incoming_ack.received_info.largest_observed,
-          incoming_ack.received_info.missing_packets,
-          incoming_ack.received_info.entropy_hash)) {
+          incoming_ack.largest_observed,
+          incoming_ack.missing_packets,
+          incoming_ack.entropy_hash)) {
     DLOG(ERROR) << ENDPOINT << "Peer sent invalid entropy.";
     return false;
   }
 
   for (SequenceNumberSet::const_iterator iter =
-           incoming_ack.received_info.revived_packets.begin();
-       iter != incoming_ack.received_info.revived_packets.end(); ++iter) {
-    if (!ContainsKey(incoming_ack.received_info.missing_packets, *iter)) {
+           incoming_ack.revived_packets.begin();
+       iter != incoming_ack.revived_packets.end(); ++iter) {
+    if (!ContainsKey(incoming_ack.missing_packets, *iter)) {
       DLOG(ERROR) << ENDPOINT
                   << "Peer specified revived packet which was not missing.";
       return false;
     }
   }
   return true;
 }
 
 bool QuicConnection::ValidateStopWaitingFrame(
     const QuicStopWaitingFrame& stop_waiting) {
@@ skipping 23 matching lines @@
   DCHECK_NE(0u, last_header_.fec_group);
   QuicFecGroup* group = GetFecGroup();
   if (group != NULL) {
     group->UpdateFec(last_decrypted_packet_level_,
                      last_header_.packet_sequence_number, fec);
   }
 }
 
 bool QuicConnection::OnRstStreamFrame(const QuicRstStreamFrame& frame) {
   DCHECK(connected_);
-  if (debug_visitor_) {
+  if (debug_visitor_.get() != NULL) {
     debug_visitor_->OnRstStreamFrame(frame);
   }
   DVLOG(1) << ENDPOINT << "Stream reset with error "
            << QuicUtils::StreamErrorToString(frame.error_code);
   last_rst_frames_.push_back(frame);
   return connected_;
 }
 
 bool QuicConnection::OnConnectionCloseFrame(
     const QuicConnectionCloseFrame& frame) {
   DCHECK(connected_);
-  if (debug_visitor_) {
+  if (debug_visitor_.get() != NULL) {
     debug_visitor_->OnConnectionCloseFrame(frame);
   }
   DVLOG(1) << ENDPOINT << "Connection " << connection_id()
            << " closed with error "
            << QuicUtils::ErrorToString(frame.error_code)
            << " " << frame.error_details;
   last_close_frames_.push_back(frame);
   return connected_;
 }
 
 bool QuicConnection::OnGoAwayFrame(const QuicGoAwayFrame& frame) {
   DCHECK(connected_);
-  if (debug_visitor_) {
+  if (debug_visitor_.get() != NULL) {
     debug_visitor_->OnGoAwayFrame(frame);
   }
   DVLOG(1) << ENDPOINT << "Go away received with error "
            << QuicUtils::ErrorToString(frame.error_code)
            << " and reason:" << frame.reason_phrase;
   last_goaway_frames_.push_back(frame);
   return connected_;
 }
 
 bool QuicConnection::OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) {
   DCHECK(connected_);
-  if (debug_visitor_) {
+  if (debug_visitor_.get() != NULL) {
     debug_visitor_->OnWindowUpdateFrame(frame);
   }
   DVLOG(1) << ENDPOINT << "WindowUpdate received for stream: "
            << frame.stream_id << " with byte offset: " << frame.byte_offset;
   last_window_update_frames_.push_back(frame);
   return connected_;
 }
 
 bool QuicConnection::OnBlockedFrame(const QuicBlockedFrame& frame) {
   DCHECK(connected_);
-  if (debug_visitor_) {
+  if (debug_visitor_.get() != NULL) {
     debug_visitor_->OnBlockedFrame(frame);
   }
   DVLOG(1) << ENDPOINT << "Blocked frame received for stream: "
            << frame.stream_id;
   last_blocked_frames_.push_back(frame);
   return connected_;
 }
 
 void QuicConnection::OnPacketComplete() {
   // Don't do anything if this packet closed the connection.
@@ skipping 112 matching lines @@
   last_blocked_frames_.clear();
   last_rst_frames_.clear();
   last_ack_frames_.clear();
   last_stop_waiting_frames_.clear();
   last_congestion_frames_.clear();
 }
 
 QuicAckFrame* QuicConnection::CreateAckFrame() {
   QuicAckFrame* outgoing_ack = new QuicAckFrame();
   received_packet_manager_.UpdateReceivedPacketInfo(
-      &(outgoing_ack->received_info), clock_->ApproximateNow());
-  UpdateStopWaiting(&(outgoing_ack->sent_info));
+      outgoing_ack, clock_->ApproximateNow());
   DVLOG(1) << ENDPOINT << "Creating ack frame: " << *outgoing_ack;
   return outgoing_ack;
 }
 
 QuicCongestionFeedbackFrame* QuicConnection::CreateFeedbackFrame() {
   return new QuicCongestionFeedbackFrame(outgoing_congestion_feedback_);
 }
 
 QuicStopWaitingFrame* QuicConnection::CreateStopWaitingFrame() {
   QuicStopWaitingFrame stop_waiting;
   UpdateStopWaiting(&stop_waiting);
   return new QuicStopWaitingFrame(stop_waiting);
 }
 
 bool QuicConnection::ShouldLastPacketInstigateAck() const {
   if (!last_stream_frames_.empty() ||
       !last_goaway_frames_.empty() ||
       !last_rst_frames_.empty() ||
       !last_window_update_frames_.empty() ||
       !last_blocked_frames_.empty()) {
     return true;
   }
 
-  if (!last_ack_frames_.empty() &&
-      last_ack_frames_.back().received_info.is_truncated) {
+  if (!last_ack_frames_.empty() && last_ack_frames_.back().is_truncated) {
     return true;
   }
   return false;
 }
 
 void QuicConnection::UpdateStopWaitingCount() {
   if (last_ack_frames_.empty()) {
     return;
   }
 
   // If the peer is still waiting for a packet that we are no longer planning to
   // send, send an ack to raise the high water mark.
-  if (!last_ack_frames_.back().received_info.missing_packets.empty() &&
-      GetLeastUnacked() >
-          *last_ack_frames_.back().received_info.missing_packets.begin()) {
+  if (!last_ack_frames_.back().missing_packets.empty() &&
+      GetLeastUnacked() > *last_ack_frames_.back().missing_packets.begin()) {
     ++stop_waiting_count_;
   } else {
     stop_waiting_count_ = 0;
   }
 }
 
 QuicPacketSequenceNumber QuicConnection::GetLeastUnacked() const {
   return sent_packet_manager_.HasUnackedPackets() ?
       sent_packet_manager_.GetLeastUnackedSentPacket() :
       packet_generator_.sequence_number() + 1;
@@ skipping 123 matching lines @@
   stats_.max_packet_size = packet_generator_.max_packet_length();
   return stats_;
 }
 
 void QuicConnection::ProcessUdpPacket(const IPEndPoint& self_address,
                                       const IPEndPoint& peer_address,
                                       const QuicEncryptedPacket& packet) {
   if (!connected_) {
     return;
   }
-  if (debug_visitor_) {
+  if (debug_visitor_.get() != NULL) {
     debug_visitor_->OnPacketReceived(self_address, peer_address, packet);
   }
   last_packet_revived_ = false;
   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_.get() != 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 134 matching lines @@
     // Flush the packet generator before making a new packet.
     // TODO(ianswett): Implement ReserializeAllFrames as a separate path that
     // does not require the creator to be flushed.
     packet_generator_.FlushAllQueuedFrames();
     SerializedPacket serialized_packet = packet_generator_.ReserializeAllFrames(
         pending.retransmittable_frames.frames(),
         pending.sequence_number_length);
 
     DVLOG(1) << ENDPOINT << "Retransmitting " << pending.sequence_number
              << " as " << serialized_packet.sequence_number;
-    if (debug_visitor_) {
+    if (debug_visitor_.get() != NULL) {
       debug_visitor_->OnPacketRetransmitted(
           pending.sequence_number, serialized_packet.sequence_number);
     }
     sent_packet_manager_.OnRetransmittedPacket(
         pending.sequence_number,
         serialized_packet.sequence_number);
 
     SendOrQueuePacket(pending.retransmittable_frames.encryption_level(),
                       serialized_packet,
                       pending.transmission_type);
@@ skipping 128 matching lines @@
   DCHECK(pending_write_.get() == NULL);
   pending_write_.reset(new QueuedPacket(packet));
 
   WriteResult result = writer_->WritePacket(encrypted->data(),
                                             encrypted->length(),
                                             self_address().address(),
                                             peer_address());
   if (result.error_code == ERR_IO_PENDING) {
     DCHECK_EQ(WRITE_STATUS_BLOCKED, result.status);
   }
-  if (debug_visitor_) {
+  if (debug_visitor_.get() != NULL) {
     // Pass the write result to the visitor.
     debug_visitor_->OnPacketSent(sequence_number,
                                  packet.encryption_level,
                                  packet.transmission_type,
                                  *encrypted,
                                  result);
   }
   if (result.status == WRITE_STATUS_BLOCKED) {
     visitor_->OnWriteBlocked();
     // If the socket buffers the the data, then the packet should not
@@ skipping 152 matching lines @@
 void QuicConnection::UpdateStopWaiting(QuicStopWaitingFrame* stop_waiting) {
   stop_waiting->least_unacked = GetLeastUnacked();
   stop_waiting->entropy_hash = sent_entropy_manager_.EntropyHash(
       stop_waiting->least_unacked - 1);
 }
 
 void QuicConnection::SendPing() {
   if (retransmission_alarm_->IsSet()) {
     return;
   }
-  if (version() <= QUIC_VERSION_16) {
+  if (version() == QUIC_VERSION_16) {
     // TODO(rch): remove this when we remove version 15 and 16.
     // This is a horrible hideous hack which we should not support.
     IOVector data;
     char c_data[] = "C";
     data.Append(c_data, 1);
     QuicConsumedData consumed_data =
         packet_generator_.ConsumeData(kCryptoStreamId, data, 0, false,
                                       MAY_FEC_PROTECT, NULL);
     if (consumed_data.bytes_consumed == 0) {
       DLOG(ERROR) << "Unable to send ping!?";
@@ skipping 10 matching lines @@
   // method is invoked.  This requires changes SetShouldSendAck
   // to be a no-arg method, and re-jiggering its implementation.
   bool send_feedback = false;
   if (received_packet_manager_.GenerateCongestionFeedback(
           &outgoing_congestion_feedback_)) {
     DVLOG(1) << ENDPOINT << "Sending feedback: "
              << outgoing_congestion_feedback_;
     send_feedback = true;
   }
 
-  packet_generator_.SetShouldSendAck(send_feedback,
-                                     version() > QUIC_VERSION_15);
+  packet_generator_.SetShouldSendAck(send_feedback, true);
 }
 
 void QuicConnection::OnRetransmissionTimeout() {
   if (!sent_packet_manager_.HasUnackedPackets()) {
     return;
   }
 
   sent_packet_manager_.OnRetransmissionTimeout();
   WriteIfNotBlocked();
   // In the TLP case, the SentPacketManager gives the connection the opportunity
@@ skipping 68 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) {

[wtc, 2014/08/04 23:28:12]

debug_visitor_ => debug_visitor_.get()

[ramant (doing other things), 2014/08/09 02:53:19]

Done.

+      for (size_t i = 0; i < undecryptable_packets_.size(); ++i) {
+        debug_visitor_->OnUndecryptablePacket();

[wtc, 2014/08/04 23:28:12]

Nit: perhaps more efficient to pass the number of undecryptable packets as the
argument to OnUndecryptablePacket so that we just need to call
OnUndecryptablePacket once?

[ramant (doing other things), 2014/08/09 02:53:19]

Good point. We are not using this method yet. Added a TODO.

Acknowledged.

+      }
+    }
     STLDeleteElements(&undecryptable_packets_);
   }
 }
 
 void QuicConnection::MaybeProcessRevivedPacket() {
   QuicFecGroup* group = GetFecGroup();
   if (!connected_ || group == NULL || !group->CanRevive()) {
     return;
   }
   QuicPacketHeader revived_header;
   char revived_payload[kMaxPacketSize];
   size_t len = group->Revive(&revived_header, revived_payload, kMaxPacketSize);
   revived_header.public_header.connection_id = connection_id_;
   revived_header.public_header.connection_id_length =
       last_header_.public_header.connection_id_length;
   revived_header.public_header.version_flag = false;
   revived_header.public_header.reset_flag = false;
   revived_header.public_header.sequence_number_length =
       last_header_.public_header.sequence_number_length;
   revived_header.fec_flag = false;
   revived_header.is_in_fec_group = NOT_IN_FEC_GROUP;
   revived_header.fec_group = 0;
   group_map_.erase(last_header_.fec_group);
   last_decrypted_packet_level_ = group->effective_encryption_level();
   DCHECK_LT(last_decrypted_packet_level_, NUM_ENCRYPTION_LEVELS);
   delete group;
 
   last_packet_revived_ = true;
-  if (debug_visitor_) {
+  if (debug_visitor_.get() != NULL) {
     debug_visitor_->OnRevivedPacket(revived_header,
                                     StringPiece(revived_payload, len));
   }
 
   ++stats_.packets_revived;
   framer_.ProcessRevivedPacket(&revived_header,
                                StringPiece(revived_payload, len));
 }
 
 QuicFecGroup* QuicConnection::GetFecGroup() {
@@ skipping 241 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