grpc 1.47.0 → 1.49.0.pre1

data/src/core/lib/event_engine/windows/windows_engine.h

@@ -0,0 +1,120 @@
+// Copyright 2022 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_CORE_LIB_EVENT_ENGINE_WINDOWS_WINDOWS_ENGINE_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_WINDOWS_WINDOWS_ENGINE_H
+#include <grpc/support/port_platform.h>
+
+#ifdef GPR_WINDOWS
+
+#include <memory>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/event_engine/endpoint_config.h>
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/memory_allocator.h>
+#include <grpc/event_engine/slice_buffer.h>
+
+#include "src/core/lib/event_engine/executor/threaded_executor.h"
+#include "src/core/lib/event_engine/handle_containers.h"
+#include "src/core/lib/event_engine/posix_engine/timer_manager.h"
+#include "src/core/lib/event_engine/windows/iocp.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class WindowsEventEngine : public EventEngine {
+ public:
+  class WindowsEndpoint : public EventEngine::Endpoint {
+   public:
+    ~WindowsEndpoint() override;
+    void Read(absl::AnyInvocable<void(absl::Status)> on_read,
+              SliceBuffer* buffer, const ReadArgs* args) override;
+    void Write(absl::AnyInvocable<void(absl::Status)> on_writable,
+               SliceBuffer* data, const WriteArgs* args) override;
+    const ResolvedAddress& GetPeerAddress() const override;
+    const ResolvedAddress& GetLocalAddress() const override;
+  };
+  class WindowsListener : public EventEngine::Listener {
+   public:
+    ~WindowsListener() override;
+    absl::StatusOr<int> Bind(const ResolvedAddress& addr) override;
+    absl::Status Start() override;
+  };
+  class WindowsDNSResolver : public EventEngine::DNSResolver {
+   public:
+    ~WindowsDNSResolver() override;
+    LookupTaskHandle LookupHostname(LookupHostnameCallback on_resolve,
+                                    absl::string_view name,
+                                    absl::string_view default_port,
+                                    Duration timeout) override;
+    LookupTaskHandle LookupSRV(LookupSRVCallback on_resolve,
+                               absl::string_view name,
+                               Duration timeout) override;
+    LookupTaskHandle LookupTXT(LookupTXTCallback on_resolve,
+                               absl::string_view name,
+                               Duration timeout) override;
+    bool CancelLookup(LookupTaskHandle handle) override;
+  };
+
+  WindowsEventEngine();
+  ~WindowsEventEngine() override;
+
+  absl::StatusOr<std::unique_ptr<Listener>> CreateListener(
+      Listener::AcceptCallback on_accept,
+      absl::AnyInvocable<void(absl::Status)> on_shutdown,
+      const EndpointConfig& config,
+      std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory)
+      override;
+
+  ConnectionHandle Connect(OnConnectCallback on_connect,
+                           const ResolvedAddress& addr,
+                           const EndpointConfig& args,
+                           MemoryAllocator memory_allocator,
+                           Duration timeout) override;
+
+  bool CancelConnect(ConnectionHandle handle) override;
+  bool IsWorkerThread() override;
+  std::unique_ptr<DNSResolver> GetDNSResolver(
+      const DNSResolver::ResolverOptions& options) override;
+  void Run(Closure* closure) override;
+  void Run(absl::AnyInvocable<void()> closure) override;
+  TaskHandle RunAfter(Duration when, Closure* closure) override;
+  TaskHandle RunAfter(Duration when,
+                      absl::AnyInvocable<void()> closure) override;
+  bool Cancel(TaskHandle handle) override;
+
+ private:
+  struct Closure;
+  EventEngine::TaskHandle RunAfterInternal(Duration when,
+                                           absl::AnyInvocable<void()> cb);
+  grpc_core::Mutex mu_;
+  TaskHandleSet known_handles_ ABSL_GUARDED_BY(mu_);
+  std::atomic<intptr_t> aba_token_{0};
+
+  posix_engine::TimerManager timer_manager_;
+  ThreadedExecutor executor_{2};
+  IOCP iocp_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_WINDOWS_WINDOWS_ENGINE_H

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

