@fails-components/webtransport 0.0.1 → 0.0.2

package/third_party/quiche/quiche/quic/core/quic_default_clock.h

@@ -0,0 +1,34 @@
+// Copyright 2022 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.
+
+#ifndef QUICHE_QUIC_CORE_QUIC_DEFAULT_CLOCK_H_
+#define QUICHE_QUIC_CORE_QUIC_DEFAULT_CLOCK_H_
+
+#include "quiche/quic/core/quic_clock.h"
+#include "quiche/quic/core/quic_time.h"
+#include "quiche/quic/platform/api/quic_export.h"
+
+namespace quic {
+
+// A QuicClock based on Abseil time API.  Thread-safe.
+class QUIC_EXPORT_PRIVATE QuicDefaultClock : public QuicClock {
+ public:
+  // Provides a single default stateless instance of QuicDefaultClock.
+  static QuicDefaultClock* Get();
+
+  explicit QuicDefaultClock() = default;
+  QuicDefaultClock(const QuicDefaultClock&) = delete;
+  QuicDefaultClock& operator=(const QuicDefaultClock&) = delete;
+
+  // QuicClock implementation.
+  QuicTime ApproximateNow() const override;
+  QuicTime Now() const override;
+  QuicWallTime WallNow() const override;
+  QuicTime ConvertWallTimeToQuicTime(
+      const QuicWallTime& walltime) const override;
+};
+
+}  // namespace quic
+
+#endif  // QUICHE_QUIC_CORE_QUIC_DEFAULT_CLOCK_H_

package/third_party/quiche/quiche/quic/core/quic_default_connection_helper.h

@@ -0,0 +1,49 @@
+// Copyright 2022 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.
+
+#ifndef QUICHE_QUIC_CORE_QUIC_DEFAULT_CONNECTION_HELPER_H_
+#define QUICHE_QUIC_CORE_QUIC_DEFAULT_CONNECTION_HELPER_H_
+
+#include "quiche/quic/core/crypto/quic_random.h"
+#include "quiche/quic/core/quic_connection.h"
+#include "quiche/quic/core/quic_default_clock.h"
+#include "quiche/common/simple_buffer_allocator.h"
+
+namespace quic {
+
+// A default implementation of QuicConnectionHelperInterface.  Thread-safe.
+class QUIC_EXPORT_PRIVATE QuicDefaultConnectionHelper
+    : public QuicConnectionHelperInterface {
+ public:
+  static QuicDefaultConnectionHelper* Get() {
+    static QuicDefaultConnectionHelper* helper =
+        new QuicDefaultConnectionHelper();
+    return helper;
+  }
+
+  // Creates a helper that uses the default allocator.
+  QuicDefaultConnectionHelper() : QuicDefaultConnectionHelper(nullptr) {}
+  // If |allocator| is nullptr, the default one is used.
+  QuicDefaultConnectionHelper(
+      std::unique_ptr<quiche::QuicheBufferAllocator> allocator)
+      : allocator_(std::move(allocator)) {}
+
+  QuicDefaultConnectionHelper(const QuicDefaultConnectionHelper&) = delete;
+  QuicDefaultConnectionHelper& operator=(const QuicDefaultConnectionHelper&) =
+      delete;
+
+  const QuicClock* GetClock() const override { return QuicDefaultClock::Get(); }
+  QuicRandom* GetRandomGenerator() override {
+    return QuicRandom::GetInstance();
+  }
+  quiche::QuicheBufferAllocator* GetStreamSendBufferAllocator() override {
+    return allocator_ ? allocator_.get() : quiche::SimpleBufferAllocator::Get();
+  }
+
+ private:
+  std::unique_ptr<quiche::QuicheBufferAllocator> allocator_;
+};
+}  // namespace quic
+
+#endif  // QUICHE_QUIC_CORE_QUIC_DEFAULT_CONNECTION_HELPER_H_

package/third_party/quiche/quiche/quic/core/quic_dispatcher.cc

