Use a QuicSession member to latch
gfe2_reloadable_flag_quic_eliminate_static_stream_map_2.

This prevents unexpected behavior from runtime flag flipping.

gfe-relnote: gfe2_reloadable_flag_quic_eliminate_static_stream_map_2 replaces
gfe2_reloadable_flag_quic_eliminate_static_stream_map for rollout purposes.
PiperOrigin-RevId: 246926123
Change-Id: I11103af393e7fa93ea5b2d3cd90f9fe423fbed96

quic/core/http/quic_spdy_client_session_base.cc

diff --git a/quic/core/http/quic_spdy_client_session_base.cc b/quic/core/http/quic_spdy_client_session_base.cc
index 4aa3348..2db5b84 100644
--- a/quic/core/http/quic_spdy_client_session_base.cc
+++ b/quic/core/http/quic_spdy_client_session_base.cc
@@ -95,8 +95,7 @@
     // It's quite possible to receive headers after a stream has been reset.
     return;
   }
-  if (GetQuicReloadableFlag(quic_eliminate_static_stream_map) &&
-      stream->is_static()) {
+  if (eliminate_static_stream_map() && stream->is_static()) {
     connection()->CloseConnection(
         QUIC_INVALID_HEADERS_STREAM_DATA, "stream is static",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);

quic/core/http/quic_spdy_session.cc

diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index cc1eee7..de34250 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -355,12 +355,12 @@
   headers_stream_ = QuicMakeUnique<QuicHeadersStream>((this));
   DCHECK_EQ(QuicUtils::GetHeadersStreamId(connection()->transport_version()),
             headers_stream_->id());
-  if (!GetQuicReloadableFlag(quic_eliminate_static_stream_map)) {
+  if (!eliminate_static_stream_map()) {
     RegisterStaticStream(
         QuicUtils::GetHeadersStreamId(connection()->transport_version()),
         headers_stream_.get());
   } else {
-    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map, 7, 15);
+    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map_2, 7, 17);
     unowned_headers_stream_ = headers_stream_.get();
     RegisterStaticStreamNew(std::move(headers_stream_));
   }
@@ -444,9 +444,8 @@
     // It's quite possible to receive headers after a stream has been reset.
     return;
   }
