grpc 1.43.1 → 1.48.0

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

@@ -19,11 +19,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdio.h>
 #include <time.h>
 
 #include "absl/status/status.h"
-#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 

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

@@ -16,12 +16,17 @@
 
 #include <grpc/support/port_platform.h>
 
+// IWYU pragma: no_include <bits/struct_stat.h>
+
+#include <string.h>
+
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+
 #ifdef GPR_POSIX_STAT
 
 #include <errno.h>
 #include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
 
 #include <grpc/support/log.h>
 

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

@@ -20,19 +20,27 @@
 
 #include "src/core/lib/gprpp/status_helper.h"
 
+#include <string.h>
+
+#include <algorithm>
+#include <utility>
+
 #include "absl/strings/cord.h"
 #include "absl/strings/escaping.h"
 #include "absl/strings/match.h"
-#include "absl/strings/str_format.h"
+#include "absl/strings/numbers.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/time/clock.h"
 #include "google/protobuf/any.upb.h"
 #include "google/rpc/status.upb.h"
+#include "upb/upb.h"
 #include "upb/upb.hpp"
 
 #include <grpc/support/log.h>
 
-#include "src/core/lib/gprpp/time_util.h"
+#include "src/core/lib/slice/percent_encoding.h"
+#include "src/core/lib/slice/slice.h"
 
 namespace grpc_core {
 
@@ -159,7 +167,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 +226,10 @@ absl::optional<std::string> StatusGetStr(const absl::Status& status,
 
 void StatusSetTime(absl::Status* status, StatusTimeProperty key,
                    absl::Time time) {
+  std::string time_str =
+      absl::FormatTime(absl::RFC3339_full, time, absl::UTCTimeZone());
   status->SetPayload(GetStatusTimePropertyUrl(key),
-                     absl::Cord(absl::string_view(
-                         reinterpret_cast<const char*>(&time), sizeof(time))));
+                     absl::Cord(std::move(time_str)));
 }
 
 absl::optional<absl::Time> StatusGetTime(const absl::Status& status,
@@ -229,11 +238,16 @@ absl::optional<absl::Time> StatusGetTime(const absl::Status& status,
       status.GetPayload(GetStatusTimePropertyUrl(key));
   if (p.has_value()) {
     absl::optional<absl::string_view> sv = p->TryFlat();
+    absl::Time time;
     if (sv.has_value()) {
-      return *reinterpret_cast<const absl::Time*>(sv->data());
+      if (absl::ParseTime(absl::RFC3339_full, sv.value(), &time, nullptr)) {
+        return time;
+      }
     } else {
       std::string s = std::string(*p);
-      return *reinterpret_cast<const absl::Time*>(s.c_str());
+      if (absl::ParseTime(absl::RFC3339_full, s, &time, nullptr)) {
+        return time;
+      }
     }
   }
   return {};
@@ -301,9 +315,14 @@ std::string StatusToString(const absl::Status& status) {
                                    absl::CHexEscape(payload_view), "\""));
       } else if (absl::StartsWith(type_url, kTypeTimeTag)) {
         type_url.remove_prefix(kTypeTimeTag.size());
-        absl::Time t =
-            *reinterpret_cast<const absl::Time*>(payload_view.data());
-        kvs.push_back(absl::StrCat(type_url, ":\"", absl::FormatTime(t), "\""));
+        absl::Time t;
+        if (absl::ParseTime(absl::RFC3339_full, payload_view, &t, nullptr)) {
+          kvs.push_back(
+              absl::StrCat(type_url, ":\"", absl::FormatTime(t), "\""));
+        } else {
+          kvs.push_back(absl::StrCat(type_url, ":\"",
+                                     absl::CHexEscape(payload_view), "\""));
+        }
       } else {
         kvs.push_back(absl::StrCat(type_url, ":\"",
                                    absl::CHexEscape(payload_view), "\""));
@@ -331,32 +350,46 @@ 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()));
+  // Protobuf string field requires to be utf-8 encoding but C++ string doesn't
+  // this requirement so it can be a non utf-8 string. So it should be converted
+  // to a percent-encoded string to keep it as a utf-8 string.
+  Slice message_percent_slice =
+      PercentEncodeSlice(Slice::FromExternalString(status.message()),
+                         PercentEncodingType::Compatible);
+  char* message_percent = reinterpret_cast<char*>(
+      upb_Arena_Malloc(arena, message_percent_slice.length()));
+  if (message_percent_slice.length() > 0) {
+    memcpy(message_percent, message_percent_slice.data(),
+           message_percent_slice.length());
+  }
   google_rpc_Status_set_message(
-      msg, upb_strview_make(status.message().data(), status.message().size()));
+      msg, upb_StringView_FromDataAndSize(message_percent,
+                                          message_percent_slice.length()));
   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 +397,29 @@ 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);
