grpc 1.84.0 → 1.85.0.pre1

data/src/core/ext/transport/chttp2/server/chttp2_server.cc

@@ -508,7 +508,7 @@ grpc_error_handle NewChttp2ServerListener::Create(
     // number.
     listener->resolved_address_ = iomgr_addr;
     {
-      MutexLock lock(&listener->mu_);
+      MutexLock lock(listener->mu_);
       listener->add_port_on_start_ = true;
     }
   } else {
@@ -583,7 +583,7 @@ void NewChttp2ServerListener::Start() {
   bool should_add_port = false;
   grpc_tcp_server* tcp_server = nullptr;
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     if (!shutdown_) {
       should_add_port = std::exchange(add_port_on_start_, false);
       // Hold a ref while we start the server
@@ -612,7 +612,7 @@ void NewChttp2ServerListener::Start() {
 }
 
 void NewChttp2ServerListener::SetOnDestroyDone(grpc_closure* on_destroy_done) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   on_destroy_done_ = on_destroy_done;
 }
 
@@ -635,7 +635,8 @@ void NewChttp2ServerListener::OnAccept(
   }
   RefCountedPtr<MitigationEngine> mitigation_engine = self->mitigation_engine();
   if (mitigation_engine != nullptr) {
-    auto action = mitigation_engine->EvaluateIncomingConnection(peer);
+    auto action = mitigation_engine->EvaluateIncomingConnection(
+        MitigationEngine::EvaluateArgs(peer, endpoint.get()));
     if (action == MitigationEngine::Action::kCloseConnection) {
       LOG_EVERY_N_SEC(INFO, 60)
           << "Mitigation engine rejected connection from " << peer;
@@ -651,7 +652,7 @@ void NewChttp2ServerListener::OnAccept(
     // tcp_server but this ref is given away when the listener is orphaned
     // (shutdown). A connection needs the tcp_server to outlast the handshake
     // since the acceptor needs it.
-    MutexLock lock(&self->mu_);
+    MutexLock lock(self->mu_);
     if (self->shutdown_) {
       self->listener_state_->connection_quota()->ReleaseConnections(1);
       return;
@@ -690,7 +691,7 @@ void NewChttp2ServerListener::TcpServerShutdownComplete(
 void NewChttp2ServerListener::Orphan() {
   grpc_tcp_server* tcp_server;
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     shutdown_ = true;
     tcp_server = tcp_server_;
   }
@@ -801,17 +802,22 @@ absl::StatusOr<int> Chttp2ServerAddPort(Server* server, const char* addr,
 
 namespace experimental {
 
+void PassiveListenerImpl::Init(RefCountedPtr<Server> server,
+                               NewChttp2ServerListener* listener) {
+  MutexLock lock(mu_);
+  server_ = std::move(server);
+  listener_ = listener;
+}
+
 absl::Status PassiveListenerImpl::AcceptConnectedEndpoint(
     std::unique_ptr<EventEngine::Endpoint> endpoint) {
-  GRPC_CHECK_NE(server_.get(), nullptr);
   RefCountedPtr<NewChttp2ServerListener> new_listener;
   {
-    MutexLock lock(&mu_);
-    auto* new_listener_ptr = std::get_if<NewChttp2ServerListener*>(&listener_);
-    if (new_listener_ptr != nullptr && *new_listener_ptr != nullptr) {
-      new_listener = (*new_listener_ptr)
-                         ->RefIfNonZero()
-                         .TakeAsSubclass<NewChttp2ServerListener>();
+    MutexLock lock(mu_);
+    GRPC_CHECK_NE(server_.get(), nullptr);
+    if (listener_ != nullptr) {
+      new_listener =
+          listener_->RefIfNonZero().TakeAsSubclass<NewChttp2ServerListener>();
     }
   }
   if (new_listener == nullptr) {
@@ -823,9 +829,13 @@ absl::Status PassiveListenerImpl::AcceptConnectedEndpoint(
 }
 
 absl::Status PassiveListenerImpl::AcceptConnectedFd(int fd) {
-  GRPC_CHECK_NE(server_.get(), nullptr);
   ExecCtx exec_ctx;
-  auto& args = server_->channel_args();
+  ChannelArgs args;
+  {
+    MutexLock lock(mu_);
+    GRPC_CHECK_NE(server_.get(), nullptr);
+    args = server_->channel_args();
+  }
   auto* supports_fd = QueryExtension<EventEngineSupportsFdExtension>(
       args.GetObjectRef<EventEngine>().get());
   if (supports_fd == nullptr) {
@@ -842,8 +852,8 @@ absl::Status PassiveListenerImpl::AcceptConnectedFd(int fd) {
 }
 
 void PassiveListenerImpl::ListenerDestroyed() {
-  MutexLock lock(&mu_);
-  listener_ = static_cast<Chttp2ServerListener*>(nullptr);
+  MutexLock lock(mu_);
+  listener_ = nullptr;
 }
 
 }  // namespace experimental
@@ -953,10 +963,9 @@ absl::Status grpc_server_add_passive_listener(
                   .SetObject(std::move(sc))
                   .Set(GRPC_ARG_USE_V3_STACK,
                        grpc_core::http2::ShouldEnablePh2Server());
-  passive_listener->listener_ =
+  passive_listener->Init(
+      server->Ref(),
       grpc_core::NewChttp2ServerListener::CreateForPassiveListener(
-          server, args, passive_listener);
-
-  passive_listener->server_ = server->Ref();
+          server, args, passive_listener));
   return absl::OkStatus();
 }

data/src/core/ext/transport/chttp2/server/chttp2_server.h

@@ -46,8 +46,6 @@ struct AcceptorDeleter {
   }
 };
 
-class Chttp2ServerListener;
-
 namespace testing {
 class Chttp2ServerListenerTestPeer;
 class ActiveConnectionTestPeer;
@@ -239,6 +237,9 @@ namespace experimental {
 // details.
 class PassiveListenerImpl final : public PassiveListener {
  public:
+  // Called by grpc_server_add_passive_listener().
+  void Init(RefCountedPtr<Server> server, NewChttp2ServerListener* listener);
+
   absl::Status AcceptConnectedEndpoint(
       std::unique_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
           endpoint) override ABSL_LOCKS_EXCLUDED(mu_);
@@ -249,17 +250,10 @@ class PassiveListenerImpl final : public PassiveListener {
   void ListenerDestroyed() ABSL_LOCKS_EXCLUDED(mu_);
 
  private:
-  // note: the grpc_core::Server redundant namespace qualification is
-  // required for older gcc versions.
-  friend absl::Status(::grpc_server_add_passive_listener)(
-      grpc_core::Server* server, grpc_server_credentials* credentials,
-      std::shared_ptr<grpc_core::experimental::PassiveListenerImpl>
-          passive_listener);
-
   Mutex mu_;
   // Data members will be populated when initialized.
-  RefCountedPtr<Server> server_;
-  std::variant<Chttp2ServerListener*, NewChttp2ServerListener*> listener_;
+  RefCountedPtr<Server> server_ ABSL_GUARDED_BY(mu_);
+  NewChttp2ServerListener* listener_ ABSL_GUARDED_BY(mu_) = nullptr;
 };
 
 }  // namespace experimental

data/src/core/ext/transport/chttp2/transport/chttp2_transport.cc

@@ -684,13 +684,14 @@ grpc_chttp2_transport::ChannelzDataSource::GetZTrace(absl::string_view name) {
 }
 
 // TODO(alishananda): add unit testing as part of chttp2 promise conversion work
-void grpc_chttp2_transport::WriteSecurityFrame(grpc_core::SliceBuffer* data) {
+void grpc_chttp2_transport::WriteSecurityFrame(grpc_core::SliceBuffer data) {
   grpc_core::ExecCtx exec_ctx;
-  combiner->Run(grpc_core::NewClosure(
-                    [transport = Ref(), data](grpc_error_handle) mutable {
-                      transport->WriteSecurityFrameLocked(data);
-                    }),
-                absl::OkStatus());
+  combiner->Run(
+      grpc_core::NewClosure([transport = Ref(), data = std::move(data)](
+                                grpc_error_handle) mutable {
+        transport->WriteSecurityFrameLocked(&data);
+      }),
+      absl::OkStatus());
 }
 
 void grpc_chttp2_transport::WriteSecurityFrameLocked(
@@ -747,6 +748,7 @@ grpc_chttp2_transport::grpc_chttp2_transport(
           &memory_owner),
       deframe_state(is_client ? GRPC_DTS_FH_0 : GRPC_DTS_CLIENT_PREFIX_0),
       is_client(is_client),
+      auth_context(channel_args.GetObject<grpc_auth_context>()),
       mitigation_engine([&]() {
         auto* provider =
             channel_args.GetObject<grpc_core::MitigationEngineProvider>();
@@ -778,7 +780,9 @@ grpc_chttp2_transport::grpc_chttp2_transport(
             ep.get()));
     if (transport_framing_endpoint_extension != nullptr) {
       transport_framing_endpoint_extension->SetSendFrameCallback(
-          [this](grpc_core::SliceBuffer* data) { WriteSecurityFrame(data); });
+          [this](grpc_core::SliceBuffer data) {
+            WriteSecurityFrame(std::move(data));
+          });
     }
   }
 
@@ -830,7 +834,6 @@ grpc_chttp2_transport::grpc_chttp2_transport(
     grpc_core::test_only_init_callback();
   }
 
-  grpc_auth_context* auth_context = channel_args.GetObject<grpc_auth_context>();
   http2_stats = grpc_core::CreateHttp2StatsCollector(auth_context);
   hpack_parser.hpack_table()->SetHttp2StatsCollector(http2_stats);
 
@@ -959,7 +962,7 @@ static void close_transport_locked(grpc_chttp2_transport* t,
           t->ep.get(), t->interested_parties_until_recv_settings);
       t->interested_parties_until_recv_settings = nullptr;
     }
-    grpc_core::MutexLock lock(&t->ep_destroy_mu);
+    grpc_core::MutexLock lock(t->ep_destroy_mu);
     t->ep.reset();
   }
   t->MaybeNotifyOnReceiveSettingsLocked(error);
@@ -3447,7 +3450,7 @@ void grpc_chttp2_transport::SetPollset(grpc_stream* /*gs*/,
   // using the "poll" polling engine, which is the only one that
   // actually uses pollsets.
   if (strcmp(grpc_get_poll_strategy_name(), "poll") != 0) return;
-  grpc_core::MutexLock lock(&ep_destroy_mu);
+  grpc_core::MutexLock lock(ep_destroy_mu);
   if (ep != nullptr) grpc_endpoint_add_to_pollset(ep.get(), pollset);
 }
 
@@ -3457,7 +3460,7 @@ void grpc_chttp2_transport::SetPollsetSet(grpc_stream* /*gs*/,
   // using the "poll" polling engine, which is the only one that
   // actually uses pollsets.
   if (strcmp(grpc_get_poll_strategy_name(), "poll") != 0) return;
-  grpc_core::MutexLock lock(&ep_destroy_mu);
+  grpc_core::MutexLock lock(ep_destroy_mu);
   if (ep != nullptr) grpc_endpoint_add_to_pollset_set(ep.get(), pollset_set);
 }
 

data/src/core/ext/transport/chttp2/transport/flow_control.cc

@@ -409,6 +409,7 @@ FlowControlAction StreamFlowControl::UpdateAction(FlowControlAction action) {
 void StreamFlowControl::IncomingUpdateContext::HackIncrementPendingSize(
     int64_t pending_size) {
   GRPC_CHECK_GE(pending_size, 0);
+  SetMinProgressSize(1u);
   if (sfc_->pending_size_.has_value()) {
     int64_t final_size = Clamp(sfc_->pending_size_.value() + pending_size,
                                int64_t{0}, kMaxWindowUpdateSize);

data/src/core/ext/transport/chttp2/transport/flow_control.h

@@ -58,10 +58,6 @@ static constexpr const uint32_t kMaxInitialWindowSize = (1u << 30);
 static constexpr const int64_t kMaxWindowDelta = (1u << 20);
 static constexpr const int kDefaultPreferredRxCryptoFrameSize = INT_MAX;
 
-// TODO(tjagtap) [PH2][P2][BDP] Remove this static sleep when the BDP code is
-// done. This needs to be dynamic.
-constexpr Duration kFlowControlPeriodicUpdateTimer = Duration::Seconds(8);
-
 class TransportFlowControl;
 class StreamFlowControl;
 

data/src/core/ext/transport/chttp2/transport/frame.h

@@ -415,6 +415,8 @@ inline constexpr absl::string_view kIdleStreamError =
     "Stream Idle : Receiving any frame other than HEADERS or PRIORITY on a "
     "stream in this state MUST be treated as a connection error of type "
     "PROTOCOL_ERROR.";
+inline constexpr absl::string_view kMaxConcurrentStreamsExceeded =
+    "Exceeded MAX_CONCURRENT_STREAMS limit.";
 
 inline constexpr uint32_t kMaxStreamId31Bit = 0x7fffffffu;
 inline constexpr uint32_t kMaxSize31Bit = 0x7fffffffu;
@@ -445,6 +447,13 @@ inline constexpr absl::string_view kFailedToEnqueueStream =
     "gRPC Transport Error : Failed to enqueue stream to writable stream list";
 inline constexpr absl::string_view kStreamCreationFailed =
     "gRPC Transport Error : Stream creation failed";
+inline constexpr absl::string_view kTransportUnderHighMemoryPressure =
+    "gRPC Stream Error : Server is under memory pressure. Stream rejected.";
+inline constexpr absl::string_view kRejectStreamBeforeSettingsAck =
+    "gRPC Stream Error : Rejecting stream before settings have been "
+    "acknowledged.";
+inline constexpr absl::string_view kRejectStreamOverload =
+    "Rejecting stream due to overload protection.";
 
 inline constexpr uint32_t kDefaultMaxPendingInducedFrames = 10000u;
 

data/src/core/ext/transport/chttp2/transport/hpack_parser.cc

@@ -1009,7 +1009,9 @@ class HPackParser::Parser {
         key_string.size() + value.wire_size + hpack_constants::kEntryOverhead;
     if (state_.mitigation_engine != nullptr) {
       auto action = state_.mitigation_engine->EvaluateIncomingMetadata(
-          key_string, value_slice.as_string_view(), state_.peer_address);
+          key_string, value_slice.as_string_view(),
+          MitigationEngine::EvaluateArgs(
+              state_.peer_address, /*endpoint=*/nullptr, state_.auth_context));
       if (action.has_value()) {
         if (action.value() == MitigationEngine::Action::kCloseConnection) {
           input_->SetErrorAndStopParsing(
@@ -1113,13 +1115,11 @@ HPackParser::HPackParser() = default;
 
 HPackParser::~HPackParser() = default;
 
-void HPackParser::BeginFrame(grpc_metadata_batch* metadata_buffer,
-                             uint32_t metadata_size_soft_limit,
-                             uint32_t metadata_size_hard_limit,
-                             Boundary boundary, Priority priority,
-                             LogInfo log_info,
-                             MitigationEngine* mitigation_engine,
-                             absl::string_view peer_address) {
+void HPackParser::BeginFrame(
+    grpc_metadata_batch* metadata_buffer, uint32_t metadata_size_soft_limit,
+    uint32_t metadata_size_hard_limit, Boundary boundary, Priority priority,
+    LogInfo log_info, MitigationEngine* mitigation_engine,
+    absl::string_view peer_address, grpc_auth_context* auth_context) {
   metadata_buffer_ = metadata_buffer;
   if (metadata_buffer != nullptr) {
     metadata_buffer->Set(GrpcStatusFromWire(), true);
@@ -1128,6 +1128,7 @@ void HPackParser::BeginFrame(grpc_metadata_batch* metadata_buffer,
   priority_ = priority;
   state_.mitigation_engine = mitigation_engine;
   state_.peer_address = peer_address;
+  state_.auth_context = auth_context;
   state_.dynamic_table_updates_allowed = 2;
   state_.metadata_early_detection.SetLimits(
       /*soft_limit=*/metadata_size_soft_limit,
@@ -1164,7 +1165,9 @@ grpc_error_handle HPackParser::ParseInput(Input input, bool is_last,
   if (is_last && is_boundary()) {
     if (state_.mitigation_engine != nullptr && metadata_buffer_ != nullptr) {
       auto action = state_.mitigation_engine->EvaluateAllIncomingMetadata(
-          *metadata_buffer_, state_.peer_address);
+          *metadata_buffer_,
+          MitigationEngine::EvaluateArgs(
+              state_.peer_address, /*endpoint=*/nullptr, state_.auth_context));
       if (action.has_value()) {
         if (action.value() == MitigationEngine::Action::kCloseConnection) {
           input.SetErrorAndStopParsing(HpackParseResult::MitigationEngineError(

data/src/core/ext/transport/chttp2/transport/hpack_parser.h

@@ -101,8 +101,9 @@ class HPackParser {
                   uint32_t metadata_size_soft_limit,
                   uint32_t metadata_size_hard_limit, Boundary boundary,
                   Priority priority, LogInfo log_info,
-                  MitigationEngine* mitigation_engine,
-                  absl::string_view peer_address = "");
+                  MitigationEngine* mitigation_engine = nullptr,
+                  absl::string_view peer_address = "",
+                  grpc_auth_context* auth_context = nullptr);
   // Start throwing away any received headers after parsing them.
   void StopBufferingFrame() { metadata_buffer_ = nullptr; }
   // Parse one slice worth of data
@@ -257,6 +258,7 @@ class HPackParser {
     ParseState parse_state = ParseState::kTop;
     MitigationEngine* mitigation_engine = nullptr;
     absl::string_view peer_address;
+    grpc_auth_context* auth_context = nullptr;
     std::variant<const HPackTable::Memento*, Slice> key;
   };
 

data/src/core/ext/transport/chttp2/transport/http2_client_transport.cc

@@ -140,20 +140,20 @@ void Http2ClientTransport::PerformOp(grpc_transport_op* op) {
 void Http2ClientTransport::StartConnectivityWatch(
     grpc_connectivity_state state,
     OrphanablePtr<ConnectivityStateWatcherInterface> watcher) {
-  MutexLock lock(&transport_mutex_);
+  MutexLock lock(transport_mutex_);
   state_tracker_.AddWatcher(state, std::move(watcher));
 }
 
 void Http2ClientTransport::StopConnectivityWatch(
     ConnectivityStateWatcherInterface* watcher) {
-  MutexLock lock(&transport_mutex_);
+  MutexLock lock(transport_mutex_);
   state_tracker_.RemoveWatcher(watcher);
 }
 
 void Http2ClientTransport::ReportDisconnection(
     const absl::Status& status, StateWatcher::DisconnectInfo disconnect_info,
     const char* reason) {
-  MutexLock lock(&transport_mutex_);
+  MutexLock lock(transport_mutex_);
   ReportDisconnectionLocked(status, disconnect_info, reason);
 }
 
@@ -168,14 +168,14 @@ void Http2ClientTransport::ReportDisconnectionLocked(
 }
 
 void Http2ClientTransport::StartWatch(RefCountedPtr<StateWatcher> watcher) {
-  MutexLock lock(&transport_mutex_);
+  MutexLock lock(transport_mutex_);
   GRPC_CHECK(watcher_ == nullptr);
   watcher_ = std::move(watcher);
   if (shutdown_tracker_.IsShutdownInitiated(transport_mutex_)) {
     // TODO(tjagtap) : [PH2][P2] : Provide better status message and
     // disconnect info here.
     NotifyStateWatcherOnDisconnectLocked(
-        absl::UnknownError("transport closed before watcher started"), {});
+        absl::UnavailableError("transport closed before watcher started"), {});
   } else {
     // TODO(tjagtap) : [PH2][P2] : Notify the state watcher of the current
     // value of the peer's MAX_CONCURRENT_STREAMS setting.
@@ -183,7 +183,7 @@ void Http2ClientTransport::StartWatch(RefCountedPtr<StateWatcher> watcher) {
 }
 
 void Http2ClientTransport::StopWatch(RefCountedPtr<StateWatcher> watcher) {
-  MutexLock lock(&transport_mutex_);
+  MutexLock lock(transport_mutex_);
   if (watcher_ == watcher) watcher_.reset();
 }
 
@@ -566,8 +566,6 @@ Http2Status Http2ClientTransport::ProcessIncomingFrame(
     GRPC_UNUSED Http2UnknownFrame&& frame) {
   // RFC9113: Implementations MUST ignore and discard frames of
   // unknown types.
-  GRPC_HTTP2_CLIENT_DLOG
-      << "Http2ClientTransport::ProcessIncomingFrame(UnknownFrame) ";
   return Http2Status::Ok();
 }
 
@@ -685,7 +683,6 @@ auto Http2ClientTransport::ReadAndProcessOneFrame() {
 }
 
 auto Http2ClientTransport::ReadLoop() {
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::ReadLoop Factory";
   return AssertResultType<absl::Status>(Loop([this]() {
     return TrySeq(ReadAndProcessOneFrame(), []() -> LoopCtl<absl::Status> {
       GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::ReadLoop Continue";
@@ -704,6 +701,7 @@ auto Http2ClientTransport::BdpLoop() {
         [this]() {
           // TODO(akshitpatel) : [PH2][P1] : Reset the keepalive ping timer
           // when a BDP ping is sent, similar to CHTTP2's start_bdp_ping_locked.
+          TriggerWriteCycleOrHandleError();
           return ping_manager_->RequestPing(
               [this] { flow_control_.StartBdpPing(); },
               /*important=*/false);
@@ -758,7 +756,7 @@ void Http2ClientTransport::ActOnFlowControlAction(
 }
 
 absl::Status Http2ClientTransport::UpdateAllStreamsWritability() {
-  MutexLock lock(&transport_mutex_);
+  MutexLock lock(transport_mutex_);
   GRPC_HTTP2_CLIENT_DLOG
       << "Http2ClientTransport::UpdateAllStreamsWritability total streams: "
       << stream_list_.size();
@@ -1133,7 +1131,7 @@ absl::Status Http2ClientTransport::InitializeStream(Stream& stream) {
 
 void Http2ClientTransport::AddToStreamList(RefCountedPtr<Stream> stream) {
   {
-    MutexLock lock(&transport_mutex_);
+    MutexLock lock(transport_mutex_);
     GRPC_DCHECK(stream != nullptr) << "stream is null";
     GRPC_DCHECK_GT(stream->GetStreamId(), 0u) << "stream id is invalid";
     GRPC_HTTP2_CLIENT_DLOG
@@ -1350,7 +1348,7 @@ void Http2ClientTransport::HandleStreamStateChange(Stream& stream,
 
 void Http2ClientTransport::CleanupStream(Stream& stream) {
   {
-    MutexLock lock(&transport_mutex_);
+    MutexLock lock(transport_mutex_);
     stream_list_.erase(stream.GetStreamId());
   }
   // Subtract any positive announced window delta of closed stream from the
@@ -1414,7 +1412,7 @@ void Http2ClientTransport::CloseAllActiveStreams(
   // Close all the streams that are still active on the transport.
   absl::flat_hash_map<uint32_t, RefCountedPtr<Stream>> stream_list_2;
   {
-    MutexLock lock(&transport_mutex_);
+    MutexLock lock(transport_mutex_);
     stream_list_2 = std::move(stream_list_);
     stream_list_.clear();
   }
@@ -1482,7 +1480,7 @@ void Http2ClientTransport::MaybeSpawnCloseTransport(Http2Status http2_status,
   // in the MPSC to be drained and block any additional frames from being
   // enqueued. Additionally this also prevents additional frames with non-zero
   // stream_ids from being processed by the read loop.
-  ReleasableMutexLock lock(&transport_mutex_);
+  ReleasableMutexLock lock(transport_mutex_);
   if (shutdown_tracker_.IsShutdownInitiated(transport_mutex_)) {
     lock.Release();
     return;
@@ -1544,7 +1542,7 @@ void Http2ClientTransport::AddData(channelz::DataSink sink) {
                       sink = std::move(sink)]() mutable {
     RefCountedPtr<Party> party = nullptr;
     {
-      MutexLock lock(&self->transport_mutex_);
+      MutexLock lock(self->transport_mutex_);
       if (GPR_LIKELY(!self->shutdown_tracker_.IsShutdownInitiated(
               self->transport_mutex_))) {
         GRPC_DCHECK(self->transport_party_ != nullptr);
@@ -1597,7 +1595,7 @@ absl::StatusOr<uint32_t> Http2ClientTransport::NextStreamId() {
     // this for incoming streams only. If a server receives more
     // streams from a client than is allowed by the clients settings,
     // whether or not we should fail is debatable.
-    MutexLock lock(&transport_mutex_);
+    MutexLock lock(transport_mutex_);
     if (GetActiveStreamCountLocked() >=
         settings_->peer().max_concurrent_streams()) {
       return absl::ResourceExhaustedError("Reached max concurrent streams");
@@ -1641,7 +1639,7 @@ absl::Status Http2ClientTransport::MaybeAddStreamToWritableStreamList(
 }
 
 RefCountedPtr<Stream> Http2ClientTransport::LookupStream(uint32_t stream_id) {
-  MutexLock lock(&transport_mutex_);
+  MutexLock lock(transport_mutex_);
   auto it = stream_list_.find(stream_id);
   if (it == stream_list_.end()) {
     GRPC_HTTP2_CLIENT_DLOG
@@ -1965,7 +1963,7 @@ Http2ClientTransport::KeepAliveInterfaceImpl::OnKeepAliveTimeout() {
 bool Http2ClientTransport::KeepAliveInterfaceImpl::NeedToSendKeepAlivePing() {
   bool need_to_send_ping = false;
   {
-    MutexLock lock(&transport_->transport_mutex_);
+    MutexLock lock(transport_->transport_mutex_);
     need_to_send_ping = (transport_->keepalive_permit_without_calls_ ||
                          transport_->GetActiveStreamCountLocked() > 0);
   }

data/src/core/ext/transport/chttp2/transport/http2_client_transport.h

@@ -44,6 +44,7 @@
 #include "src/core/ext/transport/chttp2/transport/keepalive.h"
 #include "src/core/ext/transport/chttp2/transport/ping_promise.h"
 #include "src/core/ext/transport/chttp2/transport/read_context.h"
+#include "src/core/ext/transport/chttp2/transport/reclaimer.h"
 #include "src/core/ext/transport/chttp2/transport/security_frame.h"
 #include "src/core/ext/transport/chttp2/transport/stream.h"
 #include "src/core/ext/transport/chttp2/transport/stream_data_queue.h"
@@ -532,7 +533,7 @@ class Http2ClientTransport final : public ClientTransport,
   auto WaitForPingAck() { return ping_manager_->WaitForPingAck(); }
 
   Duration NextAllowedPingInterval() {
-    MutexLock lock(&transport_mutex_);
+    MutexLock lock(transport_mutex_);
     return (!keepalive_permit_without_calls_ &&
             GetActiveStreamCountLocked() == 0)
                ? Duration::Hours(2)