@@ -77,16 +77,18 @@ static gpr_timespec to_seconds_from_sub_second_time(int64_t time_in_units,
   } else if (time_in_units == INT64_MIN) {
     out = gpr_inf_past(type);
   } else {
-    if (time_in_units >= 0) {
-      out.tv_sec = time_in_units / units_per_sec;
-    } else {
-      out.tv_sec = (-((units_per_sec - 1) - (time_in_units + units_per_sec)) /
-                    units_per_sec) -
-                   1;
-    }
+    GPR_DEBUG_ASSERT(GPR_NS_PER_SEC % units_per_sec == 0);
+
+    out.tv_sec = time_in_units / units_per_sec;
     out.tv_nsec =
-        static_cast<int32_t>((time_in_units - out.tv_sec * units_per_sec) *
-                             GPR_NS_PER_SEC / units_per_sec);
+        static_cast<int32_t>((time_in_units - (out.tv_sec * units_per_sec)) *
+                             (GPR_NS_PER_SEC / units_per_sec));
+    /// `out.tv_nsec` should always be positive.
+    if (out.tv_nsec < 0) {
+      out.tv_nsec += GPR_NS_PER_SEC;
+      out.tv_sec--;
+    }
+
     out.clock_type = type;
   }
   return out;

data/src/core/lib/gpr/time_posix.cc

