grpc 1.78.0 → 1.80.0.pre1

data/src/core/channelz/v2tov1/legacy_api.cc

@@ -37,6 +37,16 @@
 namespace grpc_core {
 namespace channelz {
 namespace v2tov1 {
+
+std::string StripAdditionalInfoFromJson(absl::string_view json_str) {
+  auto json = JsonParse(json_str);
+  if (!json.ok()) return std::string(json_str);
+  if (json->type() != Json::Type::kObject) return std::string(json_str);
+  Json::Object object = json->object();
+  object.erase("additionalInfo");
+  return JsonDump(Json::FromObject(std::move(object)));
+}
+
 namespace {
 
 class RegistryEntityFetcher : public EntityFetcher {
@@ -69,61 +79,8 @@ class RegistryEntityFetcher : public EntityFetcher {
   }
 };
 
-template <typename T>
-std::string RenderArray(std::tuple<T, bool> values_and_end,
-                        const std::string& key) {
-  auto& [values, end] = values_and_end;
-  Json::Object object;
-  if (!values.empty()) {
-    // Create list of channels.
-    Json::Array array;
-    for (size_t i = 0; i < values.size(); ++i) {
-      array.emplace_back(values[i]->RenderJson());
-    }
-    object[key] = Json::FromArray(std::move(array));
-  }
-  if (end) {
-    object["end"] = Json::FromBool(true);
-  }
-  return JsonDump(Json::FromObject(std::move(object)));
-}
-
-Json RemoveAdditionalInfo(const Json& json) {
-  switch (json.type()) {
-    case Json::Type::kArray: {
-      Json::Array out;
-      for (const auto& node : json.array()) {
-        out.emplace_back(RemoveAdditionalInfo(node));
-      }
-      return Json::FromArray(std::move(out));
-    } break;
-    case Json::Type::kObject: {
-      Json::Object out;
-      for (const auto& [key, value] : json.object()) {
-        if (key == "additionalInfo") continue;
-        out[key] = RemoveAdditionalInfo(value);
-      }
-      return Json::FromObject(std::move(out));
-    } break;
-    default:
-      return json;
-  }
-}
-
 }  // namespace
 
-std::string StripAdditionalInfoFromJson(absl::string_view json_str) {
-  auto json = JsonParse(json_str);
-  if (!json.ok()) return std::string(json_str);
-  return JsonDump(RemoveAdditionalInfo(*json));
-}
-
-// TODO(ctiller): Temporary hack to remove fields that are objectionable to the
-// protobuf parser (because we've not published them in protobuf yet).
-char* ApplyHacks(const std::string& json_str) {
-  return gpr_strdup(StripAdditionalInfoFromJson(json_str).c_str());
-}
-
 }  // namespace v2tov1
 }  // namespace channelz
 }  // namespace grpc_core
