grpc 1.46.3-x86_64-linux → 1.48.0-x86_64-linux

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

@@ -21,7 +21,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gprpp/global_config_generic.h"
+#include <stdint.h>
+
+#include "src/core/lib/gprpp/global_config_generic.h"  // IWYU pragma: export
 #include "src/core/lib/gprpp/memory.h"
 
 namespace grpc_core {

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

@@ -21,10 +21,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdint.h>
-
-#include "src/core/lib/gprpp/memory.h"
-
 #define GPR_GLOBAL_CONFIG_GET(name) gpr_global_config_get_##name()
 
 #define GPR_GLOBAL_CONFIG_SET(name, value) gpr_global_config_set_##name(value)

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

@@ -20,6 +20,8 @@
 
 #include "src/core/lib/gprpp/host_port.h"
 
+#include <stddef.h>
+
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 

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

@@ -24,14 +24,10 @@
 #include <grpc/support/port_platform.h>
 
 #include <stddef.h>
-#include <stdlib.h>
 
-#include <new>
 #include <type_traits>
 #include <utility>
 
-#include <grpc/support/log.h>
-
 #include "src/core/lib/gprpp/construct_destruct.h"
 
 namespace grpc_core {
@@ -103,70 +99,6 @@ class max_align_of<A, B...> {
 
 }  // namespace manual_ctor_impl
 
-template <class BaseType, class... DerivedTypes>
-class PolymorphicManualConstructor {
- public:
-  // No constructor or destructor because one of the most useful uses of
-  // this class is as part of a union, and members of a union could not have
-  // constructors or destructors till C++11.  And, anyway, the whole point of
-  // this class is to bypass constructor and destructor.
-
-  BaseType* get() { return reinterpret_cast<BaseType*>(&space_); }
-  const BaseType* get() const {
-    return reinterpret_cast<const BaseType*>(&space_);
-  }
-
-  BaseType* operator->() { return get(); }
-  const BaseType* operator->() const { return get(); }
-
-  BaseType& operator*() { return *get(); }
-  const BaseType& operator*() const { return *get(); }
-
-  template <class DerivedType>
-  void Init() {
-    FinishInit(new (&space_) DerivedType);
-  }
-
-  // Init() constructs the Type instance using the given arguments
-  // (which are forwarded to Type's constructor).
-  //
-  // Note that Init() with no arguments performs default-initialization,
-  // not zero-initialization (i.e it behaves the same as "new Type;", not
-  // "new Type();"), so it will leave non-class types uninitialized.
-  template <class DerivedType, typename... Ts>
-  void Init(Ts&&... args) {
-    FinishInit(new (&space_) DerivedType(std::forward<Ts>(args)...));
-  }
-
-  // Init() that is equivalent to copy and move construction.
-  // Enables usage like this:
-  //   ManualConstructor<std::vector<int>> v;
-  //   v.Init({1, 2, 3});
-  template <class DerivedType>
-  void Init(const DerivedType& x) {
-    FinishInit(new (&space_) DerivedType(x));
-  }
-  template <class DerivedType>
-  void Init(DerivedType&& x) {
-    FinishInit(new (&space_) DerivedType(std::forward<DerivedType>(x)));
-  }
-
-  void Destroy() { get()->~BaseType(); }
-
- private:
-  template <class DerivedType>
-  void FinishInit(DerivedType* p) {
-    static_assert(
-        manual_ctor_impl::is_one_of<DerivedType, DerivedTypes...>::value,
-        "DerivedType must be one of the predeclared DerivedTypes");
-    GPR_ASSERT(static_cast<BaseType*>(p) == p);
-  }
-
-  typename std::aligned_storage<
-      manual_ctor_impl::max_size_of<DerivedTypes...>::value,
-      manual_ctor_impl::max_align_of<DerivedTypes...>::value>::type space_;
-};
-
 template <typename Type>
 class ManualConstructor {
  public:

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

@@ -17,6 +17,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <type_traits>
+
 #include "absl/types/variant.h"
 
 #include "src/core/lib/gprpp/overload.h"

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

@@ -21,14 +21,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <limits>
 #include <memory>
-#include <utility>
-
-#include "absl/memory/memory.h"
+#include <type_traits>
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 
 namespace grpc_core {
 

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

@@ -23,12 +23,9 @@
 
 #include <cinttypes>
 #include <memory>
-
-#include <grpc/support/log.h>
-#include <grpc/support/sync.h>
+#include <utility>
 
 #include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 

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

@@ -25,13 +25,10 @@
 #include <cassert>
 #include <cinttypes>
 
-#include <grpc/support/atm.h>
 #include <grpc/support/log.h>
-#include <grpc/support/sync.h>
 
 #include "src/core/lib/gprpp/atomic_utils.h"
 #include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 
 namespace grpc_core {
@@ -234,6 +231,7 @@ enum UnrefBehavior {
 namespace internal {
 template <typename T, UnrefBehavior UnrefBehaviorArg>
 class Delete;
+
 template <typename T>
 class Delete<T, kUnrefDelete> {
  public:

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

@@ -21,11 +21,11 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <iosfwd>
 #include <type_traits>
 #include <utility>
 
 #include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/memory.h"
 
 namespace grpc_core {
 

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,21 +20,27 @@
 
 #include "src/core/lib/gprpp/status_helper.h"
 
-#include <type_traits>
+#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 {
 
@@ -220,23 +226,10 @@ 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);
+  std::string time_str =
+      absl::FormatTime(absl::RFC3339_full, time, absl::UTCTimeZone());
   status->SetPayload(GetStatusTimePropertyUrl(key),
-                     absl::Cord(absl::string_view(buf, sizeof(time))));
+                     absl::Cord(std::move(time_str)));
 }
 
 absl::optional<absl::Time> StatusGetTime(const absl::Status& status,
@@ -245,14 +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()) {
-      // 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);
+      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 {};
@@ -320,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), "\""));
@@ -353,9 +353,21 @@ namespace internal {
 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_StringView_FromDataAndSize(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);
@@ -385,9 +397,15 @@ 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_StringView 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);

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"
 

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;

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"

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

@@ -17,9 +17,13 @@
 #include "src/core/lib/gprpp/time.h"
 
 #include <atomic>
+#include <chrono>
 #include <cstdint>
 #include <limits>
 #include <string>
+#include <utility>
+
+#include "absl/strings/str_format.h"
 
 #include <grpc/impl/codegen/gpr_types.h>
 #include <grpc/support/log.h>
@@ -182,6 +186,18 @@ std::string Duration::ToString() const {
   return std::to_string(millis_) + "ms";
 }
 
+std::string Duration::ToJsonString() const {
+  gpr_timespec ts = as_timespec();
+  return absl::StrFormat("%d.%09ds", ts.tv_sec, ts.tv_nsec);
+}
+
+Duration::operator grpc_event_engine::experimental::EventEngine::Duration()
+    const {
+  return std::chrono::milliseconds(
+      Clamp(millis_, std::numeric_limits<int64_t>::min() / GPR_NS_PER_MS,
+            std::numeric_limits<int64_t>::max() / GPR_NS_PER_MS));
+}
+
 void TestOnlySetProcessEpoch(gpr_timespec epoch) {
   g_process_epoch_seconds.store(
       gpr_convert_clock_type(epoch, GPR_CLOCK_MONOTONIC).tv_sec);

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

@@ -19,11 +19,12 @@
 
 #include <stdint.h>
 
-#include <cstdint>
 #include <limits>
 #include <ostream>
 #include <string>
 
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/impl/codegen/gpr_types.h>
 #include <grpc/support/time.h>
 
 #include "src/core/lib/gpr/time_precise.h"
@@ -207,10 +208,18 @@ class Duration {
   constexpr int64_t millis() const { return millis_; }
   double seconds() const { return static_cast<double>(millis_) / 1000.0; }
 
+  // NOLINTNEXTLINE: google-explicit-constructor
+  operator grpc_event_engine::experimental::EventEngine::Duration() const;
+
   gpr_timespec as_timespec() const;
 
   std::string ToString() const;
 
+  // Returns the duration in the JSON form corresponding to a
+  // google.protobuf.Duration proto, as defined here:
+  // https://developers.google.com/protocol-buffers/docs/proto3#json
+  std::string ToJsonString() const;
+
  private:
   explicit constexpr Duration(int64_t millis) : millis_(millis) {}
 

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

@@ -18,7 +18,11 @@
 
 #include "src/core/lib/gprpp/time_util.h"
 
+#include <stdint.h>
+#include <time.h>
+
 #include <grpc/support/log.h>
+#include <grpc/support/time.h>
 
 namespace grpc_core {
 

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

@@ -21,7 +21,7 @@
 
 #include "absl/time/time.h"
 
-#include <grpc/support/time.h>
+#include <grpc/impl/codegen/gpr_types.h>
 
 namespace grpc_core {