@@ -88,17 +88,14 @@ static gpr_timespec now_impl(gpr_clock_type clock_type) {
 #include <mach/mach_time.h>
 #include <sys/time.h>
 
-static double g_time_scale;
-static uint64_t g_time_start;
-
-void gpr_time_init(void) {
+static double g_time_scale = []() {
   mach_timebase_info_data_t tb = {0, 1};
-  gpr_precise_clock_init();
   mach_timebase_info(&tb);
-  g_time_scale = tb.numer;
-  g_time_scale /= tb.denom;
-  g_time_start = mach_absolute_time();
-}
+  return static_cast<double>(tb.numer) / static_cast<double>(tb.denom);
+}();
+static uint64_t g_time_start = mach_absolute_time();
+
+void gpr_time_init(void) { gpr_precise_clock_init(); }
 
 static gpr_timespec now_impl(gpr_clock_type clock) {
   gpr_timespec now;

data/src/core/lib/gpr/time_windows.cc

@@ -31,15 +31,18 @@
 
 #include "src/core/lib/gpr/time_precise.h"
 
-static LARGE_INTEGER g_start_time;
-static double g_time_scale;
-
-void gpr_time_init(void) {
+static LARGE_INTEGER g_start_time = []() {
+  LARGE_INTEGER x;
+  QueryPerformanceCounter(&x);
+  return x;
+}();
+static double g_time_scale = []() {
   LARGE_INTEGER frequency;
   QueryPerformanceFrequency(&frequency);
-  QueryPerformanceCounter(&g_start_time);
-  g_time_scale = 1.0 / (double)frequency.QuadPart;
-}
+  return 1.0 / (double)frequency.QuadPart;
+}();
+
+void gpr_time_init(void) {}
 
 static gpr_timespec now_impl(gpr_clock_type clock) {
   gpr_timespec now_tv;

data/src/core/lib/gpr/useful.h

@@ -23,6 +23,9 @@
 
 #include <cstddef>
 
+#include "absl/strings/string_view.h"
+#include "absl/types/variant.h"
+
 /** useful utilities that don't belong anywhere else */
 
 namespace grpc_core {
@@ -98,6 +101,32 @@ int QsortCompare(const T& a, const T& b) {
   return 0;
 }
 
+template <typename... X>
+int QsortCompare(const absl::variant<X...>& a, const absl::variant<X...>& b) {
+  const int index = QsortCompare(a.index(), b.index());
+  if (index != 0) return index;
+  return absl::visit(
+      [&](const auto& x) {
+        return QsortCompare(x, absl::get<absl::remove_cvref_t<decltype(x)>>(b));
+      },
+      a);
+}
+
+inline int QsortCompare(absl::string_view a, absl::string_view b) {
+  return a.compare(b);
+}
+
+inline int QsortCompare(const std::string& a, const std::string& b) {
+  return a.compare(b);
+}
+
+template <typename A, typename B>
+int QsortCompare(const std::pair<A, B>& a, const std::pair<A, B>& b) {
+  const int first = QsortCompare(a.first, b.first);
+  if (first != 0) return first;
+  return QsortCompare(a.second, b.second);
+}
+
 template <typename T>
 constexpr size_t HashPointer(T* p, size_t range) {
   return (((reinterpret_cast<size_t>(p)) >> 4) ^

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

@@ -24,12 +24,6 @@
 
 #include "src/core/lib/gpr/useful.h"
 
-#if __cplusplus > 201103l
-#define GRPC_BITSET_CONSTEXPR_MUTATOR constexpr
-#else
-#define GRPC_BITSET_CONSTEXPR_MUTATOR
-#endif
-
 namespace grpc_core {
 
 // Given a bit count as an integer, vend as member type `Type` a type with
@@ -90,12 +84,10 @@ class BitSet {
   constexpr BitSet() : units_{} {}
 
   // Set bit i to true
-  GRPC_BITSET_CONSTEXPR_MUTATOR void set(int i) {
-    units_[unit_for(i)] |= mask_for(i);
-  }
+  constexpr void set(int i) { units_[unit_for(i)] |= mask_for(i); }
 
   // Set bit i to is_set
-  GRPC_BITSET_CONSTEXPR_MUTATOR void set(int i, bool is_set) {
+  constexpr void set(int i, bool is_set) {
     if (is_set) {
       set(i);
     } else {
@@ -104,9 +96,7 @@ class BitSet {
   }
 
   // Set bit i to false
-  GRPC_BITSET_CONSTEXPR_MUTATOR void clear(int i) {
-    units_[unit_for(i)] &= ~mask_for(i);
-  }
+  constexpr void clear(int i) { units_[unit_for(i)] &= ~mask_for(i); }
 
   // Return true if bit i is set
   constexpr bool is_set(int i) const {

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

@@ -19,8 +19,39 @@
 #ifndef GRPC_CORE_LIB_GPRPP_DEBUG_LOCATION_H
 #define GRPC_CORE_LIB_GPRPP_DEBUG_LOCATION_H
 
+#if defined(__has_builtin)
+#if __has_builtin(__builtin_FILE)
+#define GRPC_DEFAULT_FILE __builtin_FILE()
+#endif
+#endif
+#ifndef GRPC_DEFAULT_FILE
+#define GRPC_DEFAULT_FILE "<unknown>"
+#endif
+#if defined(__has_builtin)
+#if __has_builtin(__builtin_LINE)
+#define GRPC_DEFAULT_LINE __builtin_LINE()
+#endif
+#endif
+#ifndef GRPC_DEFAULT_LINE
+#define GRPC_DEFAULT_LINE -1
+#endif
+
 namespace grpc_core {
 
+class SourceLocation {
+ public:
+  // NOLINTNEXTLINE
+  SourceLocation(const char* file = GRPC_DEFAULT_FILE,
+                 int line = GRPC_DEFAULT_LINE)
+      : file_(file), line_(line) {}
+  const char* file() const { return file_; }
+  int line() const { return line_; }
+
+ private:
+  const char* file_;
+  int line_;
+};
+
 // Used for tracking file and line where a call is made for debug builds.
 // No-op for non-debug builds.
 // Callers can use the DEBUG_LOCATION macro in either case.
@@ -30,15 +61,15 @@ namespace grpc_core {
 // callers don't need to explicitly pass DEBUG_LOCATION anywhere.
 class DebugLocation {
  public:
-  DebugLocation(const char* file, int line) : file_(file), line_(line) {}
-  const char* file() const { return file_; }
-  int line() const { return line_; }
+  DebugLocation(const char* file = GRPC_DEFAULT_FILE,
+                int line = GRPC_DEFAULT_LINE)
+      : location_(file, line) {}
+  const char* file() const { return location_.file(); }
+  int line() const { return location_.line(); }
 
  private:
-  const char* file_;
-  const int line_;
+  SourceLocation location_;
 };
-#define DEBUG_LOCATION ::grpc_core::DebugLocation(__FILE__, __LINE__)
 #else
 class DebugLocation {
  public:
@@ -47,9 +78,10 @@ class DebugLocation {
   const char* file() const { return nullptr; }
   int line() const { return -1; }
 };
-#define DEBUG_LOCATION ::grpc_core::DebugLocation()
 #endif
 
+#define DEBUG_LOCATION ::grpc_core::DebugLocation(__FILE__, __LINE__)
+
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_GPRPP_DEBUG_LOCATION_H */

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

@@ -25,12 +25,8 @@
 
 #include <stddef.h>
 
-#include <new>
-#include <type_traits>
 #include <utility>
 
-#include <grpc/support/log.h>
-
 #include "src/core/lib/gprpp/construct_destruct.h"
 
 namespace grpc_core {
@@ -102,70 +98,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/no_destruct.h

@@ -0,0 +1,94 @@
+// 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_NO_DESTRUCT_H
+#define GRPC_CORE_LIB_GPRPP_NO_DESTRUCT_H
+
+#include <grpc/support/port_platform.h>
+
+#include <utility>
+
+#include "src/core/lib/gprpp/construct_destruct.h"
+
+namespace grpc_core {
+
+// NoDestruct<T> is a wrapper around an object of type T that:
+// - stores the value inline - no heap allocation
+// - is non-copyable
+// - is eagerly constructed (i.e. the constructor is called when NoDestruct is
+//   constructed)
+// - *NEVER* calls ~T()
+// It's useful in cases where no ordering can be assumed between destructors of
+// objects that need to refer to each other - such as at program destruction
+// time.
+// Examples:
+//  // globally available object:
+//  static NoDestruct<Foo> g_foo(1, "foo", 2.0);
+//  // used as:
+//  g_foo->DoSomething();
+//  // singleton function:
+//  Bar* BarSingleton() {
+//   static NoDestruct<Bar> bar(1, "bar", 2.0);
+//   return &*bar;
+//  }
+// The globally available version is constructed at program startup, and the
+// singleton version is constructed at the first call to BarSingleton().
+// Neither Foo nor Bar instance will be destructed.
+template <typename T>
+class NoDestruct {
+ public:
+  template <typename... Args>
+  explicit NoDestruct(Args&&... args) {
+    static_assert(std::is_trivially_destructible<NoDestruct<T>>::value,
+                  "NoDestruct must be trivially destructible");
+    Construct(reinterpret_cast<T*>(&space_), std::forward<Args>(args)...);
+  }
+  NoDestruct(const NoDestruct&) = delete;
+  NoDestruct& operator=(const NoDestruct&) = delete;
+  ~NoDestruct() = default;
+
+  T* operator->() { return get(); }
+  const T* operator->() const { return get(); }
+  T& operator*() { return *get(); }
+  const T& operator*() const { return *get(); }
+
+  T* get() { return reinterpret_cast<T*>(&space_); }
+  const T* get() const { return reinterpret_cast<const T*>(&space_); }
+
+ private:
+  typename std::aligned_storage<sizeof(T), alignof(T)>::type space_;
+};
+
+// Helper for when a program desires a single *process wide* instance of a
+// default constructed T to be always available.
+// The instance is constructed eagerly at program startup, so it's essentially
+// free to load the pointer to the instance.
+template <typename T>
+class NoDestructSingleton {
+ public:
+  static T* Get() { return &*value_; }
+
+ private:
+  NoDestructSingleton() = delete;
+  ~NoDestructSingleton() = delete;
+
+  static NoDestruct<T> value_;
+};
+
+template <typename T>
+NoDestruct<T> NoDestructSingleton<T>::value_;
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_NO_DESTRUCT_H

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

@@ -22,7 +22,6 @@
 #include <grpc/support/port_platform.h>
 
 #include <iosfwd>
-#include <type_traits>
 #include <utility>
 
 #include "src/core/lib/gprpp/debug_location.h"

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

@@ -23,7 +23,6 @@
 #include <string.h>
 
 #include <algorithm>
-#include <new>
 #include <utility>
 
 #include "absl/strings/cord.h"
@@ -35,11 +34,15 @@
 #include "absl/time/clock.h"
 #include "google/protobuf/any.upb.h"
 #include "google/rpc/status.upb.h"
+#include "upb/arena.h"
 #include "upb/upb.h"
 #include "upb/upb.hpp"
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/slice/percent_encoding.h"
+#include "src/core/lib/slice/slice.h"
+
 namespace grpc_core {
 
 namespace {
@@ -224,23 +227,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,
@@ -249,14 +239,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 {};
@@ -324,9 +316,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), "\""));
@@ -357,9 +354,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);
@@ -389,9 +398,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);