grpc 1.44.0.pre2 → 1.46.3

data/src/core/lib/debug/stats_data.h

@@ -42,8 +42,6 @@ typedef enum {
   GRPC_STATS_COUNTER_POLLSET_KICK_WAKEUP_FD,
   GRPC_STATS_COUNTER_POLLSET_KICK_WAKEUP_CV,
   GRPC_STATS_COUNTER_POLLSET_KICK_OWN_THREAD,
-  GRPC_STATS_COUNTER_SYSCALL_EPOLL_CTL,
-  GRPC_STATS_COUNTER_POLLSET_FD_CACHE_HITS,
   GRPC_STATS_COUNTER_HISTOGRAM_SLOW_LOOKUPS,
   GRPC_STATS_COUNTER_SYSCALL_WRITE,
   GRPC_STATS_COUNTER_SYSCALL_READ,
@@ -76,6 +74,7 @@ typedef enum {
   GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_STREAM_FLOW_CONTROL,
   GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_TRANSPORT_FLOW_CONTROL,
   GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_SEND_SETTINGS,
+  GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_SETTINGS_ACK,
   GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_BDP_ESTIMATOR_PING,
   GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_FLOW_CONTROL_UNSTALLED_BY_SETTING,
   GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_FLOW_CONTROL_UNSTALLED_BY_UPDATE,
@@ -206,10 +205,6 @@ typedef enum {
   GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_POLLSET_KICK_WAKEUP_CV)
 #define GRPC_STATS_INC_POLLSET_KICK_OWN_THREAD() \
   GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_POLLSET_KICK_OWN_THREAD)
-#define GRPC_STATS_INC_SYSCALL_EPOLL_CTL() \
-  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_SYSCALL_EPOLL_CTL)
-#define GRPC_STATS_INC_POLLSET_FD_CACHE_HITS() \
-  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_POLLSET_FD_CACHE_HITS)
 #define GRPC_STATS_INC_HISTOGRAM_SLOW_LOOKUPS() \
   GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_HISTOGRAM_SLOW_LOOKUPS)
 #define GRPC_STATS_INC_SYSCALL_WRITE() \