@@ -255,6 +255,7 @@ bool MaybeHandleLegacyVersionEncapsulation(
     QuicDispatcher* dispatcher,
     std::string legacy_version_encapsulation_inner_packet,
     const ReceivedPacketInfo& packet_info) {
+  QUICHE_DCHECK(!GetQuicRestartFlag(quic_disable_legacy_version_encapsulation));
   if (legacy_version_encapsulation_inner_packet.empty()) {
     // This CHLO did not contain the Legacy Version Encapsulation tag.
     return false;
@@ -587,16 +588,21 @@ bool QuicDispatcher::MaybeDispatchPacket(
         packet_info.version == LegacyVersionForEncapsulation()) {
       // This packet is using the Legacy Version Encapsulation version but the
       // corresponding session isn't, attempt extraction of inner packet.
-      ChloAlpnSniExtractor alpn_extractor;
-      if (ChloExtractor::Extract(packet_info.packet, packet_info.version,
-                                 config_->create_session_tag_indicators(),
-                                 &alpn_extractor,
-                                 server_connection_id.length())) {
-        if (MaybeHandleLegacyVersionEncapsulation(
-                this,
-                alpn_extractor.ConsumeLegacyVersionEncapsulationInnerPacket(),
-                packet_info)) {
-          return true;
+      if (GetQuicRestartFlag(quic_disable_legacy_version_encapsulation)) {
+        QUIC_CODE_COUNT(
+            quic_disable_legacy_version_encapsulation_dispatch_packet);
+      } else {
+        ChloAlpnSniExtractor alpn_extractor;
+        if (ChloExtractor::Extract(packet_info.packet, packet_info.version,
+                                   config_->create_session_tag_indicators(),
+                                   &alpn_extractor,
+                                   server_connection_id.length())) {
+          if (MaybeHandleLegacyVersionEncapsulation(
+                  this,
+                  alpn_extractor.ConsumeLegacyVersionEncapsulationInnerPacket(),
+                  packet_info)) {
+            return true;
+          }
         }
       }
     }
@@ -711,8 +717,9 @@ void QuicDispatcher::ProcessHeader(ReceivedPacketInfo* packet_info) {
   QuicPacketFate fate = ValidityChecks(*packet_info);
 
   if (fate == kFateProcess) {
-    absl::optional<ParsedClientHello> parsed_chlo =
+    ExtractChloResult extract_chlo_result =
         TryExtractChloOrBufferEarlyPacket(*packet_info);
+    auto& parsed_chlo = extract_chlo_result.parsed_chlo;
     if (!parsed_chlo.has_value()) {
       // Client Hello incomplete. Packet has been buffered or (rarely) dropped.
       return;
@@ -725,10 +732,17 @@ void QuicDispatcher::ProcessHeader(ReceivedPacketInfo* packet_info) {
       QUICHE_DCHECK(
           parsed_chlo->legacy_version_encapsulation_inner_packet.empty() ||
           !packet_info->version.UsesTls());
-      if (MaybeHandleLegacyVersionEncapsulation(
-              this, parsed_chlo->legacy_version_encapsulation_inner_packet,
-              *packet_info)) {
-        return;
+      if (GetQuicRestartFlag(quic_disable_legacy_version_encapsulation)) {
+        if (!parsed_chlo->legacy_version_encapsulation_inner_packet.empty()) {
+          QUIC_CODE_COUNT(
+              quic_disable_legacy_version_encapsulation_process_header);
+        }
+      } else {
+        if (MaybeHandleLegacyVersionEncapsulation(
+                this, parsed_chlo->legacy_version_encapsulation_inner_packet,
+                *packet_info)) {
+          return;
+        }
       }
 
       ProcessChlo(*std::move(parsed_chlo), packet_info);
@@ -767,9 +781,10 @@ void QuicDispatcher::ProcessHeader(ReceivedPacketInfo* packet_info) {
   }
 }
 
-absl::optional<ParsedClientHello>
+QuicDispatcher::ExtractChloResult
 QuicDispatcher::TryExtractChloOrBufferEarlyPacket(
     const ReceivedPacketInfo& packet_info) {
+  ExtractChloResult result;
   if (packet_info.version.UsesTls()) {
     bool has_full_tls_chlo = false;
     std::string sni;
@@ -782,7 +797,7 @@ QuicDispatcher::TryExtractChloOrBufferEarlyPacket(
       has_full_tls_chlo = buffered_packets_.IngestPacketForTlsChloExtraction(
           packet_info.destination_connection_id, packet_info.version,
           packet_info.packet, &alpns, &sni, &resumption_attempted,
-          &early_data_attempted);
+          &early_data_attempted, &result.tls_alert);
     } else {
       // If we do not have a BufferedPacketList for this connection ID,
       // create a single-use one to check whether this packet contains a
@@ -796,6 +811,8 @@ QuicDispatcher::TryExtractChloOrBufferEarlyPacket(
         sni = tls_chlo_extractor.server_name();
         resumption_attempted = tls_chlo_extractor.resumption_attempted();
         early_data_attempted = tls_chlo_extractor.early_data_attempted();
+      } else {
+        result.tls_alert = tls_chlo_extractor.tls_alert();
       }
     }
     if (!has_full_tls_chlo) {
@@ -803,10 +820,10 @@ QuicDispatcher::TryExtractChloOrBufferEarlyPacket(
       // packet that arrived before the CHLO (due to loss or reordering),
       // or it could be a fragment of a multi-packet CHLO.
       BufferEarlyPacket(packet_info);
-      return absl::nullopt;
+      return result;
     }
 
-    ParsedClientHello parsed_chlo;
+    ParsedClientHello& parsed_chlo = result.parsed_chlo.emplace();
     parsed_chlo.sni = std::move(sni);
     parsed_chlo.alpns = std::move(alpns);
     if (packet_info.retry_token.has_value()) {
@@ -814,7 +831,7 @@ QuicDispatcher::TryExtractChloOrBufferEarlyPacket(
     }
     parsed_chlo.resumption_attempted = resumption_attempted;
     parsed_chlo.early_data_attempted = early_data_attempted;
-    return parsed_chlo;
+    return result;
   }
 
   ChloAlpnSniExtractor alpn_extractor;
@@ -825,7 +842,7 @@ QuicDispatcher::TryExtractChloOrBufferEarlyPacket(
                               packet_info.destination_connection_id.length())) {
     // Buffer non-CHLO packets.
     BufferEarlyPacket(packet_info);
-    return absl::nullopt;
+    return result;
   }
 
   // We only apply this check for versions that do not use the IETF
@@ -838,16 +855,16 @@ QuicDispatcher::TryExtractChloOrBufferEarlyPacket(
     QUIC_DVLOG(1) << "Dropping CHLO packet which is too short, length: "
                   << packet_info.packet.length();
     QUIC_CODE_COUNT(quic_drop_small_chlo_packets);
-    return absl::nullopt;
+    return result;
   }
 
-  ParsedClientHello parsed_chlo;
+  ParsedClientHello& parsed_chlo = result.parsed_chlo.emplace();
   parsed_chlo.legacy_version_encapsulation_inner_packet =
       alpn_extractor.ConsumeLegacyVersionEncapsulationInnerPacket();
   parsed_chlo.sni = alpn_extractor.ConsumeSni();
   parsed_chlo.uaid = alpn_extractor.ConsumeUaid();
   parsed_chlo.alpns = {alpn_extractor.ConsumeAlpn()};
-  return parsed_chlo;
+  return result;
 }
 
 std::string QuicDispatcher::SelectAlpn(const std::vector<std::string>& alpns) {
@@ -1051,15 +1068,13 @@ void QuicDispatcher::OnConnectionClosed(QuicConnectionId server_connection_id,
       << ", with details: " << error_details;
 
   QuicConnection* connection = it->second->connection();
-  if (ShouldDestroySessionAsynchronously()) {
-    // Set up alarm to fire immediately to bring destruction of this session
-    // out of current call stack.
-    if (closed_session_list_.empty()) {
-      delete_sessions_alarm_->Update(helper()->GetClock()->ApproximateNow(),
-                                     QuicTime::Delta::Zero());
-    }
-    closed_session_list_.push_back(std::move(it->second));
+  // Set up alarm to fire immediately to bring destruction of this session
+  // out of current call stack.
+  if (closed_session_list_.empty()) {
+    delete_sessions_alarm_->Update(helper()->GetClock()->ApproximateNow(),
+                                   QuicTime::Delta::Zero());
   }
+  closed_session_list_.push_back(std::move(it->second));
   CleanUpSession(it->first, connection, error, error_details, source);
   for (const QuicConnectionId& cid :
        connection->GetActiveServerConnectionIds()) {
@@ -1088,7 +1103,7 @@ void QuicDispatcher::OnRstStreamReceived(const QuicRstStreamFrame& /*frame*/) {}
 void QuicDispatcher::OnStopSendingReceived(
     const QuicStopSendingFrame& /*frame*/) {}
 
-void QuicDispatcher::OnNewConnectionIdSent(
+bool QuicDispatcher::TryAddNewConnectionId(
     const QuicConnectionId& server_connection_id,
     const QuicConnectionId& new_connection_id) {
   auto it = reference_counted_session_map_.find(server_connection_id);
@@ -1097,13 +1112,16 @@ void QuicDispatcher::OnNewConnectionIdSent(
         << "Couldn't locate the session that issues the connection ID in "
            "reference_counted_session_map_.  server_connection_id:"
         << server_connection_id << " new_connection_id: " << new_connection_id;
-    return;
+    return false;
   }
   // Count new connection ID added to the dispatcher map.
   QUIC_RELOADABLE_FLAG_COUNT_N(quic_connection_migration_use_new_cid_v2, 6, 6);
   auto insertion_result = reference_counted_session_map_.insert(
       std::make_pair(new_connection_id, it->second));
-  QUICHE_DCHECK(insertion_result.second);
+  if (!insertion_result.second) {
+    QUIC_CODE_COUNT(quic_cid_already_in_session_map);
+  }
+  return insertion_result.second;
 }
 
 void QuicDispatcher::OnConnectionIdRetired(
@@ -1363,8 +1381,6 @@ void QuicDispatcher::ProcessChlo(ParsedClientHello parsed_chlo,
   --new_sessions_allowed_per_event_loop_;
 }
 
-bool QuicDispatcher::ShouldDestroySessionAsynchronously() { return true; }
-
 void QuicDispatcher::SetLastError(QuicErrorCode error) { last_error_ = error; }
 
 bool QuicDispatcher::OnFailedToDispatchPacket(

package/third_party/quiche/quiche/quic/core/quic_dispatcher.h

@@ -102,8 +102,9 @@ class QUIC_NO_EXPORT QuicDispatcher
 
   // QuicSession::Visitor interface implementation (via inheritance of
   // QuicTimeWaitListManager::Visitor):
-  // Add the newly issued connection ID to the session map.
-  void OnNewConnectionIdSent(
+  // Try to add the new connection ID to the session map. Returns true on
+  // success.
+  bool TryAddNewConnectionId(
       const QuicConnectionId& server_connection_id,
       const QuicConnectionId& new_connection_id) override;
 
@@ -244,10 +245,6 @@ class QUIC_NO_EXPORT QuicDispatcher
   void ProcessChlo(ParsedClientHello parsed_chlo,
                    ReceivedPacketInfo* packet_info);
 
-  // Return true if dispatcher wants to destroy session outside of
-  // OnConnectionClosed() call stack.
-  virtual bool ShouldDestroySessionAsynchronously();
-
   QuicTimeWaitListManager* time_wait_list_manager() {
     return time_wait_list_manager_.get();
   }
@@ -370,15 +367,26 @@ class QUIC_NO_EXPORT QuicDispatcher
   // ProcessValidatedPacketWithUnknownConnectionId.
   void ProcessHeader(ReceivedPacketInfo* packet_info);
 
+  struct ExtractChloResult {
+    // If set, a full client hello has been successfully parsed.
+    absl::optional<ParsedClientHello> parsed_chlo;
+    // If set, the TLS alert that will cause a connection close.
+    // Always empty for Google QUIC.
+    absl::optional<uint8_t> tls_alert;
+  };
+
   // Try to extract information(sni, alpns, ...) if the full Client Hello has
   // been parsed.
   //
-  // Return the parsed client hello if the full Client Hello has been
-  // successfully parsed.
+  // Returns the parsed client hello in ExtractChloResult.parsed_chlo, if the
+  // full Client Hello has been successfully parsed.
+  //
+  // Returns the TLS alert in ExtractChloResult.tls_alert, if the extraction of
+  // Client Hello failed due to that alert.
   //
-  // Otherwise return absl::nullopt and either buffer or (rarely) drop the
-  // packet.
-  absl::optional<ParsedClientHello> TryExtractChloOrBufferEarlyPacket(
+  // Otherwise returns a default-constructed ExtractChloResult and either buffer
+  // or (rarely) drop the packet.
+  ExtractChloResult TryExtractChloOrBufferEarlyPacket(
       const ReceivedPacketInfo& packet_info);
 
   // Deliver |packets| to |session| for further processing.

package/third_party/quiche/quiche/quic/core/quic_dispatcher_test.cc

@@ -170,7 +170,10 @@ class MockServerConnection : public MockQuicConnection {
         active_connection_ids_({connection_id}) {}
 
   void AddNewConnectionId(QuicConnectionId id) {
-    dispatcher_->OnNewConnectionIdSent(active_connection_ids_.back(), id);
+    if (!dispatcher_->TryAddNewConnectionId(active_connection_ids_.back(),
+                                            id)) {
+      return;
+    }
     QuicConnectionPeer::SetServerConnectionId(this, id);
     active_connection_ids_.push_back(id);
   }
@@ -645,6 +648,9 @@ TEST_P(QuicDispatcherTestAllVersions,
 }
 
 TEST_P(QuicDispatcherTestAllVersions, LegacyVersionEncapsulation) {
+  if (GetQuicRestartFlag(quic_disable_legacy_version_encapsulation)) {
+    return;
+  }
   if (!version_.HasLongHeaderLengths()) {
     // Decapsulating Legacy Version Encapsulation packets from these versions
     // is not currently supported in QuicDispatcher.
@@ -2240,7 +2246,14 @@ INSTANTIATE_TEST_SUITE_P(
     ::testing::PrintToStringParamName());
 
 TEST_P(QuicDispatcherSupportMultipleConnectionIdPerConnectionTest,
-       OnNewConnectionIdSent) {
+       FailToAddExistingConnectionId) {
+  AddConnection1();
+  EXPECT_FALSE(dispatcher_->TryAddNewConnectionId(TestConnectionId(1),
+                                                  TestConnectionId(1)));
+}
+
+TEST_P(QuicDispatcherSupportMultipleConnectionIdPerConnectionTest,
+       TryAddNewConnectionId) {
   AddConnection1();
   ASSERT_EQ(dispatcher_->NumSessions(), 1u);
   ASSERT_THAT(session1_, testing::NotNull());

package/third_party/quiche/quiche/quic/core/quic_flags_list.h

@@ -17,14 +17,18 @@ QUIC_FLAG(quic_restart_flag_quic_testonly_default_false, false)
 QUIC_FLAG(quic_restart_flag_quic_testonly_default_true, true)
 // If bytes in flight has dipped below 1.25*MaxBW in the last round, do not exit PROBE_UP due to excess queue buildup.
 QUIC_FLAG(quic_reloadable_flag_quic_bbr2_no_probe_up_exit_if_no_queue, true)
+// If true, 1) remove all experiments that tunes blackhole detection delay or path degrading delay, and 2) ensure network blackhole delay is at least path degrading delay plus 2 PTOs.
+QUIC_FLAG(quic_reloadable_flag_quic_remove_blackhole_detection_experiments, true)
+// If true, QUIC Legacy Version Encapsulation will be disabled.
+QUIC_FLAG(quic_restart_flag_quic_disable_legacy_version_encapsulation, false)
 // If true, QUIC will default enable MTU discovery at server, with a target of 1450 bytes.
 QUIC_FLAG(quic_reloadable_flag_quic_enable_mtu_discovery_at_server, false)
+// If true, QuicConnection::ScopedPacketFlusher::~ScopedPacketFlusher will early return if connection is disconnected after FlushPackets.
+QUIC_FLAG(quic_reloadable_flag_quic_packet_flusher_check_connected_after_flush_packets, true)
 // If true, QuicGsoBatchWriter will support release time if it is available and the process has the permission to do so.
 QUIC_FLAG(quic_restart_flag_quic_support_release_time_for_gso, false)
 // If true, TlsHandshaker::AdvanceHandshake will check if connection is closed after SSL_do_handshake.
 QUIC_FLAG(quic_reloadable_flag_quic_tls_handshaker_check_connection_closed, true)
-// If true, abort async QPACK header decompression in QuicSpdyStream::Reset() and in QuicSpdyStream::OnStreamReset().
-QUIC_FLAG(quic_reloadable_flag_quic_abort_qpack_on_stream_reset, true)
 // If true, ack frequency frame can be sent from server to client.
 QUIC_FLAG(quic_reloadable_flag_quic_can_send_ack_frequency, true)
 // If true, allow client to enable BBRv2 on server via connection option \'B2ON\'.
@@ -57,6 +61,8 @@ QUIC_FLAG(quic_reloadable_flag_quic_enable_disable_resumption, true)
 QUIC_FLAG(quic_reloadable_flag_quic_discard_initial_packet_with_key_dropped, true)
 // If true, do not bundle ACK while sending PATH_CHALLENGE on alternative path.
 QUIC_FLAG(quic_reloadable_flag_quic_not_bundle_ack_on_alternative_path, true)
+// If true, do not issue a new connection ID that has been claimed by another connection.
+QUIC_FLAG(quic_reloadable_flag_quic_check_cid_collision_when_issue_new_cid, false)
 // If true, enable server retransmittable on wire PING.
 QUIC_FLAG(quic_reloadable_flag_quic_enable_server_on_wire_ping, true)
 // If true, flush pending frames as well as pending padding bytes on connection migration.
@@ -64,7 +70,7 @@ QUIC_FLAG(quic_reloadable_flag_quic_flush_pending_frames_and_padding_bytes_on_mi
 // If true, ietf connection migration is no longer conditioned on connection option RVCM.
 QUIC_FLAG(quic_reloadable_flag_quic_remove_connection_migration_connection_option_v2, false)
 // If true, include offset in QUIC STREAM_DATA_BLOCKED and DATA_BLOCKED frames.
-QUIC_FLAG(quic_reloadable_flag_quic_include_offset_in_blocked_frames, false)
+QUIC_FLAG(quic_reloadable_flag_quic_include_offset_in_blocked_frames, true)
 // If true, include stream information in idle timeout connection close detail.
 QUIC_FLAG(quic_reloadable_flag_quic_add_stream_info_to_idle_close_detail, true)
 // If true, quic server will send ENABLE_CONNECT_PROTOCOL setting and and endpoint will validate required request/response headers and extended CONNECT mechanism and update code counts of valid/invalid headers.
@@ -76,7 +82,7 @@ QUIC_FLAG(quic_reloadable_flag_quic_require_handshake_confirmation, false)
 // If true, server proactively retires client issued connection ID on reverse path validation failure. 
 QUIC_FLAG(quic_reloadable_flag_quic_retire_cid_on_reverse_path_validation_failure, true)
 // If true, server sends bandwidth eastimate when network is idle for a while.
-QUIC_FLAG(quic_restart_flag_quic_enable_sending_bandwidth_estimate_when_network_idle, true)
+QUIC_FLAG(quic_restart_flag_quic_enable_sending_bandwidth_estimate_when_network_idle_v2, false)
 // If true, set burst token to 2 in cwnd bootstrapping experiment.
 QUIC_FLAG(quic_reloadable_flag_quic_conservative_bursts, false)
 // If true, stop resetting ideal_next_packet_send_time_ in pacing sender.

package/third_party/quiche/quiche/quic/core/quic_idle_network_detector.cc

@@ -74,10 +74,10 @@ void QuicIdleNetworkDetector::SetTimeouts(
   bandwidth_update_timeout_ = QuicTime::Delta::Infinite();
 
   if (GetQuicRestartFlag(
-          quic_enable_sending_bandwidth_estimate_when_network_idle) &&
+          quic_enable_sending_bandwidth_estimate_when_network_idle_v2) &&
       handshake_timeout_.IsInfinite()) {
     QUIC_RESTART_FLAG_COUNT_N(
-        quic_enable_sending_bandwidth_estimate_when_network_idle, 1, 3);
+        quic_enable_sending_bandwidth_estimate_when_network_idle_v2, 1, 3);
     bandwidth_update_timeout_ = idle_network_timeout_ * 0.5;
   }
 

package/third_party/quiche/quiche/quic/core/quic_idle_network_detector_test.cc

@@ -103,7 +103,7 @@ TEST_F(QuicIdleNetworkDetectorTest,
       /*handshake_timeout=*/QuicTime::Delta::Infinite(),
       /*idle_network_timeout=*/QuicTime::Delta::FromSeconds(600));
   if (!GetQuicRestartFlag(
-          quic_enable_sending_bandwidth_estimate_when_network_idle)) {
+          quic_enable_sending_bandwidth_estimate_when_network_idle_v2)) {
     EXPECT_EQ(clock_.Now() + QuicTime::Delta::FromSeconds(600),
               alarm_->deadline());
 
@@ -141,7 +141,7 @@ TEST_F(QuicIdleNetworkDetectorTest,
   // Handshake completes in 200ms.
   const bool enable_sending_bandwidth_estimate_when_network_idle =
       GetQuicRestartFlag(
-          quic_enable_sending_bandwidth_estimate_when_network_idle);
+          quic_enable_sending_bandwidth_estimate_when_network_idle_v2);
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(200));
   detector_->OnPacketReceived(clock_.Now());
   detector_->SetTimeouts(
@@ -195,7 +195,7 @@ TEST_F(QuicIdleNetworkDetectorTest, ShorterIdleTimeoutOnSentPacket) {
   detector_->enable_shorter_idle_timeout_on_sent_packet();
   QuicTime::Delta idle_network_timeout = QuicTime::Delta::Zero();
   if (GetQuicRestartFlag(
-          quic_enable_sending_bandwidth_estimate_when_network_idle)) {
+          quic_enable_sending_bandwidth_estimate_when_network_idle_v2)) {
     idle_network_timeout = QuicTime::Delta::FromSeconds(60);
   } else {
     idle_network_timeout = QuicTime::Delta::FromSeconds(30);
@@ -250,7 +250,7 @@ TEST_F(QuicIdleNetworkDetectorTest, NoAlarmAfterStopped) {
 TEST_F(QuicIdleNetworkDetectorTest,
        ResetBandwidthTimeoutWhenHandshakeTimeoutIsSet) {
   if (!GetQuicRestartFlag(
-          quic_enable_sending_bandwidth_estimate_when_network_idle)) {
+          quic_enable_sending_bandwidth_estimate_when_network_idle_v2)) {
     return;
   }
   detector_->SetTimeouts(

package/third_party/quiche/quiche/quic/core/quic_packet_creator.cc

@@ -476,6 +476,12 @@ void QuicPacketCreator::OnSerializedPacket() {
   QUIC_BUG_IF(quic_bug_12398_5, packet_.encrypted_buffer == nullptr)
       << ENDPOINT;
 
+  // Clear bytes_not_retransmitted for packets containing only
+  // NOT_RETRANSMISSION frames.
+  if (packet_.transmission_type == NOT_RETRANSMISSION) {
+    packet_.bytes_not_retransmitted.reset();
+  }
+
   SerializedPacket packet(std::move(packet_));
   ClearPacket();
   RemoveSoftMaxPacketLength();
@@ -499,6 +505,7 @@ void QuicPacketCreator::ClearPacket() {
   QUICHE_DCHECK(packet_.nonretransmittable_frames.empty()) << ENDPOINT;
   packet_.largest_acked.Clear();
   needs_full_padding_ = false;
+  packet_.bytes_not_retransmitted.reset();
 }
 
 size_t QuicPacketCreator::ReserializeInitialPacketInCoalescedPacket(
@@ -1795,9 +1802,13 @@ bool QuicPacketCreator::AddFrame(const QuicFrame& frame,
     debug_delegate_->OnFrameAddedToPacket(frame);
   }
 
-  // Packet transmission type is determined by the last added retransmittable
-  // frame.
-  if (QuicUtils::IsRetransmittableFrame(frame.type)) {
+  if (transmission_type == NOT_RETRANSMISSION) {
+    packet_.bytes_not_retransmitted.emplace(
+        packet_.bytes_not_retransmitted.value_or(0) + frame_len);
+  } else if (QuicUtils::IsRetransmittableFrame(frame.type)) {
+    // Packet transmission type is determined by the last added retransmittable
+    // frame of a retransmission type. If a packet has no retransmittable
+    // retransmission frames, it has type NOT_RETRANSMISSION.
     packet_.transmission_type = transmission_type;
   }
   return true;