grpc 1.58.0 → 1.59.0

data/src/core/ext/filters/client_channel/resolver/xds/xds_resolver.cc

@@ -74,6 +74,7 @@
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/dual_ref_counted.h"
 #include "src/core/lib/gprpp/match.h"
@@ -143,7 +144,8 @@ class XdsResolver : public Resolver {
    public:
     explicit ListenerWatcher(RefCountedPtr<XdsResolver> resolver)
         : resolver_(std::move(resolver)) {}
-    void OnResourceChanged(XdsListenerResource listener) override {
+    void OnResourceChanged(
+        std::shared_ptr<const XdsListenerResource> listener) override {
       RefCountedPtr<ListenerWatcher> self = Ref();
       resolver_->work_serializer_->Run(
           [self = std::move(self), listener = std::move(listener)]() mutable {
@@ -180,7 +182,8 @@ class XdsResolver : public Resolver {
    public:
     explicit RouteConfigWatcher(RefCountedPtr<XdsResolver> resolver)
         : resolver_(std::move(resolver)) {}
-    void OnResourceChanged(XdsRouteConfigResource route_config) override {
+    void OnResourceChanged(
+        std::shared_ptr<const XdsRouteConfigResource> route_config) override {
       RefCountedPtr<RouteConfigWatcher> self = Ref();
       resolver_->work_serializer_->Run(
           [self = std::move(self),
@@ -397,8 +400,9 @@ class XdsResolver : public Resolver {
     return it->second->Ref();
   }
 
-  void OnListenerUpdate(XdsListenerResource listener);
-  void OnRouteConfigUpdate(XdsRouteConfigResource rds_update);
+  void OnListenerUpdate(std::shared_ptr<const XdsListenerResource> listener);
+  void OnRouteConfigUpdate(
+      std::shared_ptr<const XdsRouteConfigResource> rds_update);
   void OnError(absl::string_view context, absl::Status status);
   void OnResourceDoesNotExist(std::string context);
 
@@ -418,17 +422,13 @@ class XdsResolver : public Resolver {
   uint64_t channel_id_;
 
   ListenerWatcher* listener_watcher_ = nullptr;
-  // This will not contain the RouteConfiguration, even if it comes with the
-  // LDS response; instead, the relevant VirtualHost from the
-  // RouteConfiguration will be saved in current_virtual_host_.
-  XdsListenerResource::HttpConnectionManager current_listener_;
+  std::shared_ptr<const XdsListenerResource> current_listener_;
 
   std::string route_config_name_;
   RouteConfigWatcher* route_config_watcher_ = nullptr;
-  absl::optional<XdsRouteConfigResource::VirtualHost> current_virtual_host_;
-  std::map<std::string /*cluster_specifier_plugin_name*/,
-           std::string /*LB policy config*/>
-      cluster_specifier_plugin_map_;
+  std::shared_ptr<const XdsRouteConfigResource> current_route_config_;
+
+  const XdsRouteConfigResource::VirtualHost* current_virtual_host_ = nullptr;
 
   std::map<absl::string_view, WeakRefCountedPtr<ClusterRef>> cluster_ref_map_;
 };
@@ -546,11 +546,12 @@ XdsResolver::RouteConfigData::CreateMethodConfig(
                         route_action.max_stream_duration->ToJsonString()));
   }
   // Handle xDS HTTP filters.
+  const auto& hcm = absl::get<XdsListenerResource::HttpConnectionManager>(
+      resolver->current_listener_->listener);
   auto result = XdsRouting::GeneratePerHTTPFilterConfigs(
       static_cast<const GrpcXdsBootstrap&>(resolver->xds_client_->bootstrap())
           .http_filter_registry(),
-      resolver->current_listener_.http_filters,
-      resolver->current_virtual_host_.value(), route, cluster_weight,
+      hcm.http_filters, *resolver->current_virtual_host_, route, cluster_weight,
       resolver->args_);
   if (!result.ok()) return result.status();
   for (const auto& p : result->per_filter_configs) {
@@ -673,7 +674,9 @@ XdsResolver::XdsConfigSelector::XdsConfigSelector(
   const auto& http_filter_registry =
       static_cast<const GrpcXdsBootstrap&>(resolver_->xds_client_->bootstrap())
           .http_filter_registry();
-  for (const auto& http_filter : resolver_->current_listener_.http_filters) {
+  const auto& hcm = absl::get<XdsListenerResource::HttpConnectionManager>(
+      resolver_->current_listener_->listener);
+  for (const auto& http_filter : hcm.http_filters) {
     // Find filter.  This is guaranteed to succeed, because it's checked
     // at config validation time in the XdsApi code.
     const XdsHttpFilterImpl* filter_impl =
@@ -694,7 +697,15 @@ XdsResolver::XdsConfigSelector::~XdsConfigSelector() {
             resolver_.get(), this);
   }
   route_config_data_.reset();
-  resolver_->MaybeRemoveUnusedClusters();
+  if (!IsWorkSerializerDispatchEnabled()) {
+    resolver_->MaybeRemoveUnusedClusters();
+    return;
+  }
+  resolver_->work_serializer_->Run(
+      [resolver = std::move(resolver_)]() {
+        resolver->MaybeRemoveUnusedClusters();
+      },
+      DEBUG_LOCATION);
 }
 
 absl::optional<uint64_t> HeaderHashHelper(
@@ -1006,26 +1017,27 @@ void XdsResolver::ShutdownLocked() {
   }
 }
 
-void XdsResolver::OnListenerUpdate(XdsListenerResource listener) {
+void XdsResolver::OnListenerUpdate(
+    std::shared_ptr<const XdsListenerResource> listener) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
     gpr_log(GPR_INFO, "[xds_resolver %p] received updated listener data", this);
   }
   if (xds_client_ == nullptr) return;
-  auto* hcm = absl::get_if<XdsListenerResource::HttpConnectionManager>(
-      &listener.listener);
+  const auto* hcm = absl::get_if<XdsListenerResource::HttpConnectionManager>(
+      &listener->listener);
   if (hcm == nullptr) {
     return OnError(lds_resource_name_,
                    absl::UnavailableError("not an API listener"));
   }
-  current_listener_ = std::move(*hcm);
-  MatchMutable(
-      &current_listener_.route_config,
+  current_listener_ = std::move(listener);
+  Match(
+      hcm->route_config,
       // RDS resource name
-      [&](std::string* rds_name) {
+      [&](const std::string& rds_name) {
         // If the RDS name changed, update the RDS watcher.
         // Note that this will be true on the initial update, because
         // route_config_name_ will be empty.
-        if (route_config_name_ != *rds_name) {
+        if (route_config_name_ != rds_name) {
           // If we already had a watch (i.e., if the previous config had
           // a different RDS name), stop the previous watch.
           // There will be no previous watch if either (a) this is the
@@ -1038,7 +1050,7 @@ void XdsResolver::OnListenerUpdate(XdsListenerResource listener) {
             route_config_watcher_ = nullptr;
           }
           // Start watch for the new RDS resource name.
-          route_config_name_ = std::move(*rds_name);
+          route_config_name_ = rds_name;
           auto watcher = MakeRefCounted<RouteConfigWatcher>(Ref());
           route_config_watcher_ = watcher.get();
           XdsRouteConfigResourceType::StartWatch(
@@ -1051,7 +1063,7 @@ void XdsResolver::OnListenerUpdate(XdsListenerResource listener) {
         }
       },
       // inlined RouteConfig
-      [&](XdsRouteConfigResource* route_config) {
+      [&](const std::shared_ptr<const XdsRouteConfigResource>& route_config) {
         // If the previous update specified an RDS resource instead of
         // having an inlined RouteConfig, we need to cancel the RDS watch.
         if (route_config_watcher_ != nullptr) {
@@ -1060,7 +1072,7 @@ void XdsResolver::OnListenerUpdate(XdsListenerResource listener) {
           route_config_watcher_ = nullptr;
           route_config_name_.clear();
         }
-        OnRouteConfigUpdate(std::move(*route_config));
+        OnRouteConfigUpdate(route_config);
       });
 }
 
@@ -1081,16 +1093,15 @@ class VirtualHostListIterator : public XdsRouting::VirtualHostListIterator {
   const std::vector<XdsRouteConfigResource::VirtualHost>* virtual_hosts_;
 };
 
-void XdsResolver::OnRouteConfigUpdate(XdsRouteConfigResource rds_update) {
+void XdsResolver::OnRouteConfigUpdate(
+    std::shared_ptr<const XdsRouteConfigResource> rds_update) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
     gpr_log(GPR_INFO, "[xds_resolver %p] received updated route config", this);
   }
-  if (xds_client_ == nullptr) {
-    return;
-  }
+  if (xds_client_ == nullptr) return;
   // Find the relevant VirtualHost from the RouteConfiguration.
   auto vhost_index = XdsRouting::FindVirtualHostForDomain(
-      VirtualHostListIterator(&rds_update.virtual_hosts),
+      VirtualHostListIterator(&rds_update->virtual_hosts),
       data_plane_authority_);
   if (!vhost_index.has_value()) {
     OnError(
@@ -1101,9 +1112,8 @@ void XdsResolver::OnRouteConfigUpdate(XdsRouteConfigResource rds_update) {
     return;
   }
   // Save the virtual host in the resolver.
-  current_virtual_host_ = std::move(rds_update.virtual_hosts[*vhost_index]);
-  cluster_specifier_plugin_map_ =
-      std::move(rds_update.cluster_specifier_plugin_map);
+  current_route_config_ = std::move(rds_update);
+  current_virtual_host_ = &current_route_config_->virtual_hosts[*vhost_index];
   // Send a new result to the channel.
   GenerateResult();
 }
@@ -1130,10 +1140,8 @@ void XdsResolver::OnResourceDoesNotExist(std::string context) {
           "[xds_resolver %p] LDS/RDS resource does not exist -- clearing "
           "update and returning empty service config",
           this);
-  if (xds_client_ == nullptr) {
-    return;
-  }
-  current_virtual_host_.reset();
+  if (xds_client_ == nullptr) return;
+  current_virtual_host_ = nullptr;
   Result result;
   result.addresses.emplace();
   result.service_config = ServiceConfigImpl::Create(args_, "{}");
@@ -1154,7 +1162,8 @@ XdsResolver::CreateServiceConfig() {
           "        \"childPolicy\": %s\n"
           "       }",
           cluster.first,
-          cluster_specifier_plugin_map_[std::string(child_name)]));
+          current_route_config_->cluster_specifier_plugin_map.at(
+              std::string(child_name))));
     } else {
       absl::ConsumePrefix(&child_name, "cluster:");
       clusters.push_back(
@@ -1185,12 +1194,13 @@ XdsResolver::CreateServiceConfig() {
 }
 
 void XdsResolver::GenerateResult() {
-  if (!current_virtual_host_.has_value()) return;
+  if (current_virtual_host_ == nullptr) return;
   // First create XdsConfigSelector, which may add new entries to the cluster
   // state map, and then CreateServiceConfig for LB policies.
-  auto route_config_data =
-      RouteConfigData::Create(this, current_virtual_host_->routes,
-                              current_listener_.http_max_stream_duration);
+  const auto& hcm = absl::get<XdsListenerResource::HttpConnectionManager>(
+      current_listener_->listener);
+  auto route_config_data = RouteConfigData::Create(
+      this, current_virtual_host_->routes, hcm.http_max_stream_duration);
   if (!route_config_data.ok()) {
     OnError("could not create ConfigSelector",
             absl::UnavailableError(route_config_data.status().message()));

data/src/core/ext/filters/client_channel/subchannel.cc

@@ -59,6 +59,8 @@
 #include "src/core/lib/handshaker/proxy_mapper_registry.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/promise/cancel_callback.h"
+#include "src/core/lib/promise/seq.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/surface/channel_stack_type.h"
@@ -133,6 +135,36 @@ size_t ConnectedSubchannel::GetInitialCallSizeEstimate() const {
          channel_stack_->call_stack_size;
 }
 
+ArenaPromise<ServerMetadataHandle> ConnectedSubchannel::MakeCallPromise(
+    CallArgs call_args) {
+  // If not using channelz, we just need to call the channel stack.
+  if (channelz_subchannel() == nullptr) {
+    return channel_stack_->MakeClientCallPromise(std::move(call_args));
+  }
+  // Otherwise, we need to wrap the channel stack promise with code that
+  // handles the channelz updates.
+  return OnCancel(
+      Seq(channel_stack_->MakeClientCallPromise(std::move(call_args)),
+          [self = Ref()](ServerMetadataHandle metadata) {
+            channelz::SubchannelNode* channelz_subchannel =
+                self->channelz_subchannel();
+            GPR_ASSERT(channelz_subchannel != nullptr);
+            if (metadata->get(GrpcStatusMetadata())
+                    .value_or(GRPC_STATUS_UNKNOWN) != GRPC_STATUS_OK) {
+              channelz_subchannel->RecordCallFailed();
+            } else {
+              channelz_subchannel->RecordCallSucceeded();
+            }
+            return metadata;
+          }),
+      [self = Ref()]() {
+        channelz::SubchannelNode* channelz_subchannel =
+            self->channelz_subchannel();
+        GPR_ASSERT(channelz_subchannel != nullptr);
+        channelz_subchannel->RecordCallFailed();
+      });
+}
+
 //
 // SubchannelCall
 //
@@ -431,6 +463,7 @@ Subchannel::Subchannel(SubchannelKey key,
       pollset_set_(grpc_pollset_set_create()),
       connector_(std::move(connector)),
       watcher_list_(this),
+      work_serializer_(args_.GetObjectRef<EventEngine>()),
       backoff_(ParseArgsForBackoffValues(args_, &min_connect_timeout_)),
       event_engine_(args_.GetObjectRef<EventEngine>()) {
   // A grpc_init is added here to ensure that grpc_shutdown does not happen

data/src/core/ext/filters/client_channel/subchannel.h

@@ -54,6 +54,7 @@
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/iomgr/resolved_address.h"
+#include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/connectivity_state.h"
@@ -84,6 +85,8 @@ class ConnectedSubchannel : public RefCounted<ConnectedSubchannel> {
 
   size_t GetInitialCallSizeEstimate() const;
 
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(CallArgs call_args);
+
  private:
   grpc_channel_stack* channel_stack_;
   ChannelArgs args_;
@@ -218,6 +221,8 @@ class Subchannel : public DualRefCounted<Subchannel> {
 
   channelz::SubchannelNode* channelz_node();
 
+  const grpc_resolved_address& address() const { return key_.address(); }
+
   // Starts watching the subchannel's connectivity state.
   // The first callback to the watcher will be delivered ~immediately.
   // Subsequent callbacks will be delivered as the subchannel's state
@@ -267,6 +272,10 @@ class Subchannel : public DualRefCounted<Subchannel> {
   void RemoveDataProducer(DataProducerInterface* data_producer)
       ABSL_LOCKS_EXCLUDED(mu_);
 
+  std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine() {
+    return event_engine_;
+  }
+
  private:
   // A linked list of ConnectivityStateWatcherInterfaces that are monitoring
   // the subchannel's state.

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

@@ -49,8 +49,8 @@
 #include <grpc/support/log.h>
 
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
-#include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
+#include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channelz.h"

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

@@ -55,7 +55,6 @@
 
 #include "src/core/ext/transport/chttp2/transport/context_list_entry.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
-#include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/frame_data.h"
 #include "src/core/ext/transport/chttp2/transport/frame_goaway.h"
 #include "src/core/ext/transport/chttp2/transport/frame_rst_stream.h"
@@ -63,6 +62,7 @@
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 #include "src/core/ext/transport/chttp2/transport/http_trace.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
+#include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/ext/transport/chttp2/transport/ping_abuse_policy.h"
 #include "src/core/ext/transport/chttp2/transport/ping_rate_policy.h"
 #include "src/core/ext/transport/chttp2/transport/varint.h"
@@ -569,10 +569,12 @@ grpc_chttp2_transport::grpc_chttp2_transport(
                            grpc_endpoint_get_peer(ep), ":client_transport"))),
       self_reservation(
           memory_owner.MakeReservation(sizeof(grpc_chttp2_transport))),
-      combiner(grpc_combiner_create()),
+      event_engine(
+          channel_args
+              .GetObjectRef<grpc_event_engine::experimental::EventEngine>()),
+      combiner(grpc_combiner_create(event_engine)),
       state_tracker(is_client ? "client_transport" : "server_transport",
                     GRPC_CHANNEL_READY),
-      is_client(is_client),
       next_stream_id(is_client ? 1 : 2),
       ping_abuse_policy(channel_args),
       ping_rate_policy(channel_args, is_client),
@@ -581,9 +583,7 @@ grpc_chttp2_transport::grpc_chttp2_transport(
           channel_args.GetBool(GRPC_ARG_HTTP2_BDP_PROBE).value_or(true),
           &memory_owner),
       deframe_state(is_client ? GRPC_DTS_FH_0 : GRPC_DTS_CLIENT_PREFIX_0),
-      event_engine(
-          channel_args
-              .GetObjectRef<grpc_event_engine::experimental::EventEngine>()) {
+      is_client(is_client) {
   cl = new grpc_core::ContextList();
   GPR_ASSERT(strlen(GRPC_CHTTP2_CLIENT_CONNECT_STRING) ==
              GRPC_CHTTP2_CLIENT_CONNECT_STRLEN);
@@ -1875,6 +1875,7 @@ static void perform_transport_op_locked(void* stream_op,
   if (op->set_accept_stream) {
     t->accept_stream_cb = op->set_accept_stream_fn;
     t->accept_stream_cb_user_data = op->set_accept_stream_user_data;
+    t->registered_method_matcher_cb = op->set_registered_method_matcher_fn;
   }
 
   if (op->bind_pollset) {
@@ -1944,6 +1945,10 @@ void grpc_chttp2_maybe_complete_recv_initial_metadata(grpc_chttp2_transport* t,
       *s->trailing_metadata_available = true;
       s->trailing_metadata_available = nullptr;
     }
+    if (t->registered_method_matcher_cb != nullptr) {
+      t->registered_method_matcher_cb(t->accept_stream_cb_user_data,
+                                      s->recv_initial_metadata);
+    }
     null_then_sched_closure(&s->recv_initial_metadata_ready);
   }
 }

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

@@ -116,20 +116,21 @@ TransportFlowControl::TransportFlowControl(absl::string_view name,
                           .set_integral_range(10)),
       last_pid_update_(Timestamp::Now()) {}
 
-uint32_t TransportFlowControl::MaybeSendUpdate(bool writing_anyway) {
+uint32_t TransportFlowControl::DesiredAnnounceSize(bool writing_anyway) const {
   const uint32_t target_announced_window =
       static_cast<uint32_t>(target_window());
   if ((writing_anyway || announced_window_ <= target_announced_window / 2) &&
       announced_window_ != target_announced_window) {
-    const uint32_t announce =
-        static_cast<uint32_t>(Clamp(target_announced_window - announced_window_,
-                                    int64_t{0}, kMaxWindowUpdateSize));
-    announced_window_ += announce;
-    return announce;
+    return Clamp(target_announced_window - announced_window_, int64_t{0},
+                 kMaxWindowUpdateSize);
   }
   return 0;
 }
 
+void TransportFlowControl::SentUpdate(uint32_t announce) {
+  announced_window_ += announce;
+}
+
 StreamFlowControl::StreamFlowControl(TransportFlowControl* tfc) : tfc_(tfc) {}
 
 absl::Status StreamFlowControl::IncomingUpdateContext::RecvData(
@@ -170,7 +171,7 @@ int64_t TransportFlowControl::target_window() const {
   return static_cast<uint32_t>(
       std::min(static_cast<int64_t>((1u << 31) - 1),
                announced_stream_total_over_incoming_window_ +
-                   target_initial_window_size_));
+                   std::max<int64_t>(1, target_initial_window_size_)));
 }
 
 FlowControlAction TransportFlowControl::UpdateAction(FlowControlAction action) {
@@ -363,17 +364,15 @@ FlowControlAction TransportFlowControl::PeriodicUpdate() {
   return UpdateAction(action);
 }
 
-uint32_t StreamFlowControl::MaybeSendUpdate() {
+void StreamFlowControl::SentUpdate(uint32_t announce) {
   TransportFlowControl::IncomingUpdateContext tfc_upd(tfc_);
-  const int64_t announce = DesiredAnnounceSize();
   pending_size_ = absl::nullopt;
   tfc_upd.UpdateAnnouncedWindowDelta(&announced_window_delta_, announce);
   GPR_ASSERT(DesiredAnnounceSize() == 0);
   std::ignore = tfc_upd.MakeAction();
-  return static_cast<uint32_t>(announce);
 }
 
-int64_t StreamFlowControl::DesiredAnnounceSize() const {
+uint32_t StreamFlowControl::DesiredAnnounceSize() const {
   int64_t desired_window_delta = [this]() {
     if (min_progress_size_ == 0) {
       if (pending_size_.has_value() &&
@@ -401,22 +400,29 @@ FlowControlAction StreamFlowControl::UpdateAction(FlowControlAction action) {
     // greater). 8kb means we don't send rapidly unnecessarily when the initial
     // window size is small.
     const int64_t hurry_up_size = std::max(
-        static_cast<int64_t>(tfc_->sent_init_window()) / 2, int64_t{8192});
+        static_cast<int64_t>(tfc_->queued_init_window()) / 2, int64_t{8192});
     if (desired_announce_size > hurry_up_size) {
       urgency = FlowControlAction::Urgency::UPDATE_IMMEDIATELY;
     }
     // min_progress_size_ > 0 means we have a reader ready to read.
     if (min_progress_size_ > 0) {
-      // If we're into initial window to receive that data we should wake up and
-      // send an update.
-      if (announced_window_delta_ < 0) {
-        urgency = FlowControlAction::Urgency::UPDATE_IMMEDIATELY;
-      } else if (announced_window_delta_ == 0 &&
-                 tfc_->sent_init_window() == 0) {
-        // Special case when initial window size is zero, meaning that
-        // announced_window_delta cannot become negative (it may already be so
-        // however).
-        urgency = FlowControlAction::Urgency::UPDATE_IMMEDIATELY;
+      if (IsLazierStreamUpdatesEnabled()) {
+        if (announced_window_delta_ <=
+            -static_cast<int64_t>(tfc_->sent_init_window()) / 2) {
+          urgency = FlowControlAction::Urgency::UPDATE_IMMEDIATELY;
+        }
+      } else {
+        // If we're into initial window to receive that data we should wake up
+        // and send an update.
+        if (announced_window_delta_ < 0) {
+          urgency = FlowControlAction::Urgency::UPDATE_IMMEDIATELY;
+        } else if (announced_window_delta_ == 0 &&
+                   tfc_->queued_init_window() == 0) {
+          // Special case when initial window size is zero, meaning that
+          // announced_window_delta cannot become negative (it may already be so
+          // however).
+          urgency = FlowControlAction::Urgency::UPDATE_IMMEDIATELY;
+        }
       }
     }
     action.set_send_stream_update(urgency);

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

@@ -179,7 +179,17 @@ class TransportFlowControl final {
   // else returns zero; writing_anyway indicates if a write would happen
   // regardless of the send - if it is false and this function returns non-zero,
   // this announce will cause a write to occur
-  uint32_t MaybeSendUpdate(bool writing_anyway);
+  uint32_t DesiredAnnounceSize(bool writing_anyway) const;
+  // notify that we've actually sent a stream window update
+  // (should be DesiredAnnounceSize())
+  void SentUpdate(uint32_t announce);
+
+  // Older API: combines getting the DesiredAnnounceSize() with SentUpdate()
+  uint32_t MaybeSendUpdate(bool writing_anyway) {
+    uint32_t n = DesiredAnnounceSize(writing_anyway);
+    SentUpdate(n);
+    return n;
+  }
 
   // Track an update to the incoming flow control counters - that is how many
   // tokens we report to our peer that we're willing to accept.
@@ -260,7 +270,10 @@ class TransportFlowControl final {
   BdpEstimator* bdp_estimator() { return &bdp_estimator_; }
 
   uint32_t acked_init_window() const { return acked_init_window_; }
-  uint32_t sent_init_window() const { return target_initial_window_size_; }
+  uint32_t queued_init_window() const { return target_initial_window_size_; }
+  uint32_t sent_init_window() const { return sent_init_window_; }
+
+  void FlushedSettings() { sent_init_window_ = queued_init_window(); }
 
   FlowControlAction SetAckedInitialWindow(uint32_t value);
 
@@ -319,6 +332,7 @@ class TransportFlowControl final {
       kDefaultPreferredRxCryptoFrameSize;
   int64_t announced_window_ = kDefaultWindow;
   uint32_t acked_init_window_ = kDefaultWindow;
+  uint32_t sent_init_window_ = kDefaultWindow;
 };
 
 // Implementation of flow control that abides to HTTP/2 spec and attempts
@@ -379,7 +393,17 @@ class StreamFlowControl final {
 
   // returns an announce if we should send a stream update to our peer, else
   // returns zero
-  uint32_t MaybeSendUpdate();
+  uint32_t DesiredAnnounceSize() const;
+  // notify that we've actually sent a stream window update
+  // (should be DesiredAnnounceSize())
+  void SentUpdate(uint32_t announce);
+
+  // Older API: combines getting the DesiredAnnounceSize() with SentUpdate()
+  uint32_t MaybeSendUpdate() {
+    uint32_t n = DesiredAnnounceSize();
+    SentUpdate(n);
+    return n;
+  }
 
   int64_t remote_window_delta() const { return remote_window_delta_; }
   int64_t announced_window_delta() const { return announced_window_delta_; }
@@ -393,7 +417,6 @@ class StreamFlowControl final {
   absl::optional<int64_t> pending_size_;
 
   FlowControlAction UpdateAction(FlowControlAction action);
-  int64_t DesiredAnnounceSize() const;
 };
 
 class TestOnlyTransportTargetWindowEstimatesMocker {

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

@@ -29,7 +29,7 @@
 
 #include <grpc/slice.h>
 
-#include "src/core/ext/transport/chttp2/transport/frame.h"
+#include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/slice/slice_buffer.h"

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

@@ -25,7 +25,7 @@
 
 #include <grpc/slice.h>
 
-#include "src/core/ext/transport/chttp2/transport/frame.h"
+#include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/lib/iomgr/error.h"
 
 typedef enum {

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

@@ -24,6 +24,7 @@
 
 #include <algorithm>
 #include <initializer_list>
+#include <string>
 
 #include "absl/container/flat_hash_map.h"
 #include "absl/status/status.h"
@@ -34,6 +35,10 @@
 
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/ext/transport/chttp2/transport/ping_abuse_policy.h"
+#include "src/core/lib/debug/trace.h"
+
+extern grpc_core::TraceFlag grpc_keepalive_trace;
+extern grpc_core::TraceFlag grpc_http_trace;
 
 grpc_slice grpc_chttp2_ping_create(uint8_t ack, uint64_t opaque_8bytes) {
   grpc_slice slice = GRPC_SLICE_MALLOC(9 + 8);
@@ -96,6 +101,10 @@ grpc_error_handle grpc_chttp2_ping_parser_parse(void* parser,
       if (!t->is_client) {
         const bool transport_idle =
             t->keepalive_permit_without_calls == 0 && t->stream_map.empty();
+        if (grpc_keepalive_trace.enabled() || grpc_http_trace.enabled()) {
+          gpr_log(GPR_INFO, "t=%p received ping: %s", t,
+                  t->ping_abuse_policy.GetDebugString(transport_idle).c_str());
+        }
         if (t->ping_abuse_policy.ReceivedOnePing(transport_idle)) {
           grpc_chttp2_exceeded_ping_strikes(t);
         }

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

@@ -25,7 +25,7 @@
 
 #include <grpc/slice.h>
 
-#include "src/core/ext/transport/chttp2/transport/frame.h"
+#include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/lib/iomgr/error.h"
 
 struct grpc_chttp2_ping_parser {

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

@@ -31,9 +31,9 @@
 #include <grpc/slice_buffer.h>
 #include <grpc/support/log.h>
 
-#include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/http_trace.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
+#include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/transport/http2_errors.h"

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

@@ -25,7 +25,7 @@
 
 #include <grpc/slice.h>
 
-#include "src/core/ext/transport/chttp2/transport/frame.h"
+#include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/transport/transport.h"
 

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

@@ -34,10 +34,10 @@
 #include <grpc/support/log.h>
 
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
-#include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/frame_goaway.h"
 #include "src/core/ext/transport/chttp2/transport/http_trace.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
+#include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/debug_location.h"