grpc 1.44.0.pre2 → 1.45.0

data/src/core/ext/xds/xds_listener.cc

@@ -37,6 +37,7 @@
 #include "upb/upb.h"
 #include "upb/upb.hpp"
 
+#include "src/core/ext/xds/xds_common_types.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/gprpp/host_port.h"
@@ -254,12 +255,12 @@ void MaybeLogHttpConnectionManager(
         http_connection_manager_config) {
   if (GRPC_TRACE_FLAG_ENABLED(*context.tracer) &&
       gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
-    const upb_msgdef* msg_type =
+    const upb_MessageDef* msg_type =
         envoy_extensions_filters_network_http_connection_manager_v3_HttpConnectionManager_getmsgdef(
             context.symtab);
     char buf[10240];
-    upb_text_encode(http_connection_manager_config, msg_type, nullptr, 0, buf,
-                    sizeof(buf));
+    upb_TextEncode(http_connection_manager_config, msg_type, nullptr, 0, buf,
+                   sizeof(buf));
     gpr_log(GPR_DEBUG, "[xds_client %p] HttpConnectionManager: %s",
             context.client, buf);
   }
@@ -294,7 +295,7 @@ grpc_error_handle HttpConnectionManagerParse(
         envoy_config_core_v3_HttpProtocolOptions_max_stream_duration(options);
     if (duration != nullptr) {
       http_connection_manager->http_max_stream_duration =
-          Duration::Parse(duration);
+          ParseDuration(duration);
     }
   }
   // Parse filters.
@@ -431,9 +432,11 @@ grpc_error_handle HttpConnectionManagerParse(
       return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "HttpConnectionManager missing config_source for RDS.");
     }
