grpc 1.42.0 → 1.51.0

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

@@ -21,92 +21,54 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdbool.h>
+#include <stdlib.h>
 
-#include "absl/strings/match.h"
-#include "absl/strings/str_join.h"
+#include <cstdint>
+#include <string>
+#include <utility>
+
+#include "absl/container/inlined_vector.h"
+#include "absl/functional/function_ref.h"
+#include "absl/meta/type_traits.h"
+#include "absl/strings/numbers.h"
+#include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-#include <grpc/grpc.h>
-#include <grpc/slice.h>
-#include <grpc/support/time.h>
+#include <grpc/impl/codegen/compression_types.h>
+#include <grpc/status.h>
+#include <grpc/support/log.h>
 
+#include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/gprpp/chunked_vector.h"
-#include "src/core/lib/gprpp/table.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/surface/validate_metadata.h"
-#include "src/core/lib/transport/metadata.h"
+#include "src/core/lib/gprpp/packed_table.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/resource_quota/arena.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/parsed_metadata.h"
-#include "src/core/lib/transport/static_metadata.h"
-#include "src/core/lib/transport/timeout_encoding.h"
-
-typedef struct grpc_linked_mdelem {
-  grpc_linked_mdelem() {}
-
-  grpc_mdelem md;
-  struct grpc_linked_mdelem* next = nullptr;
-  struct grpc_linked_mdelem* prev = nullptr;
-  void* reserved;
-} grpc_linked_mdelem;
-
-typedef struct grpc_mdelem_list {
-  size_t count;
-  size_t default_count;  // Number of default keys.
-  grpc_linked_mdelem* head;
-  grpc_linked_mdelem* tail;
-} grpc_mdelem_list;
-
-struct grpc_filtered_mdelem {
-  grpc_error_handle error;
-  grpc_mdelem md;
-};
-#define GRPC_FILTERED_ERROR(error) \
-  { (error), GRPC_MDNULL }
-#define GRPC_FILTERED_MDELEM(md) \
-  { GRPC_ERROR_NONE, (md) }
-#define GRPC_FILTERED_REMOVE() \
-  { GRPC_ERROR_NONE, GRPC_MDNULL }
-
-grpc_error_handle grpc_attach_md_to_error(grpc_error_handle src,
-                                          grpc_mdelem md);
 
 namespace grpc_core {
 
 // grpc-timeout metadata trait.
-// ValueType is defined as grpc_millis - an absolute timestamp (i.e. a
+// ValueType is defined as Timestamp - an absolute timestamp (i.e. a
 // deadline!), that is converted to a duration by transports before being
 // sent.
 // TODO(ctiller): Move this elsewhere. During the transition we need to be able
 // to name this in MetadataMap, but ultimately once the transition is done we
 // should not need to.
 struct GrpcTimeoutMetadata {
-  using ValueType = grpc_millis;
-  using MementoType = grpc_millis;
-  static const char* key() { return "grpc-timeout"; }
-  static MementoType ParseMemento(const grpc_slice& value) {
-    grpc_millis timeout;
-    if (GPR_UNLIKELY(!grpc_http2_decode_timeout(value, &timeout))) {
-      timeout = GRPC_MILLIS_INF_FUTURE;
-    }
-    grpc_slice_unref_internal(value);
-    return timeout;
-  }
-  static ValueType MementoToValue(MementoType timeout) {
-    if (timeout == GRPC_MILLIS_INF_FUTURE) {
-      return GRPC_MILLIS_INF_FUTURE;
-    }
-    return grpc_core::ExecCtx::Get()->Now() + timeout;
-  }
-  static grpc_slice Encode(ValueType x) {
-    char timeout[GRPC_HTTP2_TIMEOUT_ENCODE_MIN_BUFSIZE];
-    grpc_http2_encode_timeout(x, timeout);
-    return grpc_slice_from_copied_string(timeout);
-  }
-  static MementoType DisplayValue(MementoType x) { return x; }
+  static constexpr bool kRepeatable = false;
+  using ValueType = Timestamp;
+  using MementoType = Duration;
+  static absl::string_view key() { return "grpc-timeout"; }
+  static MementoType ParseMemento(Slice value, MetadataParseErrorFn on_error);
+  static ValueType MementoToValue(MementoType timeout);
+  static Slice Encode(ValueType x);
+  static std::string DisplayValue(MementoType x) { return x.ToString(); }
 };
 
 // TE metadata trait.
 struct TeMetadata {
+  static constexpr bool kRepeatable = false;
   // HTTP2 says that TE can either be empty or "trailers".
   // Empty means this trait is not included, "trailers" means kTrailers, and
   // kInvalid is used to remember an invalid value.
@@ -115,133 +77,944 @@ struct TeMetadata {
     kInvalid,
   };
   using MementoType = ValueType;
-  static const char* key() { return "te"; }
-  static MementoType ParseMemento(const grpc_slice& value) {
-    auto out = kInvalid;
-    if (grpc_slice_eq(value, GRPC_MDSTR_TRAILERS)) {
-      out = kTrailers;
-    }
-    grpc_slice_unref_internal(value);
-    return out;
-  }
+  static absl::string_view key() { return "te"; }
+  static MementoType ParseMemento(Slice value, MetadataParseErrorFn on_error);
   static ValueType MementoToValue(MementoType te) { return te; }
-  static grpc_slice Encode(ValueType x) {
+  static StaticSlice Encode(ValueType x) {
     GPR_ASSERT(x == kTrailers);
-    return GRPC_MDSTR_TRAILERS;
-  }
-  static const char* DisplayValue(MementoType te) {
-    switch (te) {
-      case ValueType::kTrailers:
-        return "trailers";
-      default:
-        return "<discarded-invalid-value>";
+    return StaticSlice::FromStaticString("trailers");
+  }
+  static const char* DisplayValue(MementoType te);
+};
+
+// content-type metadata trait.
+struct ContentTypeMetadata {
+  static constexpr bool kRepeatable = false;
+  // gRPC says that content-type can be application/grpc[;something]
+  // Core has only ever verified the prefix.
+  // IF we want to start verifying more, we can expand this type.
+  enum ValueType : uint8_t {
+    kApplicationGrpc,
+    kEmpty,
+    kInvalid,
+  };
+  using MementoType = ValueType;
+  static absl::string_view key() { return "content-type"; }
+  static MementoType ParseMemento(Slice value, MetadataParseErrorFn on_error);
+  static ValueType MementoToValue(MementoType content_type) {
+    return content_type;
+  }
+
+  static StaticSlice Encode(ValueType x);
+  static const char* DisplayValue(MementoType content_type);
+};
+
+// scheme metadata trait.
+struct HttpSchemeMetadata {
+  static constexpr bool kRepeatable = false;
+  enum ValueType : uint8_t {
+    kHttp,
+    kHttps,
+    kInvalid,
+  };
+  using MementoType = ValueType;
+  static absl::string_view key() { return ":scheme"; }
+  static MementoType ParseMemento(Slice value, MetadataParseErrorFn on_error) {
+    return Parse(value.as_string_view(), on_error);
+  }
+  static ValueType Parse(absl::string_view value,
+                         MetadataParseErrorFn on_error);
+  static ValueType MementoToValue(MementoType content_type) {
+    return content_type;
+  }
+  static StaticSlice Encode(ValueType x);
+  static const char* DisplayValue(MementoType content_type);
+};
+
+// method metadata trait.
+struct HttpMethodMetadata {
+  static constexpr bool kRepeatable = false;
+  enum ValueType : uint8_t {
+    kPost,
+    kGet,
+    kPut,
+    kInvalid,
+  };
+  using MementoType = ValueType;
+  static absl::string_view key() { return ":method"; }
+  static MementoType ParseMemento(Slice value, MetadataParseErrorFn on_error);
+  static ValueType MementoToValue(MementoType content_type) {
+    return content_type;
+  }
+  static StaticSlice Encode(ValueType x);
+  static const char* DisplayValue(MementoType content_type);
+};
+
+// Base type for metadata pertaining to a single compression algorithm
+// (e.g., "grpc-encoding").
+struct CompressionAlgorithmBasedMetadata {
+  using ValueType = grpc_compression_algorithm;
+  using MementoType = ValueType;
+  static MementoType ParseMemento(Slice value, MetadataParseErrorFn on_error);
+  static ValueType MementoToValue(MementoType x) { return x; }
+  static Slice Encode(ValueType x) {
+    GPR_ASSERT(x != GRPC_COMPRESS_ALGORITHMS_COUNT);
+    return Slice::FromStaticString(CompressionAlgorithmAsString(x));
+  }
+  static const char* DisplayValue(MementoType x) {
+    if (const char* p = CompressionAlgorithmAsString(x)) {
+      return p;
+    } else {
+      return "<discarded-invalid-value>";
     }
   }
 };
 
+// grpc-encoding metadata trait.
+struct GrpcEncodingMetadata : public CompressionAlgorithmBasedMetadata {
+  static constexpr bool kRepeatable = false;
+  static absl::string_view key() { return "grpc-encoding"; }
+};
+
+// grpc-internal-encoding-request metadata trait.
+struct GrpcInternalEncodingRequest : public CompressionAlgorithmBasedMetadata {
+  static constexpr bool kRepeatable = false;
+  static absl::string_view key() { return "grpc-internal-encoding-request"; }
+};
+
+// grpc-accept-encoding metadata trait.
+struct GrpcAcceptEncodingMetadata {
+  static constexpr bool kRepeatable = false;
+  static absl::string_view key() { return "grpc-accept-encoding"; }
+  using ValueType = CompressionAlgorithmSet;
+  using MementoType = ValueType;
+  static MementoType ParseMemento(Slice value, MetadataParseErrorFn) {
+    return CompressionAlgorithmSet::FromString(value.as_string_view());
+  }
+  static ValueType MementoToValue(MementoType x) { return x; }
+  static Slice Encode(ValueType x) { return x.ToSlice(); }
+  static absl::string_view DisplayValue(MementoType x) { return x.ToString(); }
+};
+
+struct SimpleSliceBasedMetadata {
+  using ValueType = Slice;
+  using MementoType = Slice;
+  static MementoType ParseMemento(Slice value, MetadataParseErrorFn) {
+    return value.TakeOwned();
+  }
+  static ValueType MementoToValue(MementoType value) { return value; }
+  static Slice Encode(const ValueType& x) { return x.Ref(); }
+  static absl::string_view DisplayValue(const MementoType& value) {
+    return value.as_string_view();
+  }
+};
+
+// user-agent metadata trait.
+struct UserAgentMetadata : public SimpleSliceBasedMetadata {
+  static constexpr bool kRepeatable = false;
+  static absl::string_view key() { return "user-agent"; }
+};
+
+// grpc-message metadata trait.
+struct GrpcMessageMetadata : public SimpleSliceBasedMetadata {
+  static constexpr bool kRepeatable = false;
+  static absl::string_view key() { return "grpc-message"; }
+};
+
+// host metadata trait.
+struct HostMetadata : public SimpleSliceBasedMetadata {
+  static constexpr bool kRepeatable = false;
+  static absl::string_view key() { return "host"; }
+};
+
+// endpoint-load-metrics-bin metadata trait.
+struct EndpointLoadMetricsBinMetadata : public SimpleSliceBasedMetadata {
+  static constexpr bool kRepeatable = false;
+  static absl::string_view key() { return "endpoint-load-metrics-bin"; }
+};
+
+// grpc-server-stats-bin metadata trait.
+struct GrpcServerStatsBinMetadata : public SimpleSliceBasedMetadata {
+  static constexpr bool kRepeatable = false;
+  static absl::string_view key() { return "grpc-server-stats-bin"; }
+};
+
+// grpc-trace-bin metadata trait.
+struct GrpcTraceBinMetadata : public SimpleSliceBasedMetadata {
+  static constexpr bool kRepeatable = false;
+  static absl::string_view key() { return "grpc-trace-bin"; }
+};
+
+// grpc-tags-bin metadata trait.
+struct GrpcTagsBinMetadata : public SimpleSliceBasedMetadata {
+  static constexpr bool kRepeatable = false;
+  static absl::string_view key() { return "grpc-tags-bin"; }
+};
+
+// :authority metadata trait.
+struct HttpAuthorityMetadata : public SimpleSliceBasedMetadata {
+  static constexpr bool kRepeatable = false;
+  static absl::string_view key() { return ":authority"; }
+};
+
+// :path metadata trait.
+struct HttpPathMetadata : public SimpleSliceBasedMetadata {
+  static constexpr bool kRepeatable = false;
+  static absl::string_view key() { return ":path"; }
+};
+
+// We separate SimpleIntBasedMetadata into two pieces: one that does not
+// depend on the invalid value, and one that does. This allows the compiler to
+// easily see the functions that are shared, and helps reduce code bloat here.
+template <typename Int>
+struct SimpleIntBasedMetadataBase {
+  using ValueType = Int;
+  using MementoType = Int;
+  static ValueType MementoToValue(MementoType value) { return value; }
+  static Slice Encode(ValueType x) { return Slice::FromInt64(x); }
+  static Int DisplayValue(MementoType x) { return x; }
+};
+
+template <typename Int, Int kInvalidValue>
+struct SimpleIntBasedMetadata : public SimpleIntBasedMetadataBase<Int> {
+  static constexpr Int invalid_value() { return kInvalidValue; }
+  static Int ParseMemento(Slice value, MetadataParseErrorFn on_error) {
+    Int out;
+    if (!absl::SimpleAtoi(value.as_string_view(), &out)) {
+      on_error("not an integer", value);
+      out = kInvalidValue;
+    }
+    return out;
+  }
+};
+
+// grpc-status metadata trait.
+struct GrpcStatusMetadata
+    : public SimpleIntBasedMetadata<grpc_status_code, GRPC_STATUS_UNKNOWN> {
+  static constexpr bool kRepeatable = false;
+  static absl::string_view key() { return "grpc-status"; }
+};
+
+// grpc-previous-rpc-attempts metadata trait.
+struct GrpcPreviousRpcAttemptsMetadata
+    : public SimpleIntBasedMetadata<uint32_t, 0> {
+  static constexpr bool kRepeatable = false;
+  static absl::string_view key() { return "grpc-previous-rpc-attempts"; }
+};
+
+// grpc-retry-pushback-ms metadata trait.
+struct GrpcRetryPushbackMsMetadata {
+  static constexpr bool kRepeatable = false;
+  static absl::string_view key() { return "grpc-retry-pushback-ms"; }
+  using ValueType = Duration;
+  using MementoType = Duration;
+  static ValueType MementoToValue(MementoType x) { return x; }
+  static Slice Encode(Duration x) { return Slice::FromInt64(x.millis()); }
+  static int64_t DisplayValue(Duration x) { return x.millis(); }
+  static Duration ParseMemento(Slice value, MetadataParseErrorFn on_error);
+};
+
+// :status metadata trait.
+// TODO(ctiller): consider moving to uint16_t
+struct HttpStatusMetadata : public SimpleIntBasedMetadata<uint32_t, 0> {
+  static constexpr bool kRepeatable = false;
+  static absl::string_view key() { return ":status"; }
+};
+
+// "secret" metadata trait used to pass load balancing token between filters.
+// This should not be exposed outside of gRPC core.
+class GrpcLbClientStats;
+
+struct GrpcLbClientStatsMetadata {
+  static constexpr bool kRepeatable = false;
+  static absl::string_view key() { return "grpclb_client_stats"; }
+  using ValueType = GrpcLbClientStats*;
+  using MementoType = ValueType;
+  static ValueType MementoToValue(MementoType value) { return value; }
+  static Slice Encode(ValueType) { abort(); }
+  static const char* DisplayValue(MementoType) { return "<internal-lb-stats>"; }
+  static MementoType ParseMemento(Slice, MetadataParseErrorFn) {
+    return nullptr;
+  }
+};
+
+// lb-token metadata
+struct LbTokenMetadata : public SimpleSliceBasedMetadata {
+  static constexpr bool kRepeatable = false;
+  static absl::string_view key() { return "lb-token"; }
+};
+
+// lb-cost-bin metadata
+struct LbCostBinMetadata {
+  static constexpr bool kRepeatable = true;
+  static absl::string_view key() { return "lb-cost-bin"; }
+  struct ValueType {
+    double cost;
+    std::string name;
+  };
+  using MementoType = ValueType;
+  static ValueType MementoToValue(MementoType value) { return value; }
+  static Slice Encode(const ValueType& x);
+  static std::string DisplayValue(MementoType x);
+  static MementoType ParseMemento(Slice value, MetadataParseErrorFn on_error);
+};
+
+// Annotation added by a transport to note whether a failed request was never
+// placed on the wire, or never seen by a server.
+struct GrpcStreamNetworkState {
+  static absl::string_view DebugKey() { return "GrpcStreamNetworkState"; }
+  static constexpr bool kRepeatable = false;
+  enum ValueType : uint8_t {
+    kNotSentOnWire,
+    kNotSeenByServer,
+  };
+  static std::string DisplayValue(ValueType x);
+};
+
+// Annotation added by a server transport to note the peer making a request.
+struct PeerString {
+  static absl::string_view DebugKey() { return "PeerString"; }
+  static constexpr bool kRepeatable = false;
+  using ValueType = absl::string_view;
+  static std::string DisplayValue(ValueType x);
+};
+
+// Annotation added by various systems to describe the reason for a failure.
+struct GrpcStatusContext {
+  static absl::string_view DebugKey() { return "GrpcStatusContext"; }
+  static constexpr bool kRepeatable = true;
+  using ValueType = std::string;
+  static const std::string& DisplayValue(const std::string& x);
+};
+
+// Annotation added by a transport to note that the status came from the wire.
+struct GrpcStatusFromWire {
+  static absl::string_view DebugKey() { return "GrpcStatusFromWire"; }
+  static constexpr bool kRepeatable = false;
+  using ValueType = bool;
+  static absl::string_view DisplayValue(bool x) { return x ? "true" : "false"; }
+};
+
+// Annotation added by client surface code to denote wait-for-ready state
+struct WaitForReady {
+  struct ValueType {
+    bool value = false;
+    bool explicitly_set = false;
+  };
+  static absl::string_view DebugKey() { return "WaitForReady"; }
+  static constexpr bool kRepeatable = false;
+  static std::string DisplayValue(ValueType x);
+};
+
 namespace metadata_detail {
 
-// Inner implementation of MetadataMap<Container>::Parse()
-// Recursive in terms of metadata trait, tries each known type in order by doing
-// a string comparison on key, and if that key is found parses it. If not found,
-// calls not_found to generate the result value.
-template <typename Container, typename... Traits>
-struct ParseHelper;
-
-template <typename Container, typename Trait, typename... Traits>
-struct ParseHelper<Container, Trait, Traits...> {
-  template <typename NotFound>
-  static ParsedMetadata<Container> Parse(absl::string_view key,
-                                         const grpc_slice& value,
-                                         NotFound not_found) {
+// Build a key/value formatted debug string.
+// Output looks like 'key1: value1, key2: value2'
+// The string is expected to be readable, but not necessarily parsable.
+class DebugStringBuilder {
+ public:
+  // Add one key/value pair to the output.
+  void Add(absl::string_view key, absl::string_view value);
+
+  // Finalize the output and return the string.
+  // Subsequent Add calls are UB.
+  std::string TakeOutput() { return std::move(out_); }
+
+ private:
+  std::string out_;
+};
+
+// IsEncodable: Given a trait, determine if that trait is encodable, or is
+// just a value attached to a MetadataMap. We use the presence of the key()
+// static method to determine if a trait is encodable or not - encodable
+// traits have string names, and non-encodable traits do not.
+template <typename Trait, typename Ignored = void>
+struct IsEncodableTrait {
+  static const bool value = false;
+};
+
+template <typename Trait>
+struct IsEncodableTrait<Trait, absl::void_t<decltype(Trait::key())>> {
+  static const bool value = true;
+};
+
+// Helper type - maps a string name to a trait.
+template <typename MustBeVoid, typename... Traits>
+struct NameLookup;
+
+template <typename Trait, typename... Traits>
+struct NameLookup<absl::enable_if_t<IsEncodableTrait<Trait>::value, void>,
+                  Trait, Traits...> {
+  // Call op->Found(Trait()) if op->name == Trait::key() for some Trait in
+  // Traits. If not found, call op->NotFound().
+  template <typename Op>
+  static auto Lookup(absl::string_view key, Op* op)
+      -> decltype(op->Found(Trait())) {
     if (key == Trait::key()) {
-      return ParsedMetadata<Container>(
-          Trait(), Trait::ParseMemento(value),
-          ParsedMetadata<Container>::TransportSize(key.size(),
-                                                   GRPC_SLICE_LENGTH(value)));
+      return op->Found(Trait());
     }
-    return ParseHelper<Container, Traits...>::Parse(key, value, not_found);
+    return NameLookup<void, Traits...>::Lookup(key, op);
+  }
+};
+
+template <typename Trait, typename... Traits>
+struct NameLookup<absl::enable_if_t<!IsEncodableTrait<Trait>::value, void>,
+                  Trait, Traits...> {
+  template <typename Op>
+  static auto Lookup(absl::string_view key, Op* op)
+      -> decltype(NameLookup<void, Traits...>::Lookup(key, op)) {
+    return NameLookup<void, Traits...>::Lookup(key, op);
+  }
+};
+
+template <>
+struct NameLookup<void> {
+  template <typename Op>
+  static auto Lookup(absl::string_view key, Op* op)
+      -> decltype(op->NotFound(key)) {
+    return op->NotFound(key);
+  }
+};
+
+// Helper to take a slice to a memento to a value.
+// By splitting this part out we can scale code size as the number of
+// (memento, value) types, rather than as the number of traits.
+template <typename ParseMementoFn, typename MementoToValueFn>
+struct ParseValue {
+  template <ParseMementoFn parse_memento, MementoToValueFn memento_to_value>
+  static GPR_ATTRIBUTE_NOINLINE auto Parse(Slice* value,
+                                           MetadataParseErrorFn on_error)
+      -> decltype(memento_to_value(parse_memento(std::move(*value),
+                                                 on_error))) {
+    return memento_to_value(parse_memento(std::move(*value), on_error));
+  }
+};
+
+// This is an "Op" type for NameLookup.
+// Used for MetadataMap::Parse, its Found/NotFound methods turn a slice into a
+// ParsedMetadata object.
+template <typename Container>
+class ParseHelper {
+ public:
+  ParseHelper(Slice value, MetadataParseErrorFn on_error, size_t transport_size)
+      : value_(std::move(value)),
+        on_error_(on_error),
+        transport_size_(transport_size) {}
+
+  template <typename Trait>
+  GPR_ATTRIBUTE_NOINLINE ParsedMetadata<Container> Found(Trait trait) {
+    return ParsedMetadata<Container>(
+        trait,
+        ParseValueToMemento<typename Trait::MementoType, Trait::ParseMemento>(),
+        static_cast<uint32_t>(transport_size_));
   }
+
+  GPR_ATTRIBUTE_NOINLINE ParsedMetadata<Container> NotFound(
+      absl::string_view key) {
+    return ParsedMetadata<Container>(Slice::FromCopiedString(key),
+                                     std::move(value_));
+  }
+
+ private:
+  template <typename T, T (*parse_memento)(Slice, MetadataParseErrorFn)>
+  GPR_ATTRIBUTE_NOINLINE T ParseValueToMemento() {
+    return parse_memento(std::move(value_), on_error_);
+  }
+
+  Slice value_;
+  MetadataParseErrorFn on_error_;
+  const size_t transport_size_;
 };
 
+// This is an "Op" type for NameLookup.
+// Used for MetadataMap::Append, its Found/NotFound methods turn a slice into
+// a value and add it to a container.
 template <typename Container>
-struct ParseHelper<Container> {
-  template <typename NotFound>
-  static ParsedMetadata<Container> Parse(absl::string_view, const grpc_slice&,
-                                         NotFound not_found) {
-    return not_found();
+class AppendHelper {
+ public:
+  AppendHelper(Container* container, Slice value, MetadataParseErrorFn on_error)
+      : container_(container), value_(std::move(value)), on_error_(on_error) {}
+
+  template <typename Trait>
+  GPR_ATTRIBUTE_NOINLINE void Found(Trait trait) {
+    container_->Set(
+        trait, ParseValue<decltype(Trait::ParseMemento),
+                          decltype(Trait::MementoToValue)>::
+                   template Parse<Trait::ParseMemento, Trait::MementoToValue>(
+                       &value_, on_error_));
   }
+
+  GPR_ATTRIBUTE_NOINLINE void NotFound(absl::string_view key) {
+    container_->unknown_.Append(key, std::move(value_));
+  }
+
+ private:
+  Container* const container_;
+  Slice value_;
+  MetadataParseErrorFn on_error_;
 };
 
-// Inner implementation of MetadataMap<Container>::Append()
-// Recursive in terms of metadata trait, tries each known type in order by doing
-// a string comparison on key, and if that key is found sets it. If not found,
-// calls not_found to append generically.
-template <typename Container, typename... Traits>
-struct AppendHelper;
-
-template <typename Container, typename Trait, typename... Traits>
-struct AppendHelper<Container, Trait, Traits...> {
-  template <typename NotFound>
-  static void Append(Container* container, absl::string_view key,
-                     const grpc_slice& value, NotFound not_found) {
-    if (key == Trait::key()) {
-      container->Set(Trait(),
-                     Trait::MementoToValue(Trait::ParseMemento(value)));
-      return;
-    }
-    AppendHelper<Container, Traits...>::Append(container, key, value,
-                                               not_found);
+// This is an "Op" type for NameLookup.
+// Used for MetadataMap::Remove, its Found/NotFound methods remove a key from
+// the container.
+template <typename Container>
+class RemoveHelper {
+ public:
+  explicit RemoveHelper(Container* container) : container_(container) {}
+
+  template <typename Trait>
+  GPR_ATTRIBUTE_NOINLINE void Found(Trait trait) {
+    container_->Remove(trait);
+  }
+
+  GPR_ATTRIBUTE_NOINLINE void NotFound(absl::string_view key) {
+    container_->unknown_.Remove(key);
   }
+
+ private:
+  Container* const container_;
 };
 
+// This is an "Op" type for NameLookup.
+// Used for MetadataMap::GetStringValue, its Found/NotFound methods generated
+// a string value from the container.
 template <typename Container>
-struct AppendHelper<Container> {
-  template <typename NotFound>
-  static void Append(Container*, absl::string_view, const grpc_slice&,
-                     NotFound not_found) {
-    not_found();
+class GetStringValueHelper {
+ public:
+  explicit GetStringValueHelper(const Container* container,
+                                std::string* backing)
+      : container_(container), backing_(backing) {}
+
+  template <typename Trait>
+  GPR_ATTRIBUTE_NOINLINE absl::enable_if_t<
+      Trait::kRepeatable == false &&
+          std::is_same<Slice, typename Trait::ValueType>::value,
+      absl::optional<absl::string_view>>
+  Found(Trait) {
+    const auto* value = container_->get_pointer(Trait());
+    if (value == nullptr) return absl::nullopt;
+    return value->as_string_view();
+  }
+
+  template <typename Trait>
+  GPR_ATTRIBUTE_NOINLINE absl::enable_if_t<
+      Trait::kRepeatable == true &&
+          !std::is_same<Slice, typename Trait::ValueType>::value,
+      absl::optional<absl::string_view>>
+  Found(Trait) {
+    const auto* value = container_->get_pointer(Trait());
+    if (value == nullptr) return absl::nullopt;
+    backing_->clear();
+    for (const auto& v : *value) {
+      if (!backing_->empty()) backing_->push_back(',');
+      auto new_segment = Trait::Encode(v);
+      backing_->append(new_segment.begin(), new_segment.end());
+    }
+    return *backing_;
+  }
+
+  template <typename Trait>
+  GPR_ATTRIBUTE_NOINLINE absl::enable_if_t<
+      Trait::kRepeatable == false &&
+          !std::is_same<Slice, typename Trait::ValueType>::value,
+      absl::optional<absl::string_view>>
+  Found(Trait) {
+    const auto* value = container_->get_pointer(Trait());
+    if (value == nullptr) return absl::nullopt;
+    *backing_ = std::string(Trait::Encode(*value).as_string_view());
+    return *backing_;
+  }
+
+  GPR_ATTRIBUTE_NOINLINE absl::optional<absl::string_view> NotFound(
+      absl::string_view key) {
+    return container_->unknown_.GetStringValue(key, backing_);
+  }
+
+ private:
+  const Container* const container_;
+  std::string* backing_;
+};
+
+// Sink for key value logs
+using LogFn = absl::FunctionRef<void(absl::string_view, absl::string_view)>;
+
+template <typename T>
+struct AdaptDisplayValueToLog {
+  static std::string ToString(const T& value) { return std::to_string(value); }
+};
+
+template <>
+struct AdaptDisplayValueToLog<std::string> {
+  static std::string ToString(const std::string& value) { return value; }
+};
+
+template <>
+struct AdaptDisplayValueToLog<const std::string&> {
+  static std::string ToString(const std::string& value) { return value; }
+};
+
+template <>
+struct AdaptDisplayValueToLog<absl::string_view> {
+  static std::string ToString(absl::string_view value) {
+    return std::string(value);
+  }
+};
+
+template <>
+struct AdaptDisplayValueToLog<Slice> {
+  static std::string ToString(Slice value) {
+    return std::string(value.as_string_view());
+  }
+};
+
+template <>
+struct AdaptDisplayValueToLog<StaticSlice> {
+  static absl::string_view ToString(StaticSlice value) {
+    return value.as_string_view();
+  }
+};
+
+template <typename T, typename U, typename V>
+GPR_ATTRIBUTE_NOINLINE void LogKeyValueTo(absl::string_view key, const T& value,
+                                          V (*display_value)(U), LogFn log_fn) {
+  log_fn(key, AdaptDisplayValueToLog<V>::ToString(display_value(value)));
+}
+
+// Generate a strong type for metadata values per trait.
+template <typename Which, typename Ignored = void>
+struct Value;
+
+template <typename Which>
+struct Value<Which, absl::enable_if_t<Which::kRepeatable == false &&
+                                          IsEncodableTrait<Which>::value,
+                                      void>> {
+  Value() = default;
+  explicit Value(const typename Which::ValueType& value) : value(value) {}
+  explicit Value(typename Which::ValueType&& value)
+      : value(std::forward<typename Which::ValueType>(value)) {}
+  Value(const Value&) = delete;
+  Value& operator=(const Value&) = delete;
+  Value(Value&&) noexcept = default;
+  Value& operator=(Value&& other) noexcept {
+    value = std::move(other.value);
+    return *this;
+  }
+  template <typename Encoder>
+  void EncodeTo(Encoder* encoder) const {
+    encoder->Encode(Which(), value);
+  }
+  template <typename Encoder>
+  void VisitWith(Encoder* encoder) const {
+    return EncodeTo(encoder);
+  }
+  void LogTo(LogFn log_fn) const {
+    LogKeyValueTo(Which::key(), value, Which::Encode, log_fn);
+  }
+  using StorageType = typename Which::ValueType;
+  GPR_NO_UNIQUE_ADDRESS StorageType value;
+};
+
+template <typename Which>
+struct Value<Which, absl::enable_if_t<Which::kRepeatable == false &&
+                                          !IsEncodableTrait<Which>::value,
+                                      void>> {
+  Value() = default;
+  explicit Value(const typename Which::ValueType& value) : value(value) {}
+  explicit Value(typename Which::ValueType&& value)
+      : value(std::forward<typename Which::ValueType>(value)) {}
+  Value(const Value&) = delete;
+  Value& operator=(const Value&) = delete;
+  Value(Value&&) noexcept = default;
+  Value& operator=(Value&& other) noexcept {
+    value = std::move(other.value);
+    return *this;
+  }
+  template <typename Encoder>
+  void EncodeTo(Encoder*) const {}
+  template <typename Encoder>
+  void VisitWith(Encoder* encoder) const {
+    encoder->Encode(Which(), value);
+  }
+  void LogTo(LogFn log_fn) const {
+    LogKeyValueTo(Which::DebugKey(), value, Which::DisplayValue, log_fn);
+  }
+  using StorageType = typename Which::ValueType;
+  GPR_NO_UNIQUE_ADDRESS StorageType value;
+};
+
+template <typename Which>
+struct Value<Which, absl::enable_if_t<Which::kRepeatable == true &&
+                                          IsEncodableTrait<Which>::value,
+                                      void>> {
+  Value() = default;
+  explicit Value(const typename Which::ValueType& value) {
+    this->value.push_back(value);
+  }
+  explicit Value(typename Which::ValueType&& value) {
+    this->value.emplace_back(std::forward<typename Which::ValueType>(value));
+  }
+  Value(const Value&) = delete;
+  Value& operator=(const Value&) = delete;
+  Value(Value&& other) noexcept : value(std::move(other.value)) {}
+  Value& operator=(Value&& other) noexcept {
+    value = std::move(other.value);
+    return *this;
+  }
+  template <typename Encoder>
+  void EncodeTo(Encoder* encoder) const {
+    for (const auto& v : value) {
+      encoder->Encode(Which(), v);
+    }
+  }
+  template <typename Encoder>
+  void VisitWith(Encoder* encoder) const {
+    return EncodeTo(encoder);
+  }
+  void LogTo(LogFn log_fn) const {
+    for (const auto& v : value) {
+      LogKeyValueTo(Which::key(), v, Which::Encode, log_fn);
+    }
+  }
+  using StorageType = absl::InlinedVector<typename Which::ValueType, 1>;
+  StorageType value;
+};
+
+template <typename Which>
+struct Value<Which, absl::enable_if_t<Which::kRepeatable == true &&
+                                          !IsEncodableTrait<Which>::value,
+                                      void>> {
+  Value() = default;
+  explicit Value(const typename Which::ValueType& value) {
+    this->value.push_back(value);
+  }
+  explicit Value(typename Which::ValueType&& value) {
+    this->value.emplace_back(std::forward<typename Which::ValueType>(value));
+  }
+  Value(const Value&) = delete;
+  Value& operator=(const Value&) = delete;
+  Value(Value&& other) noexcept : value(std::move(other.value)) {}
+  Value& operator=(Value&& other) noexcept {
+    value = std::move(other.value);
+    return *this;
   }
+  template <typename Encoder>
+  void EncodeTo(Encoder*) const {}
+  template <typename Encoder>
+  void VisitWith(Encoder* encoder) const {
+    for (const auto& v : value) {
+      encoder->Encode(Which(), v);
+    }
+  }
+  void LogTo(LogFn log_fn) const {
+    for (const auto& v : value) {
+      LogKeyValueTo(Which::DebugKey(), v, Which::DisplayValue, log_fn);
+    }
+  }
+  using StorageType = absl::InlinedVector<typename Which::ValueType, 1>;
+  StorageType value;
+};
+
+// Encoder to copy some metadata
+template <typename Output>
+class CopySink {
+ public:
+  explicit CopySink(Output* dst) : dst_(dst) {}
+
+  template <class T, class V>
+  void Encode(T trait, V value) {
+    dst_->Set(trait, value);
+  }
+
+  template <class T>
+  void Encode(T trait, const Slice& value) {
+    dst_->Set(trait, std::move(value.AsOwned()));
+  }
+
+  void Encode(const Slice& key, const Slice& value) {
+    dst_->unknown_.Append(key.as_string_view(), value.Ref());
+  }
+
+ private:
+  Output* dst_;
+};
+
+// Callable for the ForEach in Encode() -- for each value, call the
+// appropriate encoder method.
+template <typename Encoder>
+struct EncodeWrapper {
+  Encoder* encoder;
+  template <typename Which>
+  void operator()(const Value<Which>& which) {
+    which.EncodeTo(encoder);
+  }
+};
+
+// Callable for the table ForEach in ForEach() -- for each value, call the
+// appropriate visitor method.
+template <typename Encoder>
+struct ForEachWrapper {
+  Encoder* encoder;
+  template <typename Which>
+  void operator()(const Value<Which>& which) {
+    which.VisitWith(encoder);
+  }
+};
+
+// Callable for the ForEach in Log()
+struct LogWrapper {
+  LogFn log_fn;
+  template <typename Which>
+  void operator()(const Value<Which>& which) {
+    which.LogTo(log_fn);
+  }
+};
+
+// Encoder to compute TransportSize
+class TransportSizeEncoder {
+ public:
+  void Encode(const Slice& key, const Slice& value) {
+    size_ += key.length() + value.length() + 32;
+  }
+
+  template <typename Which>
+  void Encode(Which, const typename Which::ValueType& value) {
+    Add(Which(), value);
+  }
+
+  void Encode(ContentTypeMetadata,
+              const typename ContentTypeMetadata::ValueType& value) {
+    if (value == ContentTypeMetadata::kInvalid) return;
+    Add(ContentTypeMetadata(), value);
+  }
+
+  size_t size() const { return size_; }
+
+ private:
+  template <typename Which>
+  void Add(Which, const typename Which::ValueType& value) {
+    size_ += Which::key().length() + Which::Encode(value).length() + 32;
+  }
+
+  uint32_t size_ = 0;
+};
+
+// Handle unknown (non-trait-based) fields in the metadata map.
+class UnknownMap {
+ public:
+  explicit UnknownMap(Arena* arena) : unknown_(arena) {}
+
+  using BackingType = ChunkedVector<std::pair<Slice, Slice>, 10>;
+
+  void Append(absl::string_view key, Slice value);
+  void Remove(absl::string_view key);
+  absl::optional<absl::string_view> GetStringValue(absl::string_view key,
+                                                   std::string* backing) const;
+
+  BackingType::ConstForwardIterator begin() const { return unknown_.cbegin(); }
+  BackingType::ConstForwardIterator end() const { return unknown_.cend(); }
+
+  bool empty() const { return unknown_.empty(); }
+  size_t size() const { return unknown_.size(); }
+  void Clear() { unknown_.Clear(); }
+  Arena* arena() const { return unknown_.arena(); }
+
+ private:
+  // Backing store for added metadata.
+  ChunkedVector<std::pair<Slice, Slice>, 10> unknown_;
 };
 
 }  // namespace metadata_detail
 
+// Helper function for encoders
+// Given a metadata trait, convert the value to a slice.
+template <typename Which>
+absl::enable_if_t<std::is_same<typename Which::ValueType, Slice>::value,
+                  const Slice&>
+MetadataValueAsSlice(const Slice& slice) {
+  return slice;
+}
+
+template <typename Which>
+absl::enable_if_t<!std::is_same<typename Which::ValueType, Slice>::value, Slice>
+MetadataValueAsSlice(typename Which::ValueType value) {
+  return Slice(Which::Encode(value));
+}
+
 // MetadataMap encodes the mapping of metadata keys to metadata values.
-// Right now the API presented is the minimal one that will allow us to
-// substitute this type for grpc_metadata_batch in a relatively easy fashion. At
-// that point we'll start iterating this API into something that's ergonomic
-// again, whilst minimally holding the performance bar already set (and
-// hopefully improving some things).
-// In the meantime, we're not going to invest much time in ephemeral API
-// documentation, so if you must use one of these APIs and it's not obvious
-// how, reach out to ctiller.
 //
-// MetadataMap takes a list of traits. Each of these trait objects defines
-// one metadata field that is used by core, and so should have more specialized
-// handling than just using the generic APIs.
+// MetadataMap takes a derived class and list of traits. Each of these trait
+// objects defines one metadata field that is used by core, and so should have
+// more specialized handling than just using the generic APIs.
 //
-// Each trait object has the following signature:
-// // Traits for the grpc-xyz metadata field:
+// MetadataMap is the backing type for some derived type via the curiously
+// recursive template pattern. This is because many types consumed by
+// MetadataMap require the container type to operate on, and many of those
+// types are instantiated one per trait. A naive implementation without the
+// Derived type would, for traits A,B,C, then instantiate for some
+// T<Container, Trait>:
+//  - T<MetadataMap<A,B,C>, A>,
+//  - T<MetadataMap<A,B,C>, B>,
+//  - T<MetadataMap<A,B,C>, C>.
+// Since these types ultimately need to be recorded in the .dynstr segment
+// for dynamic linkers (if gRPC is linked as a static library) this would
+// create O(N^2) bytes of symbols even in stripped libraries. To avoid this
+// we use the derived type (e.g. grpc_metadata_batch right now) to capture
+// the container type, and we would write T<grpc_metadata_batch, A>, etc...
+// Note that now the container type uses a number of bytes that is independent
+// of the number of traits, and so we return to a linear symbol table growth
+// function.
+//
+// Each trait object has one of two possible signatures, depending on whether
+// that traits field is encodable or not.
+// Non-encodable traits are carried in a MetadataMap, but are never passed to
+// the application nor serialized to wire.
+//
+// Encodable traits have the following signature:
+// // Traits for the "grpc-xyz" metadata field:
 // struct GrpcXyzMetadata {
+//   // Can this metadata field be repeated?
+//   static constexpr bool kRepeatable = ...;
 //   // The type that's stored on MetadataBatch
 //   using ValueType = ...;
 //   // The type that's stored in compression/decompression tables
 //   using MementoType = ...;
 //   // The string key for this metadata type (for transports that require it)
-//   static constexpr char* key() { return "grpc-xyz"; }
+//   static absl::string_view key() { return "grpc-xyz"; }
 //   // Parse a memento from a slice
 //   // Takes ownership of value
-//   static MementoType ParseMemento(const grpc_slice& value) { ... }
+//   // Calls fn in the case of an error that should be reported to the user
+//   static MementoType ParseMemento(Slice value, MementoParseErrorFn fn) {
+//   ...
+//   }
 //   // Convert a memento to a value
 //   static ValueType MementoToValue(MementoType memento) { ... }
 //   // Convert a value to its canonical text wire format (the format that
 //   // ParseMemento will accept!)
-//   static grpc_slice Encode(ValueType value);
-//   // Convert a value to something that can be passed to StrCat and displayed
+//   static Slice Encode(const ValueType& value);
+//   // Convert a value to something that can be passed to StrCat and
+//   displayed
 //   // for debugging
 //   static SomeStrCatableType DisplayValue(MementoType value) { ... }
 // };
 //
+// Non-encodable traits are determined by missing the key() method, and have
+// the following signature (and by convention omit the Metadata part of the
+// type name):
+// // Traits for the GrpcXyz field:
+// struct GrpcXyz {
+//   // The string key that should be used for debug dumps - should not be a
+//   // valid http2 key (ie all lower case)
+//   static absl::string_view DebugKey() { return "GRPC_XYZ"; }
+//   // Can this metadata field be repeated?
+//   static constexpr bool kRepeatable = ...;
+//   // The type that's stored on MetadataBatch
+//   using ValueType = ...;
+//   // Convert a value to something that can be passed to StrCat and
+//   displayed
+//   // for debugging
+//   static SomeStrCatableType DisplayValue(ValueType value) { ... }
+// };
+//
 // About parsing and mementos:
 //
 // Many gRPC transports exchange metadata as key/value strings, but also allow
@@ -250,10 +1023,10 @@ struct AppendHelper<Container> {
 // in the compression table. This is what mementos are used for.
 //
 // A trait offers the capability to turn a slice into a memento via
-// ParseMemento. This is exposed to users of MetadataMap via the Parse() method,
-// that returns a ParsedMetadata object. That ParsedMetadata object can in turn
-// be used to set the same value on many different MetadataMaps without having
-// to reparse.
+// ParseMemento. This is exposed to users of MetadataMap via the Parse()
+// method, that returns a ParsedMetadata object. That ParsedMetadata object
+// can in turn be used to set the same value on many different MetadataMaps
+// without having to reparse.
 //
 // Implementation wise, ParsedMetadata is a type erased wrapper around
 // MementoType. When we set a value on MetadataMap, we first turn that memento
@@ -261,7 +1034,7 @@ struct AppendHelper<Container> {
 // for grpc-timeout we make the memento the timeout expressed on the wire, but
 // we make the value the timestamp of when the timeout will expire (i.e. the
 // deadline).
-template <typename... Traits>
+template <class Derived, typename... Traits>
 class MetadataMap {
  public:
   explicit MetadataMap(Arena* arena);
@@ -270,7 +1043,10 @@ class MetadataMap {
   MetadataMap(const MetadataMap&) = delete;
   MetadataMap& operator=(const MetadataMap&) = delete;
   MetadataMap(MetadataMap&&) noexcept;
-  MetadataMap& operator=(MetadataMap&&) noexcept;
+  // We never create MetadataMap directly, instead we create Derived, but we
+  // want to be able to move it without redeclaring this.
+  // NOLINTNEXTLINE(misc-unconventional-assign-operator)
+  Derived& operator=(MetadataMap&&) noexcept;
 
   // Encode this metadata map into some encoder.
   // For each field that is set in the MetadataMap, call
@@ -281,23 +1057,49 @@ class MetadataMap {
   //    void Encode(TraitsType, typename TraitsType::ValueType value);
   // For fields for which we do not have traits, this will be a method
   // with the signature:
-  //    void Encode(grpc_mdelem md);
-  // TODO(ctiller): It's expected that the latter Encode method will
-  // become Encode(Slice, Slice) by the end of the current metadata API
-  // transitions.
+  //    void Encode(string_view key, Slice value);
   template <typename Encoder>
   void Encode(Encoder* encoder) const {
-    for (auto* l = list_.head; l; l = l->next) {
-      encoder->Encode(l->md);
+    table_.template ForEachIn<metadata_detail::EncodeWrapper<Encoder>,
+                              Value<Traits>...>(
+        metadata_detail::EncodeWrapper<Encoder>{encoder});
+    for (const auto& unk : unknown_) {
+      encoder->Encode(unk.first, unk.second);
     }
-    table_.ForEach(EncodeWrapper<Encoder>{encoder});
+  }
+
+  // Like Encode, but also visit the non-encodable fields.
+  template <typename Encoder>
+  void ForEach(Encoder* encoder) const {
+    table_.ForEach(metadata_detail::ForEachWrapper<Encoder>{encoder});
+    for (const auto& unk : unknown_) {
+      encoder->Encode(unk.first, unk.second);
+    }
+  }
+
+  // Similar to Encode, but targeted at logging: for each metadatum,
+  // call f(key, value) as absl::string_views.
+  void Log(metadata_detail::LogFn log_fn) const {
+    table_.ForEach(metadata_detail::LogWrapper{log_fn});
+    for (const auto& unk : unknown_) {
+      log_fn(unk.first.as_string_view(), unk.second.as_string_view());
+    }
+  }
+
+  std::string DebugString() const {
+    metadata_detail::DebugStringBuilder builder;
+    Log([&builder](absl::string_view key, absl::string_view value) {
+      builder.Add(key, value);
+    });
+    return builder.TakeOutput();
   }
 
   // Get the pointer to the value of some known metadata.
   // Returns nullptr if the metadata is not present.
   // Causes a compilation error if Which is not an element of Traits.
   template <typename Which>
-  const typename Which::ValueType* get_pointer(Which) const {
+  const typename metadata_detail::Value<Which>::StorageType* get_pointer(
+      Which) const {
     if (auto* p = table_.template get<Value<Which>>()) return &p->value;
     return nullptr;
   }
@@ -306,11 +1108,20 @@ class MetadataMap {
   // Returns nullptr if the metadata is not present.
   // Causes a compilation error if Which is not an element of Traits.
   template <typename Which>
-  typename Which::ValueType* get_pointer(Which) {
+  typename metadata_detail::Value<Which>::StorageType* get_pointer(Which) {
     if (auto* p = table_.template get<Value<Which>>()) return &p->value;
     return nullptr;
   }
 
+  // Get the pointer to the value of some known metadata.
+  // Adds the default value for the metadata is not present.
+  // Causes a compilation error if Which is not an element of Traits.
+  template <typename Which>
+  typename metadata_detail::Value<Which>::StorageType* GetOrCreatePointer(
+      Which) {
+    return &table_.template get_or_create<Value<Which>>()->value;
+  }
+
   // Get the value of some known metadata.
   // Returns nullopt if the metadata is not present.
   // Causes a compilation error if Which is not an element of Traits.
@@ -323,9 +1134,14 @@ class MetadataMap {
   // Set the value of some known metadata.
   // Returns a pointer to the new value.
   template <typename Which, typename... Args>
-  typename Which::ValueType* Set(Which, Args&&... args) {
-    return &table_.template set<Value<Which>>(std::forward<Args>(args)...)
-                ->value;
+  absl::enable_if_t<Which::kRepeatable == false, void> Set(Which,
+                                                           Args&&... args) {
+    table_.template set<Value<Which>>(std::forward<Args>(args)...);
+  }
+  template <typename Which, typename... Args>
+  absl::enable_if_t<Which::kRepeatable == true, void> Set(Which,
+                                                          Args&&... args) {
+    GetOrCreatePointer(Which())->emplace_back(std::forward<Args>(args)...);
   }
 
   // Remove a specific piece of known metadata.
@@ -334,722 +1150,177 @@ class MetadataMap {
     table_.template clear<Value<Which>>();
   }
 
+  // Remove some metadata by name
+  void Remove(absl::string_view key) {
+    metadata_detail::RemoveHelper<Derived> helper(static_cast<Derived*>(this));
+    metadata_detail::NameLookup<void, Traits...>::Lookup(key, &helper);
+  }
+
+  void Remove(const char* key) { Remove(absl::string_view(key)); }
+
+  // Retrieve some metadata by name
+  absl::optional<absl::string_view> GetStringValue(absl::string_view name,
+                                                   std::string* buffer) const {
+    metadata_detail::GetStringValueHelper<Derived> helper(
+        static_cast<const Derived*>(this), buffer);
+    return metadata_detail::NameLookup<void, Traits...>::Lookup(name, &helper);
+  }
+
   // Extract a piece of known metadata.
   // Returns nullopt if the metadata was not present, or the value if it was.
   // The same as:
   //  auto value = m.get(T());
   //  m.Remove(T());
   template <typename Which>
-  absl::optional<typename Which::ValueType> Take(Which which) {
-    auto value = get(which);
-    Remove(which);
-    return value;
+  absl::enable_if_t<Which::kRepeatable == false,
+                    absl::optional<typename Which::ValueType>>
+  Take(Which which) {
+    if (auto* p = get_pointer(which)) {
+      absl::optional<typename Which::ValueType> value(std::move(*p));
+      Remove(which);
+      return value;
+    }
+    return {};
+  }
+
+  // Extract repeated known metadata.
+  // Returns an empty vector if the metadata was not present.
+  template <typename Which>
+  absl::enable_if_t<Which::kRepeatable == true,
+                    typename metadata_detail::Value<Which>::StorageType>
+  Take(Which which) {
+    if (auto* p = get_pointer(which)) {
+      typename Value<Which>::StorageType value = std::move(*p);
+      Remove(which);
+      return value;
+    }
+    return {};
   }
 
   // Parse metadata from a key/value pair, and return an object representing
   // that result.
   // TODO(ctiller): key should probably be an absl::string_view.
   // Once we don't care about interning anymore, make that change!
-  template <class KeySlice, class ValueSlice>
-  static ParsedMetadata<MetadataMap> Parse(const KeySlice& key,
-                                           const ValueSlice& value) {
-    bool parsed = true;
-    auto out = metadata_detail::ParseHelper<MetadataMap, Traits...>::Parse(
-        StringViewFromSlice(key), value, [&] {
-          parsed = false;
-          return ParsedMetadata<MetadataMap>(
-              grpc_mdelem_from_slices(key, value));
-        });
-    if (parsed) {
-      grpc_slice_unref_internal(key);
-    }
-    return out;
+  static ParsedMetadata<Derived> Parse(absl::string_view key, Slice value,
+                                       uint32_t transport_size,
+                                       MetadataParseErrorFn on_error) {
+    metadata_detail::ParseHelper<Derived> helper(value.TakeOwned(), on_error,
+                                                 transport_size);
+    return metadata_detail::NameLookup<void, Traits...>::Lookup(key, &helper);
   }
 
   // Set a value from a parsed metadata object.
-  GRPC_MUST_USE_RESULT grpc_error_handle
-  Set(const ParsedMetadata<MetadataMap>& m) {
-    return m.SetOnContainer(this);
+  void Set(const ParsedMetadata<Derived>& m) {
+    m.SetOnContainer(static_cast<Derived*>(this));
   }
 
   // Append a key/value pair - takes ownership of value
-  void Append(absl::string_view key, const grpc_slice& value) {
-    metadata_detail::AppendHelper<MetadataMap, Traits...>::Append(
-        this, key, value, [&] {
-          GPR_ASSERT(GRPC_ERROR_NONE ==
-                     Append(grpc_mdelem_from_slices(
-                         grpc_slice_intern(grpc_slice_from_static_buffer(
-                             key.data(), key.length())),
-                         value)));
-        });
-  }
-
-  //
-  // All APIs below this point are subject to change.
-  //
-
-  template <typename F>
-  void ForEach(F f) const {
-    for (auto* l = list_.head; l; l = l->next) {
-      f(l->md);
-    }
+  void Append(absl::string_view key, Slice value,
+              MetadataParseErrorFn on_error) {
+    metadata_detail::AppendHelper<Derived> helper(static_cast<Derived*>(this),
+                                                  value.TakeOwned(), on_error);
+    metadata_detail::NameLookup<void, Traits...>::Lookup(key, &helper);
   }
 
-  template <typename F>
-  grpc_error_handle Filter(F f, const char* composite_error_string) {
-    grpc_linked_mdelem* l = list_.head;
-    grpc_error_handle error = GRPC_ERROR_NONE;
-    auto add_error = [&](grpc_error_handle new_error) {
-      if (new_error == GRPC_ERROR_NONE) return;
-      if (error == GRPC_ERROR_NONE) {
-        error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(composite_error_string);
-      }
-      error = grpc_error_add_child(error, new_error);
-    };
-    while (l) {
-      grpc_linked_mdelem* next = l->next;
-      grpc_filtered_mdelem new_mdelem = f(l->md);
-      add_error(new_mdelem.error);
-      if (GRPC_MDISNULL(new_mdelem.md)) {
-        Remove(l);
-      } else if (new_mdelem.md.payload != l->md.payload) {
-        add_error(Substitute(l, new_mdelem.md));
-      }
-      l = next;
-    }
-    return error;
-  }
-
-  GRPC_MUST_USE_RESULT grpc_error_handle Append(grpc_mdelem md) {
-    return AddTail(elem_storage_.EmplaceBack(), md);
-  }
-
-  GRPC_MUST_USE_RESULT grpc_error_handle ReplaceOrAppend(grpc_slice key,
-                                                         grpc_slice value) {
-    if (ReplaceIfExists(key, value)) return GRPC_ERROR_NONE;
-    return Append(grpc_mdelem_from_slices(key, value));
-  }
-
-  // Set key to value if it exists and return true, otherwise return false.
-  // If this function returns true, it takes ownership of key and value.
-  // If this function returns false, it does not take ownership of key nor
-  // value.
-  bool ReplaceIfExists(grpc_slice key, grpc_slice value);
-
   void Clear();
-  bool empty() const { return count() == 0; }
-
-  size_t count() const { return list_.count + table_.count(); }
-  size_t non_deadline_count() const { return list_.count; }
-  size_t default_count() const { return list_.default_count; }
-
   size_t TransportSize() const;
-
-  void Remove(grpc_linked_mdelem* storage);
-  void Remove(grpc_metadata_batch_callouts_index idx);
-
-  absl::optional<grpc_slice> Remove(grpc_slice key);
-
-  grpc_error_handle Substitute(grpc_linked_mdelem* storage,
-                               grpc_mdelem new_mdelem);
-
-  absl::optional<absl::string_view> GetValue(
-      absl::string_view target_key, std::string* concatenated_value) const;
-
-  grpc_error_handle LinkHead(grpc_linked_mdelem* storage) GRPC_MUST_USE_RESULT;
-  grpc_error_handle LinkHead(grpc_linked_mdelem* storage,
-                             grpc_metadata_batch_callouts_index idx)
-      GRPC_MUST_USE_RESULT;
-  grpc_error_handle LinkTail(grpc_linked_mdelem* storage) GRPC_MUST_USE_RESULT;
-  grpc_error_handle LinkTail(grpc_linked_mdelem* storage,
-                             grpc_metadata_batch_callouts_index idx)
-      GRPC_MUST_USE_RESULT;
-
-  grpc_error_handle AddHead(grpc_linked_mdelem* storage) GRPC_MUST_USE_RESULT;
-  grpc_error_handle AddHead(grpc_linked_mdelem* storage,
-                            grpc_mdelem elem_to_add) GRPC_MUST_USE_RESULT;
-  grpc_error_handle AddTail(grpc_linked_mdelem* storage) GRPC_MUST_USE_RESULT;
-  grpc_error_handle AddTail(grpc_linked_mdelem* storage,
-                            grpc_mdelem elem_to_add) GRPC_MUST_USE_RESULT;
-
-  void CopyFrom(MetadataMap* src, grpc_linked_mdelem* storage);
-
-#ifndef NDEBUG
-  void AssertOk();
-#else
-  void AssertOk() {}
-#endif
-
-  // TODO(ctiller): the following explicit deadline handling methods are
-  // deprecated in terms of the traits based APIs.
-  grpc_millis deadline() const {
-    return get(GrpcTimeoutMetadata()).value_or(GRPC_MILLIS_INF_FUTURE);
-  };
-
-  const grpc_metadata_batch_callouts* legacy_index() const { return &idx_; }
+  Derived Copy() const;
+  bool empty() const { return table_.empty() && unknown_.empty(); }
+  size_t count() const { return table_.count() + unknown_.size(); }
 
  private:
-  // Generate a strong type for metadata values per trait.
-  template <typename Which>
-  struct Value {
-    Value() = default;
-    explicit Value(const typename Which::ValueType& value) : value(value) {}
-    Value(const Value&) = default;
-    Value& operator=(const Value&) = default;
-    Value(Value&&) noexcept = default;
-    Value& operator=(Value&&) noexcept = default;
-    GPR_NO_UNIQUE_ADDRESS typename Which::ValueType value;
-  };
-  // Callable for the ForEach in Encode() -- for each value, call the
-  // appropriate encoder method.
-  template <typename Encoder>
-  struct EncodeWrapper {
-    Encoder* encoder;
-    template <typename Which>
-    void operator()(const Value<Which>& which) {
-      encoder->Encode(Which(), which.value);
-    }
-  };
+  friend class metadata_detail::AppendHelper<Derived>;
+  friend class metadata_detail::GetStringValueHelper<Derived>;
+  friend class metadata_detail::RemoveHelper<Derived>;
+  friend class metadata_detail::CopySink<Derived>;
+  friend class ParsedMetadata<Derived>;
 
-  void AssertValidCallouts();
-  grpc_error_handle LinkCallout(grpc_linked_mdelem* storage,
-                                grpc_metadata_batch_callouts_index idx)
-      GRPC_MUST_USE_RESULT;
-  grpc_error_handle MaybeLinkCallout(grpc_linked_mdelem* storage)
-      GRPC_MUST_USE_RESULT;
-  void MaybeUnlinkCallout(grpc_linked_mdelem* storage);
-
-  static void assert_valid_list(grpc_mdelem_list* list) {
-#ifndef NDEBUG
-    grpc_linked_mdelem* l;
-
-    GPR_ASSERT((list->head == nullptr) == (list->tail == nullptr));
-    if (!list->head) return;
-    GPR_ASSERT(list->head->prev == nullptr);
-    GPR_ASSERT(list->tail->next == nullptr);
-    GPR_ASSERT((list->head == list->tail) == (list->head->next == nullptr));
-
-    size_t verified_count = 0;
-    for (l = list->head; l; l = l->next) {
-      GPR_ASSERT(!GRPC_MDISNULL(l->md));
-      GPR_ASSERT((l->prev == nullptr) == (l == list->head));
-      GPR_ASSERT((l->next == nullptr) == (l == list->tail));
-      if (l->next) GPR_ASSERT(l->next->prev == l);
-      if (l->prev) GPR_ASSERT(l->prev->next == l);
-      verified_count++;
-    }
-    GPR_ASSERT(list->count == verified_count);
-#else
-    // Avoid unused-parameter warning for debug-only parameter
-    (void)list;
-#endif /* NDEBUG */
-  }
-
-  static grpc_error_handle GPR_ATTRIBUTE_NOINLINE
-  error_with_md(grpc_mdelem md) {
-    return grpc_attach_md_to_error(
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Unallowed duplicate metadata"),
-        md);
-  }
-
-  static void link_head(grpc_mdelem_list* list, grpc_linked_mdelem* storage) {
-    assert_valid_list(list);
-    GPR_DEBUG_ASSERT(!GRPC_MDISNULL(storage->md));
-    storage->prev = nullptr;
-    storage->next = list->head;
-    storage->reserved = nullptr;
-    if (list->head != nullptr) {
-      list->head->prev = storage;
-    } else {
-      list->tail = storage;
-    }
-    list->head = storage;
-    list->count++;
-    assert_valid_list(list);
-  }
-
-  static void link_tail(grpc_mdelem_list* list, grpc_linked_mdelem* storage) {
-    assert_valid_list(list);
-    GPR_DEBUG_ASSERT(!GRPC_MDISNULL(storage->md));
-    storage->prev = list->tail;
-    storage->next = nullptr;
-    storage->reserved = nullptr;
-    if (list->tail != nullptr) {
-      list->tail->next = storage;
-    } else {
-      list->head = storage;
-    }
-    list->tail = storage;
-    list->count++;
-    assert_valid_list(list);
-  }
-
-  static void unlink_storage(grpc_mdelem_list* list,
-                             grpc_linked_mdelem* storage) {
-    assert_valid_list(list);
-    if (storage->prev != nullptr) {
-      storage->prev->next = storage->next;
-    } else {
-      list->head = storage->next;
-    }
-    if (storage->next != nullptr) {
-      storage->next->prev = storage->prev;
-    } else {
-      list->tail = storage->prev;
-    }
-    list->count--;
-    assert_valid_list(list);
-  }
+  template <typename Which>
+  using Value = metadata_detail::Value<Which>;
 
   // Table of known metadata types.
-  Table<Value<Traits>...> table_;
-  /** Metadata elements in this batch */
-  grpc_mdelem_list list_;
-  grpc_metadata_batch_callouts idx_;
-  // Backing store for added metadata.
-  ChunkedVector<grpc_linked_mdelem, 10> elem_storage_;
+  PackedTable<Value<Traits>...> table_;
+  metadata_detail::UnknownMap unknown_;
 };
 
-template <typename... Traits>
-void MetadataMap<Traits...>::AssertValidCallouts() {
-#ifndef NDEBUG
-  for (grpc_linked_mdelem* l = list_.head; l != nullptr; l = l->next) {
-    grpc_slice key_interned = grpc_slice_intern(GRPC_MDKEY(l->md));
-    grpc_metadata_batch_callouts_index callout_idx =
-        GRPC_BATCH_INDEX_OF(key_interned);
-    if (callout_idx != GRPC_BATCH_CALLOUTS_COUNT) {
-      GPR_ASSERT(idx_.array[callout_idx] == l);
-    }
-    grpc_slice_unref_internal(key_interned);
-  }
-#endif
-}
-
-#ifndef NDEBUG
-template <typename... Traits>
-void MetadataMap<Traits...>::AssertOk() {
-  assert_valid_list(&list_);
+// Ok/not-ok check for metadata maps that contain GrpcStatusMetadata, so that
+// they can be used as result types for TrySeq.
+template <typename Derived, typename... Args>
+inline bool IsStatusOk(const MetadataMap<Derived, Args...>& m) {
+  return m.get(GrpcStatusMetadata()).value_or(GRPC_STATUS_UNKNOWN) ==
+         GRPC_STATUS_OK;
 }
-#endif /* NDEBUG */
 
-template <typename... Traits>
-MetadataMap<Traits...>::MetadataMap(Arena* arena) : elem_storage_(arena) {
-  memset(&list_, 0, sizeof(list_));
-  memset(&idx_, 0, sizeof(idx_));
-}
+template <typename Derived, typename... Traits>
+MetadataMap<Derived, Traits...>::MetadataMap(Arena* arena) : unknown_(arena) {}
 
-template <typename... Traits>
-MetadataMap<Traits...>::MetadataMap(MetadataMap&& other) noexcept
-    : table_(std::move(other.table_)) {
-  list_ = other.list_;
-  idx_ = other.idx_;
-  memset(&other.list_, 0, sizeof(list_));
-  memset(&other.idx_, 0, sizeof(idx_));
-}
+template <typename Derived, typename... Traits>
+MetadataMap<Derived, Traits...>::MetadataMap(MetadataMap&& other) noexcept
+    : table_(std::move(other.table_)), unknown_(std::move(other.unknown_)) {}
 
-template <typename... Traits>
-MetadataMap<Traits...>& MetadataMap<Traits...>::operator=(
+// We never create MetadataMap directly, instead we create Derived, but we
+// want to be able to move it without redeclaring this.
+// NOLINTNEXTLINE(misc-unconventional-assign-operator)
+template <typename Derived, typename... Traits>
+Derived& MetadataMap<Derived, Traits...>::operator=(
     MetadataMap&& other) noexcept {
-  Clear();
   table_ = std::move(other.table_);
-  list_ = other.list_;
-  idx_ = other.idx_;
-  memset(&other.list_, 0, sizeof(list_));
-  memset(&other.idx_, 0, sizeof(idx_));
-  return *this;
-}
-
-template <typename... Traits>
-MetadataMap<Traits...>::~MetadataMap() {
-  AssertValidCallouts();
-  for (auto* l = list_.head; l; l = l->next) {
-    GRPC_MDELEM_UNREF(l->md);
-  }
-}
-
-template <typename... Traits>
-absl::optional<grpc_slice> MetadataMap<Traits...>::Remove(grpc_slice key) {
-  for (auto* l = list_.head; l; l = l->next) {
-    if (grpc_slice_eq(GRPC_MDKEY(l->md), key)) {
-      auto out = grpc_slice_ref_internal(GRPC_MDVALUE(l->md));
-      Remove(l);
-      return out;
-    }
-  }
-  return {};
+  unknown_ = std::move(other.unknown_);
+  return static_cast<Derived&>(*this);
 }
 
-template <typename... Traits>
-grpc_error_handle MetadataMap<Traits...>::LinkCallout(
-    grpc_linked_mdelem* storage, grpc_metadata_batch_callouts_index idx) {
-  AssertValidCallouts();
-  GPR_DEBUG_ASSERT(idx >= 0 && idx < GRPC_BATCH_CALLOUTS_COUNT);
-  if (GPR_LIKELY(idx_.array[idx] == nullptr)) {
-    ++list_.default_count;
-    idx_.array[idx] = storage;
-    AssertValidCallouts();
-    return GRPC_ERROR_NONE;
-  }
-  AssertValidCallouts();
-  return error_with_md(storage->md);
-}
-
-template <typename... Traits>
-grpc_error_handle MetadataMap<Traits...>::MaybeLinkCallout(
-    grpc_linked_mdelem* storage) {
-  grpc_metadata_batch_callouts_index idx =
-      GRPC_BATCH_INDEX_OF(GRPC_MDKEY(storage->md));
-  if (idx == GRPC_BATCH_CALLOUTS_COUNT) {
-    return GRPC_ERROR_NONE;
-  }
-  return LinkCallout(storage, idx);
-}
-
-template <typename... Traits>
-void MetadataMap<Traits...>::MaybeUnlinkCallout(grpc_linked_mdelem* storage) {
-  grpc_metadata_batch_callouts_index idx =
-      GRPC_BATCH_INDEX_OF(GRPC_MDKEY(storage->md));
-  if (idx == GRPC_BATCH_CALLOUTS_COUNT) {
-    return;
-  }
-  --list_.default_count;
-  GPR_DEBUG_ASSERT(idx_.array[idx] != nullptr);
-  idx_.array[idx] = nullptr;
-}
-
-template <typename... Traits>
-grpc_error_handle MetadataMap<Traits...>::AddHead(grpc_linked_mdelem* storage,
-                                                  grpc_mdelem elem_to_add) {
-  GPR_DEBUG_ASSERT(!GRPC_MDISNULL(elem_to_add));
-  storage->md = elem_to_add;
-  return LinkHead(storage);
-}
-
-template <typename... Traits>
-grpc_error_handle MetadataMap<Traits...>::LinkHead(
-    grpc_linked_mdelem* storage) {
-  AssertValidCallouts();
-  grpc_error_handle err = MaybeLinkCallout(storage);
-  if (err != GRPC_ERROR_NONE) {
-    AssertValidCallouts();
-    return err;
-  }
-  link_head(&list_, storage);
-  AssertValidCallouts();
-  return GRPC_ERROR_NONE;
-}
-
-// TODO(arjunroy): Need to revisit this and see what guarantees exist between
-// C-core and the internal-metadata subsystem. E.g. can we ensure a particular
-// metadata is never added twice, even in the presence of user supplied data?
-template <typename... Traits>
-grpc_error_handle MetadataMap<Traits...>::LinkHead(
-    grpc_linked_mdelem* storage, grpc_metadata_batch_callouts_index idx) {
-  GPR_DEBUG_ASSERT(GRPC_BATCH_INDEX_OF(GRPC_MDKEY(storage->md)) == idx);
-  AssertValidCallouts();
-  grpc_error_handle err = LinkCallout(storage, idx);
-  if (GPR_UNLIKELY(err != GRPC_ERROR_NONE)) {
-    AssertValidCallouts();
-    return err;
-  }
-  link_head(&list_, storage);
-  AssertValidCallouts();
-  return GRPC_ERROR_NONE;
-}
-
-template <typename... Traits>
-grpc_error_handle MetadataMap<Traits...>::AddTail(grpc_linked_mdelem* storage,
-                                                  grpc_mdelem elem_to_add) {
-  GPR_DEBUG_ASSERT(!GRPC_MDISNULL(elem_to_add));
-  storage->md = elem_to_add;
-  return LinkTail(storage);
-}
-
-template <typename... Traits>
-grpc_error_handle MetadataMap<Traits...>::LinkTail(
-    grpc_linked_mdelem* storage) {
-  AssertValidCallouts();
-  grpc_error_handle err = MaybeLinkCallout(storage);
-  if (err != GRPC_ERROR_NONE) {
-    AssertValidCallouts();
-    return err;
-  }
-  link_tail(&list_, storage);
-  AssertValidCallouts();
-  return GRPC_ERROR_NONE;
-}
+template <typename Derived, typename... Traits>
+MetadataMap<Derived, Traits...>::~MetadataMap() = default;
 
-template <typename... Traits>
-grpc_error_handle MetadataMap<Traits...>::LinkTail(
-    grpc_linked_mdelem* storage, grpc_metadata_batch_callouts_index idx) {
-  GPR_DEBUG_ASSERT(GRPC_BATCH_INDEX_OF(GRPC_MDKEY(storage->md)) == idx);
-  AssertValidCallouts();
-  grpc_error_handle err = LinkCallout(storage, idx);
-  if (GPR_UNLIKELY(err != GRPC_ERROR_NONE)) {
-    AssertValidCallouts();
-    return err;
-  }
-  link_tail(&list_, storage);
-  AssertValidCallouts();
-  return GRPC_ERROR_NONE;
+template <typename Derived, typename... Traits>
+void MetadataMap<Derived, Traits...>::Clear() {
+  table_.ClearAll();
+  unknown_.Clear();
 }
 
-template <typename... Traits>
-void MetadataMap<Traits...>::Remove(grpc_linked_mdelem* storage) {
-  AssertValidCallouts();
-  MaybeUnlinkCallout(storage);
-  unlink_storage(&list_, storage);
-  GRPC_MDELEM_UNREF(storage->md);
-  AssertValidCallouts();
+template <typename Derived, typename... Traits>
+size_t MetadataMap<Derived, Traits...>::TransportSize() const {
+  metadata_detail::TransportSizeEncoder enc;
+  Encode(&enc);
+  return enc.size();
 }
 
-template <typename... Traits>
-void MetadataMap<Traits...>::Remove(grpc_metadata_batch_callouts_index idx) {
-  AssertValidCallouts();
-  if (idx_.array[idx] == nullptr) return;
-  --list_.default_count;
-  unlink_storage(&list_, idx_.array[idx]);
-  GRPC_MDELEM_UNREF(idx_.array[idx]->md);
-  idx_.array[idx] = nullptr;
-  AssertValidCallouts();
-}
-
-template <typename... Traits>
-absl::optional<absl::string_view> MetadataMap<Traits...>::GetValue(
-    absl::string_view target_key, std::string* concatenated_value) const {
-  // Find all values for the specified key.
-  absl::InlinedVector<absl::string_view, 1> values;
-  for (grpc_linked_mdelem* md = list_.head; md != nullptr; md = md->next) {
-    absl::string_view key = grpc_core::StringViewFromSlice(GRPC_MDKEY(md->md));
-    absl::string_view value =
-        grpc_core::StringViewFromSlice(GRPC_MDVALUE(md->md));
-    if (target_key == key) values.push_back(value);
-  }
-  // If none found, no match.
-  if (values.empty()) return absl::nullopt;
-  // If exactly one found, return it as-is.
-  if (values.size() == 1) return values.front();
-  // If more than one found, concatenate the values, using
-  // *concatenated_values as a temporary holding place for the
-  // concatenated string.
-  *concatenated_value = absl::StrJoin(values, ",");
-  return *concatenated_value;
-}
-
-template <typename... Traits>
-grpc_error_handle MetadataMap<Traits...>::Substitute(
-    grpc_linked_mdelem* storage, grpc_mdelem new_mdelem) {
-  AssertValidCallouts();
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  grpc_mdelem old_mdelem = storage->md;
-  if (!grpc_slice_eq(GRPC_MDKEY(new_mdelem), GRPC_MDKEY(old_mdelem))) {
-    MaybeUnlinkCallout(storage);
-    storage->md = new_mdelem;
-    error = MaybeLinkCallout(storage);
-    if (error != GRPC_ERROR_NONE) {
-      unlink_storage(&list_, storage);
-      GRPC_MDELEM_UNREF(storage->md);
-    }
-  } else {
-    storage->md = new_mdelem;
-  }
-  GRPC_MDELEM_UNREF(old_mdelem);
-  AssertValidCallouts();
-  return error;
-}
-
-template <typename... Traits>
-void MetadataMap<Traits...>::Clear() {
-  // TODO(ctiller): implement this without deconstructing/reconstructing once
-  // linked_mdelem is no longer a thing.
-  auto* arena = elem_storage_.arena();
-  this->~MetadataMap();
-  new (this) MetadataMap(arena);
-}
-
-template <typename... Traits>
-size_t MetadataMap<Traits...>::TransportSize() const {
-  size_t size = 0;
-  for (grpc_linked_mdelem* elem = list_.head; elem != nullptr;
-       elem = elem->next) {
-    size += GRPC_MDELEM_LENGTH(elem->md);
-  }
-  return size;
-}
-
-template <typename... Traits>
-bool MetadataMap<Traits...>::ReplaceIfExists(grpc_slice key, grpc_slice value) {
-  AssertValidCallouts();
-  for (grpc_linked_mdelem* l = list_.head; l != nullptr; l = l->next) {
-    if (grpc_slice_eq(GRPC_MDKEY(l->md), key)) {
-      auto new_mdelem = grpc_mdelem_from_slices(key, value);
-      GRPC_MDELEM_UNREF(l->md);
-      l->md = new_mdelem;
-      AssertValidCallouts();
-      return true;
-    }
-  }
-  AssertValidCallouts();
-  return false;
+template <typename Derived, typename... Traits>
+Derived MetadataMap<Derived, Traits...>::Copy() const {
+  Derived out(unknown_.arena());
+  metadata_detail::CopySink<Derived> sink(&out);
+  ForEach(&sink);
+  return out;
 }
 
 }  // namespace grpc_core
 
-using grpc_metadata_batch =
-    grpc_core::MetadataMap<grpc_core::GrpcTimeoutMetadata,
-                           grpc_core::TeMetadata>;
-
-inline void grpc_metadata_batch_clear(grpc_metadata_batch* batch) {
-  batch->Clear();
-}
-inline bool grpc_metadata_batch_is_empty(grpc_metadata_batch* batch) {
-  return batch->empty();
-}
-
-/* Returns the transport size of the batch. */
-inline size_t grpc_metadata_batch_size(grpc_metadata_batch* batch) {
-  return batch->TransportSize();
-}
-
-/** Remove \a storage from the batch, unreffing the mdelem contained */
-inline void grpc_metadata_batch_remove(grpc_metadata_batch* batch,
-                                       grpc_linked_mdelem* storage) {
-  batch->Remove(storage);
-}
-inline void grpc_metadata_batch_remove(grpc_metadata_batch* batch,
-                                       grpc_metadata_batch_callouts_index idx) {
-  batch->Remove(idx);
-}
-
-/** Substitute a new mdelem for an old value */
-inline grpc_error_handle grpc_metadata_batch_substitute(
-    grpc_metadata_batch* batch, grpc_linked_mdelem* storage,
-    grpc_mdelem new_mdelem) {
-  return batch->Substitute(storage, new_mdelem);
-}
-
-void grpc_metadata_batch_set_value(grpc_linked_mdelem* storage,
-                                   const grpc_slice& value);
-
-/** Returns metadata value(s) for the specified key.
-    If the key is not present in the batch, returns absl::nullopt.
-    If the key is present exactly once in the batch, returns a string_view of
-    that value.
-    If the key is present more than once in the batch, constructs a
-    comma-concatenated string of all values in concatenated_value and returns a
-    string_view of that string. */
-inline absl::optional<absl::string_view> grpc_metadata_batch_get_value(
-    grpc_metadata_batch* batch, absl::string_view target_key,
-    std::string* concatenated_value) {
-  return batch->GetValue(target_key, concatenated_value);
-}
-
-/** Add \a storage to the beginning of \a batch. storage->md is
-    assumed to be valid.
-    \a storage is owned by the caller and must survive for the
-    lifetime of batch. This usually means it should be around
-    for the lifetime of the call. */
-inline GRPC_MUST_USE_RESULT grpc_error_handle grpc_metadata_batch_link_head(
-    grpc_metadata_batch* batch, grpc_linked_mdelem* storage) {
-  return batch->LinkHead(storage);
-}
-
-inline GRPC_MUST_USE_RESULT grpc_error_handle grpc_metadata_batch_link_head(
-    grpc_metadata_batch* batch, grpc_linked_mdelem* storage,
-    grpc_metadata_batch_callouts_index idx) {
-  return batch->LinkHead(storage, idx);
-}
-
-/** Add \a storage to the end of \a batch. storage->md is
-    assumed to be valid.
-    \a storage is owned by the caller and must survive for the
-    lifetime of batch. This usually means it should be around
-    for the lifetime of the call. */
-inline GRPC_MUST_USE_RESULT grpc_error_handle grpc_metadata_batch_link_tail(
-    grpc_metadata_batch* batch, grpc_linked_mdelem* storage) {
-  return batch->LinkTail(storage);
-}
-
-inline GRPC_MUST_USE_RESULT grpc_error_handle grpc_metadata_batch_link_tail(
-    grpc_metadata_batch* batch, grpc_linked_mdelem* storage,
-    grpc_metadata_batch_callouts_index idx) {
-  return batch->LinkTail(storage, idx);
-}
-
-/** Add \a elem_to_add as the first element in \a batch, using
-    \a storage as backing storage for the linked list element.
-    \a storage is owned by the caller and must survive for the
-    lifetime of batch. This usually means it should be around
-    for the lifetime of the call.
-    Takes ownership of \a elem_to_add */
-inline grpc_error_handle grpc_metadata_batch_add_head(
-    grpc_metadata_batch* batch, grpc_linked_mdelem* storage,
-    grpc_mdelem elem_to_add) {
-  return batch->AddHead(storage, elem_to_add);
-}
-
-// TODO(arjunroy, roth): Remove redundant methods.
-// add/link_head/tail are almost identical.
-inline grpc_error_handle GRPC_MUST_USE_RESULT grpc_metadata_batch_add_head(
-    grpc_metadata_batch* batch, grpc_linked_mdelem* storage,
-    grpc_metadata_batch_callouts_index idx) {
-  return grpc_metadata_batch_link_head(batch, storage, idx);
-}
-
-inline grpc_error_handle GRPC_MUST_USE_RESULT grpc_metadata_batch_add_head(
-    grpc_metadata_batch* batch, grpc_linked_mdelem* storage,
-    grpc_mdelem elem_to_add, grpc_metadata_batch_callouts_index idx) {
-  GPR_DEBUG_ASSERT(!GRPC_MDISNULL(elem_to_add));
-  storage->md = elem_to_add;
-  return grpc_metadata_batch_add_head(batch, storage, idx);
-}
-
-/** Add \a elem_to_add as the last element in \a batch, using
-    \a storage as backing storage for the linked list element.
-    \a storage is owned by the caller and must survive for the
-    lifetime of batch. This usually means it should be around
-    for the lifetime of the call.
-    Takes ownership of \a elem_to_add */
-inline GRPC_MUST_USE_RESULT grpc_error_handle grpc_metadata_batch_add_tail(
-    grpc_metadata_batch* batch, grpc_linked_mdelem* storage,
-    grpc_mdelem elem_to_add) {
-  return batch->AddTail(storage, elem_to_add);
-}
-
-inline grpc_error_handle GRPC_MUST_USE_RESULT grpc_metadata_batch_add_tail(
-    grpc_metadata_batch* batch, grpc_linked_mdelem* storage,
-    grpc_metadata_batch_callouts_index idx) {
-  return grpc_metadata_batch_link_tail(batch, storage, idx);
-}
-
-inline grpc_error_handle GRPC_MUST_USE_RESULT grpc_metadata_batch_add_tail(
-    grpc_metadata_batch* batch, grpc_linked_mdelem* storage,
-    grpc_mdelem elem_to_add, grpc_metadata_batch_callouts_index idx) {
-  GPR_DEBUG_ASSERT(!GRPC_MDISNULL(elem_to_add));
-  storage->md = elem_to_add;
-  return grpc_metadata_batch_add_tail(batch, storage, idx);
-}
-
-typedef grpc_filtered_mdelem (*grpc_metadata_batch_filter_func)(
-    void* user_data, grpc_mdelem elem);
-inline GRPC_MUST_USE_RESULT grpc_error_handle grpc_metadata_batch_filter(
-    grpc_metadata_batch* batch, grpc_metadata_batch_filter_func func,
-    void* user_data, const char* composite_error_string) {
-  return batch->Filter([=](grpc_mdelem elem) { return func(user_data, elem); },
-                       composite_error_string);
-}
-
-inline void grpc_metadata_batch_assert_ok(grpc_metadata_batch* batch) {
-  batch->AssertOk();
-}
-
-/// Copies \a src to \a dst.
-///
-/// For each mdelem in \a src, if the mdelem is of storage types
-/// GRPC_MDELEM_STORAGE_INTERNED or GRPC_MDELEM_STORAGE_ALLOCATED,
-/// refs the original mdelem for the copy.  Otherwise, makes a new
-/// mdelem that will hold its own refs to the key and value slices.
-void grpc_metadata_batch_copy(const grpc_metadata_batch* src,
-                              grpc_metadata_batch* dst);
+struct grpc_metadata_batch;
+
+using grpc_metadata_batch_base = grpc_core::MetadataMap<
+    grpc_metadata_batch,
+    // Colon prefixed headers first
+    grpc_core::HttpPathMetadata, grpc_core::HttpAuthorityMetadata,
+    grpc_core::HttpMethodMetadata, grpc_core::HttpStatusMetadata,
+    grpc_core::HttpSchemeMetadata,
+    // Non-colon prefixed headers begin here
+    grpc_core::ContentTypeMetadata, grpc_core::TeMetadata,
+    grpc_core::GrpcEncodingMetadata, grpc_core::GrpcInternalEncodingRequest,
+    grpc_core::GrpcAcceptEncodingMetadata, grpc_core::GrpcStatusMetadata,
+    grpc_core::GrpcTimeoutMetadata, grpc_core::GrpcPreviousRpcAttemptsMetadata,
+    grpc_core::GrpcRetryPushbackMsMetadata, grpc_core::UserAgentMetadata,
+    grpc_core::GrpcMessageMetadata, grpc_core::HostMetadata,
+    grpc_core::EndpointLoadMetricsBinMetadata,
+    grpc_core::GrpcServerStatsBinMetadata, grpc_core::GrpcTraceBinMetadata,
+    grpc_core::GrpcTagsBinMetadata, grpc_core::GrpcLbClientStatsMetadata,
+    grpc_core::LbCostBinMetadata, grpc_core::LbTokenMetadata,
+    // Non-encodable things
+    grpc_core::GrpcStreamNetworkState, grpc_core::PeerString,
+    grpc_core::GrpcStatusContext, grpc_core::GrpcStatusFromWire,
+    grpc_core::WaitForReady>;
+
+struct grpc_metadata_batch : public grpc_metadata_batch_base {
+  using grpc_metadata_batch_base::grpc_metadata_batch_base;
+};
 
 #endif /* GRPC_CORE_LIB_TRANSPORT_METADATA_BATCH_H */