Update naming of maxStreamGroupsAdvertized to match that of similar variables

Summary: This is a cosmetic change to make the naming consistent for all the advertised* variables in the transport settings.

Reviewed By: sharmafb

Differential Revision: D42465443

fbshipit-source-id: d570cbb1a2ca017105ac335b8efc404cb73f3c57

quic/api/test/QuicTransportBaseTest.cpp

@@ -4285,7 +4285,7 @@ INSTANTIATE_TEST_SUITE_P(
 
 TEST_P(QuicTransportImplTestWithGroups, ReadCallbackWithGroupsDataAvailable) {
   auto transportSettings = transport->getTransportSettings();
-  transportSettings.maxStreamGroupsAdvertized = 16;
+  transportSettings.advertisedMaxStreamGroups = 16;
   transport->setTransportSettings(transportSettings);
   transport->getConnectionState().streamManager->refreshTransportSettings(
       transportSettings);
@@ -4335,7 +4335,7 @@ TEST_P(QuicTransportImplTestWithGroups, ReadCallbackWithGroupsDataAvailable) {
 
 TEST_P(QuicTransportImplTestWithGroups, ReadErrorCallbackWithGroups) {
   auto transportSettings = transport->getTransportSettings();
-  transportSettings.maxStreamGroupsAdvertized = 16;
+  transportSettings.advertisedMaxStreamGroups = 16;
   transport->setTransportSettings(transportSettings);
   transport->getConnectionState().streamManager->refreshTransportSettings(
       transportSettings);
@@ -4364,7 +4364,7 @@ TEST_P(
     QuicTransportImplTestWithGroups,
     ReadCallbackWithGroupsCancellCallbacks) {
   auto transportSettings = transport->getTransportSettings();
-  transportSettings.maxStreamGroupsAdvertized = 16;
+  transportSettings.advertisedMaxStreamGroups = 16;
   transport->setTransportSettings(transportSettings);
   transport->getConnectionState().streamManager->refreshTransportSettings(
       transportSettings);
@@ -4400,7 +4400,7 @@ TEST_P(
 
 TEST_P(QuicTransportImplTestWithGroups, onNewStreamsAndGroupsCallbacks) {
   auto transportSettings = transport->getTransportSettings();
-  transportSettings.maxStreamGroupsAdvertized = 16;
+  transportSettings.advertisedMaxStreamGroups = 16;
   transport->setTransportSettings(transportSettings);
   transport->getConnectionState().streamManager->refreshTransportSettings(
       transportSettings);

quic/client/QuicClientTransport.cpp

@@ -1867,14 +1867,14 @@ void QuicClientTransport::maybeSendTransportKnobs() {
 }
 
 void QuicClientTransport::maybeEnableStreamGroups() {
-  if (conn_->transportSettings.maxStreamGroupsAdvertized == 0) {
+  if (conn_->transportSettings.advertisedMaxStreamGroups == 0) {
     return;
   }
 
   auto streamGroupsEnabledParam =
       std::make_unique<CustomIntegralTransportParameter>(
           static_cast<uint64_t>(TransportParameterId::stream_groups_enabled),
-          conn_->transportSettings.maxStreamGroupsAdvertized);
+          conn_->transportSettings.advertisedMaxStreamGroups);
 
   if (!setCustomTransportParameter(
           std::move(streamGroupsEnabledParam), customTransportParameters_)) {

quic/client/state/ClientStateMachine.cpp

@@ -132,7 +132,7 @@ void processServerInitialParams(
       serverParams.parameters);
   auto maxDatagramFrameSize = getIntegerParameter(
       TransportParameterId::max_datagram_frame_size, serverParams.parameters);
-  auto peerMaxStreamGroupsAdvertized = getIntegerParameter(
+  auto peerAdvertisedMaxStreamGroups = getIntegerParameter(
       static_cast<TransportParameterId>(
           TransportParameterId::stream_groups_enabled),
       serverParams.parameters);
@@ -248,8 +248,8 @@ void processServerInitialParams(
     conn.datagramState.maxWriteFrameSize = maxDatagramFrameSize.value();
   }
 
-  if (peerMaxStreamGroupsAdvertized) {
+  if (peerAdvertisedMaxStreamGroups) {
-    conn.peerMaxStreamGroupsAdvertized = *peerMaxStreamGroupsAdvertized;
+    conn.peerAdvertisedMaxStreamGroups = *peerAdvertisedMaxStreamGroups;
   }
 
   if (isAckReceiveTimestampsEnabled.has_value() &&

quic/client/test/ClientStateMachineTest.cpp

@@ -208,7 +208,7 @@ TEST_P(
   processServerInitialParams(clientConn, serverTransportParams, 0);
 
   EXPECT_EQ(
-      clientConn.peerMaxStreamGroupsAdvertized,
+      clientConn.peerAdvertisedMaxStreamGroups,
       GetParam().expectedTransportSettingVal);
 }
 

quic/samples/echo/EchoClient.h

@@ -219,7 +219,7 @@ class EchoClient : public quic::QuicSocket::ConnectionSetupCallback,
       settings.disableMigration = !enableMigration_;
       if (enableStreamGroups_) {
         settings.notifyOnNewStreamsExplicitly = true;
-        settings.maxStreamGroupsAdvertized = kNumTestStreamGroups;
+        settings.advertisedMaxStreamGroups = kNumTestStreamGroups;
       }
       quicClient_->setTransportSettings(settings);
 

quic/samples/echo/EchoServer.h

@@ -92,7 +92,7 @@ class EchoServer {
     settingsCopy.disableMigration = !enableMigration;
     if (enableStreamGroups) {
       settingsCopy.notifyOnNewStreamsExplicitly = true;
-      settingsCopy.maxStreamGroupsAdvertized = 1024;
+      settingsCopy.advertisedMaxStreamGroups = 1024;
     }
     server_->setTransportSettings(std::move(settingsCopy));
   }

quic/server/state/ServerStateMachine.cpp

@@ -222,7 +222,7 @@ void processClientInitialParams(
       TransportParameterId::max_ack_delay, clientParams.parameters);
   auto maxDatagramFrameSize = getIntegerParameter(
       TransportParameterId::max_datagram_frame_size, clientParams.parameters);
-  auto peerMaxStreamGroupsAdvertized = getIntegerParameter(
+  auto peerAdvertisedMaxStreamGroups = getIntegerParameter(
       static_cast<TransportParameterId>(
           TransportParameterId::stream_groups_enabled),
       clientParams.parameters);
@@ -405,8 +405,8 @@ void processClientInitialParams(
     }
   }
 
-  if (peerMaxStreamGroupsAdvertized) {
+  if (peerAdvertisedMaxStreamGroups) {
-    conn.peerMaxStreamGroupsAdvertized = *peerMaxStreamGroupsAdvertized;
+    conn.peerAdvertisedMaxStreamGroups = *peerAdvertisedMaxStreamGroups;
   }
   if (isAckReceiveTimestampsEnabled.has_value() &&
       isAckReceiveTimestampsEnabled.value() == 1) {
@@ -1625,11 +1625,11 @@ std::vector<TransportParameter> setSupportedExtensionTransportParameters(
     customTransportParams.push_back(maxDatagramFrameSize->encode());
   }
 
-  if (conn.transportSettings.maxStreamGroupsAdvertized > 0) {
+  if (conn.transportSettings.advertisedMaxStreamGroups > 0) {
     auto streamGroupsEnabledParam =
         std::make_unique<CustomIntegralTransportParameter>(
             static_cast<uint64_t>(TransportParameterId::stream_groups_enabled),
-            conn.transportSettings.maxStreamGroupsAdvertized);
+            conn.transportSettings.advertisedMaxStreamGroups);
 
     if (!setCustomTransportParameter(
             std::move(streamGroupsEnabledParam), customTransportParams)) {

quic/server/test/ServerStateMachineTest.cpp

@@ -312,19 +312,19 @@ TEST(ServerStateMachineTest, TestProcessMaxRecvPacketSizeParams) {
   runMaxPacketSizeTestWithFixture(fixture);
 }
 
-struct maxStreamGroupsAdvertizedtestStruct {
+struct advertisedMaxStreamGroupstestStruct {
   uint64_t peerMaxGroupsIn;
   folly::Optional<uint64_t> expectedTransportSettingVal;
 };
 
-class ServerStateMachineMaxStreamGroupsAdvertizedParamTest
+class ServerStateMachineAdvertisedMaxStreamGroupsParamTest
     : public Test,
       public ::testing::WithParamInterface<
-          maxStreamGroupsAdvertizedtestStruct> {};
+          advertisedMaxStreamGroupstestStruct> {};
 
 TEST_P(
-    ServerStateMachineMaxStreamGroupsAdvertizedParamTest,
+    ServerStateMachineAdvertisedMaxStreamGroupsParamTest,
-    TestMaxStreamGroupsAdvertizedParam) {
+    TestAdvertisedMaxStreamGroupsParam) {
   QuicServerConnectionState serverConn(
       FizzServerQuicHandshakeContext::Builder().build());
   std::vector<TransportParameter> transportParams;
@@ -342,16 +342,16 @@ TEST_P(
   processClientInitialParams(serverConn, clientTransportParams);
 
   EXPECT_EQ(
-      serverConn.peerMaxStreamGroupsAdvertized,
+      serverConn.peerAdvertisedMaxStreamGroups,
       GetParam().expectedTransportSettingVal);
 }
 
 INSTANTIATE_TEST_SUITE_P(
-    ServerStateMachineMaxStreamGroupsAdvertizedParamTest,
+    ServerStateMachineAdvertisedMaxStreamGroupsParamTest,
-    ServerStateMachineMaxStreamGroupsAdvertizedParamTest,
+    ServerStateMachineAdvertisedMaxStreamGroupsParamTest,
     ::testing::Values(
-        maxStreamGroupsAdvertizedtestStruct{0, folly::none},
+        advertisedMaxStreamGroupstestStruct{0, folly::none},
-        maxStreamGroupsAdvertizedtestStruct{16, 16}));
+        advertisedMaxStreamGroupstestStruct{16, 16}));
 
 } // namespace test
 } // namespace quic

quic/state/QuicStreamManager.cpp

@@ -382,7 +382,7 @@ QuicStreamManager::createNextStreamGroup(
     StreamGroupId& groupId,
     folly::F14FastSet<StreamGroupId>& streamGroups) {
   auto maxLocalStreamGroupId = std::min(
-      transportSettings_->maxStreamGroupsAdvertized *
+      transportSettings_->advertisedMaxStreamGroups *
           detail::kStreamGroupIncrement,
       detail::kMaxStreamGroupId);
   if (groupId >= maxLocalStreamGroupId) {
@@ -435,7 +435,7 @@ QuicStreamState* FOLLY_NULLABLE QuicStreamManager::getOrCreatePeerStream(
     }
 
     auto maxPeerStreamGroupId = std::min(
-        transportSettings_->maxStreamGroupsAdvertized *
+        transportSettings_->advertisedMaxStreamGroups *
             detail::kStreamGroupIncrement,
         detail::kMaxStreamGroupId);
     if (*streamGroupId >= maxPeerStreamGroupId) {

quic/state/StateData.h

@@ -780,8 +780,8 @@ struct QuicConnectionStateBase : public folly::DelayedDestruction {
 
   DatagramState datagramState;
 
-  // Peer max stream groups advertized.
+  // Peer max stream groups advertised.
-  folly::Optional<uint64_t> peerMaxStreamGroupsAdvertized;
+  folly::Optional<uint64_t> peerAdvertisedMaxStreamGroups;
 
   // Sequence number to use for the next ACK_FREQUENCY frame
   uint64_t nextAckFrequencyFrameSequenceNumber{0};

quic/state/TransportSettings.h

@@ -326,7 +326,7 @@ struct TransportSettings {
   bool notifyOnNewStreamsExplicitly{false};
   // Both peers must support stream groups; negotiated during handshake.
   // 0 means stream groups are disabled.
-  uint64_t maxStreamGroupsAdvertized{0};
+  uint64_t advertisedMaxStreamGroups{0};
   bool experimentalPacer{false};
   // experimental flag to close ingress SM when invoking stopSending
   bool dropIngressOnStopSending{false};

quic/state/test/QuicStreamManagerTest.cpp

@@ -781,7 +781,7 @@ TEST_P(QuicStreamManagerGroupsTest, TestStreamGroupLimits) {
   EXPECT_EQ(getNumGroups(), 0);
 
   // Bump group limits.
-  conn.transportSettings.maxStreamGroupsAdvertized = 1;
+  conn.transportSettings.advertisedMaxStreamGroups = 1;
   manager.refreshTransportSettings(conn.transportSettings);
   groupId = createNextStreamGroup();
   EXPECT_TRUE(groupId.hasValue());
@@ -795,7 +795,7 @@ TEST_P(QuicStreamManagerGroupsTest, TestStreamGroupLimits) {
 
 TEST_P(QuicStreamManagerGroupsTest, TestStreamsCreationInGroupsNoGroup) {
   auto& manager = *conn.streamManager;
-  conn.transportSettings.maxStreamGroupsAdvertized = 16;
+  conn.transportSettings.advertisedMaxStreamGroups = 16;
   manager.refreshTransportSettings(conn.transportSettings);
 
   // Should throw because no stream groups exist yet.
@@ -805,7 +805,7 @@ TEST_P(QuicStreamManagerGroupsTest, TestStreamsCreationInGroupsNoGroup) {
 
 TEST_P(QuicStreamManagerGroupsTest, TestStreamsCreationInGroupsWrongNodeType) {
   auto& manager = *conn.streamManager;
-  conn.transportSettings.maxStreamGroupsAdvertized = 16;
+  conn.transportSettings.advertisedMaxStreamGroups = 16;
   manager.refreshTransportSettings(conn.transportSettings);
 
   // Should throw because client stream group id is provided.
@@ -815,7 +815,7 @@ TEST_P(QuicStreamManagerGroupsTest, TestStreamsCreationInGroupsWrongNodeType) {
 
 TEST_P(QuicStreamManagerGroupsTest, TestStreamsCreationInGroupsSuccess) {
   auto& manager = *conn.streamManager;
-  conn.transportSettings.maxStreamGroupsAdvertized = 16;
+  conn.transportSettings.advertisedMaxStreamGroups = 16;
   manager.refreshTransportSettings(conn.transportSettings);
 
   auto groupId = createNextStreamGroup();
@@ -838,7 +838,7 @@ TEST_P(QuicStreamManagerGroupsTest, TestPeerStreamsWithGroupDisabled) {
 
 TEST_P(QuicStreamManagerGroupsTest, TestPeerStreamsWithGroup) {
   auto& manager = *conn.streamManager;
-  conn.transportSettings.maxStreamGroupsAdvertized = 16;
+  conn.transportSettings.advertisedMaxStreamGroups = 16;
   manager.refreshTransportSettings(conn.transportSettings);
 
   const StreamId peerStreamId = 2;
@@ -850,7 +850,7 @@ TEST_P(QuicStreamManagerGroupsTest, TestPeerStreamsWithGroup) {
 
 TEST_P(QuicStreamManagerGroupsTest, TestPeerStreamsWithGroupBadGroupId) {
   auto& manager = *conn.streamManager;
-  conn.transportSettings.maxStreamGroupsAdvertized = 16;
+  conn.transportSettings.advertisedMaxStreamGroups = 16;
   manager.refreshTransportSettings(conn.transportSettings);
 
   const StreamId peerStreamId = 2;
@@ -862,7 +862,7 @@ TEST_P(QuicStreamManagerGroupsTest, TestPeerStreamsWithGroupBadGroupId) {
 
 TEST_P(QuicStreamManagerGroupsTest, TestPeerStreamsWithGroupAccounting) {
   auto& manager = *conn.streamManager;
-  conn.transportSettings.maxStreamGroupsAdvertized = 16;
+  conn.transportSettings.advertisedMaxStreamGroups = 16;
   manager.refreshTransportSettings(conn.transportSettings);
 
   StreamId peerStreamId = 2;