@@ -133,299 +90,199 @@ using grpc_core::channelz::v2tov1::RegistryEntityFetcher;
 
 char* grpc_channelz_get_top_channels(intptr_t start_channel_id) {
   grpc_core::ExecCtx exec_ctx;
-  if (grpc_core::IsChannelzUseV2ForV1ApiEnabled()) {
-    RegistryEntityFetcher fetcher;
-    auto [channels, end] = ChannelzRegistry::GetTopChannels(start_channel_id);
-    grpc_core::Json::Array array;
-    for (const auto& channel_node : channels) {
-      if (channel_node == nullptr) continue;
-      auto serialized_v2 =
-          channel_node->SerializeEntityToString(absl::ZeroDuration());
-      auto serialized_v1 = grpc_core::channelz::v2tov1::ConvertChannel(
-          serialized_v2, fetcher, true);
-      if (!serialized_v1.ok()) {
-        LOG(ERROR) << "Failed to convert channel: " << serialized_v1.status();
-        continue;
-      }
-      auto json = grpc_core::JsonParse(*serialized_v1);
-      if (!json.ok()) {
-        LOG(ERROR) << "Failed to parse converted channel json: "
-                   << json.status();
-        continue;
-      }
-      array.emplace_back(std::move(*json));
+  RegistryEntityFetcher fetcher;
+  auto [channels, end] = ChannelzRegistry::GetTopChannels(start_channel_id);
+  grpc_core::Json::Array array;
+  for (const auto& channel_node : channels) {
+    if (channel_node == nullptr) continue;
+    auto serialized_v2 =
+        channel_node->SerializeEntityToString(absl::ZeroDuration());
+    auto serialized_v1 = grpc_core::channelz::v2tov1::ConvertChannel(
+        serialized_v2, fetcher, true);
+    if (!serialized_v1.ok()) {
+      LOG(ERROR) << "Failed to convert channel: " << serialized_v1.status();
+      continue;
     }
-    grpc_core::Json json = grpc_core::Json::FromObject({
-        {"channel", grpc_core::Json::FromArray(std::move(array))},
-        {"end", grpc_core::Json::FromBool(end)},
-    });
-    std::string json_str = grpc_core::JsonDump(json);
-    return gpr_strdup(json_str.c_str());
-  } else {
-    return grpc_core::channelz::v2tov1::ApplyHacks(
-        grpc_core::channelz::v2tov1::RenderArray(
-            grpc_core::channelz::ChannelzRegistry::GetTopChannels(
-                start_channel_id),
-            "channel"));
-  }
-}
-
-char* grpc_channelz_get_servers(intptr_t start_server_id) {
-  grpc_core::ExecCtx exec_ctx;
-  if (grpc_core::IsChannelzUseV2ForV1ApiEnabled()) {
-    RegistryEntityFetcher fetcher;
-    auto [servers, end] = ChannelzRegistry::GetServers(start_server_id);
-    grpc_core::Json::Array array;
-    for (const auto& server_node : servers) {
-      if (server_node == nullptr) continue;
-      auto serialized_v2 =
-          server_node->SerializeEntityToString(absl::ZeroDuration());
-      auto serialized_v1 = grpc_core::channelz::v2tov1::ConvertServer(
-          serialized_v2, fetcher, true);
-      if (!serialized_v1.ok()) {
-        LOG(ERROR) << "Failed to convert server: " << serialized_v1.status();
-        continue;
-      }
-      auto json = grpc_core::JsonParse(*serialized_v1);
-      if (!json.ok()) {
-        LOG(ERROR) << "Failed to parse converted server json: "
-                   << json.status();
-        continue;
-      }
-      array.emplace_back(std::move(*json));
+    auto json = grpc_core::JsonParse(*serialized_v1);
+    if (!json.ok()) {
+      LOG(ERROR) << "Failed to parse converted channel json: " << json.status();
+      continue;
     }
-    grpc_core::Json json = grpc_core::Json::FromObject({
-        {"server", grpc_core::Json::FromArray(std::move(array))},
-        {"end", grpc_core::Json::FromBool(end)},
-    });
-    std::string json_str = grpc_core::JsonDump(json);
-    return gpr_strdup(json_str.c_str());
-  } else {
-    return grpc_core::channelz::v2tov1::ApplyHacks(
-        grpc_core::channelz::v2tov1::RenderArray(
-            grpc_core::channelz::ChannelzRegistry::GetServers(start_server_id),
-            "server"));
+    array.emplace_back(std::move(*json));
   }
+  grpc_core::Json json = grpc_core::Json::FromObject({
+      {"channel", grpc_core::Json::FromArray(std::move(array))},
+      {"end", grpc_core::Json::FromBool(end)},
+  });
+  std::string json_str = grpc_core::JsonDump(json);
+  return gpr_strdup(json_str.c_str());
 }
 
-char* grpc_channelz_get_server(intptr_t server_id) {
+char* grpc_channelz_get_servers(intptr_t start_server_id) {
   grpc_core::ExecCtx exec_ctx;
-  if (grpc_core::IsChannelzUseV2ForV1ApiEnabled()) {
-    auto server_node = ChannelzRegistry::GetServer(server_id);
-    if (server_node == nullptr) return nullptr;
-    RegistryEntityFetcher fetcher;
+  RegistryEntityFetcher fetcher;
+  auto [servers, end] = ChannelzRegistry::GetServers(start_server_id);
+  grpc_core::Json::Array array;
+  for (const auto& server_node : servers) {
+    if (server_node == nullptr) continue;
     auto serialized_v2 =
         server_node->SerializeEntityToString(absl::ZeroDuration());
     auto serialized_v1 = grpc_core::channelz::v2tov1::ConvertServer(
         serialized_v2, fetcher, true);
     if (!serialized_v1.ok()) {
       LOG(ERROR) << "Failed to convert server: " << serialized_v1.status();
-      return nullptr;
+      continue;
     }
     auto json = grpc_core::JsonParse(*serialized_v1);
     if (!json.ok()) {
       LOG(ERROR) << "Failed to parse converted server json: " << json.status();
-      return nullptr;
-    }
-    grpc_core::Json wrapped_json = grpc_core::Json::FromObject({
-        {"server", std::move(*json)},
-    });
-    std::string json_str = grpc_core::JsonDump(wrapped_json);
-    return gpr_strdup(json_str.c_str());
-  } else {
-    grpc_core::WeakRefCountedPtr<grpc_core::channelz::BaseNode> server_node =
-        grpc_core::channelz::ChannelzRegistry::Get(server_id);
-    if (server_node == nullptr ||
-        server_node->type() !=
-            grpc_core::channelz::BaseNode::EntityType::kServer) {
-      return nullptr;
+      continue;
     }
-    grpc_core::Json json = grpc_core::Json::FromObject({
-        {"server", server_node->RenderJson()},
-    });
-    return grpc_core::channelz::v2tov1::ApplyHacks(
-        grpc_core::JsonDump(json).c_str());
+    array.emplace_back(std::move(*json));
   }
+  grpc_core::Json json = grpc_core::Json::FromObject({
+      {"server", grpc_core::Json::FromArray(std::move(array))},
+      {"end", grpc_core::Json::FromBool(end)},
+  });
+  std::string json_str = grpc_core::JsonDump(json);
+  return gpr_strdup(json_str.c_str());
+}
+
+char* grpc_channelz_get_server(intptr_t server_id) {
+  grpc_core::ExecCtx exec_ctx;
+  auto server_node = ChannelzRegistry::GetServer(server_id);
+  if (server_node == nullptr) return nullptr;
+  RegistryEntityFetcher fetcher;
+  auto serialized_v2 =
+      server_node->SerializeEntityToString(absl::ZeroDuration());
+  auto serialized_v1 =
+      grpc_core::channelz::v2tov1::ConvertServer(serialized_v2, fetcher, true);
+  if (!serialized_v1.ok()) {
+    LOG(ERROR) << "Failed to convert server: " << serialized_v1.status();
+    return nullptr;
+  }
+  auto json = grpc_core::JsonParse(*serialized_v1);
+  if (!json.ok()) {
+    LOG(ERROR) << "Failed to parse converted server json: " << json.status();
+    return nullptr;
+  }
+  grpc_core::Json wrapped_json = grpc_core::Json::FromObject({
+      {"server", std::move(*json)},
+  });
+  std::string json_str = grpc_core::JsonDump(wrapped_json);
+  return gpr_strdup(json_str.c_str());
 }
 
 char* grpc_channelz_get_server_sockets(intptr_t server_id,
                                        intptr_t start_socket_id,
                                        intptr_t max_results) {
   grpc_core::ExecCtx exec_ctx;
-  if (grpc_core::IsChannelzUseV2ForV1ApiEnabled()) {
-    auto server_node = ChannelzRegistry::GetServer(server_id);
-    if (server_node == nullptr) return nullptr;
-    size_t max =
-        max_results == 0 ? std::numeric_limits<size_t>::max() : max_results;
-    auto [sockets, end] = ChannelzRegistry::GetChildrenOfType(
-        start_socket_id, server_node.get(),
-        grpc_core::channelz::BaseNode::EntityType::kSocket, max);
-    grpc_core::Json::Array array;
-    for (const auto& socket_node : sockets) {
-      if (socket_node == nullptr) continue;
-      array.emplace_back(grpc_core::Json::FromObject({
-          {"socketId",
-           grpc_core::Json::FromString(absl::StrCat(socket_node->uuid()))},
-          {"name", grpc_core::Json::FromString(socket_node->name())},
-      }));
-    }
-    grpc_core::Json json = grpc_core::Json::FromObject({
-        {"socketRef", grpc_core::Json::FromArray(std::move(array))},
-        {"end", grpc_core::Json::FromBool(end)},
-    });
-    std::string json_str = grpc_core::JsonDump(json);
-    return gpr_strdup(json_str.c_str());
-  } else {
-    // Validate inputs before handing them of to the renderer.
-    grpc_core::WeakRefCountedPtr<grpc_core::channelz::BaseNode> base_node =
-        grpc_core::channelz::ChannelzRegistry::Get(server_id);
-    if (base_node == nullptr ||
-        base_node->type() !=
-            grpc_core::channelz::BaseNode::EntityType::kServer ||
-        start_socket_id < 0 || max_results < 0) {
-      return nullptr;
-    }
-    // This cast is ok since we have just checked to make sure base_node is
-    // actually a server node.
-    grpc_core::channelz::ServerNode* server_node =
-        static_cast<grpc_core::channelz::ServerNode*>(base_node.get());
-    return grpc_core::channelz::v2tov1::ApplyHacks(
-        server_node->RenderServerSockets(start_socket_id, max_results).c_str());
+  auto server_node = ChannelzRegistry::GetServer(server_id);
+  if (server_node == nullptr) return nullptr;
+  size_t max =
+      max_results == 0 ? std::numeric_limits<size_t>::max() : max_results;
+  auto [sockets, end] = ChannelzRegistry::GetChildrenOfType(
+      start_socket_id, server_node.get(),
+      grpc_core::channelz::BaseNode::EntityType::kSocket, max);
+  grpc_core::Json::Array array;
+  for (const auto& socket_node : sockets) {
+    if (socket_node == nullptr) continue;
+    array.emplace_back(grpc_core::Json::FromObject({
+        {"socketId",
+         grpc_core::Json::FromString(absl::StrCat(socket_node->uuid()))},
+        {"name", grpc_core::Json::FromString(socket_node->name())},
+    }));
   }
+  grpc_core::Json json = grpc_core::Json::FromObject({
+      {"socketRef", grpc_core::Json::FromArray(std::move(array))},
+      {"end", grpc_core::Json::FromBool(end)},
+  });
+  std::string json_str = grpc_core::JsonDump(json);
+  return gpr_strdup(json_str.c_str());
 }
 
 char* grpc_channelz_get_channel(intptr_t channel_id) {
   grpc_core::ExecCtx exec_ctx;
-  if (grpc_core::IsChannelzUseV2ForV1ApiEnabled()) {
-    auto channel_node = ChannelzRegistry::GetChannel(channel_id);
-    if (channel_node == nullptr) return nullptr;
-    RegistryEntityFetcher fetcher;
-    auto serialized_v2 =
-        channel_node->SerializeEntityToString(absl::ZeroDuration());
-    auto serialized_v1 = grpc_core::channelz::v2tov1::ConvertChannel(
-        serialized_v2, fetcher, true);
-    if (!serialized_v1.ok()) {
-      LOG(ERROR) << "Failed to convert channel: " << serialized_v1.status();
-      return nullptr;
-    }
-    auto json = grpc_core::JsonParse(*serialized_v1);
-    if (!json.ok()) {
-      LOG(ERROR) << "Failed to parse converted channel json: " << json.status();
-      return nullptr;
-    }
-    grpc_core::Json wrapped_json = grpc_core::Json::FromObject({
-        {"channel", std::move(*json)},
-    });
-    std::string json_str = grpc_core::JsonDump(wrapped_json);
-    return gpr_strdup(json_str.c_str());
-  } else {
-    grpc_core::WeakRefCountedPtr<grpc_core::channelz::BaseNode> channel_node =
-        grpc_core::channelz::ChannelzRegistry::Get(channel_id);
-    if (channel_node == nullptr ||
-        (channel_node->type() !=
-             grpc_core::channelz::BaseNode::EntityType::kTopLevelChannel &&
-         channel_node->type() !=
-             grpc_core::channelz::BaseNode::EntityType::kInternalChannel)) {
-      return nullptr;
-    }
-    grpc_core::Json json = grpc_core::Json::FromObject({
-        {"channel", channel_node->RenderJson()},
-    });
-    return grpc_core::channelz::v2tov1::ApplyHacks(
-        grpc_core::JsonDump(json).c_str());
+  auto channel_node = ChannelzRegistry::GetChannel(channel_id);
+  if (channel_node == nullptr) return nullptr;
+  RegistryEntityFetcher fetcher;
+  auto serialized_v2 =
+      channel_node->SerializeEntityToString(absl::ZeroDuration());
+  auto serialized_v1 =
+      grpc_core::channelz::v2tov1::ConvertChannel(serialized_v2, fetcher, true);
+  if (!serialized_v1.ok()) {
+    LOG(ERROR) << "Failed to convert channel: " << serialized_v1.status();
+    return nullptr;
   }
+  auto json = grpc_core::JsonParse(*serialized_v1);
+  if (!json.ok()) {
+    LOG(ERROR) << "Failed to parse converted channel json: " << json.status();
+    return nullptr;
+  }
+  grpc_core::Json wrapped_json = grpc_core::Json::FromObject({
+      {"channel", std::move(*json)},
+  });
+  std::string json_str = grpc_core::JsonDump(wrapped_json);
+  return gpr_strdup(json_str.c_str());
 }
 
 char* grpc_channelz_get_subchannel(intptr_t subchannel_id) {
   grpc_core::ExecCtx exec_ctx;
-  if (grpc_core::IsChannelzUseV2ForV1ApiEnabled()) {
-    auto subchannel_node = ChannelzRegistry::GetSubchannel(subchannel_id);
-    if (subchannel_node == nullptr) return nullptr;
-    RegistryEntityFetcher fetcher;
-    auto serialized_v2 =
-        subchannel_node->SerializeEntityToString(absl::ZeroDuration());
-    auto serialized_v1 = grpc_core::channelz::v2tov1::ConvertSubchannel(
-        serialized_v2, fetcher, true);
-    if (!serialized_v1.ok()) {
-      LOG(ERROR) << "Failed to convert subchannel: " << serialized_v1.status();
-      return nullptr;
-    }
-    auto json = grpc_core::JsonParse(*serialized_v1);
-    if (!json.ok()) {
-      LOG(ERROR) << "Failed to parse converted subchannel json: "
-                 << json.status();
-      return nullptr;
-    }
-    grpc_core::Json wrapped_json = grpc_core::Json::FromObject({
-        {"subchannel", std::move(*json)},
-    });
-    std::string json_str = grpc_core::JsonDump(wrapped_json);
-    return gpr_strdup(json_str.c_str());
-  } else {
-    grpc_core::WeakRefCountedPtr<grpc_core::channelz::BaseNode>
-        subchannel_node =
-            grpc_core::channelz::ChannelzRegistry::Get(subchannel_id);
-    if (subchannel_node == nullptr ||
-        subchannel_node->type() !=
-            grpc_core::channelz::BaseNode::EntityType::kSubchannel) {
-      return nullptr;
-    }
-    grpc_core::Json json = grpc_core::Json::FromObject({
-        {"subchannel", subchannel_node->RenderJson()},
-    });
-    return grpc_core::channelz::v2tov1::ApplyHacks(
-        grpc_core::JsonDump(json).c_str());
+  auto subchannel_node = ChannelzRegistry::GetSubchannel(subchannel_id);
+  if (subchannel_node == nullptr) return nullptr;
+  RegistryEntityFetcher fetcher;
+  auto serialized_v2 =
+      subchannel_node->SerializeEntityToString(absl::ZeroDuration());
+  auto serialized_v1 = grpc_core::channelz::v2tov1::ConvertSubchannel(
+      serialized_v2, fetcher, true);
+  if (!serialized_v1.ok()) {
+    LOG(ERROR) << "Failed to convert subchannel: " << serialized_v1.status();
+    return nullptr;
+  }
+  auto json = grpc_core::JsonParse(*serialized_v1);
+  if (!json.ok()) {
+    LOG(ERROR) << "Failed to parse converted subchannel json: "
+               << json.status();
+    return nullptr;
   }
+  grpc_core::Json wrapped_json = grpc_core::Json::FromObject({
+      {"subchannel", std::move(*json)},
+  });
+  std::string json_str = grpc_core::JsonDump(wrapped_json);
+  return gpr_strdup(json_str.c_str());
 }
 
 char* grpc_channelz_get_socket(intptr_t socket_id) {
   grpc_core::ExecCtx exec_ctx;
-  if (grpc_core::IsChannelzUseV2ForV1ApiEnabled()) {
-    auto node = ChannelzRegistry::GetNode(socket_id);
-    if (node == nullptr) return nullptr;
-    RegistryEntityFetcher fetcher;
-    auto serialized_v2 = node->SerializeEntityToString(absl::ZeroDuration());
-    absl::StatusOr<std::string> serialized_v1;
-    if (node->type() == grpc_core::channelz::BaseNode::EntityType::kSocket) {
-      serialized_v1 = grpc_core::channelz::v2tov1::ConvertSocket(serialized_v2,
-                                                                 fetcher, true);
-    } else if (node->type() ==
-               grpc_core::channelz::BaseNode::EntityType::kListenSocket) {
-      serialized_v1 = grpc_core::channelz::v2tov1::ConvertListenSocket(
-          serialized_v2, fetcher, true);
-    } else {
-      return nullptr;
-    }
-    if (!serialized_v1.ok()) {
-      LOG(ERROR) << "Failed to convert socket: " << serialized_v1.status();
-      return nullptr;
-    }
-    // The old API returned a JSON object with a "socket" key.
-    // The new converter returns the socket JSON directly. We need to wrap it.
-    auto json = grpc_core::JsonParse(*serialized_v1);
-    if (!json.ok()) {
-      LOG(ERROR) << "Failed to parse converted socket json: " << json.status();
-      return nullptr;
-    }
-    grpc_core::Json wrapped_json = grpc_core::Json::FromObject({
-        {"socket", std::move(*json)},
-    });
-    std::string json_str = grpc_core::JsonDump(wrapped_json);
-    return gpr_strdup(json_str.c_str());
+  auto node = ChannelzRegistry::GetNode(socket_id);
+  if (node == nullptr) return nullptr;
+  RegistryEntityFetcher fetcher;
+  auto serialized_v2 = node->SerializeEntityToString(absl::ZeroDuration());
+  absl::StatusOr<std::string> serialized_v1;
+  if (node->type() == grpc_core::channelz::BaseNode::EntityType::kSocket) {
+    serialized_v1 = grpc_core::channelz::v2tov1::ConvertSocket(serialized_v2,
+                                                               fetcher, true);
+  } else if (node->type() ==
+             grpc_core::channelz::BaseNode::EntityType::kListenSocket) {
+    serialized_v1 = grpc_core::channelz::v2tov1::ConvertListenSocket(
+        serialized_v2, fetcher, true);
   } else {
-    grpc_core::WeakRefCountedPtr<grpc_core::channelz::BaseNode> socket_node =
-        grpc_core::channelz::ChannelzRegistry::Get(socket_id);
-    if (socket_node == nullptr ||
-        (socket_node->type() !=
-             grpc_core::channelz::BaseNode::EntityType::kSocket &&
-         socket_node->type() !=
-             grpc_core::channelz::BaseNode::EntityType::kListenSocket)) {
-      return nullptr;
-    }
-    grpc_core::Json json = grpc_core::Json::FromObject({
-        {"socket", socket_node->RenderJson()},
-    });
-    return grpc_core::channelz::v2tov1::ApplyHacks(
-        grpc_core::JsonDump(json).c_str());
+    return nullptr;
+  }
+  if (!serialized_v1.ok()) {
+    LOG(ERROR) << "Failed to convert socket: " << serialized_v1.status();
+    return nullptr;
+  }
+  // The old API returned a JSON object with a "socket" key.
+  // The new converter returns the socket JSON directly. We need to wrap it.
+  auto json = grpc_core::JsonParse(*serialized_v1);
+  if (!json.ok()) {
+    LOG(ERROR) << "Failed to parse converted socket json: " << json.status();
+    return nullptr;
   }
+  grpc_core::Json wrapped_json = grpc_core::Json::FromObject({
+      {"socket", std::move(*json)},
+  });
+  std::string json_str = grpc_core::JsonDump(wrapped_json);
+  return gpr_strdup(json_str.c_str());
 }

data/src/core/client_channel/buffered_call.cc

@@ -111,7 +111,8 @@ void BufferedCall::ResumePendingBatchInCallCombiner(
 
 // This is called via the call combiner, so access to calld is synchronized.
 void BufferedCall::Resume(
-    absl::AnyInvocable<void(grpc_transport_stream_op_batch*)> start_batch) {
+    absl::AnyInvocable<void(grpc_transport_stream_op_batch*)> start_batch,
+    YieldCallCombinerPredicate yield_call_combiner_predicate) {
   if (GRPC_TRACE_FLAG_ENABLED_OBJ(*tracer_)) {
     size_t num_batches = 0;
     for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
@@ -133,8 +134,11 @@ void BufferedCall::Resume(
       batch = nullptr;
     }
   }
-  // Note: This will release the call combiner.
-  closures.RunClosures(call_combiner_);
+  if (yield_call_combiner_predicate(closures)) {
+    closures.RunClosures(call_combiner_);
+  } else {
+    closures.RunClosuresWithoutYielding(call_combiner_);
+  }
 }
 
 }  // namespace grpc_core

data/src/core/client_channel/buffered_call.h

@@ -45,11 +45,6 @@ class BufferedCall {
   // Must be called from within the call combiner.
   void EnqueueBatch(grpc_transport_stream_op_batch* batch);
 
-  // Resumes all queued batches by passing them to start_batch().
-  // Must be called from within the call combiner.
-  void Resume(
-      absl::AnyInvocable<void(grpc_transport_stream_op_batch*)> start_batch);
-
   // A predicate type and some useful implementations for Fail().
   typedef bool (*YieldCallCombinerPredicate)(
       const CallCombinerClosureList& closures);
@@ -63,6 +58,17 @@ class BufferedCall {
       const CallCombinerClosureList& closures) {
     return closures.size() > 0;
   }
+
+  // Resumes all queued batches by passing them to start_batch().
+  // Must be called from within the call combiner.
+  void Resume(
+      absl::AnyInvocable<void(grpc_transport_stream_op_batch*)> start_batch) {
+    Resume(std::move(start_batch), YieldCallCombiner);
+  }
+  void Resume(
+      absl::AnyInvocable<void(grpc_transport_stream_op_batch*)> start_batch,
+      YieldCallCombinerPredicate yield_call_combiner_predicate);
+
   // Fails all queued batches.
   // Must be called from within the call combiner.
   // If yield_call_combiner_predicate returns true, assumes responsibility for