-  if (GetQuicReloadableFlag(quic_eliminate_static_stream_map) &&
-      stream->is_static()) {
-    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map, 8, 15);
+  if (eliminate_static_stream_map() && stream->is_static()) {
+    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map_2, 8, 17);
     connection()->CloseConnection(
         QUIC_INVALID_HEADERS_STREAM_DATA, "stream is static",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
@@ -709,13 +708,13 @@
 }
 
 bool QuicSpdySession::HasActiveRequestStreams() const {
-  if (!GetQuicReloadableFlag(quic_eliminate_static_stream_map)) {
+  if (!eliminate_static_stream_map()) {
     return !dynamic_streams().empty();
   }
   // In the case where session is destructed by calling
   // dynamic_streams().clear(), we will have incorrect accounting here.
   // TODO(renjietang): Modify destructors and make this a DCHECK.
-  QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map, 9, 15);
+  QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map_2, 9, 17);
   if (static_cast<size_t>(dynamic_streams().size()) >
       num_incoming_static_streams() + num_outgoing_static_streams()) {
     return dynamic_streams().size() - num_incoming_static_streams() -

quic/core/http/quic_spdy_session.h

diff --git a/quic/core/http/quic_spdy_session.h b/quic/core/http/quic_spdy_session.h
index 9248fa5..23e57c3 100644
--- a/quic/core/http/quic_spdy_session.h
+++ b/quic/core/http/quic_spdy_session.h
@@ -140,15 +140,13 @@
   QpackEncoder* qpack_encoder();
   QpackDecoder* qpack_decoder();
   QuicHeadersStream* headers_stream() {
-    return GetQuicReloadableFlag(quic_eliminate_static_stream_map)
-               ? unowned_headers_stream_
-               : headers_stream_.get();
+    return eliminate_static_stream_map() ? unowned_headers_stream_
+                                         : headers_stream_.get();
   }
 
   const QuicHeadersStream* headers_stream() const {
-    return GetQuicReloadableFlag(quic_eliminate_static_stream_map)
-               ? unowned_headers_stream_
-               : headers_stream_.get();
+    return eliminate_static_stream_map() ? unowned_headers_stream_
+                                         : headers_stream_.get();
   }
 
   bool server_push_enabled() const { return server_push_enabled_; }

quic/core/http/quic_spdy_session_test.cc

diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index 83ea72f..6724e69 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -923,7 +923,7 @@
   TestCryptoStream* crypto_stream = session_.GetMutableCryptoStream();
   EXPECT_CALL(*crypto_stream, OnCanWrite());
   TestHeadersStream* headers_stream;
-  if (!GetQuicReloadableFlag(quic_eliminate_static_stream_map)) {
+  if (!GetQuicReloadableFlag(quic_eliminate_static_stream_map_2)) {
     QuicSpdySessionPeer::SetHeadersStream(&session_, nullptr);
     headers_stream = new TestHeadersStream(&session_);
     QuicSpdySessionPeer::SetHeadersStream(&session_, headers_stream);
@@ -1643,7 +1643,7 @@
 
 TEST_P(QuicSpdySessionTestClient, WritePriority) {
   TestHeadersStream* headers_stream;
-  if (!GetQuicReloadableFlag(quic_eliminate_static_stream_map)) {
+  if (!GetQuicReloadableFlag(quic_eliminate_static_stream_map_2)) {
     QuicSpdySessionPeer::SetHeadersStream(&session_, nullptr);
     headers_stream = new TestHeadersStream(&session_);
     QuicSpdySessionPeer::SetHeadersStream(&session_, headers_stream);

quic/core/quic_session.cc

diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 5d02a12..2505f7e 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -84,7 +84,9 @@
       control_frame_manager_(this),
       last_message_id_(0),
       closed_streams_clean_up_alarm_(nullptr),
-      supported_versions_(supported_versions) {
+      supported_versions_(supported_versions),
+      eliminate_static_stream_map_(
+          GetQuicReloadableFlag(quic_eliminate_static_stream_map_2)) {
   closed_streams_clean_up_alarm_ =
       QuicWrapUnique<QuicAlarm>(connection_->alarm_factory()->CreateAlarm(
           new ClosedStreamsCleanUpDelegate(this)));
@@ -98,12 +100,12 @@
 
   DCHECK_EQ(QuicUtils::GetCryptoStreamId(connection_->transport_version()),
             GetMutableCryptoStream()->id());
-  if (!GetQuicReloadableFlag(quic_eliminate_static_stream_map)) {
+  if (!eliminate_static_stream_map_) {
     RegisterStaticStream(
         QuicUtils::GetCryptoStreamId(connection_->transport_version()),
         GetMutableCryptoStream());
   } else {
-    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map, 10, 15);
+    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map_2, 10, 17);
     QuicStreamId id =
         QuicUtils::GetCryptoStreamId(connection_->transport_version());
     largest_static_stream_id_ = std::max(id, largest_static_stream_id_);
@@ -133,7 +135,7 @@
 }
 
 void QuicSession::RegisterStaticStreamNew(std::unique_ptr<QuicStream> stream) {
-  DCHECK(GetQuicReloadableFlag(quic_eliminate_static_stream_map));
+  DCHECK(eliminate_static_stream_map_);
   QuicStreamId stream_id = stream->id();
   dynamic_stream_map_[stream_id] = std::move(stream);
   if (connection_->transport_version() == QUIC_VERSION_99) {
@@ -180,9 +182,9 @@
     }
     return;
   }
-  if (GetQuicReloadableFlag(quic_eliminate_static_stream_map) && frame.fin &&
+  if (eliminate_static_stream_map_ && frame.fin &&
       handler.stream->is_static()) {
-    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map, 1, 15);
+    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map_2, 1, 17);
     connection()->CloseConnection(
         QUIC_INVALID_STREAM_ID, "Attempt to close a static stream",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
@@ -269,9 +271,8 @@
     return true;
   }
 
-  if (GetQuicReloadableFlag(quic_eliminate_static_stream_map) &&
-      stream->is_static()) {
-    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map, 2, 15);
+  if (eliminate_static_stream_map_ && stream->is_static()) {
+    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map_2, 2, 17);
     QUIC_DVLOG(1) << ENDPOINT
                   << "Received STOP_SENDING for a static stream, id: "
                   << stream_id << " Closing connection";
@@ -328,9 +329,8 @@
     HandleRstOnValidNonexistentStream(frame);
     return;  // Errors are handled by GetOrCreateStream.
   }
-  if (GetQuicReloadableFlag(quic_eliminate_static_stream_map) &&
-      handler.stream->is_static()) {
-    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map, 3, 15);
+  if (eliminate_static_stream_map_ && handler.stream->is_static()) {
+    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map_2, 3, 17);
     connection()->CloseConnection(
         QUIC_INVALID_STREAM_ID, "Attempt to reset a static stream",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
@@ -376,7 +376,7 @@
     error_ = error;
   }
 
-  if (!GetQuicReloadableFlag(quic_eliminate_static_stream_map)) {
+  if (!eliminate_static_stream_map_) {
     while (!dynamic_stream_map_.empty()) {
       DynamicStreamMap::iterator it = dynamic_stream_map_.begin();
       QuicStreamId id = it->first;
@@ -389,7 +389,7 @@
       }
     }
   } else {
-    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map, 4, 15);
+    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map_2, 4, 17);
     // Copy all non static streams in a new map for the ease of deleting.
     QuicSmallMap<QuicStreamId, QuicStream*, 10> non_static_streams;
     for (const auto& it : dynamic_stream_map_) {
@@ -714,9 +714,8 @@
 
   DynamicStreamMap::iterator it = dynamic_stream_map_.find(id);
   if (it != dynamic_stream_map_.end()) {
-    if (GetQuicReloadableFlag(quic_eliminate_static_stream_map) &&
-        it->second->is_static()) {
-      QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map, 5, 15);
+    if (eliminate_static_stream_map_ && it->second->is_static()) {
+      QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map_2, 5, 17);
       QUIC_DVLOG(1) << ENDPOINT
                     << "Try to send rst for a static stream, id: " << id
                     << " Closing connection";
@@ -790,9 +789,8 @@
     return;
   }
   QuicStream* stream = it->second.get();
-  if (GetQuicReloadableFlag(quic_eliminate_static_stream_map) &&
-      stream->is_static()) {
-    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map, 6, 15);
+  if (eliminate_static_stream_map_ && stream->is_static()) {
+    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map_2, 6, 17);
     QUIC_DVLOG(1) << ENDPOINT
                   << "Try to close a static stream, id: " << stream_id
                   << " Closing connection";
@@ -1026,8 +1024,8 @@
   for (auto const& kv : dynamic_stream_map_) {
     kv.second->flow_controller()->UpdateReceiveWindowSize(stream_window);
   }
-  if (GetQuicReloadableFlag(quic_eliminate_static_stream_map)) {
-    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map, 11, 15);
+  if (eliminate_static_stream_map_) {
+    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map_2, 11, 17);
     GetMutableCryptoStream()->flow_controller()->UpdateReceiveWindowSize(
         stream_window);
   }
@@ -1076,8 +1074,8 @@
   for (auto const& kv : dynamic_stream_map_) {
     kv.second->UpdateSendWindowOffset(new_window);
   }
-  if (GetQuicReloadableFlag(quic_eliminate_static_stream_map)) {
-    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map, 12, 15);
+  if (eliminate_static_stream_map_) {
+    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map_2, 12, 17);
     GetMutableCryptoStream()->UpdateSendWindowOffset(new_window);
   }
 }
@@ -1208,10 +1206,10 @@
 QuicSession::StreamHandler QuicSession::GetOrCreateStreamImpl(
     QuicStreamId stream_id,
     bool may_buffer) {
-  if (GetQuicReloadableFlag(quic_eliminate_static_stream_map) &&
+  if (eliminate_static_stream_map_ &&
       stream_id ==
           QuicUtils::GetCryptoStreamId(connection_->transport_version())) {
-    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map, 13, 15);
+    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map_2, 13, 17);
     return StreamHandler(GetMutableCryptoStream());
   }
   StaticStreamMap::iterator it = static_stream_map_.find(stream_id);
@@ -1455,9 +1453,9 @@
       return true;
     }
   }
-  if (GetQuicReloadableFlag(quic_eliminate_static_stream_map) &&
+  if (eliminate_static_stream_map_ &&
       GetMutableCryptoStream()->flow_controller()->IsBlocked()) {
-    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map, 14, 15);
+    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map_2, 14, 17);
     return true;
   }
   return false;
