Allow 0-RTT handshakes for QUIC HTTPS requests.

net/quic/quic_fec_group.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_fec_group.h"
 
 #include <limits>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 
 using base::StringPiece;
 using std::numeric_limits;
 using std::set;
 
 namespace net {
 
 namespace {
 const QuicPacketSequenceNumber kNoSequenceNumber = kuint64max;
 }  // namespace
 
 QuicFecGroup::QuicFecGroup()
     : min_protected_packet_(kNoSequenceNumber),
       max_protected_packet_(kNoSequenceNumber),
-      payload_parity_len_(0) {
+      payload_parity_len_(0),
+      effective_encryption_level_(NUM_ENCRYPTION_LEVELS) {
 }
 
 QuicFecGroup::~QuicFecGroup() {}
 
-bool QuicFecGroup::Update(const QuicPacketHeader& header,
+bool QuicFecGroup::Update(EncryptionLevel encryption_level,
+                          const QuicPacketHeader& header,
                           StringPiece decrypted_payload) {
   if (received_packets_.count(header.packet_sequence_number) != 0) {
     return false;
   }
   if (min_protected_packet_ != kNoSequenceNumber &&
       max_protected_packet_ != kNoSequenceNumber &&
       (header.packet_sequence_number < min_protected_packet_ ||
        header.packet_sequence_number > max_protected_packet_)) {
     DLOG(ERROR) << "FEC group does not cover received packet: "
                 << header.packet_sequence_number;
     return false;
   }
   if (!UpdateParity(decrypted_payload)) {
     return false;
   }
   received_packets_.insert(header.packet_sequence_number);
+  if (encryption_level < effective_encryption_level_) {
+    effective_encryption_level_ = encryption_level;
+  }
   return true;
 }
 
 bool QuicFecGroup::UpdateFec(
+    EncryptionLevel encryption_level,
     QuicPacketSequenceNumber fec_packet_sequence_number,
     const QuicFecData& fec) {
   if (min_protected_packet_ != kNoSequenceNumber) {
     return false;
   }
   SequenceNumberSet::const_iterator it = received_packets_.begin();
   while (it != received_packets_.end()) {
     if ((*it < fec.fec_group) || (*it >= fec_packet_sequence_number)) {
       DLOG(ERROR) << "FEC group does not cover received packet: " << *it;
       return false;
     }
     ++it;
   }
   if (!UpdateParity(fec.redundancy)) {
     return false;
   }
   min_protected_packet_ = fec.fec_group;
   max_protected_packet_ = fec_packet_sequence_number - 1;
+  if (encryption_level < effective_encryption_level_) {
+    effective_encryption_level_ = encryption_level;
+  }
   return true;
 }
 
 bool QuicFecGroup::CanRevive() const {
   // We can revive if we're missing exactly 1 packet.
   return NumMissingPackets() == 1;
 }
 
 bool QuicFecGroup::IsFinished() const {
   // We are finished if we are not missing any packets.
@@ skipping 73 matching lines @@
 }
 
 size_t QuicFecGroup::NumMissingPackets() const {
   if (min_protected_packet_ == kNoSequenceNumber)
     return numeric_limits<size_t>::max();
   return (max_protected_packet_ - min_protected_packet_ + 1) -
       received_packets_.size();
 }
 
 }  // namespace net