grpc 1.69.0 → 1.71.0

data/include/grpc/event_engine/endpoint_config.h

@@ -16,10 +16,10 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <string>
 
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 
 namespace grpc_event_engine {
 namespace experimental {
@@ -32,11 +32,11 @@ class EndpointConfig {
  public:
   virtual ~EndpointConfig() = default;
   // If the key points to an integer config, an integer value gets returned.
-  // Otherwise it returns an absl::nullopt_t
-  virtual absl::optional<int> GetInt(absl::string_view key) const = 0;
+  // Otherwise it returns an std::nullopt_t
+  virtual std::optional<int> GetInt(absl::string_view key) const = 0;
   // If the key points to an string config, an string value gets returned.
-  // Otherwise it returns an absl::nullopt_t
-  virtual absl::optional<absl::string_view> GetString(
+  // Otherwise it returns an std::nullopt_t
+  virtual std::optional<absl::string_view> GetString(
       absl::string_view key) const = 0;
   // If the key points to an void* config, a void* pointer value gets returned.
   // Otherwise it returns nullptr

data/include/grpc/event_engine/event_engine.h

@@ -28,6 +28,7 @@
 #include "absl/status/statusor.h"
 
 // TODO(vigneshbabu): Define the Endpoint::Write metrics collection system
+// TODO(hork): remove all references to the factory methods.
 namespace grpc_event_engine {
 namespace experimental {
 
@@ -471,7 +472,7 @@ class EventEngine : public std::enable_shared_from_this<EventEngine>,
   virtual bool Cancel(TaskHandle handle) = 0;
 };
 
-/// Replace gRPC's default EventEngine factory.
+/// [DEPRECATED] Replace gRPC's default EventEngine factory.
 ///
 /// Applications may call \a SetEventEngineFactory at any time to replace the
 /// default factory used within gRPC. EventEngines will be created when
@@ -480,18 +481,56 @@ class EventEngine : public std::enable_shared_from_this<EventEngine>,
 /// To be certain that none of the gRPC-provided built-in EventEngines are
 /// created, applications must set a custom EventEngine factory method *before*
 /// grpc is initialized.
+// TODO(hork): delete once all known users have migrated away
 void SetEventEngineFactory(
-    absl::AnyInvocable<std::unique_ptr<EventEngine>()> factory);
+    absl::AnyInvocable<std::shared_ptr<EventEngine>()> factory);
 
-/// Reset gRPC's EventEngine factory to the built-in default.
+/// [DEPRECATED] Reset gRPC's EventEngine factory to the built-in default.
 ///
 /// Applications that have called \a SetEventEngineFactory can remove their
 /// custom factory using this method. The built-in EventEngine factories will be
 /// used going forward. This has no affect on any EventEngines that were created
 /// using the previous factories.
+//
+// TODO(hork): delete once all known users have migrated away
 void EventEngineFactoryReset();
-/// Create an EventEngine using the default factory.
-std::unique_ptr<EventEngine> CreateEventEngine();
+
+/// Create a new EventEngine instance.
+std::shared_ptr<EventEngine> CreateEventEngine();
+
+/// Set the default EventEngine instance, which will be used throughout gRPC
+///
+/// gRPC will hold a ref to this engine until either
+/// \a ShutdownDefaultEventEngine() is called or \a SetDefaultEventEngine() is
+/// called again with a different value. Passing a value of nullptr will cause
+/// gRPC to drop the ref it was holding without setting it to a new one.
+///
+/// Earlier calls to \a GetDefaultEventEngine will still hold a ref to the
+/// previous default engine instance, if any.
+void SetDefaultEventEngine(std::shared_ptr<EventEngine> engine);
+
+/// Returns the default EventEngine instance.
+///
+/// Note that if SetDefaultEventEngine() has not been called, then the default
+/// EventEngine may be created and destroyed as needed, meaning that multiple
+/// calls to GetDefaultEventEngine() over a process's lifetime may return
+/// different instances. Callers are expected to call GetDefaultEventEngine()
+/// once and hold the returned reference for as long as they need the
+/// EventEngine instance.
+std::shared_ptr<EventEngine> GetDefaultEventEngine();
+
+/// Resets gRPC to use one of the default internal EventEngines for all *new*
+/// \a GetDefaultEventEngine requests and blocks until all refs on the active
+/// default engine have been released (destroying that engine).
+///
+/// If you called \a SetDefaultEventEngine, you must call either
+/// \a ShutdownDefaultEventEngine or \a SetDefaultEventEngine(nullptr) at the
+/// end of your program. If you don't, the engine will never be destroyed.
+///
+/// If you want to reset the default engine to one of gRPC's internal versions
+/// without waiting for all references to be released on the current default
+/// engine, call \a SetDefaultEventEngine(nullptr) instead.
+void ShutdownDefaultEventEngine();
 
 bool operator==(const EventEngine::TaskHandle& lhs,
                 const EventEngine::TaskHandle& rhs);

data/include/grpc/status.h

@@ -146,7 +146,7 @@ typedef enum {
   GRPC_STATUS_DATA_LOSS = 15,
 
   /** Force users to include a default branch: */
-  GRPC_STATUS__DO_NOT_USE = -1
+  GRPC_STATUS__DO_NOT_USE = 0x7fffffffu,
 } grpc_status_code;
 
 #ifdef __cplusplus

data/include/grpc/support/atm.h

@@ -79,17 +79,4 @@
 #error could not determine platform for atm
 #endif
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** Adds \a delta to \a *value, clamping the result to the range specified
-    by \a min and \a max.  Returns the new value. */
-gpr_atm gpr_atm_no_barrier_clamped_add(gpr_atm* value, gpr_atm delta,
-                                       gpr_atm min, gpr_atm max);
-
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_SUPPORT_ATM_H */

data/include/grpc/support/json.h

@@ -23,10 +23,10 @@
 #include <map>
 #include <string>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "absl/strings/str_cat.h"
-#include "absl/types/variant.h"
 
 namespace grpc_core {
 namespace experimental {
@@ -147,46 +147,46 @@ class Json {
 
   // Moveable.
   Json(Json&& other) noexcept : value_(std::move(other.value_)) {
-    other.value_ = absl::monostate();
+    other.value_ = std::monostate();
   }
   Json& operator=(Json&& other) noexcept {
     value_ = std::move(other.value_);
-    other.value_ = absl::monostate();
+    other.value_ = std::monostate();
     return *this;
   }
 
   // Returns the JSON type.
   Type type() const {
     struct ValueFunctor {
-      Json::Type operator()(const absl::monostate&) { return Type::kNull; }
+      Json::Type operator()(const std::monostate&) { return Type::kNull; }
       Json::Type operator()(bool) { return Type::kBoolean; }
       Json::Type operator()(const NumberValue&) { return Type::kNumber; }
       Json::Type operator()(const std::string&) { return Type::kString; }
       Json::Type operator()(const Object&) { return Type::kObject; }
       Json::Type operator()(const Array&) { return Type::kArray; }
     };
-    return absl::visit(ValueFunctor(), value_);
+    return std::visit(ValueFunctor(), value_);
   }
 
   // Payload accessor for kBoolean.
   // Must not be called for other types.
-  bool boolean() const { return absl::get<bool>(value_); }
+  bool boolean() const { return std::get<bool>(value_); }
 
   // Payload accessor for kNumber or kString.
   // Must not be called for other types.
   const std::string& string() const {
-    const NumberValue* num = absl::get_if<NumberValue>(&value_);
+    const NumberValue* num = std::get_if<NumberValue>(&value_);
     if (num != nullptr) return num->value;
-    return absl::get<std::string>(value_);
+    return std::get<std::string>(value_);
   }
 
   // Payload accessor for kObject.
   // Must not be called for other types.
-  const Object& object() const { return absl::get<Object>(value_); }
+  const Object& object() const { return std::get<Object>(value_); }
 
   // Payload accessor for kArray.
   // Must not be called for other types.
-  const Array& array() const { return absl::get<Array>(value_); }
+  const Array& array() const { return std::get<Array>(value_); }
 
   bool operator==(const Json& other) const { return value_ == other.value_; }
   bool operator!=(const Json& other) const { return !(*this == other); }
@@ -199,12 +199,12 @@ class Json {
       return value == other.value;
     }
   };
-  using Value = absl::variant<absl::monostate,  // kNull
-                              bool,             // kBoolean
-                              NumberValue,      // kNumber
-                              std::string,      // kString
-                              Object,           // kObject
-                              Array>;           // kArray
+  using Value = std::variant<std::monostate,  // kNull
+                             bool,            // kBoolean
+                             NumberValue,     // kNumber
+                             std::string,     // kString
+                             Object,          // kObject
+                             Array>;          // kArray
 
   explicit Json(Value value) : value_(std::move(value)) {}
 

data/src/core/call/request_buffer.cc

@@ -0,0 +1,224 @@
+// Copyright 2024 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/core/call/request_buffer.h"
+
+#include <cstdint>
+#include <optional>
+
+#include "absl/strings/str_cat.h"
+#include "src/core/util/match.h"
+
+namespace grpc_core {
+
+RequestBuffer::Buffering::Buffering() {}
+
+RequestBuffer::RequestBuffer() : state_(absl::in_place_type_t<Buffering>()) {}
+
+ValueOrFailure<size_t> RequestBuffer::PushClientInitialMetadata(
+    ClientMetadataHandle md) {
+  MutexLock lock(&mu_);
+  if (std::get_if<Cancelled>(&state_)) return Failure{};
+  auto& buffering = std::get<Buffering>(state_);
+  CHECK_EQ(buffering.initial_metadata.get(), nullptr);
+  buffering.initial_metadata = std::move(md);
+  buffering.buffered += buffering.initial_metadata->TransportSize();
+  WakeupAsyncAllPullers();
+  return buffering.buffered;
+}
+
+Poll<ValueOrFailure<size_t>> RequestBuffer::PollPushMessage(
+    MessageHandle& message) {
+  MutexLock lock(&mu_);
+  if (std::get_if<Cancelled>(&state_)) return Failure{};
+  size_t buffered = 0;
+  if (auto* buffering = std::get_if<Buffering>(&state_)) {
+    if (winner_ != nullptr) return PendingPush();
+    buffering->buffered += message->payload()->Length();
+    buffered = buffering->buffered;
+    buffering->messages.push_back(std::move(message));
+  } else {
+    auto& streaming = std::get<Streaming>(state_);
+    CHECK_EQ(streaming.end_of_stream, false);
+    if (streaming.message != nullptr) {
+      return PendingPush();
+    }
+    streaming.message = std::move(message);
+  }
+  WakeupAsyncAllPullers();
+  return buffered;
+}
+
+StatusFlag RequestBuffer::FinishSends() {
+  MutexLock lock(&mu_);
+  if (std::get_if<Cancelled>(&state_)) return Failure{};
+  if (auto* buffering = std::get_if<Buffering>(&state_)) {
+    Buffered buffered(std::move(buffering->initial_metadata),
+                      std::move(buffering->messages));
+    state_.emplace<Buffered>(std::move(buffered));
+  } else {
+    auto& streaming = std::get<Streaming>(state_);
+    CHECK_EQ(streaming.end_of_stream, false);
+    streaming.end_of_stream = true;
+  }
+  WakeupAsyncAllPullers();
+  return Success{};
+}
+
+void RequestBuffer::Cancel(absl::Status error) {
+  MutexLock lock(&mu_);
+  if (std::holds_alternative<Cancelled>(state_)) return;
+  state_.emplace<Cancelled>(std::move(error));
+  WakeupAsyncAllPullers();
+}
+
+void RequestBuffer::Commit(Reader* winner) {
+  MutexLock lock(&mu_);
+  CHECK_EQ(winner_, nullptr);
+  winner_ = winner;
+  if (auto* buffering = std::get_if<Buffering>(&state_)) {
+    if (buffering->initial_metadata != nullptr &&
+        winner->message_index_ == buffering->messages.size() &&
+        winner->pulled_client_initial_metadata_) {
+      state_.emplace<Streaming>();
+    }
+  } else if (auto* buffered = std::get_if<Buffered>(&state_)) {
+    CHECK_NE(buffered->initial_metadata.get(), nullptr);
+    if (winner->message_index_ == buffered->messages.size()) {
+      state_.emplace<Streaming>().end_of_stream = true;
+    }
+  }
+  WakeupAsyncAllPullersExcept(winner);
+}
+
+void RequestBuffer::WakeupAsyncAllPullersExcept(Reader* except_reader) {
+  for (auto wakeup_reader : readers_) {
+    if (wakeup_reader == except_reader) continue;
+    wakeup_reader->pull_waker_.WakeupAsync();
+  }
+}
+
+Poll<ValueOrFailure<ClientMetadataHandle>>
+RequestBuffer::Reader::PollPullClientInitialMetadata() {
+  MutexLock lock(&buffer_->mu_);
+  if (buffer_->winner_ != nullptr && buffer_->winner_ != this) {
+    error_ = absl::CancelledError("Another call was chosen");
+    return Failure{};
+  }
+  if (auto* buffering = std::get_if<Buffering>(&buffer_->state_)) {
+    if (buffering->initial_metadata.get() == nullptr) {
+      return buffer_->PendingPull(this);
+    }
+    pulled_client_initial_metadata_ = true;
+    auto result = ClaimObject(buffering->initial_metadata);
+    buffer_->MaybeSwitchToStreaming();
+    return std::move(result);
+  }
+  if (auto* buffered = std::get_if<Buffered>(&buffer_->state_)) {
+    pulled_client_initial_metadata_ = true;
+    return ClaimObject(buffered->initial_metadata);
+  }
+  error_ = std::get<Cancelled>(buffer_->state_).error;
+  return Failure{};
+}
+
+Poll<ValueOrFailure<std::optional<MessageHandle>>>
+RequestBuffer::Reader::PollPullMessage() {
+  ReleasableMutexLock lock(&buffer_->mu_);
+  if (buffer_->winner_ != nullptr && buffer_->winner_ != this) {
+    error_ = absl::CancelledError("Another call was chosen");
+    return Failure{};
+  }
+  if (auto* buffering = std::get_if<Buffering>(&buffer_->state_)) {
+    if (message_index_ == buffering->messages.size()) {
+      return buffer_->PendingPull(this);
+    }
+    const auto idx = message_index_;
+    auto result = ClaimObject(buffering->messages[idx]);
+    ++message_index_;
+    buffer_->MaybeSwitchToStreaming();
+    return std::move(result);
+  }
+  if (auto* buffered = std::get_if<Buffered>(&buffer_->state_)) {
+    if (message_index_ == buffered->messages.size()) return std::nullopt;
+    const auto idx = message_index_;
+    ++message_index_;
+    return ClaimObject(buffered->messages[idx]);
+  }
+  if (auto* streaming = std::get_if<Streaming>(&buffer_->state_)) {
+    if (streaming->message == nullptr) {
+      if (streaming->end_of_stream) return std::nullopt;
+      return buffer_->PendingPull(this);
+    }
+    auto msg = std::move(streaming->message);
+    auto waker = std::move(buffer_->push_waker_);
+    lock.Release();
+    waker.Wakeup();
+    return std::move(msg);
+  }
+  error_ = std::get<Cancelled>(buffer_->state_).error;
+  return Failure{};
+}
+
+std::string RequestBuffer::DebugString(Reader* caller)
+    ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+  return absl::StrCat(
+      "have_winner=",
+      (winner_ == nullptr ? "no" : (winner_ == caller ? "this" : "other")),
+      " num_readers=", readers_.size(),
+      " push_waker=", push_waker_.DebugString(),
+      Match(
+          state_,
+          [](const Buffering& buffering) {
+            return absl::StrCat(
+                " buffering initial_metadata=",
+                (buffering.initial_metadata != nullptr
+                     ? buffering.initial_metadata->DebugString()
+                     : "null"),
+                " messages=[",
+                absl::StrJoin(
+                    buffering.messages, ",",
+                    [](std::string* output, const MessageHandle& hdl) {
+                      absl::StrAppend(output, hdl->DebugString());
+                    }),
+                "] buffered=", buffering.buffered);
+          },
+          [](const Buffered& buffered) {
+            return absl::StrCat(
+                " buffered initial_metadata=",
+                (buffered.initial_metadata != nullptr
+                     ? buffered.initial_metadata->DebugString()
+                     : "null"),
+                " messages=[",
+                absl::StrJoin(
+                    buffered.messages, ",",
+                    [](std::string* output, const MessageHandle& hdl) {
+                      absl::StrAppend(
+                          output, hdl != nullptr ? hdl->DebugString() : "null");
+                    }),
+                "]");
+          },
+          [](const Streaming& streaming) {
+            return absl::StrCat(
+                " streaming message=",
+                (streaming.message != nullptr ? streaming.message->DebugString()
+                                              : "null"),
+                " end_of_stream=", streaming.end_of_stream);
+          },
+          [](const Cancelled& cancelled) {
+            return absl::StrCat(" cancelled error=",
+                                cancelled.error.ToString());
+          }));
+}
+}  // namespace grpc_core

data/src/core/call/request_buffer.h

@@ -0,0 +1,192 @@
+// Copyright 2024 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_SRC_CORE_CALL_REQUEST_BUFFER_H
+#define GRPC_SRC_CORE_CALL_REQUEST_BUFFER_H
+
+#include <utility>
+
+#include "src/core/lib/transport/call_spine.h"
+#include "src/core/lib/transport/message.h"
+#include "src/core/lib/transport/metadata.h"
+
+namespace grpc_core {
+
+// Outbound request buffer.
+// Collects client->server metadata and messages whilst in its initial buffering
+// mode. In buffering mode it can have zero or more Reader objects attached to
+// it.
+// The buffer can later be switched to committed mode, at which point it
+// will have exactly one Reader object attached to it.
+// Callers can choose to switch to committed mode based upon policy of their
+// choice.
+class RequestBuffer {
+ public:
+  // One reader of the request buffer.
+  class Reader {
+   public:
+    explicit Reader(RequestBuffer* buffer) ABSL_LOCKS_EXCLUDED(buffer->mu_)
+        : buffer_(buffer) {
+      buffer->AddReader(this);
+    }
+    ~Reader() ABSL_LOCKS_EXCLUDED(buffer_->mu_) { buffer_->RemoveReader(this); }
+
+    Reader(const Reader&) = delete;
+    Reader& operator=(const Reader&) = delete;
+
+    // Pull client initial metadata. Returns a promise that resolves to
+    // ValueOrFailure<ClientMetadataHandle>.
+    GRPC_MUST_USE_RESULT auto PullClientInitialMetadata() {
+      return [this]() { return PollPullClientInitialMetadata(); };
+    }
+    // Pull a message. Returns a promise that resolves to a
+    // ValueOrFailure<std::optional<MessageHandle>>.
+    GRPC_MUST_USE_RESULT auto PullMessage() {
+      return [this]() { return PollPullMessage(); };
+    }
+
+    absl::Status TakeError() { return std::move(error_); }
+
+   private:
+    friend class RequestBuffer;
+
+    Poll<ValueOrFailure<ClientMetadataHandle>> PollPullClientInitialMetadata();
+    Poll<ValueOrFailure<std::optional<MessageHandle>>> PollPullMessage();
+
+    template <typename T>
+    T ClaimObject(T& object) ABSL_EXCLUSIVE_LOCKS_REQUIRED(buffer_->mu_) {
+      if (buffer_->winner_ == this) return std::move(object);
+      return CopyObject(object);
+    }
+
+    ClientMetadataHandle CopyObject(const ClientMetadataHandle& md) {
+      return Arena::MakePooled<ClientMetadata>(md->Copy());
+    }
+
+    MessageHandle CopyObject(const MessageHandle& msg) {
+      return Arena::MakePooled<Message>(msg->payload()->Copy(), msg->flags());
+    }
+
+    RequestBuffer* const buffer_;
+    bool pulled_client_initial_metadata_ = false;
+    size_t message_index_ = 0;
+    absl::Status error_;
+    Waker pull_waker_;
+  };
+
+  RequestBuffer();
+
+  // Push ClientInitialMetadata into the buffer.
+  // This is instantaneous, and returns success with the amount of data
+  // buffered, or failure.
+  ValueOrFailure<size_t> PushClientInitialMetadata(ClientMetadataHandle md);
+  // Resolves to a ValueOrFailure<size_t> where the size_t is the amount of data
+  // buffered (or 0 if we're in committed mode).
+  GRPC_MUST_USE_RESULT auto PushMessage(MessageHandle message) {
+    return [this, message = std::move(message)]() mutable {
+      return PollPushMessage(message);
+    };
+  }
+  // Push end of stream (client half-closure).
+  StatusFlag FinishSends();
+  // Cancel the request, propagate failure to all readers.
+  void Cancel(absl::Status error = absl::CancelledError());
+
+  // Switch to committed mode - needs to be called exactly once with the winning
+  // reader. All other readers will see failure.
+  void Commit(Reader* winner);
+
+  bool committed() const {
+    MutexLock lock(&mu_);
+    return winner_ != nullptr;
+  }
+
+ private:
+  // Buffering state: we're collecting metadata and messages.
+  struct Buffering {
+    Buffering();
+    // Initial metadata, or nullptr if not yet received.
+    ClientMetadataHandle initial_metadata;
+    // Buffered messages.
+    absl::InlinedVector<MessageHandle, 1> messages;
+    // Amount of data buffered.
+    size_t buffered = 0;
+  };
+  // Buffered state: all messages have been collected (the client has finished
+  // sending).
+  struct Buffered {
+    Buffered(ClientMetadataHandle md,
+             absl::InlinedVector<MessageHandle, 1> msgs)
+        : initial_metadata(std::move(md)), messages(std::move(msgs)) {}
+    ClientMetadataHandle initial_metadata;
+    absl::InlinedVector<MessageHandle, 1> messages;
+  };
+  // Streaming state: we're streaming messages to the server.
+  // This implies winner_ is set.
+  struct Streaming {
+    MessageHandle message;
+    bool end_of_stream = false;
+  };
+  // Cancelled state: the request has been cancelled.
+  struct Cancelled {
+    explicit Cancelled(absl::Status error) : error(std::move(error)) {}
+    absl::Status error;
+  };
+  using State = std::variant<Buffering, Buffered, Streaming, Cancelled>;
+
+  Poll<ValueOrFailure<size_t>> PollPushMessage(MessageHandle& message);
+  Pending PendingPull(Reader* reader) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+    reader->pull_waker_ = Activity::current()->MakeOwningWaker();
+    return Pending{};
+  }
+  Pending PendingPush() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+    push_waker_ = Activity::current()->MakeOwningWaker();
+    return Pending{};
+  }
+  void MaybeSwitchToStreaming() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+    auto& buffering = std::get<Buffering>(state_);
+    if (winner_ == nullptr) return;
+    if (winner_->message_index_ < buffering.messages.size()) return;
+    state_.emplace<Streaming>();
+    push_waker_.Wakeup();
+  }
+
+  void WakeupAsyncAllPullers() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+    WakeupAsyncAllPullersExcept(nullptr);
+  }
+  void WakeupAsyncAllPullersExcept(Reader* except_reader)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  void AddReader(Reader* reader) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+    readers_.insert(reader);
+  }
+
+  void RemoveReader(Reader* reader) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+    readers_.erase(reader);
+  }
+
+  std::string DebugString(Reader* caller) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  mutable Mutex mu_;
+  Reader* winner_ ABSL_GUARDED_BY(mu_){nullptr};
+  State state_ ABSL_GUARDED_BY(mu_);
+  // TODO(ctiller): change this to an intrusively linked list to avoid
+  // allocations.
+  absl::flat_hash_set<Reader*> readers_ ABSL_GUARDED_BY(mu_);
+  Waker push_waker_ ABSL_GUARDED_BY(mu_);
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_CALL_REQUEST_BUFFER_H

data/src/core/channelz/channelz.cc

@@ -334,7 +334,7 @@ ServerNode::~ServerNode() {}
 
 void ServerNode::AddChildSocket(RefCountedPtr<SocketNode> node) {
   MutexLock lock(&child_mu_);
-  child_sockets_.insert(std::make_pair(node->uuid(), std::move(node)));
+  child_sockets_.insert(std::pair(node->uuid(), std::move(node)));
 }
 
 void ServerNode::RemoveChildSocket(intptr_t child_uuid) {
@@ -344,7 +344,7 @@ void ServerNode::RemoveChildSocket(intptr_t child_uuid) {
 
 void ServerNode::AddChildListenSocket(RefCountedPtr<ListenSocketNode> node) {
   MutexLock lock(&child_mu_);
-  child_listen_sockets_.insert(std::make_pair(node->uuid(), std::move(node)));
+  child_listen_sockets_.insert(std::pair(node->uuid(), std::move(node)));
 }
 
 void ServerNode::RemoveChildListenSocket(intptr_t child_uuid) {