grpc 1.42.0 → 1.46.3

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/chunked_vector.h

@@ -17,8 +17,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gprpp/arena.h"
+#include <cstddef>
+
 #include "src/core/lib/gprpp/manual_constructor.h"
+#include "src/core/lib/resource_quota/arena.h"
 
 namespace grpc_core {
 
@@ -48,8 +50,9 @@ class ChunkedVector {
   }
   ChunkedVector(const ChunkedVector& other)
       : ChunkedVector(other.arena_, other.begin(), other.end()) {}
-  ChunkedVector& operator=(ChunkedVector other) {
-    Swap(&other);
+  ChunkedVector& operator=(const ChunkedVector& other) {
+    ChunkedVector tmp(other);
+    Swap(&tmp);
     return *this;
   }
   ChunkedVector(ChunkedVector&& other) noexcept
@@ -113,6 +116,12 @@ class ChunkedVector {
    public:
     ForwardIterator(Chunk* chunk, size_t n) : chunk_(chunk), n_(n) {}
 
+    using difference_type = std::ptrdiff_t;
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = T;
+    using pointer = T*;
+    using reference = T&;
+
     T& operator*() const { return *chunk_->data[n_]; }
     T* operator->() const { return &*chunk_->data[n_]; }
     ForwardIterator& operator++() {
@@ -123,6 +132,11 @@ class ChunkedVector {
       }
       return *this;
     }
+    ForwardIterator& operator++(int) {
+      ForwardIterator tmp = *this;
+      ++*this;
+      return tmp;
+    }
     bool operator==(const ForwardIterator& other) const {
       return chunk_ == other.chunk_ && n_ == other.n_;
     }
@@ -131,6 +145,8 @@ class ChunkedVector {
     }
 
    private:
+    friend class ChunkedVector;
+
     Chunk* chunk_;
     size_t n_;
   };
@@ -140,6 +156,8 @@ class ChunkedVector {
    public:
     ConstForwardIterator(const Chunk* chunk, size_t n) : chunk_(chunk), n_(n) {}
 
+    using iterator_category = std::forward_iterator_tag;
+
     const T& operator*() const { return *chunk_->data[n_]; }
     const T* operator->() const { return &*chunk_->data[n_]; }
     ConstForwardIterator& operator++() {
@@ -150,6 +168,11 @@ class ChunkedVector {
       }
       return *this;
     }
+    ConstForwardIterator& operator++(int) {
+      ConstForwardIterator tmp = *this;
+      ++*this;
+      return tmp;
+    }
     bool operator==(const ConstForwardIterator& other) const {
       return chunk_ == other.chunk_ && n_ == other.n_;
     }
@@ -186,6 +209,25 @@ class ChunkedVector {
     return n;
   }
 
+  // Return true if the vector is empty.
+  bool empty() const { return first_ == nullptr || first_->count == 0; }
+
+  void SetEnd(ForwardIterator it) {
+    if (it == end()) return;
+    Chunk* chunk = it.chunk_;
+    for (size_t i = it.n_; i < chunk->count; i++) {
+      chunk->data[i].Destroy();
+    }
+    chunk->count = it.n_;
+    append_ = chunk;
+    while ((chunk = chunk->next) != nullptr) {
+      for (size_t i = 0; i < chunk->count; i++) {
+        chunk->data[i].Destroy();
+      }
+      chunk->count = 0;
+    }
+  }
+
  private:
   ManualConstructor<T>* AppendSlot() {
     if (append_ == nullptr) {

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

@@ -0,0 +1,49 @@
+// 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_CPP_IMPL_OF_H
+#define GRPC_CORE_LIB_GPRPP_CPP_IMPL_OF_H
+
+namespace grpc_core {
+
+// Declares CppType to be the backing implementation of CType.
+// Use via the curiously recursive template:
+// class Foo : public CppImplOf<Foo, grpc_foo> {};
+// Provides casting methods each way.
+// grpc_foo should be `typedef struct grpc_foo grpc_foo` and otherwise
+// not defined.
+template <typename CppType, typename CType>
+class CppImplOf {
+ public:
+  // Convert the C struct to C++
+  static CppType* FromC(CType* c_type) {
+    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));
+  }
+
+ protected:
+  ~CppImplOf() = default;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_CPP_IMPL_OF_H

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/global_config_env.cc

@@ -58,8 +58,8 @@ void SetGlobalConfigEnvErrorFunction(GlobalConfigEnvErrorFunctionType func) {
   g_global_config_env_error_func = func;
 }
 
-grpc_core::UniquePtr<char> GlobalConfigEnv::GetValue() {
-  return grpc_core::UniquePtr<char>(gpr_getenv(GetName()));
+UniquePtr<char> GlobalConfigEnv::GetValue() {
+  return UniquePtr<char>(gpr_getenv(GetName()));
 }
 
 void GlobalConfigEnv::SetValue(const char* value) {
@@ -80,7 +80,7 @@ static_assert(std::is_trivially_destructible<GlobalConfigEnvBool>::value,
               "GlobalConfigEnvBool needs to be trivially destructible.");
 
 bool GlobalConfigEnvBool::Get() {
-  grpc_core::UniquePtr<char> str = GetValue();
+  UniquePtr<char> str = GetValue();
   if (str == nullptr) {
     return default_value_;
   }
@@ -101,7 +101,7 @@ static_assert(std::is_trivially_destructible<GlobalConfigEnvInt32>::value,
               "GlobalConfigEnvInt32 needs to be trivially destructible.");
 
 int32_t GlobalConfigEnvInt32::Get() {
-  grpc_core::UniquePtr<char> str = GetValue();
+  UniquePtr<char> str = GetValue();
   if (str == nullptr) {
     return default_value_;
   }
@@ -124,10 +124,10 @@ void GlobalConfigEnvInt32::Set(int32_t value) {
 static_assert(std::is_trivially_destructible<GlobalConfigEnvString>::value,
               "GlobalConfigEnvString needs to be trivially destructible.");
 
-grpc_core::UniquePtr<char> GlobalConfigEnvString::Get() {
-  grpc_core::UniquePtr<char> str = GetValue();
+UniquePtr<char> GlobalConfigEnvString::Get() {
+  UniquePtr<char> str = GetValue();
   if (str == nullptr) {
-    return grpc_core::UniquePtr<char>(gpr_strdup(default_value_));
+    return UniquePtr<char>(gpr_strdup(default_value_));
   }
   return str;
 }

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

@@ -43,7 +43,7 @@ class GlobalConfigEnv {
 
  public:
   // Returns the value of `name` variable.
-  grpc_core::UniquePtr<char> GetValue();
+  UniquePtr<char> GetValue();
 
   // Sets the value of `name` variable.
   void SetValue(const char* value);
@@ -87,7 +87,7 @@ class GlobalConfigEnvString : public GlobalConfigEnv {
   constexpr GlobalConfigEnvString(char* name, const char* default_value)
       : GlobalConfigEnv(name), default_value_(default_value) {}
 
-  grpc_core::UniquePtr<char> Get();
+  UniquePtr<char> Get();
   void Set(const char* value);
 
  private:

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

@@ -163,9 +163,8 @@ class PolymorphicManualConstructor {
   }
 
   typename std::aligned_storage<
-      grpc_core::manual_ctor_impl::max_size_of<DerivedTypes...>::value,
-      grpc_core::manual_ctor_impl::max_align_of<DerivedTypes...>::value>::type
-      space_;
+      manual_ctor_impl::max_size_of<DerivedTypes...>::value,
+      manual_ctor_impl::max_align_of<DerivedTypes...>::value>::type space_;
 };
 
 template <typename Type>

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

@@ -117,7 +117,7 @@ class InternallyRefCounted : public Orphanable {
     refs_.Ref(location, reason);
   }
 
-  grpc_core::RefCount refs_;
+  RefCount refs_;
 };
 
 }  // namespace grpc_core

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

@@ -208,7 +208,7 @@ class PolymorphicRefCount {
 };
 
 // NonPolymorphicRefCount does not enforce polymorphic destruction of
-// RefCounted. Please refer to grpc_core::RefCounted for more details, and
+// RefCounted. Please refer to RefCounted for more details, and
 // when in doubt use PolymorphicRefCount.
 class NonPolymorphicRefCount {
  public:
@@ -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;
 

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

@@ -40,8 +40,7 @@ class RefCountedPtr {
 
   // If value is non-null, we take ownership of a ref to it.
   template <typename Y>
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  RefCountedPtr(Y* value) : value_(value) {}
+  explicit RefCountedPtr(Y* value) : value_(value) {}
 
   // Move ctors.
   RefCountedPtr(RefCountedPtr&& other) noexcept {
@@ -191,8 +190,7 @@ class WeakRefCountedPtr {
 
   // If value is non-null, we take ownership of a ref to it.
   template <typename Y>
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  WeakRefCountedPtr(Y* value) {
+  explicit WeakRefCountedPtr(Y* value) {
     value_ = value;
   }
 

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

@@ -0,0 +1,87 @@
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_CORE_LIB_GPRPP_SINGLE_SET_PTR_H
+#define GRPC_CORE_LIB_GPRPP_SINGLE_SET_PTR_H
+
+#include <grpc/support/port_platform.h>
+
+#include <atomic>
+#include <memory>
+
+#include <grpc/support/log.h>
+
+namespace grpc_core {
+
+template <class T, class Deleter = std::default_delete<T>>
+class SingleSetPtr {
+ public:
+  SingleSetPtr() = default;
+  explicit SingleSetPtr(T* p) : p_{p} {}
+  explicit SingleSetPtr(std::unique_ptr<T, Deleter> p) : p_{p.release()} {}
+  ~SingleSetPtr() { Delete(p_.load(std::memory_order_relaxed)); }
+
+  SingleSetPtr(const SingleSetPtr&) = delete;
+  SingleSetPtr& operator=(const SingleSetPtr&) = delete;
+  SingleSetPtr(SingleSetPtr&& other) noexcept
+      : p_(other.p_.exchange(nullptr)) {}
+  SingleSetPtr& operator=(SingleSetPtr&& other) noexcept {
+    Set(other.p_.exchange(nullptr, std::memory_order_acq_rel));
+    return *this;
+  }
+
+  // Set the pointer;
+  // if already set, return the pre-set value and delete ptr;
+  // if deleted, return nullptr and delete ptr.
+  T* Set(T* ptr) {
+    T* expected = nullptr;
+    if (!p_.compare_exchange_strong(expected, ptr, std::memory_order_acq_rel,
+                                    std::memory_order_acquire)) {
+      Delete(ptr);
+      return expected;
+    }
+    return ptr;
+  }
+
+  // Set the pointer from a compatible unique_ptr - with the same caveats as
+  // above.
+  T* Set(std::unique_ptr<T, Deleter> ptr) { return Set(ptr.release()); }
+
+  // Clear the pointer.
+  void Reset() { Delete(p_.exchange(nullptr, std::memory_order_acq_rel)); }
+
+  bool is_set() const {
+    T* p = p_.load(std::memory_order_acquire);
+    return p != nullptr;
+  }
+
+  T* operator->() const {
+    T* p = p_.load(std::memory_order_acquire);
+    GPR_DEBUG_ASSERT(p != nullptr);
+    return p;
+  }
+
+  T& operator*() const { return *operator->(); }
+
+ private:
+  static void Delete(T* p) {
+    if (p == nullptr) return;
+    Deleter()(p);
+  }
+  std::atomic<T*> p_{nullptr};
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_SINGLE_SET_PTR_H

data/src/core/lib/gprpp/status_helper.cc

@@ -20,6 +20,8 @@
 
 #include "src/core/lib/gprpp/status_helper.h"
 
+#include <type_traits>
+
 #include "absl/strings/cord.h"
 #include "absl/strings/escaping.h"
 #include "absl/strings/match.h"
@@ -159,7 +161,7 @@ std::vector<absl::Status> ParseChildren(absl::Cord children) {
 
 absl::Status StatusCreate(absl::StatusCode code, absl::string_view msg,
                           const DebugLocation& location,
-                          std::initializer_list<absl::Status> children) {
+                          std::vector<absl::Status> children) {
   absl::Status s(code, msg);
   if (location.file() != nullptr) {
     StatusSetStr(&s, StatusStrProperty::kFile, location.file());
@@ -218,9 +220,23 @@ absl::optional<std::string> StatusGetStr(const absl::Status& status,
 
 void StatusSetTime(absl::Status* status, StatusTimeProperty key,
                    absl::Time time) {
+#if !defined(__clang__) && defined(_MSC_VER) && _MSC_VER < 1910
+  // Abseil has a workaround for MSVC 2015 which prevents absl::Time
+  // from being is_trivially_copyable but it's still safe to be
+  // memcopied.
+#elif defined(__GNUG__) && __GNUC__ < 5
+  // GCC versions < 5 do not support std::is_trivially_copyable
+#else
+  static_assert(std::is_trivially_copyable<absl::Time>::value,
+                "absl::Time needs to be able to be memcopied");
+#endif
+  // This is required not to get uninitialized padding of absl::Time.
+  alignas(absl::Time) char buf[sizeof(time)] = {
+      0,
+  };
+  new (buf) absl::Time(time);
   status->SetPayload(GetStatusTimePropertyUrl(key),
-                     absl::Cord(absl::string_view(
-                         reinterpret_cast<const char*>(&time), sizeof(time))));
+                     absl::Cord(absl::string_view(buf, sizeof(time))));
 }
 
 absl::optional<absl::Time> StatusGetTime(const absl::Status& status,
@@ -230,7 +246,10 @@ absl::optional<absl::Time> StatusGetTime(const absl::Status& status,
   if (p.has_value()) {
     absl::optional<absl::string_view> sv = p->TryFlat();
     if (sv.has_value()) {
-      return *reinterpret_cast<const absl::Time*>(sv->data());
+      // copy the content before casting to avoid misaligned address access
+      alignas(absl::Time) char buf[sizeof(const absl::Time)];
+      memcpy(buf, sv->data(), sizeof(const absl::Time));
+      return *reinterpret_cast<const absl::Time*>(buf);
     } else {
       std::string s = std::string(*p);
       return *reinterpret_cast<const absl::Time*>(s.c_str());
@@ -331,32 +350,34 @@ std::string StatusToString(const absl::Status& status) {
 
 namespace internal {
 
-google_rpc_Status* StatusToProto(const absl::Status& status, upb_arena* arena) {
+google_rpc_Status* StatusToProto(const absl::Status& status, upb_Arena* arena) {
   google_rpc_Status* msg = google_rpc_Status_new(arena);
   google_rpc_Status_set_code(msg, int32_t(status.code()));
   google_rpc_Status_set_message(
-      msg, upb_strview_make(status.message().data(), status.message().size()));
+      msg, upb_StringView_FromDataAndSize(status.message().data(),
+                                          status.message().size()));
   status.ForEachPayload([&](absl::string_view type_url,
                             const absl::Cord& payload) {
     google_protobuf_Any* any = google_rpc_Status_add_details(msg, arena);
     char* type_url_buf =
-        reinterpret_cast<char*>(upb_arena_malloc(arena, type_url.size()));
+        reinterpret_cast<char*>(upb_Arena_Malloc(arena, type_url.size()));
     memcpy(type_url_buf, type_url.data(), type_url.size());
     google_protobuf_Any_set_type_url(
-        any, upb_strview_make(type_url_buf, type_url.size()));
+        any, upb_StringView_FromDataAndSize(type_url_buf, type_url.size()));
     absl::optional<absl::string_view> v_view = payload.TryFlat();
     if (v_view.has_value()) {
       google_protobuf_Any_set_value(
-          any, upb_strview_make(v_view->data(), v_view->size()));
+          any, upb_StringView_FromDataAndSize(v_view->data(), v_view->size()));
     } else {
       char* buf =
-          reinterpret_cast<char*>(upb_arena_malloc(arena, payload.size()));
+          reinterpret_cast<char*>(upb_Arena_Malloc(arena, payload.size()));
       char* cur = buf;
       for (absl::string_view chunk : payload.Chunks()) {
         memcpy(cur, chunk.data(), chunk.size());
         cur += chunk.size();
       }
-      google_protobuf_Any_set_value(any, upb_strview_make(buf, payload.size()));
+      google_protobuf_Any_set_value(
+          any, upb_StringView_FromDataAndSize(buf, payload.size()));
     }
   });
   return msg;
@@ -364,47 +385,23 @@ google_rpc_Status* StatusToProto(const absl::Status& status, upb_arena* arena) {
 
 absl::Status StatusFromProto(google_rpc_Status* msg) {
   int32_t code = google_rpc_Status_code(msg);
-  upb_strview message = google_rpc_Status_message(msg);
+  upb_StringView message = google_rpc_Status_message(msg);
   absl::Status status(static_cast<absl::StatusCode>(code),
                       absl::string_view(message.data, message.size));
   size_t detail_len;
   const google_protobuf_Any* const* details =
       google_rpc_Status_details(msg, &detail_len);
   for (size_t i = 0; i < detail_len; i++) {
-    upb_strview type_url = google_protobuf_Any_type_url(details[i]);
-    upb_strview value = google_protobuf_Any_value(details[i]);
+    upb_StringView type_url = google_protobuf_Any_type_url(details[i]);
+    upb_StringView value = google_protobuf_Any_value(details[i]);
     status.SetPayload(absl::string_view(type_url.data, type_url.size),
                       absl::Cord(absl::string_view(value.data, value.size)));
   }
   return status;
 }
 
-uintptr_t StatusAllocPtr(absl::Status s) {
-  // This relies the fact that absl::Status has only one member, StatusRep*
-  // so the sizeof(absl::Status) has the same size of intptr_t and StatusRep*
-  // can be stolen using placement allocation.
-  static_assert(sizeof(intptr_t) == sizeof(absl::Status),
-                "absl::Status should be as big as intptr_t");
-  // This does two things;
-  // 1. Copies StatusRep* of absl::Status to ptr
-  // 2. Increases the counter of StatusRep if it's not inlined
-  uintptr_t ptr;
-  new (&ptr) absl::Status(s);
-  return ptr;
-}
-
-void StatusFreePtr(uintptr_t ptr) {
-  // Decreases the counter of StatusRep if it's not inlined.
-  reinterpret_cast<absl::Status*>(&ptr)->~Status();
-}
-
-absl::Status StatusGetFromPtr(uintptr_t ptr) {
-  // Constructs Status from ptr having the address of StatusRep.
-  return *reinterpret_cast<absl::Status*>(&ptr);
-}
-
 uintptr_t StatusAllocHeapPtr(absl::Status s) {
-  if (s.ok()) return kOkStatusPtr;
+  if (s.ok()) return 0;
   absl::Status* ptr = new absl::Status(s);
   return reinterpret_cast<uintptr_t>(ptr);
 }
@@ -415,13 +412,24 @@ void StatusFreeHeapPtr(uintptr_t ptr) {
 }
 
 absl::Status StatusGetFromHeapPtr(uintptr_t ptr) {
-  if (ptr == kOkStatusPtr) {
+  if (ptr == 0) {
     return absl::OkStatus();
   } else {
     return *reinterpret_cast<absl::Status*>(ptr);
   }
 }
 
+absl::Status StatusMoveFromHeapPtr(uintptr_t ptr) {
+  if (ptr == 0) {
+    return absl::OkStatus();
+  } else {
+    absl::Status* s = reinterpret_cast<absl::Status*>(ptr);
+    absl::Status ret = std::move(*s);
+    delete s;
+    return ret;
+  }
+}
+
 }  // namespace internal
 
 }  // namespace grpc_core

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

@@ -31,7 +31,7 @@
 
 extern "C" {
 struct google_rpc_Status;
-struct upb_arena;
+struct upb_Arena;
 }
 
 namespace grpc_core {
@@ -110,7 +110,7 @@ enum class StatusTimeProperty {
 /// Creates a status with given additional information
 absl::Status StatusCreate(
     absl::StatusCode code, absl::string_view msg, const DebugLocation& location,
-    std::initializer_list<absl::Status> children) GRPC_MUST_USE_RESULT;
+    std::vector<absl::Status> children) GRPC_MUST_USE_RESULT;
 
 /// Sets the int property to the status
 void StatusSetInt(absl::Status* status, StatusIntProperty key, intptr_t value);
@@ -154,28 +154,12 @@ namespace internal {
 /// Builds a upb message, google_rpc_Status from a status
 /// This is for internal implementation & test only
 google_rpc_Status* StatusToProto(const absl::Status& status,
-                                 upb_arena* arena) GRPC_MUST_USE_RESULT;
+                                 upb_Arena* arena) GRPC_MUST_USE_RESULT;
 
 /// Builds a status from a upb message, google_rpc_Status
 /// This is for internal implementation & test only
 absl::Status StatusFromProto(google_rpc_Status* msg) GRPC_MUST_USE_RESULT;
 
-/// The same value of grpc_core::internal::StatusAllocPtr(absl::OkStatus())
-static constexpr uintptr_t kOkStatusPtr = 0;
-
-/// Returns ptr where the given status is copied into.
-/// This ptr can be used to get Status later and should be freed by
-/// StatusFreePtr. This shouldn't be used except migration purpose.
-uintptr_t StatusAllocPtr(absl::Status s);
-
-/// Frees the allocated status at ptr.
-/// This shouldn't be used except migration purpose.
-void StatusFreePtr(uintptr_t ptr);
-
-/// Get the status from ptr.
-/// This shouldn't be used except migration purpose.
-absl::Status StatusGetFromPtr(uintptr_t ptr);
-
 /// Returns ptr that is allocated in the heap memory and the given status is
 /// copied into. This ptr can be used to get Status later and should be
 /// freed by StatusFreeHeapPtr. This can be 0 in case of OkStatus.
@@ -187,6 +171,9 @@ void StatusFreeHeapPtr(uintptr_t ptr);
 /// Get the status from a heap ptr.
 absl::Status StatusGetFromHeapPtr(uintptr_t ptr);
 
+/// Move the status from a heap ptr. (GetFrom & FreeHeap)
+absl::Status StatusMoveFromHeapPtr(uintptr_t ptr);
+
 }  // namespace internal
 
 }  // namespace grpc_core