-  absl::Status status(static_cast<absl::StatusCode>(code),
-                      absl::string_view(message.data, message.size));
+  upb_StringView message_percent_upb = google_rpc_Status_message(msg);
+  Slice message_percent_slice = Slice::FromExternalString(
+      absl::string_view(message_percent_upb.data, message_percent_upb.size));
+  Slice message_slice =
+      PermissivePercentDecodeSlice(std::move(message_percent_slice));
+  absl::Status status(
+      static_cast<absl::StatusCode>(code),
+      absl::string_view(reinterpret_cast<const char*>(message_slice.data()),
+                        message_slice.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 +430,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

@@ -21,9 +21,13 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
+
+#include <string>
 #include <vector>
 
 #include "absl/status/status.h"
+#include "absl/strings/string_view.h"
 #include "absl/time/time.h"
 #include "absl/types/optional.h"
 
@@ -31,7 +35,7 @@
 
 extern "C" {
 struct google_rpc_Status;
-struct upb_arena;
+struct upb_Arena;
 }
 
 namespace grpc_core {
@@ -110,7 +114,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 +158,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 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 +175,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

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

@@ -21,13 +21,15 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/base/thread_annotations.h"
 #include "absl/synchronization/mutex.h"
 
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
-#include <grpc/support/time.h>
 
+#ifndef GPR_ABSEIL_SYNC
 #include "src/core/lib/gprpp/time_util.h"
+#endif
 
 // The core library is not accessible in C++ codegen headers, and vice versa.
 // Thus, we need to have duplicate headers with similar functionality.

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

@@ -17,8 +17,14 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
+#include <initializer_list>
+#include <new>
+#include <type_traits>
 #include <utility>
 
+#include "absl/meta/type_traits.h"
 #include "absl/utility/utility.h"
 
 #include "src/core/lib/gprpp/bitset.h"
@@ -31,6 +37,7 @@ namespace table_detail {
 // A tuple-like type that contains manually constructed elements.
 template <typename... Ts>
 struct Elements;
+
 template <typename T, typename... Ts>
 struct Elements<T, Ts...> : Elements<Ts...> {
   union U {
@@ -71,6 +78,7 @@ struct GetElem<I, T, Ts...> {
 // Sets a member constant N to the number of times Needle is in Haystack.
 template <typename Needle, typename... Haystack>
 struct CountIncludedStruct;
+
 template <typename Needle, typename Straw, typename... RestOfHaystack>
 struct CountIncludedStruct<Needle, Straw, RestOfHaystack...> {
   static constexpr size_t N =
@@ -92,6 +100,7 @@ constexpr size_t CountIncluded() {
 // Ignored should be void always, and is used for enable_if_t.
 template <typename Ignored, typename Needle, typename... Haystack>
 struct IndexOfStruct;
+
 template <typename Needle, typename Straw, typename... RestOfHaystack>
 struct IndexOfStruct<absl::enable_if_t<std::is_same<Needle, Straw>::value>,
                      Needle, Straw, RestOfHaystack...> {
@@ -123,6 +132,7 @@ IndexOf() {
 // Implemented as a simple type recursion.
 template <size_t I, typename... Ts>
 struct TypeIndexStruct;
+
 template <typename T, typename... Ts>
 struct TypeIndexStruct<0, T, Ts...> {
   using Type = T;
@@ -311,6 +321,12 @@ class Table {
   // Count the number of set fields in the table
   size_t count() const { return present_bits_.count(); }
 
+  // Check if the table is completely empty
+  bool empty() const { return present_bits_.none(); }
+
+  // Clear all elements in the table.
+  void ClearAll() { ClearAllImpl(absl::make_index_sequence<sizeof...(Ts)>()); }
+
  private:
   // Bit field for which elements of the table are set (true) or un-set (false,
   // the default) -- one bit for each type in Ts.
@@ -412,6 +428,11 @@ class Table {
     table_detail::do_these_things<int>({(CallIf<I>(&f), 1)...});
   }
 
+  template <size_t... I>
+  void ClearAllImpl(absl::index_sequence<I...>) {
+    table_detail::do_these_things<int>({(clear<I>(), 1)...});
+  }
+
   // Bit field indicating which elements are set.
   GPR_NO_UNIQUE_ADDRESS PresentBits present_bits_;
   // The memory to store the elements themselves.

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

@@ -23,12 +23,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/support/log.h>
-#include <grpc/support/sync.h>
-#include <grpc/support/thd_id.h>
-#include <grpc/support/time.h>
+#include <stddef.h>
 
-#include "src/core/lib/gprpp/memory.h"
+#include <grpc/support/log.h>
 
 namespace grpc_core {
 namespace internal {

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

@@ -20,6 +20,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <grpc/impl/codegen/gpr_types.h>
+#include <grpc/support/time.h>
+
 #ifdef GPR_POSIX_SYNC
 
 #include <pthread.h>
@@ -27,19 +30,18 @@
 #include <string.h>
 #include <unistd.h>
 
-#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/thd_id.h>
 
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/fork.h"
-#include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/thd.h"
 
 namespace grpc_core {
 namespace {
 class ThreadInternalsPosix;
+
 struct thd_arg {
   ThreadInternalsPosix* thread;
   void (*body)(void* arg); /* body of a thread */

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

@@ -26,7 +26,9 @@
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/sync.h>
 #include <grpc/support/thd_id.h>
+#include <grpc/support/time.h>
 
 #include "src/core/lib/gpr/tls.h"
 #include "src/core/lib/gprpp/memory.h"