@@ -1516,9 +1514,9 @@
     return zombie_stream->second.get();
   }
 
-  if (GetQuicReloadableFlag(quic_eliminate_static_stream_map) &&
+  if (eliminate_static_stream_map_ &&
       id == QuicUtils::GetCryptoStreamId(connection_->transport_version())) {
-    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map, 15, 15);
+    QUIC_RELOADABLE_FLAG_COUNT_N(quic_eliminate_static_stream_map_2, 15, 17);
     return const_cast<QuicCryptoStream*>(GetCryptoStream());
   }
 

quic/core/quic_session.h

diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index b24e5b6..172c52c 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -575,6 +575,10 @@
 
   StreamHandler GetOrCreateStreamImpl(QuicStreamId stream_id, bool may_buffer);
 
+  const bool eliminate_static_stream_map() const {
+    return eliminate_static_stream_map_;
+  }
+
  private:
   friend class test::QuicSessionPeer;
 
@@ -717,6 +721,9 @@
   // Supported version list used by the crypto handshake only. Please note, this
   // list may be a superset of the connection framer's supported versions.
   ParsedQuicVersionVector supported_versions_;
+
+  //  Latched value of quic_eliminate_static_stream_map.
+  const bool eliminate_static_stream_map_;
 };
 
 }  // namespace quic