grpc 1.46.2-x86_64-linux → 1.48.0.pre1-x86_64-linux

data/src/core/lib/iomgr/tcp_server_utils_posix_common.cc

@@ -85,38 +85,41 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, int fd,
                                               unsigned port_index,
                                               unsigned fd_index,
                                               grpc_tcp_listener** listener) {
-  grpc_tcp_listener* sp = nullptr;
+  *listener = nullptr;
   int port = -1;
 
   grpc_error_handle err =
       grpc_tcp_server_prepare_socket(s, fd, addr, s->so_reuseport, &port);
-  if (err == GRPC_ERROR_NONE) {
-    GPR_ASSERT(port > 0);
-    std::string addr_str = grpc_sockaddr_to_string(addr, true);
-    std::string name = absl::StrCat("tcp-server-listener:", addr_str);
-    gpr_mu_lock(&s->mu);
-    s->nports++;
-    GPR_ASSERT(!s->on_accept_cb && "must add ports before starting server");
-    sp = static_cast<grpc_tcp_listener*>(gpr_malloc(sizeof(grpc_tcp_listener)));
-    sp->next = nullptr;
-    if (s->head == nullptr) {
-      s->head = sp;
-    } else {
-      s->tail->next = sp;
-    }
-    s->tail = sp;
-    sp->server = s;
-    sp->fd = fd;
-    sp->emfd = grpc_fd_create(fd, name.c_str(), true);
-    memcpy(&sp->addr, addr, sizeof(grpc_resolved_address));
-    sp->port = port;
-    sp->port_index = port_index;
-    sp->fd_index = fd_index;
-    sp->is_sibling = 0;
-    sp->sibling = nullptr;
-    GPR_ASSERT(sp->emfd);
-    gpr_mu_unlock(&s->mu);
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
+  GPR_ASSERT(port > 0);
+  absl::StatusOr<std::string> addr_str = grpc_sockaddr_to_string(addr, true);
+  if (!addr_str.ok()) {
+    return GRPC_ERROR_CREATE_FROM_CPP_STRING(addr_str.status().ToString());
+  }
+  std::string name = absl::StrCat("tcp-server-listener:", addr_str.value());
+  gpr_mu_lock(&s->mu);
+  s->nports++;
+  GPR_ASSERT(!s->on_accept_cb && "must add ports before starting server");
+  grpc_tcp_listener* sp =
+      static_cast<grpc_tcp_listener*>(gpr_malloc(sizeof(grpc_tcp_listener)));
+  sp->next = nullptr;
+  if (s->head == nullptr) {
+    s->head = sp;
+  } else {
+    s->tail->next = sp;
   }
+  s->tail = sp;
+  sp->server = s;
+  sp->fd = fd;
+  sp->emfd = grpc_fd_create(fd, name.c_str(), true);
+  memcpy(&sp->addr, addr, sizeof(grpc_resolved_address));
+  sp->port = port;
+  sp->port_index = port_index;
+  sp->fd_index = fd_index;
+  sp->is_sibling = 0;
+  sp->sibling = nullptr;
+  GPR_ASSERT(sp->emfd);
+  gpr_mu_unlock(&s->mu);
 
   *listener = sp;
   return err;
@@ -134,7 +137,7 @@ grpc_error_handle grpc_tcp_server_add_addr(grpc_tcp_server* s,
   int fd;
   grpc_error_handle err =
       grpc_create_dualstack_socket(addr, SOCK_STREAM, 0, dsmode, &fd);
-  if (err != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(err)) {
     return err;
   }
   if (*dsmode == GRPC_DSMODE_IPV4 &&
@@ -155,36 +158,36 @@ grpc_error_handle grpc_tcp_server_prepare_socket(
 
   if (so_reuseport && !grpc_is_unix_socket(addr)) {
     err = grpc_set_socket_reuse_port(fd, 1);
-    if (err != GRPC_ERROR_NONE) goto error;
+    if (!GRPC_ERROR_IS_NONE(err)) goto error;
   }
 
 #ifdef GRPC_LINUX_ERRQUEUE
   err = grpc_set_socket_zerocopy(fd);
-  if (err != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(err)) {
     /* it's not fatal, so just log it. */
     gpr_log(GPR_DEBUG, "Node does not support SO_ZEROCOPY, continuing.");
     GRPC_ERROR_UNREF(err);
   }
 #endif
   err = grpc_set_socket_nonblocking(fd, 1);
-  if (err != GRPC_ERROR_NONE) goto error;
+  if (!GRPC_ERROR_IS_NONE(err)) goto error;
   err = grpc_set_socket_cloexec(fd, 1);
-  if (err != GRPC_ERROR_NONE) goto error;
+  if (!GRPC_ERROR_IS_NONE(err)) goto error;
   if (!grpc_is_unix_socket(addr)) {
     err = grpc_set_socket_low_latency(fd, 1);
-    if (err != GRPC_ERROR_NONE) goto error;
+    if (!GRPC_ERROR_IS_NONE(err)) goto error;
     err = grpc_set_socket_reuse_addr(fd, 1);
-    if (err != GRPC_ERROR_NONE) goto error;
+    if (!GRPC_ERROR_IS_NONE(err)) goto error;
     err = grpc_set_socket_tcp_user_timeout(fd, s->channel_args,
                                            false /* is_client */);
-    if (err != GRPC_ERROR_NONE) goto error;
+    if (!GRPC_ERROR_IS_NONE(err)) goto error;
   }
   err = grpc_set_socket_no_sigpipe_if_possible(fd);
-  if (err != GRPC_ERROR_NONE) goto error;
+  if (!GRPC_ERROR_IS_NONE(err)) goto error;
 
   err = grpc_apply_socket_mutator_in_args(fd, GRPC_FD_SERVER_LISTENER_USAGE,
                                           s->channel_args);
-  if (err != GRPC_ERROR_NONE) goto error;
+  if (!GRPC_ERROR_IS_NONE(err)) goto error;
 
   if (bind(fd, reinterpret_cast<grpc_sockaddr*>(const_cast<char*>(addr->addr)),
            addr->len) < 0) {
@@ -209,7 +212,7 @@ grpc_error_handle grpc_tcp_server_prepare_socket(
   return GRPC_ERROR_NONE;
 
 error:
-  GPR_ASSERT(err != GRPC_ERROR_NONE);
+  GPR_ASSERT(!GRPC_ERROR_IS_NONE(err));
   if (fd >= 0) {
     close(fd);
   }

data/src/core/lib/iomgr/tcp_server_utils_posix_ifaddrs.cc

@@ -65,7 +65,7 @@ static grpc_error_handle get_unused_port(int* port) {
   int fd;
   grpc_error_handle err =
       grpc_create_dualstack_socket(&wild, SOCK_STREAM, 0, &dsmode, &fd);
-  if (err != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(err)) {
     return err;
   }
   if (dsmode == GRPC_DSMODE_IPV4) {
@@ -133,21 +133,24 @@ grpc_error_handle grpc_tcp_server_add_all_local_addrs(grpc_tcp_server* s,
       err = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed to set port");
       break;
     }
-    std::string addr_str = grpc_sockaddr_to_string(&addr, false);
+    auto addr_str = grpc_sockaddr_to_string(&addr, false);
+    if (!addr_str.ok()) {
+      return GRPC_ERROR_CREATE_FROM_CPP_STRING(addr_str.status().ToString());
+    }
     gpr_log(GPR_DEBUG,
             "Adding local addr from interface %s flags 0x%x to server: %s",
-            ifa_name, ifa_it->ifa_flags, addr_str.c_str());
+            ifa_name, ifa_it->ifa_flags, addr_str->c_str());
     /* We could have multiple interfaces with the same address (e.g., bonding),
        so look for duplicates. */
     if (find_listener_with_addr(s, &addr) != nullptr) {
       gpr_log(GPR_DEBUG, "Skipping duplicate addr %s on interface %s",
-              addr_str.c_str(), ifa_name);
+              addr_str->c_str(), ifa_name);
       continue;
     }
     if ((err = grpc_tcp_server_add_addr(s, &addr, port_index, fd_index, &dsmode,
                                         &new_sp)) != GRPC_ERROR_NONE) {
       grpc_error_handle root_err = GRPC_ERROR_CREATE_FROM_CPP_STRING(
-          absl::StrCat("Failed to add listener: ", addr_str));
+          absl::StrCat("Failed to add listener: ", addr_str.value()));
       err = grpc_error_add_child(root_err, err);
       break;
     } else {
@@ -161,7 +164,7 @@ grpc_error_handle grpc_tcp_server_add_all_local_addrs(grpc_tcp_server* s,
     }
   }
   freeifaddrs(ifa);
-  if (err != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(err)) {
     return err;
   } else if (sp == nullptr) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("No local addresses");

data/src/core/lib/iomgr/tcp_server_windows.cc

@@ -197,7 +197,7 @@ static grpc_error_handle prepare_socket(SOCKET sock,
   int sockname_temp_len;
 
   error = grpc_tcp_prepare_socket(sock);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     goto failure;
   }
 
@@ -224,12 +224,14 @@ static grpc_error_handle prepare_socket(SOCKET sock,
   return GRPC_ERROR_NONE;
 
 failure:
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
+  GPR_ASSERT(!GRPC_ERROR_IS_NONE(error));
+  auto addr_uri = grpc_sockaddr_to_uri(addr);
   grpc_error_set_int(
-      grpc_error_set_str(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                             "Failed to prepare server socket", &error, 1),
-                         GRPC_ERROR_STR_TARGET_ADDRESS,
-                         grpc_sockaddr_to_uri(addr)),
+      grpc_error_set_str(
+          GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+              "Failed to prepare server socket", &error, 1),
+          GRPC_ERROR_STR_TARGET_ADDRESS,
+          addr_uri.ok() ? *addr_uri : addr_uri.status().ToString()),
       GRPC_ERROR_INT_FD, (intptr_t)sock);
   GRPC_ERROR_UNREF(error);
   if (sock != INVALID_SOCKET) closesocket(sock);
@@ -265,7 +267,7 @@ static grpc_error_handle start_accept_locked(grpc_tcp_listener* port) {
   }
 
   error = grpc_tcp_prepare_socket(sock);
-  if (error != GRPC_ERROR_NONE) goto failure;
+  if (!GRPC_ERROR_IS_NONE(error)) goto failure;
 
   /* Start the "accept" asynchronously. */
   success = port->AcceptEx(port->socket->socket, sock, port->addresses, 0,
@@ -290,7 +292,7 @@ static grpc_error_handle start_accept_locked(grpc_tcp_listener* port) {
   return error;
 
 failure:
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
+  GPR_ASSERT(!GRPC_ERROR_IS_NONE(error));
   if (sock != INVALID_SOCKET) closesocket(sock);
   return error;
 }
@@ -314,7 +316,7 @@ static void on_accept(void* arg, grpc_error_handle error) {
   /* The general mechanism for shutting down is to queue abortion calls. While
      this is necessary in the read/write case, it's useless for the accept
      case. We only need to adjust the pending callback count */
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_INFO, "Skipping on_accept due to error: %s",
             grpc_error_std_string(error).c_str());
 
@@ -347,7 +349,13 @@ static void on_accept(void* arg, grpc_error_handle error) {
       peer_name.len = (size_t)peer_name_len;
       std::string peer_name_string;
       if (!err) {
-        peer_name_string = grpc_sockaddr_to_uri(&peer_name);
+        auto addr_uri = grpc_sockaddr_to_uri(&peer_name);
+        if (addr_uri.ok()) {
+          peer_name_string = addr_uri.value();
+        } else {
+          gpr_log(GPR_ERROR, "invalid peer name: %s",
+                  addr_uri.status().ToString().c_str());
+        }
       } else {
         char* utf8_message = gpr_format_message(WSAGetLastError());
         gpr_log(GPR_ERROR, "getpeername error: %s", utf8_message);
@@ -411,7 +419,7 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, SOCKET sock,
   }
 
   error = prepare_socket(sock, addr, &port);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     return error;
   }
 
@@ -503,7 +511,7 @@ static grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
 done:
   gpr_free(allocated_addr);
 
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     grpc_error_handle error_out =
         GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
             "Failed to add port to server", &error, 1);

data/src/core/lib/iomgr/tcp_windows.cc

@@ -31,6 +31,7 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/sockaddr.h"
@@ -88,11 +89,11 @@ static grpc_error_handle enable_socket_low_latency(SOCKET sock) {
 grpc_error_handle grpc_tcp_prepare_socket(SOCKET sock) {
   grpc_error_handle err;
   err = grpc_tcp_set_non_block(sock);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   err = set_dualstack(sock);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   err = enable_socket_low_latency(sock);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   return GRPC_ERROR_NONE;
 }
 
@@ -185,7 +186,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
 
   (void)GRPC_ERROR_REF(error);
 
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     if (info->wsa_error != 0 && !tcp->shutting_down) {
       char* utf8_message = gpr_format_message(info->wsa_error);
       error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(utf8_message);
@@ -237,7 +238,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
 #define DEFAULT_TARGET_READ_SIZE 8192
 #define MAX_WSABUF_COUNT 16
 static void win_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
-                     grpc_closure* cb, bool urgent) {
+                     grpc_closure* cb, bool urgent, int /*min_progress_size*/) {
   grpc_tcp* tcp = (grpc_tcp*)ep;
   grpc_winsocket* handle = tcp->socket;
   grpc_winsocket_callback_info* info = &handle->read_info;
@@ -330,7 +331,7 @@ static void on_write(void* tcpp, grpc_error_handle error) {
   tcp->write_cb = NULL;
   gpr_mu_unlock(&tcp->mu);
 
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     if (info->wsa_error != 0) {
       error = GRPC_WSA_ERROR(info->wsa_error, "WSASend");
     } else {
@@ -344,7 +345,7 @@ static void on_write(void* tcpp, grpc_error_handle error) {
 
 /* Initiates a write. */
 static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                      grpc_closure* cb, void* arg) {
+                      grpc_closure* cb, void* arg, int /*max_frame_size*/) {
   grpc_tcp* tcp = (grpc_tcp*)ep;
   grpc_winsocket* socket = tcp->socket;
   grpc_winsocket_callback_info* info = &socket->write_info;
@@ -517,12 +518,14 @@ grpc_endpoint* grpc_tcp_create(grpc_winsocket* socket,
   GRPC_CLOSURE_INIT(&tcp->on_write, on_write, tcp, grpc_schedule_on_exec_ctx);
   grpc_resolved_address resolved_local_addr;
   resolved_local_addr.len = sizeof(resolved_local_addr.addr);
+  absl::StatusOr<std::string> addr_uri;
   if (getsockname(tcp->socket->socket,
                   reinterpret_cast<sockaddr*>(resolved_local_addr.addr),
-                  &resolved_local_addr.len) < 0) {
+                  &resolved_local_addr.len) < 0 ||
+      !(addr_uri = grpc_sockaddr_to_uri(&resolved_local_addr)).ok()) {
     tcp->local_address = "";
   } else {
-    tcp->local_address = grpc_sockaddr_to_uri(&resolved_local_addr);
+    tcp->local_address = grpc_sockaddr_to_uri(&resolved_local_addr).value();
   }
   tcp->peer_string = std::string(peer_string);
   grpc_slice_buffer_init(&tcp->last_read_buffer);

data/src/core/lib/iomgr/unix_sockets_posix.cc

@@ -45,7 +45,7 @@ absl::StatusOr<std::vector<grpc_resolved_address>>
 grpc_resolve_unix_domain_address(absl::string_view name) {
   grpc_resolved_address addr;
   grpc_error_handle error = grpc_core::UnixSockaddrPopulate(name, &addr);
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     return std::vector<grpc_resolved_address>({addr});
   }
   auto result = grpc_error_to_absl_status(error);
@@ -58,7 +58,7 @@ grpc_resolve_unix_abstract_domain_address(const absl::string_view name) {
   grpc_resolved_address addr;
   grpc_error_handle error =
       grpc_core::UnixAbstractSockaddrPopulate(name, &addr);
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     return std::vector<grpc_resolved_address>({addr});
   }
   auto result = grpc_error_to_absl_status(error);

data/src/core/lib/iomgr/wakeup_fd_pipe.cc

@@ -41,9 +41,9 @@ static grpc_error_handle pipe_init(grpc_wakeup_fd* fd_info) {
   }
   grpc_error_handle err;
   err = grpc_set_socket_nonblocking(pipefd[0], 1);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   err = grpc_set_socket_nonblocking(pipefd[1], 1);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   fd_info->read_fd = pipefd[0];
   fd_info->write_fd = pipefd[1];
   return GRPC_ERROR_NONE;

data/src/core/lib/iomgr/wakeup_fd_posix.cc

@@ -32,22 +32,25 @@ static const grpc_wakeup_fd_vtable* wakeup_fd_vtable = nullptr;
 int grpc_allow_specialized_wakeup_fd = 1;
 int grpc_allow_pipe_wakeup_fd = 1;
 
-int has_real_wakeup_fd = 1;
-int cv_wakeup_fds_enabled = 0;
+static int has_real_wakeup_fd = 1;
+
+static gpr_once once_init_wakeup_fd = GPR_ONCE_INIT;
 
 void grpc_wakeup_fd_global_init(void) {
-  if (grpc_allow_specialized_wakeup_fd &&
-      grpc_specialized_wakeup_fd_vtable.check_availability()) {
-    wakeup_fd_vtable = &grpc_specialized_wakeup_fd_vtable;
-  } else if (grpc_allow_pipe_wakeup_fd &&
-             grpc_pipe_wakeup_fd_vtable.check_availability()) {
-    wakeup_fd_vtable = &grpc_pipe_wakeup_fd_vtable;
-  } else {
-    has_real_wakeup_fd = 0;
-  }
+  gpr_once_init(&once_init_wakeup_fd, []() {
+    if (grpc_allow_specialized_wakeup_fd &&
+        grpc_specialized_wakeup_fd_vtable.check_availability()) {
+      wakeup_fd_vtable = &grpc_specialized_wakeup_fd_vtable;
+    } else if (grpc_allow_pipe_wakeup_fd &&
+               grpc_pipe_wakeup_fd_vtable.check_availability()) {
+      wakeup_fd_vtable = &grpc_pipe_wakeup_fd_vtable;
+    } else {
+      has_real_wakeup_fd = 0;
+    }
+  });
 }
 
-void grpc_wakeup_fd_global_destroy(void) { wakeup_fd_vtable = nullptr; }
+void grpc_wakeup_fd_global_destroy(void) {}
 
 int grpc_has_wakeup_fd(void) { return has_real_wakeup_fd; }
 

data/src/core/lib/iomgr/wakeup_fd_posix.h

@@ -59,8 +59,6 @@ void grpc_wakeup_fd_global_destroy(void);
 void grpc_wakeup_fd_global_init_force_fallback(void);
 
 int grpc_has_wakeup_fd(void);
-int grpc_cv_wakeup_fds_enabled(void);
-void grpc_enable_cv_wakeup_fds(int enable);
 
 typedef struct grpc_wakeup_fd grpc_wakeup_fd;
 

data/src/core/lib/iomgr/work_serializer.h

@@ -16,6 +16,8 @@
  *
  */
 
+#ifndef GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H
+#define GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H
 #include <grpc/support/port_platform.h>
 
 #include <atomic>
@@ -30,9 +32,6 @@
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 
-#ifndef GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H
-#define GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H
-
 namespace grpc_core {
 
 // WorkSerializer is a mechanism to schedule callbacks in a synchronized manner.

data/src/core/lib/json/json.h

@@ -21,10 +21,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdlib.h>
-
 #include <map>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "absl/strings/string_view.h"

data/src/core/lib/json/json_reader.cc

@@ -18,15 +18,23 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <string.h>
+#include <inttypes.h>
+#include <stdlib.h>
 
+#include <algorithm>
+#include <map>
 #include <string>
+#include <utility>
+#include <vector>
 
+#include "absl/base/attributes.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/json/json.h"
 
 #define GRPC_JSON_MAX_DEPTH 255

data/src/core/lib/json/json_util.cc

@@ -20,9 +20,12 @@
 
 #include "src/core/lib/json/json_util.h"
 
+#include <string.h>
+
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/memory.h"
 
 namespace grpc_core {
 
@@ -30,6 +33,10 @@ bool ParseDurationFromJson(const Json& field, Duration* duration) {
   if (field.type() != Json::Type::STRING) return false;
   size_t len = field.string_value().size();
   if (field.string_value()[len - 1] != 's') return false;
+  if (field.string_value() == Duration::Infinity().ToJsonString()) {
+    *duration = Duration::Infinity();
+    return true;
+  }
   UniquePtr<char> buf(gpr_strdup(field.string_value().c_str()));
   *(buf.get() + len - 1) = '\0';  // Remove trailing 's'.
   char* decimal_point = strchr(buf.get(), '.');

data/src/core/lib/json/json_util.h

@@ -21,10 +21,19 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <algorithm>
+#include <map>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 
-#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/json/json.h"
 
 namespace grpc_core {

data/src/core/lib/json/json_writer.cc

@@ -18,8 +18,13 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
 #include <stdlib.h>
-#include <string.h>
+
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
 
 #include "absl/strings/string_view.h"
 

data/src/core/lib/matchers/matchers.cc

@@ -16,11 +16,14 @@
 
 #include "src/core/lib/matchers/matchers.h"
 
+#include <utility>
+
 #include "absl/memory/memory.h"
-#include "absl/strings/str_cat.h"
+#include "absl/status/status.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/match.h"
+#include "absl/strings/numbers.h"
 #include "absl/strings/str_format.h"
-#include "absl/strings/str_join.h"
-#include "absl/strings/str_split.h"
 
 namespace grpc_core {
 

data/src/core/lib/matchers/matchers.h

@@ -17,6 +17,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
+
 #include <memory>
 #include <string>
 

data/src/core/lib/promise/activity.cc

@@ -16,7 +16,7 @@
 
 #include "src/core/lib/promise/activity.h"
 
-#include "absl/base/attributes.h"
+#include <stddef.h>
 
 #include "src/core/lib/gprpp/atomic_utils.h"
 
@@ -26,7 +26,6 @@ namespace grpc_core {
 // GLOBALS
 
 GPR_THREAD_LOCAL(Activity*) Activity::g_current_activity_{nullptr};
-Waker::Unwakeable Waker::unwakeable_;
 
 namespace promise_detail {
 

data/src/core/lib/promise/activity.h

@@ -17,14 +17,11 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <atomic>
-#include <functional>
 #include <memory>
-#include <type_traits>
 #include <utility>
 
 #include "absl/base/thread_annotations.h"
@@ -64,13 +61,13 @@ class Wakeable {
 class Waker {
  public:
   explicit Waker(Wakeable* wakeable) : wakeable_(wakeable) {}
-  Waker() : wakeable_(&unwakeable_) {}
-  ~Waker() { wakeable_->Drop(); }
+  Waker() : Waker(nullptr) {}
+  ~Waker() {
+    if (wakeable_ != nullptr) wakeable_->Drop();
+  }
   Waker(const Waker&) = delete;
   Waker& operator=(const Waker&) = delete;
-  Waker(Waker&& other) noexcept : wakeable_(other.wakeable_) {
-    other.wakeable_ = &unwakeable_;
-  }
+  Waker(Waker&& other) noexcept : wakeable_(other.Take()) {}
   Waker& operator=(Waker&& other) noexcept {
     std::swap(wakeable_, other.wakeable_);
     return *this;
@@ -78,8 +75,7 @@ class Waker {
 
   // Wake the underlying activity.
   void Wakeup() {
-    wakeable_->Wakeup();
-    wakeable_ = &unwakeable_;
+    if (auto* wakeable = Take()) wakeable->Wakeup();
   }
 
   template <typename H>
@@ -92,14 +88,9 @@ class Waker {
   }
 
  private:
-  class Unwakeable final : public Wakeable {
-   public:
-    void Wakeup() final {}
-    void Drop() final {}
-  };
+  Wakeable* Take() { return absl::exchange(wakeable_, nullptr); }
 
   Wakeable* wakeable_;
-  static Unwakeable unwakeable_;
 };
 
 // An Activity tracks execution of a single promise.
@@ -150,13 +141,16 @@ class Activity : public Orphanable {
   // Set the current activity at construction, clean it up at destruction.
   class ScopedActivity {
    public:
-    explicit ScopedActivity(Activity* activity) {
-      GPR_ASSERT(g_current_activity_ == nullptr);
+    explicit ScopedActivity(Activity* activity)
+        : prior_activity_(g_current_activity_) {
       g_current_activity_ = activity;
     }
-    ~ScopedActivity() { g_current_activity_ = nullptr; }
+    ~ScopedActivity() { g_current_activity_ = prior_activity_; }
     ScopedActivity(const ScopedActivity&) = delete;
     ScopedActivity& operator=(const ScopedActivity&) = delete;
+
+   private:
+    Activity* const prior_activity_;
   };
 
  private: