Landing 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>
@@ skipping 178 matching lines @@
               is_server),
       helper_(helper),
       writer_(writer_factory.Create(this)),
       owns_writer_(owns_writer),
       encryption_level_(ENCRYPTION_NONE),
       clock_(helper->GetClock()),
       random_generator_(helper->GetRandomGenerator()),
       connection_id_(connection_id),
       peer_address_(address),
       migrating_peer_port_(0),
+      last_packet_decrypted_(false),
       last_packet_revived_(false),
       last_size_(0),
       last_decrypted_packet_level_(ENCRYPTION_NONE),
       largest_seen_packet_with_ack_(0),
       largest_seen_packet_with_stop_waiting_(0),
       max_undecryptable_packets_(0),
       pending_version_negotiation_packet_(false),
       received_packet_manager_(&stats_),
       ack_queued_(false),
       num_packets_received_since_last_ack_sent_(0),
@@ skipping 75 matching lines @@
                   version) != available_versions.end()) {
       framer_.set_version(version);
       return true;
     }
   }
 
   return false;
 }
 
 void QuicConnection::OnError(QuicFramer* framer) {
-  // Packets that we cannot decrypt are dropped.
+  // Packets that we can not or have not decrypted are dropped.
   // TODO(rch): add stats to measure this.
-  if (!connected_ || framer->error() == QUIC_DECRYPTION_FAILURE) {
-    return;
+  if (FLAGS_quic_drop_junk_packets) {
+    if (!connected_ || last_packet_decrypted_ == false) {
+      return;
+    }
+  } else {
+    if (!connected_ || framer->error() == QUIC_DECRYPTION_FAILURE) {
+      return;
+    }
   }
   SendConnectionCloseWithDetails(framer->error(), framer->detailed_error());
 }
 
 void QuicConnection::OnPacket() {
   DCHECK(last_stream_frames_.empty() &&
          last_ack_frames_.empty() &&
          last_congestion_frames_.empty() &&
          last_stop_waiting_frames_.empty() &&
          last_rst_frames_.empty() &&
          last_goaway_frames_.empty() &&
          last_window_update_frames_.empty() &&
          last_blocked_frames_.empty() &&
          last_ping_frames_.empty() &&
          last_close_frames_.empty());
+  last_packet_decrypted_ = false;
+  last_packet_revived_ = false;
 }
 
 void QuicConnection::OnPublicResetPacket(
     const QuicPublicResetPacket& packet) {
   if (debug_visitor_.get() != nullptr) {
     debug_visitor_->OnPublicResetPacket(packet);
   }
   CloseConnection(QUIC_PUBLIC_RESET, true);
 
   DVLOG(1) << ENDPOINT << "Connection " << connection_id()
@@ skipping 105 matching lines @@
     const QuicPacketPublicHeader& header) {
   return true;
 }
 
 bool QuicConnection::OnUnauthenticatedHeader(const QuicPacketHeader& header) {
   return true;
 }
 
 void QuicConnection::OnDecryptedPacket(EncryptionLevel level) {
   last_decrypted_packet_level_ = level;
+  last_packet_decrypted_ = true;
 }
 
 bool QuicConnection::OnPacketHeader(const QuicPacketHeader& header) {
   if (debug_visitor_.get() != nullptr) {
     debug_visitor_->OnPacketHeader(header);
   }
 
   if (!ProcessValidatedPacket()) {
     return false;
   }
@@ skipping 627 matching lines @@
 
 void QuicConnection::SendBlocked(QuicStreamId id) {
   // Opportunistically bundle an ack with this outgoing packet.
   ScopedPacketBundler ack_bundler(this, BUNDLE_PENDING_ACK);
   packet_generator_.AddControlFrame(QuicFrame(new QuicBlockedFrame(id)));
 }
 
 const QuicConnectionStats& QuicConnection::GetStats() {
   // Update rtt and estimated bandwidth.
   stats_.min_rtt_us =
-      sent_packet_manager_.GetRttStats()->min_rtt().ToMicroseconds();
+      sent_packet_manager_.GetRttStats()->MinRtt().ToMicroseconds();
   stats_.srtt_us =
       sent_packet_manager_.GetRttStats()->SmoothedRtt().ToMicroseconds();
   stats_.estimated_bandwidth =
       sent_packet_manager_.BandwidthEstimate().ToBytesPerSecond();
   stats_.congestion_window = sent_packet_manager_.GetCongestionWindow();
   stats_.slow_start_threshold = sent_packet_manager_.GetSlowStartThreshold();
   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_.get() != nullptr) {
     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.
@@ skipping 598 matching lines @@
   ++stats_.packets_revived;
   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 nullptr;
   }
-  if (group_map_.count(fec_group_num) == 0) {
+  if (!ContainsKey(group_map_, fec_group_num)) {
     if (group_map_.size() >= kMaxFecGroups) {  // Too many groups
       if (fec_group_num < group_map_.begin()->first) {
         // The group being requested is a group we've seen before and deleted.
         // Don't recreate it.
         return nullptr;
       }
       // Clear the lowest group number.
       delete group_map_.begin()->second;
       group_map_.erase(group_map_.begin());
     }
@@ skipping 296 matching lines @@
   }
   for (size_t i = 0; i < retransmittable_frames->frames().size(); ++i) {
     if (retransmittable_frames->frames()[i].type == CONNECTION_CLOSE_FRAME) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace net