gfe-relnote: Refactor QuicFramer to use array of QuicDecrypter. Not flag protected.

PiperOrigin-RevId: 240227711
Change-Id: I93eaee5a6176dff23fdd84361c372ca76f903c94

quic/core/quic_framer.cc

diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index 4640d39..2594497 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -489,7 +489,7 @@
       version_(PROTOCOL_UNSUPPORTED, QUIC_VERSION_UNSUPPORTED),
       supported_versions_(supported_versions),
       decrypter_level_(ENCRYPTION_INITIAL),
-      alternative_decrypter_level_(ENCRYPTION_INITIAL),
+      alternative_decrypter_level_(NUM_ENCRYPTION_LEVELS),
       alternative_decrypter_latch_(false),
       perspective_(perspective),
       validate_flags_(true),
@@ -505,7 +505,7 @@
       supports_multiple_packet_number_spaces_(false) {
   DCHECK(!supported_versions.empty());
   version_ = supported_versions_[0];
-  decrypter_ = QuicMakeUnique<NullDecrypter>(perspective);
+  decrypter_[ENCRYPTION_INITIAL] = QuicMakeUnique<NullDecrypter>(perspective);
   encrypter_[ENCRYPTION_INITIAL] = QuicMakeUnique<NullEncrypter>(perspective);
 }
 
@@ -3910,9 +3910,10 @@
 
 void QuicFramer::SetDecrypter(EncryptionLevel level,
                               std::unique_ptr<QuicDecrypter> decrypter) {
-  DCHECK(alternative_decrypter_ == nullptr);
+  DCHECK_EQ(alternative_decrypter_level_, NUM_ENCRYPTION_LEVELS);
   DCHECK_GE(level, decrypter_level_);
-  decrypter_ = std::move(decrypter);
+  decrypter_[decrypter_level_] = nullptr;
+  decrypter_[level] = std::move(decrypter);
   decrypter_level_ = level;
 }
 
@@ -3920,17 +3921,24 @@
     EncryptionLevel level,
     std::unique_ptr<QuicDecrypter> decrypter,
     bool latch_once_used) {
-  alternative_decrypter_ = std::move(decrypter);
+  DCHECK_NE(level, decrypter_level_);
+  if (alternative_decrypter_level_ != NUM_ENCRYPTION_LEVELS) {
+    decrypter_[alternative_decrypter_level_] = nullptr;
+  }
+  decrypter_[level] = std::move(decrypter);
   alternative_decrypter_level_ = level;
   alternative_decrypter_latch_ = latch_once_used;
 }
 
 const QuicDecrypter* QuicFramer::decrypter() const {
-  return decrypter_.get();
+  return decrypter_[decrypter_level_].get();
 }
 
 const QuicDecrypter* QuicFramer::alternative_decrypter() const {
-  return alternative_decrypter_.get();
+  if (alternative_decrypter_level_ == NUM_ENCRYPTION_LEVELS) {
+    return nullptr;
+  }
+  return decrypter_[alternative_decrypter_level_].get();
 }
 
 void QuicFramer::SetEncrypter(EncryptionLevel level,
@@ -4017,18 +4025,22 @@
                                 size_t buffer_length,
                                 size_t* decrypted_length,
                                 EncryptionLevel* decrypted_level) {
-  DCHECK(decrypter_ != nullptr);
+  DCHECK(decrypter_[decrypter_level_] != nullptr);
+  QuicDecrypter* alternative_decrypter = nullptr;
+  if (alternative_decrypter_level_ != NUM_ENCRYPTION_LEVELS) {
+    alternative_decrypter = decrypter_[alternative_decrypter_level_].get();
+  }
 
-  bool success = decrypter_->DecryptPacket(
+  bool success = decrypter_[decrypter_level_]->DecryptPacket(
       header.packet_number.ToUint64(), associated_data, encrypted,
       decrypted_buffer, decrypted_length, buffer_length);
   if (success) {
     visitor_->OnDecryptedPacket(decrypter_level_);
     *decrypted_level = decrypter_level_;
-  } else if (alternative_decrypter_ != nullptr) {
+  } else if (alternative_decrypter != nullptr) {
     if (header.nonce != nullptr) {
       DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
-      alternative_decrypter_->SetDiversificationNonce(*header.nonce);
+      alternative_decrypter->SetDiversificationNonce(*header.nonce);
     }
     bool try_alternative_decryption = true;
     if (alternative_decrypter_level_ == ENCRYPTION_ZERO_RTT) {
@@ -4043,7 +4055,7 @@
     }
 
     if (try_alternative_decryption) {
-      success = alternative_decrypter_->DecryptPacket(
+      success = alternative_decrypter->DecryptPacket(
           header.packet_number.ToUint64(), associated_data, encrypted,
           decrypted_buffer, decrypted_length, buffer_length);
     }
@@ -4053,12 +4065,12 @@
       if (alternative_decrypter_latch_) {
         // Switch to the alternative decrypter and latch so that we cannot
         // switch back.
-        decrypter_ = std::move(alternative_decrypter_);
         decrypter_level_ = alternative_decrypter_level_;
-        alternative_decrypter_level_ = ENCRYPTION_INITIAL;
+        decrypter_[decrypter_level_] =
+            std::move(decrypter_[alternative_decrypter_level_]);
+        alternative_decrypter_level_ = NUM_ENCRYPTION_LEVELS;
       } else {
         // Switch the alternative decrypter so that we use it first next time.
-        decrypter_.swap(alternative_decrypter_);
         EncryptionLevel level = alternative_decrypter_level_;
         alternative_decrypter_level_ = decrypter_level_;
         decrypter_level_ = level;

quic/core/quic_framer.h

diff --git a/quic/core/quic_framer.h b/quic/core/quic_framer.h
index 98f7385..6e5b6aa 100644
--- a/quic/core/quic_framer.h
+++ b/quic/core/quic_framer.h
@@ -893,17 +893,17 @@
   // element, with subsequent elements in descending order (versions can be
   // skipped as necessary).
   ParsedQuicVersionVector supported_versions_;
-  // Primary decrypter used to decrypt packets during parsing.
-  std::unique_ptr<QuicDecrypter> decrypter_;
-  // Alternative decrypter that can also be used to decrypt packets.
-  std::unique_ptr<QuicDecrypter> alternative_decrypter_;
-  // The encryption level of |decrypter_|.
+  // Decrypters used to decrypt packets during parsing.
+  std::unique_ptr<QuicDecrypter> decrypter_[NUM_ENCRYPTION_LEVELS];
+  // The encryption level of the primary decrypter to use in |decrypter_|.
   EncryptionLevel decrypter_level_;
-  // The encryption level of |alternative_decrypter_|.
-  EncryptionLevel alternative_decrypter_level_;
-  // |alternative_decrypter_latch_| is true if, when |alternative_decrypter_|
-  // successfully decrypts a packet, we should install it as the only
+  // The encryption level of the alternative decrypter to use in |decrypter_|.
+  // When set to NUM_ENCRYPTION_LEVELS, indicates that there is no alternative
   // decrypter.
+  EncryptionLevel alternative_decrypter_level_;
+  // |alternative_decrypter_latch_| is true if, when the decrypter at
+  // |alternative_decrypter_level_| successfully decrypts a packet, we should
+  // install it as the only decrypter.
   bool alternative_decrypter_latch_;
   // Encrypters used to encrypt packets via EncryptPayload().
   std::unique_ptr<QuicEncrypter> encrypter_[NUM_ENCRYPTION_LEVELS];

quic/test_tools/quic_framer_peer.cc

diff --git a/quic/test_tools/quic_framer_peer.cc b/quic/test_tools/quic_framer_peer.cc
index b8b749f..68c7d0e 100644
--- a/quic/test_tools/quic_framer_peer.cc
+++ b/quic/test_tools/quic_framer_peer.cc
@@ -307,9 +307,8 @@
 void QuicFramerPeer::SwapCrypters(QuicFramer* framer1, QuicFramer* framer2) {
   for (int i = ENCRYPTION_INITIAL; i < NUM_ENCRYPTION_LEVELS; i++) {
     framer1->encrypter_[i].swap(framer2->encrypter_[i]);
+    framer1->decrypter_[i].swap(framer2->decrypter_[i]);
   }
-  framer1->decrypter_.swap(framer2->decrypter_);
-  framer1->alternative_decrypter_.swap(framer2->alternative_decrypter_);
 
   EncryptionLevel framer2_level = framer2->decrypter_level_;
   framer2->decrypter_level_ = framer1->decrypter_level_;