-    if (!envoy_config_core_v3_ConfigSource_has_ads(config_source)) {
+    if (!envoy_config_core_v3_ConfigSource_has_ads(config_source) &&
+        !envoy_config_core_v3_ConfigSource_has_self(config_source)) {
       return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "HttpConnectionManager ConfigSource for RDS does not specify ADS.");
+          "HttpConnectionManager ConfigSource for RDS does not specify ADS "
+          "or SELF.");
     }
     // Get the route_config_name.
     http_connection_manager->route_config_name = UpbStringToStdString(
@@ -448,7 +451,7 @@ grpc_error_handle LdsResourceParseClient(
     const envoy_config_listener_v3_ApiListener* api_listener, bool is_v2,
     XdsListenerResource* lds_update) {
   lds_update->type = XdsListenerResource::ListenerType::kHttpApiListener;
-  const upb_strview encoded_api_listener = google_protobuf_Any_value(
+  const upb_StringView encoded_api_listener = google_protobuf_Any_value(
       envoy_config_listener_v3_ApiListener_api_listener(api_listener));
   const auto* http_connection_manager =
       envoy_extensions_filters_network_http_connection_manager_v3_HttpConnectionManager_parse(
@@ -476,7 +479,7 @@ grpc_error_handle DownstreamTlsContextParse(
       envoy_config_core_v3_TransportSocket_typed_config(transport_socket);
   std::vector<grpc_error_handle> errors;
   if (typed_config != nullptr) {
-    const upb_strview encoded_downstream_tls_context =
+    const upb_StringView encoded_downstream_tls_context =
         google_protobuf_Any_value(typed_config);
     auto* downstream_tls_context_proto =
         envoy_extensions_transport_sockets_tls_v3_DownstreamTlsContext_parse(
@@ -662,7 +665,7 @@ grpc_error_handle FilterChainParse(
         errors.push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
             absl::StrCat("Unsupported filter type ", type_url)));
       } else {
-        const upb_strview encoded_http_connection_manager =
+        const upb_StringView encoded_http_connection_manager =
             google_protobuf_Any_value(typed_config);
         const auto* http_connection_manager =
             envoy_extensions_filters_network_http_connection_manager_v3_HttpConnectionManager_parse(
@@ -987,10 +990,10 @@ void MaybeLogListener(const XdsEncodingContext& context,
                       const envoy_config_listener_v3_Listener* listener) {
   if (GRPC_TRACE_FLAG_ENABLED(*context.tracer) &&
       gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
-    const upb_msgdef* msg_type =
+    const upb_MessageDef* msg_type =
         envoy_config_listener_v3_Listener_getmsgdef(context.symtab);
     char buf[10240];
-    upb_text_encode(listener, msg_type, nullptr, 0, buf, sizeof(buf));
+    upb_TextEncode(listener, msg_type, nullptr, 0, buf, sizeof(buf));
     gpr_log(GPR_DEBUG, "[xds_client %p] Listener: %s", context.client, buf);
   }
 }

data/src/core/ext/xds/xds_listener.h

@@ -207,7 +207,7 @@ class XdsListenerResourceType
 
   bool AllResourcesRequiredInSotW() const override { return true; }
 
-  void InitUpbSymtab(upb_symtab* symtab) const override {
+  void InitUpbSymtab(upb_DefPool* symtab) const override {
     envoy_config_listener_v3_Listener_getmsgdef(symtab);
     envoy_extensions_filters_network_http_connection_manager_v3_HttpConnectionManager_getmsgdef(
         symtab);

data/src/core/ext/xds/xds_resource_type.h

@@ -85,7 +85,7 @@ class XdsResourceType {
   // properly in logs.
   // Note: This won't actually work properly until upb adds support for
   // Any fields in textproto printing (internal b/178821188).
-  virtual void InitUpbSymtab(upb_symtab* symtab) const = 0;
+  virtual void InitUpbSymtab(upb_DefPool* symtab) const = 0;
 
   // Convenience method for checking if resource_type matches this type.
   // Checks against both type_url() and v2_type_url().

data/src/core/ext/xds/xds_route_config.cc

@@ -484,10 +484,10 @@ template <typename ParentType, typename EntryType>
 grpc_error_handle ParseTypedPerFilterConfig(
     const XdsEncodingContext& context, const ParentType* parent,
     const EntryType* (*entry_func)(const ParentType*, size_t*),
-    upb_strview (*key_func)(const EntryType*),
+    upb_StringView (*key_func)(const EntryType*),
     const google_protobuf_Any* (*value_func)(const EntryType*),
     XdsRouteConfigResource::TypedPerFilterConfig* typed_per_filter_config) {
-  size_t filter_it = UPB_MAP_BEGIN;
+  size_t filter_it = kUpb_Map_Begin;
   while (true) {
     const auto* filter_entry = entry_func(parent, &filter_it);
     if (filter_entry == nullptr) break;
@@ -506,7 +506,7 @@ grpc_error_handle ParseTypedPerFilterConfig(
     bool is_optional = false;
     if (filter_type ==
         "type.googleapis.com/envoy.config.route.v3.FilterConfig") {
-      upb_strview any_value = google_protobuf_Any_value(any);
+      upb_StringView any_value = google_protobuf_Any_value(any);
       const auto* filter_config = envoy_config_route_v3_FilterConfig_parse(
           any_value.data, any_value.size, context.arena);
       if (filter_config == nullptr) {
@@ -595,29 +595,21 @@ grpc_error_handle RetryPolicyParse(
           "RouteAction RetryPolicy RetryBackoff missing base interval."));
     } else {
       retry_to_return.retry_back_off.base_interval =
-          Duration::Parse(base_interval);
+          ParseDuration(base_interval);
     }
     const google_protobuf_Duration* max_interval =
         envoy_config_route_v3_RetryPolicy_RetryBackOff_max_interval(backoff);
     Duration max;
     if (max_interval != nullptr) {
-      max = Duration::Parse(max_interval);
+      max = ParseDuration(max_interval);
     } else {
-      // if max interval is not set, it is 10x the base, if the value in nanos
-      // can yield another second, adjust the value in seconds accordingly.
-      max.seconds = retry_to_return.retry_back_off.base_interval.seconds * 10;
-      max.nanos = retry_to_return.retry_back_off.base_interval.nanos * 10;
-      if (max.nanos > 1000000000) {
-        max.seconds += max.nanos / 1000000000;
-        max.nanos = max.nanos % 1000000000;
-      }
+      // if max interval is not set, it is 10x the base.
+      max = 10 * retry_to_return.retry_back_off.base_interval;
     }
     retry_to_return.retry_back_off.max_interval = max;
   } else {
-    retry_to_return.retry_back_off.base_interval.seconds = 0;
-    retry_to_return.retry_back_off.base_interval.nanos = 25000000;
-    retry_to_return.retry_back_off.max_interval.seconds = 0;
-    retry_to_return.retry_back_off.max_interval.nanos = 250000000;
+    retry_to_return.retry_back_off.base_interval = Duration::Milliseconds(25);
+    retry_to_return.retry_back_off.max_interval = Duration::Milliseconds(250);
   }
   if (errors.empty()) {
     *retry = retry_to_return;
@@ -718,7 +710,7 @@ grpc_error_handle RouteActionParse(
                 max_stream_duration);
       }
       if (duration != nullptr) {
-        route->max_stream_duration = Duration::Parse(duration);
+        route->max_stream_duration = ParseDuration(duration);
       }
     }
   }
@@ -827,7 +819,7 @@ grpc_error_handle XdsRouteConfigResource::Parse(
         rds_update->virtual_hosts.back();
     // Parse domains.
     size_t domain_size;
-    upb_strview const* domains = envoy_config_route_v3_VirtualHost_domains(
+    upb_StringView const* domains = envoy_config_route_v3_VirtualHost_domains(
         virtual_hosts[i], &domain_size);
     for (size_t j = 0; j < domain_size; ++j) {
       std::string domain_pattern = UpbStringToStdString(domains[j]);
@@ -941,10 +933,10 @@ void MaybeLogRouteConfiguration(
     const envoy_config_route_v3_RouteConfiguration* route_config) {
   if (GRPC_TRACE_FLAG_ENABLED(*context.tracer) &&
       gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
-    const upb_msgdef* msg_type =
+    const upb_MessageDef* msg_type =
         envoy_config_route_v3_RouteConfiguration_getmsgdef(context.symtab);
     char buf[10240];
-    upb_text_encode(route_config, msg_type, nullptr, 0, buf, sizeof(buf));
+    upb_TextEncode(route_config, msg_type, nullptr, 0, buf, sizeof(buf));
     gpr_log(GPR_DEBUG, "[xds_client %p] RouteConfiguration: %s", context.client,
             buf);
   }

data/src/core/ext/xds/xds_route_config.h

@@ -205,7 +205,7 @@ class XdsRouteConfigResourceType
                                       absl::string_view serialized_resource,
                                       bool /*is_v2*/) const override;
 
-  void InitUpbSymtab(upb_symtab* symtab) const override {
+  void InitUpbSymtab(upb_DefPool* symtab) const override {
     envoy_config_route_v3_RouteConfiguration_getmsgdef(symtab);
   }
 };

data/src/core/ext/xds/xds_routing.cc

@@ -70,7 +70,7 @@ bool DomainMatch(MatchType match_type, absl::string_view domain_pattern_in,
 
 MatchType DomainPatternMatchType(absl::string_view domain_pattern) {
   if (domain_pattern.empty()) return INVALID_MATCH;
-  if (domain_pattern.find('*') == std::string::npos) return EXACT_MATCH;
+  if (!absl::StrContains(domain_pattern, '*')) return EXACT_MATCH;
   if (domain_pattern == "*") return UNIVERSE_MATCH;
   if (domain_pattern[0] == '*') return SUFFIX_MATCH;
   if (domain_pattern[domain_pattern.size() - 1] == '*') return PREFIX_MATCH;

data/src/core/ext/xds/xds_server_config_fetcher.cc

@@ -37,7 +37,8 @@
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
 #include "src/core/lib/security/credentials/xds/xds_credentials.h"
-#include "src/core/lib/slice/slice_utils.h"
+#include "src/core/lib/service_config/service_config_impl.h"
+#include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/server.h"
 #include "src/core/lib/transport/error_utils.h"
@@ -1121,7 +1122,7 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
             "}");
         grpc_error_handle error = GRPC_ERROR_NONE;
         config_selector_route.method_config =
-            ServiceConfig::Create(result.args, json.c_str(), &error);
+            ServiceConfigImpl::Create(result.args, json.c_str(), &error);
         GPR_ASSERT(error == GRPC_ERROR_NONE);
       }
       grpc_channel_args_destroy(result.args);

data/src/core/lib/backoff/backoff.cc

@@ -28,20 +28,17 @@ namespace grpc_core {
 
 BackOff::BackOff(const Options& options) : options_(options) { Reset(); }
 
-grpc_millis BackOff::NextAttemptTime() {
+Timestamp BackOff::NextAttemptTime() {
   if (initial_) {
     initial_ = false;
     return current_backoff_ + ExecCtx::Get()->Now();
   }
-  current_backoff_ = static_cast<grpc_millis>(
-      std::min(current_backoff_ * options_.multiplier(),
-               static_cast<double>(options_.max_backoff())));
-  const double jitter =
-      absl::Uniform(rand_gen_, -options_.jitter() * current_backoff_,
-                    options_.jitter() * current_backoff_);
-  const grpc_millis next_timeout =
-      static_cast<grpc_millis>(current_backoff_ + jitter);
-  return next_timeout + ExecCtx::Get()->Now();
+  current_backoff_ = std::min(current_backoff_ * options_.multiplier(),
+                              options_.max_backoff());
+  const Duration jitter = Duration::FromSecondsAsDouble(
+      absl::Uniform(rand_gen_, -options_.jitter() * current_backoff_.seconds(),
+                    options_.jitter() * current_backoff_.seconds()));
+  return ExecCtx::Get()->Now() + current_backoff_ + jitter;
 }
 
 void BackOff::Reset() {

data/src/core/lib/backoff/backoff.h

@@ -37,7 +37,7 @@ class BackOff {
   explicit BackOff(const Options& options);
 
   /// Returns the time at which the next attempt should start.
-  grpc_millis NextAttemptTime();
+  Timestamp NextAttemptTime();
 
   /// Reset the backoff, so the next value returned by NextAttemptTime()
   /// will be the time of the second attempt (rather than the Nth).
@@ -45,7 +45,7 @@ class BackOff {
 
   class Options {
    public:
-    Options& set_initial_backoff(grpc_millis initial_backoff) {
+    Options& set_initial_backoff(Duration initial_backoff) {
       initial_backoff_ = initial_backoff;
       return *this;
     }
@@ -57,24 +57,24 @@ class BackOff {
       jitter_ = jitter;
       return *this;
     }
-    Options& set_max_backoff(grpc_millis max_backoff) {
+    Options& set_max_backoff(Duration max_backoff) {
       max_backoff_ = max_backoff;
       return *this;
     }
     /// how long to wait after the first failure before retrying
-    grpc_millis initial_backoff() const { return initial_backoff_; }
+    Duration initial_backoff() const { return initial_backoff_; }
     /// factor with which to multiply backoff after a failed retry
     double multiplier() const { return multiplier_; }
     /// amount to randomize backoffs
     double jitter() const { return jitter_; }
     /// maximum time between retries
-    grpc_millis max_backoff() const { return max_backoff_; }
+    Duration max_backoff() const { return max_backoff_; }
 
    private:
-    grpc_millis initial_backoff_;
+    Duration initial_backoff_;
     double multiplier_;
     double jitter_;
-    grpc_millis max_backoff_;
+    Duration max_backoff_;
   };  // class Options
 
  private:
@@ -82,7 +82,7 @@ class BackOff {
   absl::BitGen rand_gen_;
   bool initial_;
   /// current delay before retries
-  grpc_millis current_backoff_;
+  Duration current_backoff_;
 };
 
 }  // namespace grpc_core

data/src/core/lib/channel/call_finalization.h

@@ -0,0 +1,86 @@
+// 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_CHANNEL_CALL_FINALIZATION_H
+#define GRPC_CORE_LIB_CHANNEL_CALL_FINALIZATION_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/resource_quota/arena.h"
+
+namespace grpc_core {
+
+// Call finalization context.
+// Sometimes a filter needs to perform some operation after the last byte of
+// data is flushed to the wire. This context is used to perform that
+// finalization.
+// Filters can register a finalizer by calling Add().
+// The finalizer will be called before the call is destroyed but after
+// the top level promise is completed.
+class CallFinalization {
+ public:
+  // Add a step to the finalization context.
+  // Takes a callable with a signature compatible with:
+  // (const grpc_call_final_info&) -> void.
+  // Finalizers are run in the reverse order they are added.
+  template <typename F>
+  void Add(F&& t) {
+    first_ =
+        GetContext<Arena>()->New<FuncFinalizer<F>>(std::forward<F>(t), first_);
+  }
+
+  void Run(const grpc_call_final_info* final_info) {
+    if (Finalizer* f = absl::exchange(first_, nullptr)) f->Run(final_info);
+  }
+
+ private:
+  // Base class for finalizer implementations.
+  class Finalizer {
+   public:
+    // Run the finalizer and call the destructor of this Finalizer.
+    virtual void Run(const grpc_call_final_info* final_info) = 0;
+
+   protected:
+    ~Finalizer() {}
+  };
+  // Specialization for callable objects.
+  template <typename F>
+  class FuncFinalizer final : public Finalizer {
+   public:
+    FuncFinalizer(F&& f, Finalizer* next)
+        : next_(next), f_(std::forward<F>(f)) {}
+
+    void Run(const grpc_call_final_info* final_info) override {
+      f_(final_info);
+      Finalizer* next = next_;
+      this->~FuncFinalizer();
+      if (next != nullptr) next->Run(final_info);
+    }
+
+   private:
+    Finalizer* next_;
+    F f_;
+  };
+  // The first finalizer in the chain.
+  Finalizer* first_ = nullptr;
+};
+
+template <>
+struct ContextType<CallFinalization> {};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_CHANNEL_CALL_FINALIZATION_H

data/src/core/lib/channel/channel_args.cc

@@ -23,6 +23,7 @@
 #include <limits.h>
 #include <string.h>
 
+#include <map>
 #include <vector>
 
 #include "absl/strings/match.h"
@@ -382,6 +383,65 @@ const grpc_channel_args* RemoveGrpcInternalArgs(const grpc_channel_args* src) {
   }
   return dst;
 }
+
+const grpc_channel_args* UniquifyChannelArgKeys(const grpc_channel_args* src) {
+  if (src == nullptr) return nullptr;
+  std::map<absl::string_view, const grpc_arg*> values;
+  std::map<absl::string_view, std::vector<std::string>> concatenated_values;
+  for (size_t i = 0; i < src->num_args; i++) {
+    absl::string_view key = src->args[i].key;
+    // User-agent strings were traditionally multi-valued and concatenated.
+    // We preserve this behavior for backwards compatibility.
+    if (key == GRPC_ARG_PRIMARY_USER_AGENT_STRING ||
+        key == GRPC_ARG_SECONDARY_USER_AGENT_STRING) {
+      if (src->args[i].type != GRPC_ARG_STRING) {
+        gpr_log(GPR_ERROR, "Channel argument '%s' should be a string",
+                std::string(key).c_str());
+      } else {
+        concatenated_values[key].push_back(src->args[i].value.string);
+      }
+      continue;
+    }
+    auto it = values.find(key);
+    if (it == values.end()) {
+      values[key] = &src->args[i];
+    } else {
+      // Traditional grpc_channel_args_find behavior was to pick the first
+      // value.
+      // For compatibility with existing users, we will do the same here.
+    }
+  }
+  if (values.size() + concatenated_values.size() == src->num_args) {
+    return grpc_channel_args_copy(src);
+  }
+  // Concatenate the concatenated values.
+  std::map<absl::string_view, std::string> concatenated_values_str;
+  for (const auto& concatenated_value : concatenated_values) {
+    concatenated_values_str[concatenated_value.first] =
+        absl::StrJoin(concatenated_value.second, " ");
+  }
+  // Create the result
+  std::vector<grpc_arg> argv;
+  argv.reserve(values.size());
+  for (const auto& a : values) {
+    argv.push_back(*a.second);
+  }
+  for (const auto& a : concatenated_values_str) {
+    argv.push_back(
+        grpc_channel_arg_string_create(const_cast<char*>(a.first.data()),
+                                       const_cast<char*>(a.second.c_str())));
+  }
+  grpc_channel_args args = {argv.size(), argv.data()};
+  // Log that we're mutating things
+  gpr_log(GPR_INFO,
+          "Uniquification pass on channel args is mutating them: {%s} is being "
+          "changed to {%s}",
+          grpc_channel_args_string(src).c_str(),
+          grpc_channel_args_string(&args).c_str());
+  // Return the result (note we need to copy because we're borrowing the args
+  // from src still!)
+  return grpc_channel_args_copy(&args);
+}
 }  // namespace grpc_core
 
 namespace {

data/src/core/lib/channel/channel_args.h

@@ -127,6 +127,8 @@ namespace grpc_core {
  *  Does not take ownership of \a src.
  *  Should be called by any public API that receives channel args. */
 const grpc_channel_args* RemoveGrpcInternalArgs(const grpc_channel_args* src);
+/** Ensure no duplicate channel args, in preparation for moving to a map<> */
+const grpc_channel_args* UniquifyChannelArgKeys(const grpc_channel_args* src);
 }  // namespace grpc_core
 
 // Takes ownership of the old_args

data/src/core/lib/channel/channel_args_preconditioning.cc

@@ -27,6 +27,7 @@ void ChannelArgsPreconditioning::Builder::RegisterStage(Stage stage) {
 ChannelArgsPreconditioning ChannelArgsPreconditioning::Builder::Build() {
   // TODO(ctiller): should probably make this registered too.
   stages_.emplace_back(RemoveGrpcInternalArgs);
+  stages_.emplace_back(UniquifyChannelArgKeys);
 
   ChannelArgsPreconditioning preconditioning;
   preconditioning.stages_ = std::move(stages_);

data/src/core/lib/channel/channel_stack.cc

@@ -104,8 +104,8 @@ grpc_call_element* grpc_call_stack_element(grpc_call_stack* call_stack,
 grpc_error_handle grpc_channel_stack_init(
     int initial_refs, grpc_iomgr_cb_func destroy, void* destroy_arg,
     const grpc_channel_filter** filters, size_t filter_count,
-    const grpc_channel_args* channel_args, grpc_transport* optional_transport,
-    const char* name, grpc_channel_stack* stack) {
+    const grpc_channel_args* channel_args, const char* name,
+    grpc_channel_stack* stack) {
   if (grpc_trace_channel_stack.enabled()) {
     gpr_log(GPR_INFO, "CHANNEL_STACK: init %s", name);
     for (size_t i = 0; i < filter_count; i++) {
@@ -134,7 +134,6 @@ grpc_error_handle grpc_channel_stack_init(
   for (i = 0; i < filter_count; i++) {
     args.channel_stack = stack;
     args.channel_args = channel_args;
-    args.optional_transport = optional_transport;
     args.is_first = i == 0;
     args.is_last = i == (filter_count - 1);
     elems[i].filter = filters[i];

data/src/core/lib/channel/channel_stack.h

@@ -48,15 +48,19 @@
 
 #include <stddef.h>
 
+#include <functional>
+
 #include <grpc/grpc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/time_precise.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/resource_quota/arena.h"
+#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 
 typedef struct grpc_channel_element grpc_channel_element;
@@ -65,11 +69,11 @@ typedef struct grpc_call_element grpc_call_element;
 typedef struct grpc_channel_stack grpc_channel_stack;
 typedef struct grpc_call_stack grpc_call_stack;
 
+#define GRPC_ARG_TRANSPORT "grpc.internal.transport"
+
 struct grpc_channel_element_args {
   grpc_channel_stack* channel_stack;
   const grpc_channel_args* channel_args;
-  /** Transport, iff it is known */
-  grpc_transport* optional_transport;
   int is_first;
   int is_last;
 };
@@ -79,7 +83,7 @@ struct grpc_call_element_args {
   grpc_call_context_element* context;
   const grpc_slice& path;
   gpr_cycle_counter start_time;  // Note: not populated in subchannel stack.
-  grpc_millis deadline;
+  grpc_core::Timestamp deadline;
   grpc_core::Arena* arena;
   grpc_core::CallCombiner* call_combiner;
 };
@@ -109,6 +113,19 @@ struct grpc_channel_filter {
      See grpc_call_next_op on how to call the next element in the stack */
   void (*start_transport_stream_op_batch)(grpc_call_element* elem,
                                           grpc_transport_stream_op_batch* op);
+  /* Create a promise to execute one call.
+     If this is non-null, it may be used in preference to
+     start_transport_stream_op_batch.
+     If this is used in preference to start_transport_stream_op_batch, the
+     following can be omitted also:
+       - calling init_call_elem, destroy_call_elem, set_pollset_or_pollset_set
+       - allocation of memory for call data
+     There is an on-going migration to move all filters to providing this, and
+     then to drop start_transport_stream_op_batch. */
+  grpc_core::ArenaPromise<grpc_core::TrailingMetadata> (*make_call_promise)(
+      grpc_channel_element* elem,
+      grpc_core::ClientInitialMetadata initial_metadata,
+      grpc_core::NextPromiseFactory next_promise_factory);
   /* Called to handle channel level operations - e.g. new calls, or transport
      closure.
      See grpc_channel_next_op on how to call the next element in the stack */
@@ -185,6 +202,18 @@ struct grpc_channel_stack {
   /* Memory required for a call stack (computed at channel stack
      initialization) */
   size_t call_stack_size;
+
+  // Minimal infrastructure to act like a RefCounted thing without converting
+  // everything.
+  // It's likely that we'll want to replace grpc_channel_stack with something
+  // less regimented once the promise conversion completes, so avoiding doing a
+  // full C++-ification for now.
+  void IncrementRefCount();
+  void Unref();
+  grpc_core::RefCountedPtr<grpc_channel_stack> Ref() {
+    IncrementRefCount();
+    return grpc_core::RefCountedPtr<grpc_channel_stack>(this);
+  }
 };
 
 /* A call stack tracks a set of related filters for one call, and guarantees
@@ -221,8 +250,7 @@ size_t grpc_channel_stack_size(const grpc_channel_filter** filters,
 grpc_error_handle grpc_channel_stack_init(
     int initial_refs, grpc_iomgr_cb_func destroy, void* destroy_arg,
     const grpc_channel_filter** filters, size_t filter_count,
-    const grpc_channel_args* args, grpc_transport* optional_transport,
-    const char* name, grpc_channel_stack* stack);
+    const grpc_channel_args* args, const char* name, grpc_channel_stack* stack);
 /* Destroy a channel stack */
 void grpc_channel_stack_destroy(grpc_channel_stack* stack);
 
@@ -271,6 +299,14 @@ void grpc_call_stack_set_pollset_or_pollset_set(grpc_call_stack* call_stack,
   } while (0);
 #endif
 
+inline void grpc_channel_stack::IncrementRefCount() {
+  GRPC_CHANNEL_STACK_REF(this, "smart_pointer");
+}
+
+inline void grpc_channel_stack::Unref() {
+  GRPC_CHANNEL_STACK_UNREF(this, "smart_pointer");
+}
+
 /* Destroy a call stack */
 void grpc_call_stack_destroy(grpc_call_stack* stack,
                              const grpc_call_final_info* final_info,