@@ -287,6 +282,9 @@ typedef enum {
 #define GRPC_STATS_INC_HTTP2_INITIATE_WRITE_DUE_TO_SEND_SETTINGS() \
   GRPC_STATS_INC_COUNTER(                                          \
       GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_SEND_SETTINGS)
+#define GRPC_STATS_INC_HTTP2_INITIATE_WRITE_DUE_TO_SETTINGS_ACK() \
+  GRPC_STATS_INC_COUNTER(                                         \
+      GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_SETTINGS_ACK)
 #define GRPC_STATS_INC_HTTP2_INITIATE_WRITE_DUE_TO_BDP_ESTIMATOR_PING() \
   GRPC_STATS_INC_COUNTER(                                               \
       GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_BDP_ESTIMATOR_PING)
@@ -398,43 +396,43 @@ typedef enum {
   GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_CQ_EV_QUEUE_TRANSIENT_POP_FAILURES)
 #define GRPC_STATS_INC_CALL_INITIAL_SIZE(value) \
   grpc_stats_inc_call_initial_size((int)(value))
-void grpc_stats_inc_call_initial_size(int value);
+void grpc_stats_inc_call_initial_size(int x);
 #define GRPC_STATS_INC_POLL_EVENTS_RETURNED(value) \
   grpc_stats_inc_poll_events_returned((int)(value))
-void grpc_stats_inc_poll_events_returned(int value);
+void grpc_stats_inc_poll_events_returned(int x);
 #define GRPC_STATS_INC_TCP_WRITE_SIZE(value) \
   grpc_stats_inc_tcp_write_size((int)(value))
-void grpc_stats_inc_tcp_write_size(int value);
+void grpc_stats_inc_tcp_write_size(int x);
 #define GRPC_STATS_INC_TCP_WRITE_IOV_SIZE(value) \
   grpc_stats_inc_tcp_write_iov_size((int)(value))
-void grpc_stats_inc_tcp_write_iov_size(int value);
+void grpc_stats_inc_tcp_write_iov_size(int x);
 #define GRPC_STATS_INC_TCP_READ_SIZE(value) \
   grpc_stats_inc_tcp_read_size((int)(value))
-void grpc_stats_inc_tcp_read_size(int value);
+void grpc_stats_inc_tcp_read_size(int x);
 #define GRPC_STATS_INC_TCP_READ_OFFER(value) \
   grpc_stats_inc_tcp_read_offer((int)(value))
-void grpc_stats_inc_tcp_read_offer(int value);
+void grpc_stats_inc_tcp_read_offer(int x);
 #define GRPC_STATS_INC_TCP_READ_OFFER_IOV_SIZE(value) \
   grpc_stats_inc_tcp_read_offer_iov_size((int)(value))
-void grpc_stats_inc_tcp_read_offer_iov_size(int value);
+void grpc_stats_inc_tcp_read_offer_iov_size(int x);
 #define GRPC_STATS_INC_HTTP2_SEND_MESSAGE_SIZE(value) \
   grpc_stats_inc_http2_send_message_size((int)(value))
-void grpc_stats_inc_http2_send_message_size(int value);
+void grpc_stats_inc_http2_send_message_size(int x);
 #define GRPC_STATS_INC_HTTP2_SEND_INITIAL_METADATA_PER_WRITE(value) \
   grpc_stats_inc_http2_send_initial_metadata_per_write((int)(value))
-void grpc_stats_inc_http2_send_initial_metadata_per_write(int value);
+void grpc_stats_inc_http2_send_initial_metadata_per_write(int x);
 #define GRPC_STATS_INC_HTTP2_SEND_MESSAGE_PER_WRITE(value) \
   grpc_stats_inc_http2_send_message_per_write((int)(value))
-void grpc_stats_inc_http2_send_message_per_write(int value);
+void grpc_stats_inc_http2_send_message_per_write(int x);
 #define GRPC_STATS_INC_HTTP2_SEND_TRAILING_METADATA_PER_WRITE(value) \
   grpc_stats_inc_http2_send_trailing_metadata_per_write((int)(value))
-void grpc_stats_inc_http2_send_trailing_metadata_per_write(int value);
+void grpc_stats_inc_http2_send_trailing_metadata_per_write(int x);
 #define GRPC_STATS_INC_HTTP2_SEND_FLOWCTL_PER_WRITE(value) \
   grpc_stats_inc_http2_send_flowctl_per_write((int)(value))
-void grpc_stats_inc_http2_send_flowctl_per_write(int value);
+void grpc_stats_inc_http2_send_flowctl_per_write(int x);
 #define GRPC_STATS_INC_SERVER_CQS_CHECKED(value) \
   grpc_stats_inc_server_cqs_checked((int)(value))
-void grpc_stats_inc_server_cqs_checked(int value);
+void grpc_stats_inc_server_cqs_checked(int x);
 #else
 #define GRPC_STATS_INC_CLIENT_CALLS_CREATED()
 #define GRPC_STATS_INC_SERVER_CALLS_CREATED()
@@ -450,8 +448,6 @@ void grpc_stats_inc_server_cqs_checked(int value);
 #define GRPC_STATS_INC_POLLSET_KICK_WAKEUP_FD()
 #define GRPC_STATS_INC_POLLSET_KICK_WAKEUP_CV()
 #define GRPC_STATS_INC_POLLSET_KICK_OWN_THREAD()
-#define GRPC_STATS_INC_SYSCALL_EPOLL_CTL()
-#define GRPC_STATS_INC_POLLSET_FD_CACHE_HITS()
 #define GRPC_STATS_INC_HISTOGRAM_SLOW_LOOKUPS()
 #define GRPC_STATS_INC_SYSCALL_WRITE()
 #define GRPC_STATS_INC_SYSCALL_READ()
@@ -484,6 +480,7 @@ void grpc_stats_inc_server_cqs_checked(int value);
 #define GRPC_STATS_INC_HTTP2_INITIATE_WRITE_DUE_TO_STREAM_FLOW_CONTROL()
 #define GRPC_STATS_INC_HTTP2_INITIATE_WRITE_DUE_TO_TRANSPORT_FLOW_CONTROL()
 #define GRPC_STATS_INC_HTTP2_INITIATE_WRITE_DUE_TO_SEND_SETTINGS()
+#define GRPC_STATS_INC_HTTP2_INITIATE_WRITE_DUE_TO_SETTINGS_ACK()
 #define GRPC_STATS_INC_HTTP2_INITIATE_WRITE_DUE_TO_BDP_ESTIMATOR_PING()
 #define GRPC_STATS_INC_HTTP2_INITIATE_WRITE_DUE_TO_FLOW_CONTROL_UNSTALLED_BY_SETTING()
 #define GRPC_STATS_INC_HTTP2_INITIATE_WRITE_DUE_TO_FLOW_CONTROL_UNSTALLED_BY_UPDATE()

data/src/core/{ext/filters/max_age/max_age_filter.h → lib/event_engine/default_event_engine_factory.cc}

@@ -1,5 +1,4 @@
-//
-// Copyright 2017 gRPC authors.
+// Copyright 2022 The gRPC Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,15 +11,17 @@
 // 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_EXT_FILTERS_MAX_AGE_MAX_AGE_FILTER_H
-#define GRPC_CORE_EXT_FILTERS_MAX_AGE_MAX_AGE_FILTER_H
-
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/event_engine/event_engine_factory.h"
+
+namespace grpc_event_engine {
+namespace experimental {
 
-extern const grpc_channel_filter grpc_max_age_filter;
+std::unique_ptr<EventEngine> DefaultEventEngineFactory() {
+  // TODO(hork): call LibuvEventEngineFactory
+  return nullptr;
+}
 
-#endif /* GRPC_CORE_EXT_FILTERS_MAX_AGE_MAX_AGE_FILTER_H */
+}  // namespace experimental
+}  // namespace grpc_event_engine

data/src/core/lib/event_engine/event_engine.cc

@@ -17,21 +17,36 @@
 #include <grpc/event_engine/port.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/event_engine/event_engine_factory.h"
+#include "src/core/lib/gprpp/sync.h"
+
 namespace grpc_event_engine {
 namespace experimental {
 
-EventEngine::ResolvedAddress::ResolvedAddress(const sockaddr* address,
-                                              socklen_t size)
-    : size_(size) {
-  GPR_ASSERT(size <= sizeof(address_));
-  memcpy(&address_, address, size);
+namespace {
+const std::function<std::unique_ptr<EventEngine>()>* g_event_engine_factory =
+    nullptr;
+grpc_core::Mutex* g_mu = new grpc_core::Mutex();
+}  // namespace
+
+void SetDefaultEventEngineFactory(
+    const std::function<std::unique_ptr<EventEngine>()>* factory) {
+  grpc_core::MutexLock lock(g_mu);
+  g_event_engine_factory = factory;
 }
 
-const struct sockaddr* EventEngine::ResolvedAddress::address() const {
-  return reinterpret_cast<const struct sockaddr*>(address_);
+std::unique_ptr<EventEngine> CreateEventEngine() {
+  grpc_core::MutexLock lock(g_mu);
+  if (g_event_engine_factory != nullptr) {
+    return (*g_event_engine_factory)();
+  }
+  return DefaultEventEngineFactory();
 }
 
-socklen_t EventEngine::ResolvedAddress::size() const { return size_; }
+EventEngine* GetDefaultEventEngine() {
+  static EventEngine* default_event_engine = CreateEventEngine().release();
+  return default_event_engine;
+}
 
 }  // namespace experimental
 }  // namespace grpc_event_engine

data/src/core/lib/event_engine/event_engine_factory.h

@@ -27,6 +27,9 @@ namespace experimental {
 /// Strongly consider whether you could use \a CreateEventEngine instead.
 EventEngine* GetDefaultEventEngine();
 
+/// Create an EventEngine using the default factory provided at link time.
+std::unique_ptr<EventEngine> DefaultEventEngineFactory();
+
 }  // namespace experimental
 }  // namespace grpc_event_engine
 

data/src/core/lib/event_engine/memory_allocator.cc

@@ -26,28 +26,24 @@ namespace {
 
 // Reference count for a slice allocated by MemoryAllocator::MakeSlice.
 // Takes care of releasing memory back when the slice is destroyed.
-class SliceRefCount {
+class SliceRefCount : public grpc_slice_refcount {
  public:
-  static void Destroy(void* p) {
-    auto* rc = static_cast<SliceRefCount*>(p);
-    rc->~SliceRefCount();
-    gpr_free(rc);
-  }
   SliceRefCount(std::shared_ptr<internal::MemoryAllocatorImpl> allocator,
                 size_t size)
-      : base_(grpc_slice_refcount::Type::REGULAR, &refs_, Destroy, this,
-              &base_),
+      : grpc_slice_refcount(Destroy),
         allocator_(std::move(allocator)),
         size_(size) {
     // Nothing to do here.
   }
   ~SliceRefCount() { allocator_->Release(size_); }
 
-  grpc_slice_refcount* base_refcount() { return &base_; }
-
  private:
-  grpc_slice_refcount base_;
-  std::atomic<size_t> refs_{1};
+  static void Destroy(grpc_slice_refcount* p) {
+    auto* rc = static_cast<SliceRefCount*>(p);
+    rc->~SliceRefCount();
+    gpr_free(rc);
+  }
+
   std::shared_ptr<internal::MemoryAllocatorImpl> allocator_;
   size_t size_;
 };
@@ -59,7 +55,7 @@ grpc_slice MemoryAllocator::MakeSlice(MemoryRequest request) {
   void* p = gpr_malloc(size);
   new (p) SliceRefCount(allocator_, size);
   grpc_slice slice;
-  slice.refcount = static_cast<SliceRefCount*>(p)->base_refcount();
+  slice.refcount = static_cast<SliceRefCount*>(p);
   slice.data.refcounted.bytes =
       static_cast<uint8_t*>(p) + sizeof(SliceRefCount);
   slice.data.refcounted.length = size - sizeof(SliceRefCount);

data/src/core/lib/event_engine/{event_engine_factory.cc → resolved_address.cc}

@@ -14,36 +14,26 @@
 #include <grpc/support/port_platform.h>
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/port.h>
+#include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/sync.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
-namespace {
-std::function<std::unique_ptr<EventEngine>()>* g_event_engine_factory = nullptr;
-grpc_core::Mutex* g_mu = new grpc_core::Mutex();
-}  // namespace
-
-EventEngine* GetDefaultEventEngine() {
-  static EventEngine* default_event_engine = CreateEventEngine().release();
-  return default_event_engine;
+EventEngine::ResolvedAddress::ResolvedAddress(const sockaddr* address,
+                                              socklen_t size)
+    : size_(size) {
+  GPR_ASSERT(size <= sizeof(address_));
+  memcpy(&address_, address, size);
 }
 
-void SetDefaultEventEngineFactory(
-    std::function<std::unique_ptr<EventEngine>()>* factory) {
-  grpc_core::MutexLock lock(g_mu);
-  g_event_engine_factory = factory;
+const struct sockaddr* EventEngine::ResolvedAddress::address() const {
+  return reinterpret_cast<const struct sockaddr*>(address_);
 }
 
-std::unique_ptr<EventEngine> CreateEventEngine() {
-  grpc_core::MutexLock lock(g_mu);
-  if (g_event_engine_factory == nullptr) {
-    // TODO(hork): call LibuvEventEngineFactory
-    abort();
-  }
-  return (*g_event_engine_factory)();
-}
+socklen_t EventEngine::ResolvedAddress::size() const { return size_; }
 
 }  // namespace experimental
 }  // namespace grpc_event_engine

data/src/core/lib/gpr/sync_posix.cc

@@ -131,6 +131,7 @@ int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) {
     abs_deadline = gpr_convert_clock_type(abs_deadline, GPR_CLOCK_MONOTONIC);
 #else
     abs_deadline = gpr_convert_clock_type(abs_deadline, GPR_CLOCK_REALTIME);
+    abs_deadline = gpr_time_max(abs_deadline, gpr_now(abs_deadline.clock_type));
 #endif  // GPR_LINUX
     abs_deadline_ts.tv_sec = static_cast<time_t>(abs_deadline.tv_sec);
     abs_deadline_ts.tv_nsec = abs_deadline.tv_nsec;

data/src/core/lib/gpr/time.cc

@@ -184,7 +184,8 @@ gpr_timespec gpr_time_sub(gpr_timespec a, gpr_timespec b) {
     dec++;
   }
   if (a.tv_sec == INT64_MAX || a.tv_sec == INT64_MIN) {
-    diff = a;
+    diff.tv_sec = a.tv_sec;
+    diff.tv_nsec = a.tv_nsec;
   } else if (b.tv_sec == INT64_MIN ||
              (b.tv_sec <= 0 && a.tv_sec >= INT64_MAX + b.tv_sec)) {
     diff = gpr_inf_future(GPR_CLOCK_REALTIME);

data/src/core/lib/gpr/tls.h

@@ -50,6 +50,7 @@ class TlsTypeConstrainer {
 
 #include <pthread.h>
 
+#include <algorithm>
 #include <array>
 #include <cstring>
 

data/src/core/lib/gpr/useful.h

@@ -106,6 +106,20 @@ constexpr size_t HashPointer(T* p, size_t range) {
          range;
 }
 
+// Compute a+b.
+// If the result is greater than INT64_MAX, return INT64_MAX.
+// If the result is less than INT64_MIN, return INT64_MIN.
+inline int64_t SaturatingAdd(int64_t a, int64_t b) {
+  if (a > 0) {
+    if (b > INT64_MAX - a) {
+      return INT64_MAX;
+    }
+  } else if (b < INT64_MIN - a) {
+    return INT64_MIN;
+  }
+  return a + b;
+}
+
 inline uint32_t MixHash32(uint32_t a, uint32_t b) {
   return RotateLeft(a, 2u) ^ b;
 }

data/src/core/lib/gprpp/bitset.h

@@ -153,6 +153,18 @@ class BitSet {
     return true;
   }
 
+  template <typename Int>
+  typename std::enable_if<std::is_unsigned<Int>::value &&
+                              (sizeof(Int) * 8 >= kTotalBits),
+                          Int>::type
+  ToInt() const {
+    Int result = 0;
+    for (size_t i = 0; i < kTotalBits; i++) {
+      if (is_set(i)) result |= (Int(1) << i);
+    }
+    return result;
+  }
+
  private:
   // Given a bit index, return which unit it's stored in.
   static constexpr size_t unit_for(size_t bit) { return bit / kUnitBits; }

data/src/core/lib/gprpp/capture.h

@@ -0,0 +1,76 @@
+// Copyright 2021 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_GPRPP_CAPTURE_H
+#define GRPC_CORE_LIB_GPRPP_CAPTURE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <tuple>
+#include <utility>
+
+#include "absl/utility/utility.h"
+
+namespace grpc_core {
+
+namespace detail {
+
+template <typename F, typename... Captures>
+class Capture {
+ public:
+  explicit Capture(F f, Captures... captures)
+      : f_(std::move(f)), captures_(std::move(captures)...) {}
+
+  template <typename... Args>
+  decltype(std::declval<F>()(static_cast<Captures*>(nullptr)...,
+                             std::declval<Args>()...))
+  operator()(Args... args) {
+    auto f = &f_;
+    return absl::apply(
+        [f, &args...](Captures&... captures) {
+          return (*f)(&captures..., std::move(args)...);
+        },
+        captures_);
+  }
+
+ private:
+  GPR_NO_UNIQUE_ADDRESS F f_;
+  GPR_NO_UNIQUE_ADDRESS std::tuple<Captures...> captures_;
+};
+
+}  // namespace detail
+
+// C++11 helper - best explained by usage:
+//
+// BigThing big_thing;
+// auto f = Capture(
+//             [](BigThing* c, int a, int b) { /*...*/ },
+//             std::move(big_thing));
+//
+// results in: f being a callable that takes arguments (int a, int b), and
+// captures the original value of big_thing by move. Each call, a pointer to
+// each captured thing is inserted into the argument list at the beginning so it
+// can be manipulated.
+//
+// Captured values are mutable, and it's the users responsibility to ensure,
+// should this callable be invoked from different threads, that proper locking
+// is implemented.
+template <typename F, typename... Captures>
+detail::Capture<F, Captures...> Capture(F f, Captures... captures) {
+  return detail::Capture<F, Captures...>(std::move(f), std::move(captures)...);
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_CAPTURE_H

data/src/core/lib/gprpp/cpp_impl_of.h

@@ -31,6 +31,10 @@ class CppImplOf {
     return reinterpret_cast<CppType*>(c_type);
   }
 
+  static const CppType* FromC(const CType* c_type) {
+    return reinterpret_cast<const CppType*>(c_type);
+  }
+
   // Retrieve a c pointer (of the same ownership as this)
   CType* c_ptr() {
     return reinterpret_cast<CType*>(static_cast<CppType*>(this));

data/src/core/lib/gprpp/debug_location.h

@@ -42,6 +42,8 @@ class DebugLocation {
 #else
 class DebugLocation {
  public:
+  DebugLocation() {}
+  DebugLocation(const char* /* file */, int /* line */) {}
   const char* file() const { return nullptr; }
   int line() const { return -1; }
 };

data/src/core/lib/gprpp/match.h

@@ -0,0 +1,73 @@
+// Copyright 2021 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_GPRPP_MATCH_H
+#define GRPC_CORE_LIB_GPRPP_MATCH_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/types/variant.h"
+
+#include "src/core/lib/gprpp/overload.h"
+
+namespace grpc_core {
+
+namespace detail {
+
+template <typename... Cases>
+struct MatchPointerExtractor {
+  OverloadType<Cases...> cases;
+  template <typename T>
+  auto operator()(T& value) -> decltype(cases(&value)) {
+    return cases(&value);
+  }
+};
+
+}  // namespace detail
+
+/// Match on a variant.
+/// Given variant \a value, and a set of callables \a fs, call the appropriate
+/// callable based on the type contained in \a value.
+///
+/// Example (prints "hoorah"):
+///   variant<int, string> v = 42;
+///   Match(v,
+///         [](int i) { puts("hoorah"); },
+///         [](string s) { puts("boo"); });
+template <typename... Fs, typename T0, typename... Ts>
+auto Match(const absl::variant<T0, Ts...>& value, Fs... fs)
+    -> decltype(std::declval<OverloadType<Fs...>>()(std::declval<T0>())) {
+  return absl::visit(Overload(std::move(fs)...), value);
+}
+
+/// A version of Match that takes a mutable pointer to a variant and calls its
+/// overload callables with a mutable pointer to the current variant value.
+///
+/// Example:
+///   variant<int, string> v = 42;
+///   MatchMutable(&v,
+///                [](int* i) { *i = 1; },
+///                [](string* s) { *s = "foo"; });
+///   // v now contains 1.
+template <typename... Fs, typename T0, typename... Ts>
+auto MatchMutable(absl::variant<T0, Ts...>* value, Fs... fs)
+    -> decltype(std::declval<OverloadType<Fs...>>()(std::declval<T0*>())) {
+  return absl::visit(detail::MatchPointerExtractor<Fs...>{OverloadType<Fs...>(
+                         std::move(fs)...)},
+                     *value);
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_MATCH_H

data/src/core/lib/gprpp/overload.h

@@ -0,0 +1,59 @@
+// Copyright 2021 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_GPRPP_OVERLOAD_H
+#define GRPC_CORE_LIB_GPRPP_OVERLOAD_H
+
+#include <grpc/support/port_platform.h>
+
+#include <utility>
+
+namespace grpc_core {
+
+template <typename... Cases>
+struct OverloadType;
+// Compose one overload with N more -- use inheritance to leverage using and the
+// empty base class optimization.
+template <typename Case, typename... Cases>
+struct OverloadType<Case, Cases...> : public Case,
+                                      public OverloadType<Cases...> {
+  explicit OverloadType(Case&& c, Cases&&... cases)
+      : Case(std::forward<Case>(c)),
+        OverloadType<Cases...>(std::forward<Cases>(cases)...) {}
+  using Case::operator();
+  using OverloadType<Cases...>::operator();
+};
+// Overload of a single case is just that case itself
+template <typename Case>
+struct OverloadType<Case> : public Case {
+  explicit OverloadType(Case&& c) : Case(std::forward<Case>(c)) {}
+  using Case::operator();
+};
+
+/// Compose callables into a single callable.
+/// e.g. given [](int i) { puts("a"); } and [](double d) { puts("b"); },
+/// return a callable object like:
+/// struct {
+///   void operator()(int i) { puts("a"); }
+///   void operator()(double i) { puts("b"); }
+/// };
+/// Preserves all captures.
+template <typename... Cases>
+OverloadType<Cases...> Overload(Cases... cases) {
+  return OverloadType<Cases...>(std::move(cases)...);
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_OVERLOAD_H

data/src/core/lib/gprpp/ref_counted.h

@@ -281,6 +281,8 @@ template <typename Child, typename Impl = PolymorphicRefCount,
           UnrefBehavior UnrefBehaviorArg = kUnrefDelete>
 class RefCounted : public Impl {
  public:
+  using RefCountedChildType = Child;
+
   // Note: Depending on the Impl used, this dtor can be implicitly virtual.
   ~RefCounted() = default;