grpc 1.68.1 → 1.71.0

data/src/core/util/uri.h

@@ -76,7 +76,7 @@ class URI {
     return query_parameter_map_;
   }
   // A vector of key:value query parameter pairs, kept in order of appearance
-  // within the URI search string. Repeated keys are represented as separate
+  // within the URI string. Repeated keys are represented as separate
   // key:value elements.
   const std::vector<QueryParam>& query_parameter_pairs() const {
     return query_parameter_pairs_;
@@ -85,6 +85,17 @@ class URI {
 
   std::string ToString() const;
 
+  // Returns the encoded path and query params, such as would be used on
+  // the wire in an HTTP request.
+  std::string EncodedPathAndQueryParams() const;
+
+  bool operator==(const URI& other) const {
+    return scheme_ == other.scheme_ && authority_ == other.authority_ &&
+           path_ == other.path_ &&
+           query_parameter_pairs_ == other.query_parameter_pairs_ &&
+           fragment_ == other.fragment_;
+  }
+
  private:
   URI(std::string scheme, std::string authority, std::string path,
       std::vector<QueryParam> query_parameter_pairs, std::string fragment);

data/src/core/util/useful.h

@@ -1,5 +1,3 @@
-//
-//
 // Copyright 2015 gRPC authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,8 +11,6 @@
 // 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_UTIL_USEFUL_H
 #define GRPC_SRC_CORE_UTIL_USEFUL_H
@@ -22,11 +18,12 @@
 #include <grpc/support/port_platform.h>
 
 #include <cstddef>
+#include <limits>
+#include <variant>
 
 #include "absl/log/check.h"
 #include "absl/numeric/bits.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
 
 /// useful utilities that don't belong anywhere else
 
@@ -69,12 +66,12 @@ int QsortCompare(const T& a, const T& b) {
 }
 
 template <typename... X>
-int QsortCompare(const absl::variant<X...>& a, const absl::variant<X...>& b) {
+int QsortCompare(const std::variant<X...>& a, const std::variant<X...>& b) {
   const int index = QsortCompare(a.index(), b.index());
   if (index != 0) return index;
-  return absl::visit(
+  return std::visit(
       [&](const auto& x) {
-        return QsortCompare(x, absl::get<absl::remove_cvref_t<decltype(x)>>(b));
+        return QsortCompare(x, std::get<absl::remove_cvref_t<decltype(x)>>(b));
       },
       a);
 }
@@ -103,15 +100,16 @@ constexpr size_t HashPointer(T* p, size_t 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 the result is greater than MAX, return MAX.
+// If the result is less than MIN, return MIN.
+template <typename T>
+inline T SaturatingAdd(T a, T b) {
   if (a > 0) {
-    if (b > INT64_MAX - a) {
-      return INT64_MAX;
+    if (b > std::numeric_limits<T>::max() - a) {
+      return std::numeric_limits<T>::max();
     }
-  } else if (b < INT64_MIN - a) {
-    return INT64_MIN;
+  } else if (b < std::numeric_limits<T>::min() - a) {
+    return std::numeric_limits<T>::min();
   }
   return a + b;
 }

data/src/core/util/validation_errors.cc

@@ -58,13 +58,13 @@ absl::Status ValidationErrors::status(absl::StatusCode code,
 std::string ValidationErrors::message(absl::string_view prefix) const {
   if (field_errors_.empty()) return "";
   std::vector<std::string> errors;
-  for (const auto& p : field_errors_) {
-    if (p.second.size() > 1) {
-      errors.emplace_back(absl::StrCat("field:", p.first, " errors:[",
-                                       absl::StrJoin(p.second, "; "), "]"));
+  for (const auto& [field, field_errors] : field_errors_) {
+    if (field_errors.size() > 1) {
+      errors.emplace_back(absl::StrCat("field:", field, " errors:[",
+                                       absl::StrJoin(field_errors, "; "), "]"));
     } else {
       errors.emplace_back(
-          absl::StrCat("field:", p.first, " error:", p.second[0]));
+          absl::StrCat("field:", field, " error:", field_errors[0]));
     }
   }
   return absl::StrCat(prefix, ": [", absl::StrJoin(errors, "; "), "]");

data/src/core/util/wait_for_single_owner.h

@@ -0,0 +1,62 @@
+// Copyright 2024 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.
+// 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_UTIL_WAIT_FOR_SINGLE_OWNER_H
+#define GRPC_SRC_CORE_UTIL_WAIT_FOR_SINGLE_OWNER_H
+
+#include <memory>
+
+#include "absl/log/log.h"
+#include "src/core/util/crash.h"
+#include "src/core/util/time.h"
+
+namespace grpc_core {
+
+// Waits until the use_count of the shared_ptr has reached 1 and returns,
+// destroying the object.
+//
+// Callers must first give up their ref, or this method will block forever.
+// Usage: WaitForSingleOwner(std::move(obj))
+template <typename T>
+void WaitForSingleOwner(std::shared_ptr<T> obj) {
+  WaitForSingleOwnerWithTimeout(std::move(obj), Duration::Hours(24));
+}
+
+// Waits until the use_count of the shared_ptr has reached 1 and returns,
+// destroying the object.
+//
+// This version will CRASH after the given timeout.
+// Usage: WaitForSingleOwnerWithTimeout(std::move(obj), Duration::Seconds(30));
+template <typename T>
+void WaitForSingleOwnerWithTimeout(std::shared_ptr<T> obj, Duration timeout) {
+  auto start = Timestamp::Now();
+  while (obj.use_count() > 1) {
+    auto elapsed = Timestamp::Now() - start;
+    auto remaining = timeout - elapsed;
+    if (remaining < Duration::Zero()) {
+      Crash("Timed out waiting for a single shared_ptr owner");
+    }
+    // To avoid log spam, wait a few seconds to begin logging the wait time.
+    if (elapsed >= Duration::Seconds(2)) {
+      LOG_EVERY_N_SEC(INFO, 2)
+          << "obj.use_count() = " << obj.use_count() << " timeout_remaining = "
+          << absl::FormatDuration(absl::Milliseconds(remaining.millis()));
+    }
+    absl::SleepFor(absl::Milliseconds(100));
+  }
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_UTIL_WAIT_FOR_SINGLE_OWNER_H

data/src/core/util/windows/env.cc

@@ -29,14 +29,14 @@
 
 namespace grpc_core {
 
-absl::optional<std::string> GetEnv(const char* name) {
+std::optional<std::string> GetEnv(const char* name) {
   auto tname = CharToTchar(name);
   DWORD ret = GetEnvironmentVariable(tname.c_str(), NULL, 0);
-  if (ret == 0) return absl::nullopt;
+  if (ret == 0) return std::nullopt;
   std::unique_ptr<TCHAR[]> tresult(new TCHAR[ret]);
   ret =
       GetEnvironmentVariable(tname.c_str(), tresult.get(), ret * sizeof(TCHAR));
-  if (ret == 0) return absl::nullopt;
+  if (ret == 0) return std::nullopt;
   return TcharToChar(tresult.get());
 }
 

data/src/core/util/windows/sync.cc

@@ -27,7 +27,6 @@
 #include <grpc/support/time.h>
 
 #include "absl/log/check.h"
-#include "src/core/util/crash.h"
 
 void gpr_mu_init(gpr_mu* mu) {
   InitializeCriticalSection(&mu->cs);

data/src/core/util/windows/time.cc

@@ -28,7 +28,6 @@
 #include <sys/timeb.h>
 
 #include "absl/log/check.h"
-#include "src/core/util/crash.h"
 #include "src/core/util/time_precise.h"
 
 static LARGE_INTEGER g_start_time = []() {

data/src/core/util/work_serializer.cc

@@ -48,262 +48,35 @@ namespace grpc_core {
 // WorkSerializer::WorkSerializerImpl
 //
 
-class WorkSerializer::WorkSerializerImpl : public Orphanable {
- public:
-  virtual void Run(std::function<void()> callback,
-                   const DebugLocation& location) = 0;
-  virtual void Schedule(std::function<void()> callback,
-                        const DebugLocation& location) = 0;
-  virtual void DrainQueue() = 0;
-
-#ifndef NDEBUG
-  virtual bool RunningInWorkSerializer() const = 0;
-#endif
-};
-
-//
-// WorkSerializer::LegacyWorkSerializer
-//
-
-class WorkSerializer::LegacyWorkSerializer final : public WorkSerializerImpl {
- public:
-  void Run(std::function<void()> callback,
-           const DebugLocation& location) override;
-  void Schedule(std::function<void()> callback,
-                const DebugLocation& location) override;
-  void DrainQueue() override;
-  void Orphan() override;
-
-#ifndef NDEBUG
-  bool RunningInWorkSerializer() const override {
-    return std::this_thread::get_id() == current_thread_;
-  }
-#endif
-
- private:
-  struct CallbackWrapper {
-    CallbackWrapper(std::function<void()> cb, const DebugLocation& loc)
-        : callback(std::move(cb)), location(loc) {}
-
-    MultiProducerSingleConsumerQueue::Node mpscq_node;
-    const std::function<void()> callback;
-    const DebugLocation location;
-  };
-
-  // Callers of DrainQueueOwned should make sure to grab the lock on the
-  // workserializer with
-  //
-  //   prev_ref_pair =
-  //     refs_.fetch_add(MakeRefPair(1, 1), std::memory_order_acq_rel);
-  //
-  // and only invoke DrainQueueOwned() if there was previously no owner. Note
-  // that the queue size is also incremented as part of the fetch_add to allow
-  // the callers to add a callback to the queue if another thread already holds
-  // the lock to the work serializer.
-  void DrainQueueOwned();
-
-  // First 16 bits indicate ownership of the WorkSerializer, next 48 bits are
-  // queue size (i.e., refs).
-  static uint64_t MakeRefPair(uint16_t owners, uint64_t size) {
-    CHECK_EQ(size >> 48, 0u);
-    return (static_cast<uint64_t>(owners) << 48) + static_cast<int64_t>(size);
-  }
-  static uint32_t GetOwners(uint64_t ref_pair) {
-    return static_cast<uint32_t>(ref_pair >> 48);
-  }
-  static uint64_t GetSize(uint64_t ref_pair) {
-    return static_cast<uint64_t>(ref_pair & 0xffffffffffffu);
-  }
-
-#ifndef NDEBUG
-  void SetCurrentThread() { current_thread_ = std::this_thread::get_id(); }
-  void ClearCurrentThread() { current_thread_ = std::thread::id(); }
-#else
-  void SetCurrentThread() {}
-  void ClearCurrentThread() {}
-#endif
-
-  // An initial size of 1 keeps track of whether the work serializer has been
-  // orphaned.
-  std::atomic<uint64_t> refs_{MakeRefPair(0, 1)};
-  MultiProducerSingleConsumerQueue queue_;
-#ifndef NDEBUG
-  std::thread::id current_thread_;
-#endif
-};
-
-void WorkSerializer::LegacyWorkSerializer::Run(std::function<void()> callback,
-                                               const DebugLocation& location) {
-  GRPC_TRACE_LOG(work_serializer, INFO)
-      << "WorkSerializer::Run() " << this << " Scheduling callback ["
-      << location.file() << ":" << location.line() << "]";
-  // Increment queue size for the new callback and owner count to attempt to
-  // take ownership of the WorkSerializer.
-  const uint64_t prev_ref_pair =
-      refs_.fetch_add(MakeRefPair(1, 1), std::memory_order_acq_rel);
-  // The work serializer should not have been orphaned.
-  DCHECK_GT(GetSize(prev_ref_pair), 0u);
-  if (GetOwners(prev_ref_pair) == 0) {
-    // We took ownership of the WorkSerializer. Invoke callback and drain queue.
-    SetCurrentThread();
-    GRPC_TRACE_LOG(work_serializer, INFO) << "  Executing immediately";
-    callback();
-    // Delete the callback while still holding the WorkSerializer, so
-    // that any refs being held by the callback via lambda captures will
-    // be destroyed inside the WorkSerializer.
-    callback = nullptr;
-    DrainQueueOwned();
-  } else {
-    // Another thread is holding the WorkSerializer, so decrement the
-    // ownership count we just added and queue the callback.
-    refs_.fetch_sub(MakeRefPair(1, 0), std::memory_order_acq_rel);
-    CallbackWrapper* cb_wrapper =
-        new CallbackWrapper(std::move(callback), location);
-    GRPC_TRACE_LOG(work_serializer, INFO)
-        << "  Scheduling on queue : item " << cb_wrapper;
-    queue_.Push(&cb_wrapper->mpscq_node);
-  }
-}
-
-void WorkSerializer::LegacyWorkSerializer::Schedule(
-    std::function<void()> callback, const DebugLocation& location) {
-  CallbackWrapper* cb_wrapper =
-      new CallbackWrapper(std::move(callback), location);
-  GRPC_TRACE_LOG(work_serializer, INFO)
-      << "WorkSerializer::Schedule() " << this << " Scheduling callback "
-      << cb_wrapper << " [" << location.file() << ":" << location.line() << "]";
-  refs_.fetch_add(MakeRefPair(0, 1), std::memory_order_acq_rel);
-  queue_.Push(&cb_wrapper->mpscq_node);
-}
-
-void WorkSerializer::LegacyWorkSerializer::Orphan() {
-  GRPC_TRACE_LOG(work_serializer, INFO) << "WorkSerializer::Orphan() " << this;
-  const uint64_t prev_ref_pair =
-      refs_.fetch_sub(MakeRefPair(0, 1), std::memory_order_acq_rel);
-  if (GetOwners(prev_ref_pair) == 0 && GetSize(prev_ref_pair) == 1) {
-    GRPC_TRACE_LOG(work_serializer, INFO) << "  Destroying";
-    delete this;
-  }
-}
-
-// The thread that calls this loans itself to the work serializer so as to
-// execute all the scheduled callbacks.
-void WorkSerializer::LegacyWorkSerializer::DrainQueue() {
-  GRPC_TRACE_LOG(work_serializer, INFO)
-      << "WorkSerializer::DrainQueue() " << this;
-  // Attempt to take ownership of the WorkSerializer. Also increment the queue
-  // size as required by `DrainQueueOwned()`.
-  const uint64_t prev_ref_pair =
-      refs_.fetch_add(MakeRefPair(1, 1), std::memory_order_acq_rel);
-  if (GetOwners(prev_ref_pair) == 0) {
-    SetCurrentThread();
-    // We took ownership of the WorkSerializer. Drain the queue.
-    DrainQueueOwned();
-  } else {
-    // Another thread is holding the WorkSerializer, so decrement the
-    // ownership count we just added and queue a no-op callback.
-    refs_.fetch_sub(MakeRefPair(1, 0), std::memory_order_acq_rel);
-    CallbackWrapper* cb_wrapper = new CallbackWrapper([]() {}, DEBUG_LOCATION);
-    queue_.Push(&cb_wrapper->mpscq_node);
-  }
-}
-
-void WorkSerializer::LegacyWorkSerializer::DrainQueueOwned() {
-  GRPC_TRACE_LOG(work_serializer, INFO)
-      << "WorkSerializer::DrainQueueOwned() " << this;
-  while (true) {
-    auto prev_ref_pair = refs_.fetch_sub(MakeRefPair(0, 1));
-    // It is possible that while draining the queue, the last callback ended
-    // up orphaning the work serializer. In that case, delete the object.
-    if (GetSize(prev_ref_pair) == 1) {
-      GRPC_TRACE_LOG(work_serializer, INFO) << "  Queue Drained. Destroying";
-      delete this;
-      return;
-    }
-    if (GetSize(prev_ref_pair) == 2) {
-      // Queue drained. Give up ownership but only if queue remains empty.
-      // Reset current_thread_ before giving up ownership to avoid TSAN
-      // race.  If we don't wind up giving up ownership, we'll set this
-      // again below before we pull the next callback out of the queue.
-      ClearCurrentThread();
-      uint64_t expected = MakeRefPair(1, 1);
-      if (refs_.compare_exchange_strong(expected, MakeRefPair(0, 1),
-                                        std::memory_order_acq_rel)) {
-        // Queue is drained.
-        return;
-      }
-      if (GetSize(expected) == 0) {
-        // WorkSerializer got orphaned while this was running
-        GRPC_TRACE_LOG(work_serializer, INFO) << "  Queue Drained. Destroying";
-        delete this;
-        return;
-      }
-      // Didn't wind up giving up ownership, so set current_thread_ again.
-      SetCurrentThread();
-    }
-    // There is at least one callback on the queue. Pop the callback from the
-    // queue and execute it.
-    CallbackWrapper* cb_wrapper = nullptr;
-    bool empty_unused;
-    while ((cb_wrapper = reinterpret_cast<CallbackWrapper*>(
-                queue_.PopAndCheckEnd(&empty_unused))) == nullptr) {
-      // This can happen due to a race condition within the mpscq
-      // implementation or because of a race with Run()/Schedule().
-      GRPC_TRACE_LOG(work_serializer, INFO)
-          << "  Queue returned nullptr, trying again";
-    }
-    GRPC_TRACE_LOG(work_serializer, INFO)
-        << "  Running item " << cb_wrapper << " : callback scheduled at ["
-        << cb_wrapper->location.file() << ":" << cb_wrapper->location.line()
-        << "]";
-    cb_wrapper->callback();
-    delete cb_wrapper;
-  }
-}
-
-//
-// WorkSerializer::DispatchingWorkSerializer
-//
-
-// DispatchingWorkSerializer: executes callbacks one at a time on EventEngine.
+// Executes callbacks one at a time on EventEngine.
 // One at a time guarantees that fixed size thread pools in EventEngine
 // implementations are not starved of threads by long running work
 // serializers. We implement EventEngine::Closure directly to avoid allocating
 // once per callback in the queue when scheduling.
-class WorkSerializer::DispatchingWorkSerializer final
-    : public WorkSerializerImpl,
+class WorkSerializer::WorkSerializerImpl
+    : public Orphanable,
       public grpc_event_engine::experimental::EventEngine::Closure {
  public:
-  explicit DispatchingWorkSerializer(
+  explicit WorkSerializerImpl(
       std::shared_ptr<grpc_event_engine::experimental::EventEngine>
           event_engine)
       : event_engine_(std::move(event_engine)) {}
-  void Run(std::function<void()> callback,
-           const DebugLocation& location) override;
-  void Schedule(std::function<void()> callback,
-                const DebugLocation& location) override {
-    // We always dispatch to event engine, so Schedule and Run share
-    // semantics.
-    Run(callback, location);
-  }
-  void DrainQueue() override {}
-  void Orphan() override;
-
-  // Override EventEngine::Closure
+  void Run(absl::AnyInvocable<void()> callback, DebugLocation location);
   void Run() override;
+  void Orphan() override;
 
 #ifndef NDEBUG
-  bool RunningInWorkSerializer() const override {
+  bool RunningInWorkSerializer() const {
     return running_work_serializer_ == this;
   }
 #endif
-
  private:
   // Wrapper to capture DebugLocation for the callback.
   struct CallbackWrapper {
-    CallbackWrapper(std::function<void()> cb, const DebugLocation& loc)
-        : callback(std::move(cb)), location(loc) {}
-    std::function<void()> callback;
+    CallbackWrapper(absl::AnyInvocable<void()>&& cb, const DebugLocation& loc)
+        : callback(std::forward<absl::AnyInvocable<void()>>(cb)),
+          location(loc) {}
+    absl::AnyInvocable<void()> callback;
     // GPR_NO_UNIQUE_ADDRESS means this is 0 sized in release builds.
     GPR_NO_UNIQUE_ADDRESS DebugLocation location;
   };
@@ -351,8 +124,8 @@ class WorkSerializer::DispatchingWorkSerializer final
   //   on an idle WorkSerializer, and transitions back to false after the last
   //   callback scheduled is completed and the WorkSerializer is again idle.
   // - orphaned_ transitions to true once upon Orphan being called.
-  // When orphaned_ is true and running_ is false, the
-  // DispatchingWorkSerializer instance is deleted.
+  // When orphaned_ is true and running_ is false, the WorkSerializerImpl
+  // instance is deleted.
   bool running_ ABSL_GUARDED_BY(mu_) = false;
   bool orphaned_ ABSL_GUARDED_BY(mu_) = false;
   Mutex mu_;
@@ -366,17 +139,16 @@ class WorkSerializer::DispatchingWorkSerializer final
   GPR_NO_UNIQUE_ADDRESS latent_see::Flow flow_;
 
 #ifndef NDEBUG
-  static thread_local DispatchingWorkSerializer* running_work_serializer_;
+  static thread_local WorkSerializerImpl* running_work_serializer_;
 #endif
 };
 
 #ifndef NDEBUG
-thread_local WorkSerializer::DispatchingWorkSerializer*
-    WorkSerializer::DispatchingWorkSerializer::running_work_serializer_ =
-        nullptr;
+thread_local WorkSerializer::WorkSerializerImpl*
+    WorkSerializer::WorkSerializerImpl::running_work_serializer_ = nullptr;
 #endif
 
-void WorkSerializer::DispatchingWorkSerializer::Orphan() {
+void WorkSerializer::WorkSerializerImpl::Orphan() {
   ReleasableMutexLock lock(&mu_);
   // If we're not running, then we can delete immediately.
   if (!running_) {
@@ -389,8 +161,8 @@ void WorkSerializer::DispatchingWorkSerializer::Orphan() {
 }
 
 // Implementation of WorkSerializerImpl::Run
-void WorkSerializer::DispatchingWorkSerializer::Run(
-    std::function<void()> callback, const DebugLocation& location) {
+void WorkSerializer::WorkSerializerImpl::Run(
+    absl::AnyInvocable<void()> callback, DebugLocation location) {
   GRPC_TRACE_LOG(work_serializer, INFO)
       << "WorkSerializer[" << this << "] Scheduling callback ["
       << location.file() << ":" << location.line() << "]";
@@ -414,11 +186,10 @@ void WorkSerializer::DispatchingWorkSerializer::Run(
 }
 
 // Implementation of EventEngine::Closure::Run - our actual work loop
-void WorkSerializer::DispatchingWorkSerializer::Run() {
+void WorkSerializer::WorkSerializerImpl::Run() {
   GRPC_LATENT_SEE_PARENT_SCOPE("WorkSerializer::Run");
   flow_.End();
   // TODO(ctiller): remove these when we can deprecate ExecCtx
-  ApplicationCallbackExecCtx app_exec_ctx;
   ExecCtx exec_ctx;
   // Grab the last element of processing_ - which is the next item in our
   // queue since processing_ is stored in reverse order.
@@ -449,8 +220,8 @@ void WorkSerializer::DispatchingWorkSerializer::Run() {
   event_engine_->Run(this);
 }
 
-WorkSerializer::DispatchingWorkSerializer::RefillResult
-WorkSerializer::DispatchingWorkSerializer::RefillInner() {
+WorkSerializer::WorkSerializerImpl::RefillResult
+WorkSerializer::WorkSerializerImpl::RefillInner() {
   // Recover any memory held by processing_, so that we don't grow forever.
   // Do so before acquiring a lock so we don't cause inadvertent contention.
   processing_.shrink_to_fit();
@@ -481,7 +252,7 @@ WorkSerializer::DispatchingWorkSerializer::RefillInner() {
   return RefillResult::kRefilled;
 }
 
-bool WorkSerializer::DispatchingWorkSerializer::Refill() {
+bool WorkSerializer::WorkSerializerImpl::Refill() {
   const auto result = RefillInner();
   switch (result) {
     case RefillResult::kRefilled:
@@ -508,27 +279,16 @@ bool WorkSerializer::DispatchingWorkSerializer::Refill() {
 
 WorkSerializer::WorkSerializer(
     std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine)
-    : impl_(IsWorkSerializerDispatchEnabled()
-                ? OrphanablePtr<WorkSerializerImpl>(
-                      MakeOrphanable<DispatchingWorkSerializer>(
-                          std::move(event_engine)))
-                : OrphanablePtr<WorkSerializerImpl>(
-                      MakeOrphanable<LegacyWorkSerializer>())) {}
+    : impl_(OrphanablePtr<WorkSerializerImpl>(
+          MakeOrphanable<WorkSerializerImpl>(std::move(event_engine)))) {}
 
 WorkSerializer::~WorkSerializer() = default;
 
-void WorkSerializer::Run(std::function<void()> callback,
-                         const DebugLocation& location) {
+void WorkSerializer::Run(absl::AnyInvocable<void()> callback,
+                         DebugLocation location) {
   impl_->Run(std::move(callback), location);
 }
 
-void WorkSerializer::Schedule(std::function<void()> callback,
-                              const DebugLocation& location) {
-  impl_->Schedule(std::move(callback), location);
-}
-
-void WorkSerializer::DrainQueue() { impl_->DrainQueue(); }
-
 #ifndef NDEBUG
 bool WorkSerializer::RunningInWorkSerializer() const {
   return impl_->RunningInWorkSerializer();

data/src/core/util/work_serializer.h

@@ -24,6 +24,7 @@
 #include <memory>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/functional/any_invocable.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/orphanable.h"
 
@@ -33,16 +34,7 @@ namespace grpc_core {
 // All callbacks scheduled on a WorkSerializer instance will be executed
 // serially in a borrowed thread. The API provides a FIFO guarantee to the
 // execution of callbacks scheduled on the thread.
-// When a thread calls Run() with a callback, the thread is considered borrowed.
-// The callback might run inline, or it might run asynchronously in a different
-// thread that is already inside of Run(). If the callback runs directly inline,
-// other callbacks from other threads might also be executed before Run()
-// returns. Since an arbitrary set of callbacks might be executed when Run() is
-// called, generally no locks should be held while calling Run().
-// If a thread wants to preclude the possibility of the callback being invoked
-// inline in Run() (for example, if a mutex lock is held and executing callbacks
-// inline would cause a deadlock), it should use Schedule() instead and then
-// invoke DrainQueue() when it is safe to invoke the callback.
+// When a thread calls Run() with a callback the callback runs asynchronously.
 class ABSL_LOCKABLE WorkSerializer {
  public:
   explicit WorkSerializer(
@@ -57,17 +49,9 @@ class ABSL_LOCKABLE WorkSerializer {
 
   // Runs a given callback on the work serializer.
   //
-  // If experiment `work_serializer_dispatch` is enabled:
   // The callback will be executed as an EventEngine callback, that then
   // arranges for the next callback in the queue to execute.
   //
-  // If experiment `work_serializer_dispatch` is NOT enabled:
-  // If there is no other thread currently executing the WorkSerializer, the
-  // callback is run immediately. In this case, the current thread is also
-  // borrowed for draining the queue for any callbacks that get added in the
-  // meantime.
-  // This behavior is deprecated and will be removed soon.
-  //
   // If you want to use clang thread annotation to make sure that callback is
   // called by WorkSerializer only, you need to add the annotation to both the
   // lambda function given to Run and the actual callback function like;
@@ -79,13 +63,7 @@ class ABSL_LOCKABLE WorkSerializer {
   //         }, DEBUG_LOCATION);
   //   }
   //   void callback() ABSL_EXCLUSIVE_LOCKS_REQUIRED(work_serializer) { ... }
-  void Run(std::function<void()> callback, const DebugLocation& location);
-
-  // Schedule \a callback to be run later when the queue of callbacks is
-  // drained.
-  void Schedule(std::function<void()> callback, const DebugLocation& location);
-  // Drains the queue of callbacks.
-  void DrainQueue();
+  void Run(absl::AnyInvocable<void()> callback, DebugLocation location = {});
 
 #ifndef NDEBUG
   // Returns true if the current thread is running in the WorkSerializer.
@@ -94,8 +72,6 @@ class ABSL_LOCKABLE WorkSerializer {
 
  private:
   class WorkSerializerImpl;
-  class LegacyWorkSerializer;
-  class DispatchingWorkSerializer;
 
   OrphanablePtr<WorkSerializerImpl> impl_;
 };