grpc 1.46.2 → 1.48.0.pre1

data/src/core/lib/transport/parsed_metadata.h

@@ -17,16 +17,23 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <string.h>
+
 #include <cstdint>
+#include <string>
 #include <type_traits>
+#include <utility>
 
+#include "absl/functional/function_ref.h"
 #include "absl/meta/type_traits.h"
 #include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/slice.h>
 
 #include "src/core/lib/gprpp/time.h"
-#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/slice/slice.h"
-#include "src/core/lib/surface/validate_metadata.h"
 
 namespace grpc_core {
 
@@ -371,7 +378,7 @@ ParsedMetadata<MetadataContainer>::KeyValueVTable(absl::string_view key) {
   };
   static const auto set = [](const Buffer& value, MetadataContainer* map) {
     auto* p = static_cast<KV*>(value.pointer);
-    map->AppendUnknown(p->first.as_string_view(), p->second.Ref());
+    map->unknown_.Append(p->first.as_string_view(), p->second.Ref());
   };
   static const auto with_new_value = [](Slice* value, MetadataParseErrorFn,
                                         ParsedMetadata* result) {

data/src/core/lib/transport/status_conversion.cc

@@ -20,6 +20,8 @@
 
 #include "src/core/lib/transport/status_conversion.h"
 
+#include "src/core/lib/iomgr/exec_ctx.h"
+
 grpc_http2_error_code grpc_status_to_http2_error(grpc_status_code status) {
   switch (status) {
     case GRPC_STATUS_OK:

data/src/core/lib/transport/status_conversion.h

@@ -21,9 +21,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/grpc.h>
+#include <grpc/status.h>
 
-#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/transport/http2_errors.h"
 
 /* Conversion of grpc status codes to http2 error codes (for RST_STREAM) */

data/src/core/lib/transport/tcp_connect_handshaker.cc

@@ -0,0 +1,253 @@
+//
+//
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/transport/tcp_connect_handshaker.h"
+
+#include <memory>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/memory/memory.h"
+#include "absl/status/statusor.h"
+
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/slice.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+
+#include "src/core/lib/address_utils/parse_address.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
+#include "src/core/lib/iomgr/polling_entity.h"
+#include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/iomgr/resolved_address.h"
+#include "src/core/lib/iomgr/tcp_client.h"
+#include "src/core/lib/iomgr/tcp_server.h"
+#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/transport/handshaker.h"
+#include "src/core/lib/transport/handshaker_factory.h"
+#include "src/core/lib/transport/handshaker_registry.h"
+#include "src/core/lib/uri/uri_parser.h"
+
+namespace grpc_core {
+
+namespace {
+
+class TCPConnectHandshaker : public Handshaker {
+ public:
+  explicit TCPConnectHandshaker(grpc_pollset_set* pollset_set);
+  void Shutdown(grpc_error_handle why) override;
+  void DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
+                   grpc_closure* on_handshake_done,
+                   HandshakerArgs* args) override;
+  const char* name() const override { return "tcp_connect"; }
+
+ private:
+  ~TCPConnectHandshaker() override;
+  void CleanupArgsForFailureLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  void FinishLocked(grpc_error_handle error) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  static void Connected(void* arg, grpc_error_handle error);
+
+  Mutex mu_;
+  bool shutdown_ ABSL_GUARDED_BY(mu_) = false;
+  // Endpoint and read buffer to destroy after a shutdown.
+  grpc_endpoint* endpoint_to_destroy_ ABSL_GUARDED_BY(mu_) = nullptr;
+  grpc_slice_buffer* read_buffer_to_destroy_ ABSL_GUARDED_BY(mu_) = nullptr;
+  grpc_closure* on_handshake_done_ ABSL_GUARDED_BY(mu_) = nullptr;
+  grpc_pollset_set* interested_parties_ = nullptr;
+  grpc_polling_entity pollent_;
+  HandshakerArgs* args_ = nullptr;
+  bool bind_endpoint_to_pollset_ = false;
+  grpc_resolved_address addr_;
+  grpc_closure connected_;
+};
+
+TCPConnectHandshaker::TCPConnectHandshaker(grpc_pollset_set* pollset_set)
+    : interested_parties_(grpc_pollset_set_create()),
+      pollent_(grpc_polling_entity_create_from_pollset_set(pollset_set)) {
+  // Interested parties might be null for platforms like Apple.
+  // Explicitly check before adding/deleting from pollset_set to handle this
+  // use case.
+  if (interested_parties_ != nullptr) {
+    grpc_polling_entity_add_to_pollset_set(&pollent_, interested_parties_);
+  }
+  GRPC_CLOSURE_INIT(&connected_, Connected, this, grpc_schedule_on_exec_ctx);
+}
+
+void TCPConnectHandshaker::Shutdown(grpc_error_handle why) {
+  // TODO(anramach): After migration to EventEngine, cancel the in-progress
+  // TCP connection attempt.
+  {
+    MutexLock lock(&mu_);
+    if (!shutdown_) {
+      shutdown_ = true;
+      // If we are shutting down while connecting, respond back with
+      // handshake done.
+      // The callback from grpc_tcp_client_connect will perform
+      // the necessary clean up.
+      if (on_handshake_done_ != nullptr) {
+        CleanupArgsForFailureLocked();
+        FinishLocked(
+            GRPC_ERROR_CREATE_FROM_STATIC_STRING("tcp handshaker shutdown"));
+      }
+    }
+  }
+  GRPC_ERROR_UNREF(why);
+}
+
+void TCPConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
+                                       grpc_closure* on_handshake_done,
+                                       HandshakerArgs* args) {
+  {
+    MutexLock lock(&mu_);
+    on_handshake_done_ = on_handshake_done;
+  }
+  GPR_ASSERT(args->endpoint == nullptr);
+  args_ = args;
+  char* address = grpc_channel_args_find_string(
+      args->args, GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS);
+  absl::StatusOr<URI> uri = URI::Parse(address);
+  if (!uri.ok() || !grpc_parse_uri(*uri, &addr_)) {
+    MutexLock lock(&mu_);
+    FinishLocked(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "Resolved address in invalid format"));
+    return;
+  }
+  bind_endpoint_to_pollset_ = grpc_channel_args_find_bool(
+      args->args, GRPC_ARG_TCP_HANDSHAKER_BIND_ENDPOINT_TO_POLLSET, false);
+  const char* args_to_remove[] = {
+      GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS,
+      GRPC_ARG_TCP_HANDSHAKER_BIND_ENDPOINT_TO_POLLSET};
+  // Update args to not contain the args relevant to TCP connect handshaker.
+  grpc_channel_args* channel_args = grpc_channel_args_copy_and_remove(
+      args->args, args_to_remove, GPR_ARRAY_SIZE(args_to_remove));
+  grpc_channel_args_destroy(args->args);
+  args->args = channel_args;
+  // In some implementations, the closure can be flushed before
+  // grpc_tcp_client_connect() returns, and since the closure requires access
+  // to mu_, this can result in a deadlock (see
+  // https://github.com/grpc/grpc/issues/16427 for details).
+  // grpc_tcp_client_connect() will fill endpoint_ with proper contents, and we
+  // make sure that we still exist at that point by taking a ref.
+  Ref().release();  // Ref held by callback.
+  // As we fake the TCP client connection failure when shutdown is called
+  // we don't want to pass args->endpoint directly.
+  // Instead pass endpoint_ and swap this endpoint to
+  // args endpoint on success.
+  grpc_tcp_client_connect(&connected_, &endpoint_to_destroy_,
+                          interested_parties_, args->args, &addr_,
+                          args->deadline);
+}
+
+void TCPConnectHandshaker::Connected(void* arg, grpc_error_handle error) {
+  RefCountedPtr<TCPConnectHandshaker> self(
+      static_cast<TCPConnectHandshaker*>(arg));
+  {
+    MutexLock lock(&self->mu_);
+    if (!GRPC_ERROR_IS_NONE(error) || self->shutdown_) {
+      if (GRPC_ERROR_IS_NONE(error)) {
+        error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("tcp handshaker shutdown");
+      } else {
+        error = GRPC_ERROR_REF(error);
+      }
+      if (self->endpoint_to_destroy_ != nullptr) {
+        grpc_endpoint_shutdown(self->endpoint_to_destroy_,
+                               GRPC_ERROR_REF(error));
+      }
+      if (!self->shutdown_) {
+        self->CleanupArgsForFailureLocked();
+        self->shutdown_ = true;
+        self->FinishLocked(error);
+      } else {
+        // The on_handshake_done_ is already as part of shutdown when connecting
+        // So nothing to be done here other than unrefing the error.
+        GRPC_ERROR_UNREF(error);
+      }
+      return;
+    }
+    GPR_ASSERT(self->endpoint_to_destroy_ != nullptr);
+    self->args_->endpoint = self->endpoint_to_destroy_;
+    self->endpoint_to_destroy_ = nullptr;
+    if (self->bind_endpoint_to_pollset_) {
+      grpc_endpoint_add_to_pollset_set(self->args_->endpoint,
+                                       self->interested_parties_);
+    }
+    self->FinishLocked(GRPC_ERROR_NONE);
+  }
+}
+
+TCPConnectHandshaker::~TCPConnectHandshaker() {
+  if (endpoint_to_destroy_ != nullptr) {
+    grpc_endpoint_destroy(endpoint_to_destroy_);
+  }
+  if (read_buffer_to_destroy_ != nullptr) {
+    grpc_slice_buffer_destroy_internal(read_buffer_to_destroy_);
+    gpr_free(read_buffer_to_destroy_);
+  }
+  grpc_pollset_set_destroy(interested_parties_);
+}
+
+void TCPConnectHandshaker::CleanupArgsForFailureLocked() {
+  read_buffer_to_destroy_ = args_->read_buffer;
+  args_->read_buffer = nullptr;
+  grpc_channel_args_destroy(args_->args);
+  args_->args = nullptr;
+}
+
+void TCPConnectHandshaker::FinishLocked(grpc_error_handle error) {
+  if (interested_parties_ != nullptr) {
+    grpc_polling_entity_del_from_pollset_set(&pollent_, interested_parties_);
+  }
+  ExecCtx::Run(DEBUG_LOCATION, on_handshake_done_, error);
+  on_handshake_done_ = nullptr;
+}
+
+//
+// TCPConnectHandshakerFactory
+//
+
+class TCPConnectHandshakerFactory : public HandshakerFactory {
+ public:
+  void AddHandshakers(const grpc_channel_args* /*args*/,
+                      grpc_pollset_set* interested_parties,
+                      HandshakeManager* handshake_mgr) override {
+    handshake_mgr->Add(
+        MakeRefCounted<TCPConnectHandshaker>(interested_parties));
+  }
+  ~TCPConnectHandshakerFactory() override = default;
+};
+
+}  // namespace
+
+void RegisterTCPConnectHandshaker(CoreConfiguration::Builder* builder) {
+  builder->handshaker_registry()->RegisterHandshakerFactory(
+      true /* at_start */, HANDSHAKER_CLIENT,
+      absl::make_unique<TCPConnectHandshakerFactory>());
+}
+
+}  // namespace grpc_core

data/src/core/lib/transport/tcp_connect_handshaker.h

@@ -0,0 +1,39 @@
+//
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_CORE_LIB_TRANSPORT_TCP_CONNECT_HANDSHAKER_H
+#define GRPC_CORE_LIB_TRANSPORT_TCP_CONNECT_HANDSHAKER_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/config/core_configuration.h"
+
+// Indicates the address that the tcp connect handshaker should connect to.
+#define GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS \
+  "grpc.internal.tcp_handshaker_resolved_address"
+
+// Whether the TCP connect handshaker should bind the endpoint to the pollset.
+#define GRPC_ARG_TCP_HANDSHAKER_BIND_ENDPOINT_TO_POLLSET \
+  "grpc.internal.tcp_handshaker_bind_endpoint_to_pollset"
+
+namespace grpc_core {
+
+// Register the TCP Connect handshaker into the configuration builder.
+void RegisterTCPConnectHandshaker(CoreConfiguration::Builder* builder);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_TRANSPORT_TCP_CONNECT_HANDSHAKER_H

data/src/core/lib/transport/timeout_encoding.cc

@@ -20,14 +20,10 @@
 
 #include "src/core/lib/transport/timeout_encoding.h"
 
-#include <stdio.h>
-#include <string.h>
-
-#include <cstdint>
+#include "absl/base/attributes.h"
 
 #include <grpc/support/log.h>
-
-#include "src/core/lib/gpr/string.h"
+#include <grpc/support/time.h>
 
 namespace grpc_core {
 

data/src/core/lib/transport/timeout_encoding.h

@@ -21,7 +21,11 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/iomgr/exec_ctx.h"
+#include <stdint.h>
+
+#include "absl/types/optional.h"
+
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/slice/slice.h"
 
 namespace grpc_core {

data/src/core/lib/transport/transport.cc

@@ -22,18 +22,12 @@
 
 #include <string.h>
 
-#include <grpc/support/alloc.h>
-#include <grpc/support/atm.h>
-#include <grpc/support/log.h>
-#include <grpc/support/sync.h>
+#include <new>
 
 #include "src/core/lib/gpr/alloc.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr.h"
-#include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/transport/transport_impl.h"
 
 grpc_core::DebugOnlyTraceFlag grpc_trace_stream_refcount(false,
@@ -157,34 +151,38 @@ grpc_endpoint* grpc_transport_get_endpoint(grpc_transport* transport) {
 void grpc_transport_stream_op_batch_finish_with_failure(
     grpc_transport_stream_op_batch* batch, grpc_error_handle error,
     grpc_core::CallCombiner* call_combiner) {
-  if (batch->send_message) {
-    batch->payload->send_message.send_message.reset();
-  }
+  grpc_core::CallCombinerClosureList closures;
+  grpc_transport_stream_op_batch_queue_finish_with_failure(batch, error,
+                                                           &closures);
+  // Execute closures.
+  closures.RunClosures(call_combiner);
+}
+
+void grpc_transport_stream_op_batch_queue_finish_with_failure(
+    grpc_transport_stream_op_batch* batch, grpc_error_handle error,
+    grpc_core::CallCombinerClosureList* closures) {
   if (batch->cancel_stream) {
     GRPC_ERROR_UNREF(batch->payload->cancel_stream.cancel_error);
   }
   // Construct a list of closures to execute.
-  grpc_core::CallCombinerClosureList closures;
   if (batch->recv_initial_metadata) {
-    closures.Add(
+    closures->Add(
         batch->payload->recv_initial_metadata.recv_initial_metadata_ready,
         GRPC_ERROR_REF(error), "failing recv_initial_metadata_ready");
   }
   if (batch->recv_message) {
-    closures.Add(batch->payload->recv_message.recv_message_ready,
-                 GRPC_ERROR_REF(error), "failing recv_message_ready");
+    closures->Add(batch->payload->recv_message.recv_message_ready,
+                  GRPC_ERROR_REF(error), "failing recv_message_ready");
   }
   if (batch->recv_trailing_metadata) {
-    closures.Add(
+    closures->Add(
         batch->payload->recv_trailing_metadata.recv_trailing_metadata_ready,
         GRPC_ERROR_REF(error), "failing recv_trailing_metadata_ready");
   }
   if (batch->on_complete != nullptr) {
-    closures.Add(batch->on_complete, GRPC_ERROR_REF(error),
-                 "failing on_complete");
+    closures->Add(batch->on_complete, GRPC_ERROR_REF(error),
+                  "failing on_complete");
   }
-  // Execute closures.
-  closures.RunClosures(call_combiner);
   GRPC_ERROR_UNREF(error);
 }
 

data/src/core/lib/transport/transport.h

@@ -22,21 +22,45 @@
 #include <grpc/support/port_platform.h>
 
 #include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include <functional>
+#include <string>
+
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include <grpc/impl/codegen/connectivity_state.h>
+#include <grpc/slice.h>
+#include <grpc/status.h>
+#include <grpc/support/atm.h>
+#include <grpc/support/log.h>
 
 #include "src/core/lib/channel/context.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/iomgr/call_combiner.h"
+#include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/iomgr/pollset.h"
-#include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/promise/arena_promise.h"
+#include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/latch.h"
 #include "src/core/lib/resource_quota/arena.h"
-#include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/transport/byte_stream.h"
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/transport_fwd.h"
+
+struct grpc_transport_stream_op_batch_payload;
 
 /* Minimum and maximum protocol accepted versions. */
 #define GRPC_PROTOCOL_VERSION_MAX_MAJOR 2
@@ -46,6 +70,17 @@
 
 #define GRPC_ARG_TRANSPORT "grpc.internal.transport"
 
+/** Internal bit flag for grpc_begin_message's \a flags signaling the use of
+ * compression for the message. (Does not apply for stream compression.) */
+#define GRPC_WRITE_INTERNAL_COMPRESS (0x80000000u)
+/** Internal bit flag for determining whether the message was compressed and had
+ * to be decompressed by the message_decompress filter. (Does not apply for
+ * stream compression.) */
+#define GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED (0x40000000u)
+/** Mask of all valid internal flags. */
+#define GRPC_WRITE_INTERNAL_USED_MASK \
+  (GRPC_WRITE_INTERNAL_COMPRESS | GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED)
+
 namespace grpc_core {
 // TODO(ctiller): eliminate once MetadataHandle is constructable directly.
 namespace promise_filter_detail {
@@ -133,8 +168,6 @@ using NextPromiseFactory =
 
 /* forward declarations */
 
-typedef struct grpc_transport grpc_transport;
-
 /* grpc_stream doesn't actually exist. It's used as a typesafe
    opaque pointer for whatever data the transport wants to track
    for a stream. */
@@ -309,12 +342,6 @@ struct grpc_transport_stream_op_batch_payload {
   explicit grpc_transport_stream_op_batch_payload(
       grpc_call_context_element* context)
       : context(context) {}
-  ~grpc_transport_stream_op_batch_payload() {
-    // We don't really own `send_message`, so release ownership and let the
-    // owner clean the data.
-    (void)send_message.send_message.release();
-  }
-
   struct {
     grpc_metadata_batch* send_initial_metadata = nullptr;
     /** Iff send_initial_metadata != NULL, flags associated with
@@ -343,7 +370,8 @@ struct grpc_transport_stream_op_batch_payload {
     // the op gets down to the transport) takes ownership.
     // The batch's on_complete will not be called until after the byte
     // stream is orphaned.
-    grpc_core::OrphanablePtr<grpc_core::ByteStream> send_message;
+    grpc_core::SliceBuffer* send_message;
+    uint32_t flags = 0;
     // Set by the transport if the stream has been closed for writes. If this
     // is set and send message op is present, we set the operation to be a
     // failure without sending a cancel OP down the stack. This is so that the
@@ -382,10 +410,11 @@ struct grpc_transport_stream_op_batch_payload {
   } recv_initial_metadata;
 
   struct {
-    // Will be set by the transport to point to the byte stream
-    // containing a received message.
-    // Will be NULL if trailing metadata is received instead of a message.
-    grpc_core::OrphanablePtr<grpc_core::ByteStream>* recv_message = nullptr;
+    // Will be set by the transport to point to the byte stream containing a
+    // received message. Will be nullopt if trailing metadata is received
+    // instead of a message.
+    absl::optional<grpc_core::SliceBuffer>* recv_message = nullptr;
+    uint32_t* flags = nullptr;
     // Was this recv_message failed for reasons other than a clean end-of-stream
     bool* call_failed_before_recv_message = nullptr;
     /** Should be enqueued when one message is ready to be processed. */
@@ -514,6 +543,9 @@ void grpc_transport_destroy_stream(grpc_transport* transport,
 void grpc_transport_stream_op_batch_finish_with_failure(
     grpc_transport_stream_op_batch* batch, grpc_error_handle error,
     grpc_core::CallCombiner* call_combiner);
+void grpc_transport_stream_op_batch_queue_finish_with_failure(
+    grpc_transport_stream_op_batch* batch, grpc_error_handle error,
+    grpc_core::CallCombinerClosureList* closures);
 
 std::string grpc_transport_stream_op_batch_string(
     grpc_transport_stream_op_batch* op);

data/src/core/lib/transport/transport_fwd.h

@@ -0,0 +1,20 @@
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_CORE_LIB_TRANSPORT_TRANSPORT_FWD_H
+#define GRPC_CORE_LIB_TRANSPORT_TRANSPORT_FWD_H
+
+typedef struct grpc_transport grpc_transport;
+
+#endif  // GRPC_CORE_LIB_TRANSPORT_TRANSPORT_FWD_H

data/src/core/lib/transport/transport_impl.h

@@ -21,7 +21,18 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
+#include "absl/strings/string_view.h"
+
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
+#include "src/core/lib/iomgr/pollset.h"
+#include "src/core/lib/promise/arena_promise.h"
+#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/lib/transport/transport_fwd.h"
 
 typedef struct grpc_transport_vtable {
   /* Memory required for a single stream element - this is allocated by upper