grpc 1.35.0 → 1.38.0

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

@@ -24,10 +24,10 @@
 
 #include "src/core/lib/iomgr/tcp_server_utils_posix.h"
 
-grpc_error* grpc_tcp_server_add_all_local_addrs(grpc_tcp_server* s,
-                                                unsigned port_index,
-                                                int requested_port,
-                                                int* out_port) {
+grpc_error_handle grpc_tcp_server_add_all_local_addrs(grpc_tcp_server* s,
+                                                      unsigned port_index,
+                                                      int requested_port,
+                                                      int* out_port) {
   return GRPC_ERROR_CREATE_FROM_STATIC_STRING("no ifaddrs available");
 }
 

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

@@ -38,11 +38,11 @@
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/pollset_windows.h"
 #include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/iomgr/socket_windows.h"
 #include "src/core/lib/iomgr/tcp_server.h"
 #include "src/core/lib/iomgr/tcp_windows.h"
@@ -101,9 +101,9 @@ struct grpc_tcp_server {
 
 /* Public function. Allocates the proper data structures to hold a
    grpc_tcp_server. */
-static grpc_error* tcp_server_create(grpc_closure* shutdown_complete,
-                                     const grpc_channel_args* args,
-                                     grpc_tcp_server** server) {
+static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
+                                           const grpc_channel_args* args,
+                                           grpc_tcp_server** server) {
   grpc_tcp_server* s = (grpc_tcp_server*)gpr_malloc(sizeof(grpc_tcp_server));
   s->channel_args = grpc_channel_args_copy(args);
   gpr_ref_init(&s->refs, 1);
@@ -120,7 +120,7 @@ static grpc_error* tcp_server_create(grpc_closure* shutdown_complete,
   return GRPC_ERROR_NONE;
 }
 
-static void destroy_server(void* arg, grpc_error* error) {
+static void destroy_server(void* arg, grpc_error_handle error) {
   grpc_tcp_server* s = (grpc_tcp_server*)arg;
 
   /* Now that the accepts have been aborted, we can destroy the sockets.
@@ -191,11 +191,11 @@ static void tcp_server_unref(grpc_tcp_server* s) {
 }
 
 /* Prepare (bind) a recently-created socket for listening. */
-static grpc_error* prepare_socket(SOCKET sock,
-                                  const grpc_resolved_address* addr,
-                                  int* port) {
+static grpc_error_handle prepare_socket(SOCKET sock,
+                                        const grpc_resolved_address* addr,
+                                        int* port) {
   grpc_resolved_address sockname_temp;
-  grpc_error* error = GRPC_ERROR_NONE;
+  grpc_error_handle error = GRPC_ERROR_NONE;
   int sockname_temp_len;
 
   error = grpc_tcp_prepare_socket(sock);
@@ -249,12 +249,12 @@ static void decrement_active_ports_and_notify_locked(grpc_tcp_listener* sp) {
 
 /* In order to do an async accept, we need to create a socket first which
    will be the one assigned to the new incoming connection. */
-static grpc_error* start_accept_locked(grpc_tcp_listener* port) {
+static grpc_error_handle start_accept_locked(grpc_tcp_listener* port) {
   SOCKET sock = INVALID_SOCKET;
   BOOL success;
   DWORD addrlen = sizeof(grpc_sockaddr_in6) + 16;
   DWORD bytes_received = 0;
-  grpc_error* error = GRPC_ERROR_NONE;
+  grpc_error_handle error = GRPC_ERROR_NONE;
 
   if (port->shutting_down) {
     return GRPC_ERROR_NONE;
@@ -299,7 +299,7 @@ failure:
 }
 
 /* Event manager callback when reads are ready. */
-static void on_accept(void* arg, grpc_error* error) {
+static void on_accept(void* arg, grpc_error_handle error) {
   grpc_tcp_listener* sp = (grpc_tcp_listener*)arg;
   SOCKET sock = sp->new_socket;
   grpc_winsocket_callback_info* info = &sp->socket->read_info;
@@ -318,8 +318,8 @@ static void on_accept(void* arg, grpc_error* error) {
      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) {
-    const char* msg = grpc_error_string(error);
-    gpr_log(GPR_INFO, "Skipping on_accept due to error: %s", msg);
+    gpr_log(GPR_INFO, "Skipping on_accept due to error: %s",
+            grpc_error_std_string(error).c_str());
 
     gpr_mu_unlock(&sp->server->mu);
     return;
@@ -388,17 +388,17 @@ static void on_accept(void* arg, grpc_error* error) {
   gpr_mu_unlock(&sp->server->mu);
 }
 
-static grpc_error* add_socket_to_server(grpc_tcp_server* s, SOCKET sock,
-                                        const grpc_resolved_address* addr,
-                                        unsigned port_index,
-                                        grpc_tcp_listener** listener) {
+static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, SOCKET sock,
+                                              const grpc_resolved_address* addr,
+                                              unsigned port_index,
+                                              grpc_tcp_listener** listener) {
   grpc_tcp_listener* sp = NULL;
   int port = -1;
   int status;
   GUID guid = WSAID_ACCEPTEX;
   DWORD ioctl_num_bytes;
   LPFN_ACCEPTEX AcceptEx;
-  grpc_error* error = GRPC_ERROR_NONE;
+  grpc_error_handle error = GRPC_ERROR_NONE;
 
   /* We need to grab the AcceptEx pointer for that port, as it may be
      interface-dependent. We'll cache it to avoid doing that again. */
@@ -446,9 +446,9 @@ static grpc_error* add_socket_to_server(grpc_tcp_server* s, SOCKET sock,
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error* tcp_server_add_port(grpc_tcp_server* s,
-                                       const grpc_resolved_address* addr,
-                                       int* port) {
+static grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
+                                             const grpc_resolved_address* addr,
+                                             int* port) {
   grpc_tcp_listener* sp = NULL;
   SOCKET sock;
   grpc_resolved_address addr6_v4mapped;
@@ -456,7 +456,7 @@ static grpc_error* tcp_server_add_port(grpc_tcp_server* s,
   grpc_resolved_address* allocated_addr = NULL;
   grpc_resolved_address sockname_temp;
   unsigned port_index = 0;
-  grpc_error* error = GRPC_ERROR_NONE;
+  grpc_error_handle error = GRPC_ERROR_NONE;
 
   if (s->tail != NULL) {
     port_index = s->tail->port_index + 1;
@@ -508,8 +508,9 @@ done:
   gpr_free(allocated_addr);
 
   if (error != GRPC_ERROR_NONE) {
-    grpc_error* error_out = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-        "Failed to add port to server", &error, 1);
+    grpc_error_handle error_out =
+        GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+            "Failed to add port to server", &error, 1);
     GRPC_ERROR_UNREF(error);
     error = error_out;
     *port = -1;

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

@@ -55,7 +55,7 @@ typedef struct uv_socket_t {
 
   int pending_connections;
   grpc_custom_socket* accept_socket;
-  grpc_error* accept_error;
+  grpc_error_handle accept_error;
 
   grpc_custom_connect_callback connect_cb;
   grpc_custom_write_callback write_cb;
@@ -65,11 +65,11 @@ typedef struct uv_socket_t {
 
 } uv_socket_t;
 
-static grpc_error* tcp_error_create(const char* desc, int status) {
+static grpc_error_handle tcp_error_create(const char* desc, int status) {
   if (status == 0) {
     return GRPC_ERROR_NONE;
   }
-  grpc_error* error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(desc);
+  grpc_error_handle error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(desc);
   /* All tcp errors are marked with UNAVAILABLE so that application may
    * choose to retry. */
   error = grpc_error_set_int(error, GRPC_ERROR_INT_GRPC_STATUS,
@@ -95,7 +95,7 @@ static void alloc_uv_buf(uv_handle_t* handle, size_t suggested_size,
 
 static void uv_read_callback(uv_stream_t* stream, ssize_t nread,
                              const uv_buf_t* buf) {
-  grpc_error* error = GRPC_ERROR_NONE;
+  grpc_error_handle error = GRPC_ERROR_NONE;
   if (nread == 0) {
     // Nothing happened. Wait for the next callback
     return;
@@ -126,7 +126,7 @@ static void uv_socket_read(grpc_custom_socket* socket, char* buffer,
                            size_t length, grpc_custom_read_callback read_cb) {
   uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
   int status;
-  grpc_error* error;
+  grpc_error_handle error;
   uv_socket->read_cb = read_cb;
   uv_socket->read_buf = buffer;
   uv_socket->read_len = length;
@@ -184,7 +184,8 @@ static void uv_socket_close(grpc_custom_socket* socket,
   uv_close((uv_handle_t*)uv_socket->handle, uv_close_callback);
 }
 
-static grpc_error* uv_socket_init_helper(uv_socket_t* uv_socket, int domain) {
+static grpc_error_handle uv_socket_init_helper(uv_socket_t* uv_socket,
+                                               int domain) {
   uv_tcp_t* tcp = (uv_tcp_t*)gpr_malloc(sizeof(uv_tcp_t));
   uv_socket->handle = tcp;
   int status = uv_tcp_init_ex(uv_default_loop(), tcp, (unsigned int)domain);
@@ -212,9 +213,10 @@ static grpc_error* uv_socket_init_helper(uv_socket_t* uv_socket, int domain) {
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error* uv_socket_init(grpc_custom_socket* socket, int domain) {
+static grpc_error_handle uv_socket_init(grpc_custom_socket* socket,
+                                        int domain) {
   uv_socket_t* uv_socket = (uv_socket_t*)gpr_malloc(sizeof(uv_socket_t));
-  grpc_error* error = uv_socket_init_helper(uv_socket, domain);
+  grpc_error_handle error = uv_socket_init_helper(uv_socket, domain);
   if (error != GRPC_ERROR_NONE) {
     return error;
   }
@@ -223,18 +225,18 @@ static grpc_error* uv_socket_init(grpc_custom_socket* socket, int domain) {
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error* uv_socket_getpeername(grpc_custom_socket* socket,
-                                         const grpc_sockaddr* addr,
-                                         int* addr_len) {
+static grpc_error_handle uv_socket_getpeername(grpc_custom_socket* socket,
+                                               const grpc_sockaddr* addr,
+                                               int* addr_len) {
   uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
   int err = uv_tcp_getpeername(uv_socket->handle,
                                (struct sockaddr*)IGNORE_CONST(addr), addr_len);
   return tcp_error_create("getpeername failed", err);
 }
 
-static grpc_error* uv_socket_getsockname(grpc_custom_socket* socket,
-                                         const grpc_sockaddr* addr,
-                                         int* addr_len) {
+static grpc_error_handle uv_socket_getsockname(grpc_custom_socket* socket,
+                                               const grpc_sockaddr* addr,
+                                               int* addr_len) {
   uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
   int err = uv_tcp_getsockname(uv_socket->handle,
                                (struct sockaddr*)IGNORE_CONST(addr), addr_len);
@@ -247,13 +249,13 @@ static void accept_new_connection(grpc_custom_socket* socket) {
     return;
   }
   grpc_custom_socket* new_socket = uv_socket->accept_socket;
-  grpc_error* error = uv_socket->accept_error;
+  grpc_error_handle error = uv_socket->accept_error;
   uv_socket->accept_socket = nullptr;
   uv_socket->accept_error = GRPC_ERROR_NONE;
   uv_socket->pending_connections -= 1;
   if (uv_socket->accept_error != GRPC_ERROR_NONE) {
-    uv_stream_t dummy_handle;
-    uv_accept((uv_stream_t*)uv_socket->handle, &dummy_handle);
+    uv_stream_t phony_handle;
+    uv_accept((uv_stream_t*)uv_socket->handle, &phony_handle);
     uv_socket->accept_cb(socket, new_socket, error);
   } else {
     uv_socket_t* uv_new_socket = (uv_socket_t*)gpr_malloc(sizeof(uv_socket_t));
@@ -293,16 +295,16 @@ void uv_socket_accept(grpc_custom_socket* socket,
   accept_new_connection(socket);
 }
 
-static grpc_error* uv_socket_bind(grpc_custom_socket* socket,
-                                  const grpc_sockaddr* addr, size_t len,
-                                  int flags) {
+static grpc_error_handle uv_socket_bind(grpc_custom_socket* socket,
+                                        const grpc_sockaddr* addr, size_t len,
+                                        int flags) {
   uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
   int status =
       uv_tcp_bind((uv_tcp_t*)uv_socket->handle, (struct sockaddr*)addr, 0);
   return tcp_error_create("Failed to bind to port", status);
 }
 
-static grpc_error* uv_socket_listen(grpc_custom_socket* socket) {
+static grpc_error_handle uv_socket_listen(grpc_custom_socket* socket) {
   uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
   int status =
       uv_listen((uv_stream_t*)uv_socket->handle, SOMAXCONN, uv_on_connect);
@@ -312,7 +314,7 @@ static grpc_error* uv_socket_listen(grpc_custom_socket* socket) {
 static void uv_tc_on_connect(uv_connect_t* req, int status) {
   grpc_custom_socket* socket = (grpc_custom_socket*)req->data;
   uv_socket_t* uv_socket = (uv_socket_t*)socket->impl;
-  grpc_error* error;
+  grpc_error_handle error;
   if (status == UV_ECANCELED) {
     // This should only happen if the handle is already closed
     error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Timeout occurred");
@@ -370,8 +372,8 @@ static void uv_resolve_callback(uv_getaddrinfo_t* req, int status,
                                tcp_error_create("getaddrinfo failed", status));
 }
 
-static grpc_error* uv_resolve(const char* host, const char* port,
-                              grpc_resolved_addresses** result) {
+static grpc_error_handle uv_resolve(const char* host, const char* port,
+                                    grpc_resolved_addresses** result) {
   int status;
   uv_getaddrinfo_t req;
   struct addrinfo hints;
@@ -403,7 +405,7 @@ static void uv_resolve_async(grpc_custom_resolver* r, const char* host,
                           port, &hints);
   if (status != 0) {
     gpr_free(req);
-    grpc_error* error = tcp_error_create("getaddrinfo failed", status);
+    grpc_error_handle error = tcp_error_create("getaddrinfo failed", status);
     grpc_custom_resolve_callback(r, NULL, error);
   }
 }

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

@@ -32,10 +32,10 @@
 #include <grpc/support/log_windows.h>
 #include <grpc/support/string_util.h>
 
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/sockaddr.h"
-#include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/iomgr/socket_windows.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_windows.h"
@@ -53,7 +53,7 @@
 
 extern grpc_core::TraceFlag grpc_tcp_trace;
 
-grpc_error* grpc_tcp_set_non_block(SOCKET sock) {
+grpc_error_handle grpc_tcp_set_non_block(SOCKET sock) {
   int status;
   uint32_t param = 1;
   DWORD ret;
@@ -64,7 +64,7 @@ grpc_error* grpc_tcp_set_non_block(SOCKET sock) {
              : GRPC_WSA_ERROR(WSAGetLastError(), "WSAIoctl(GRPC_FIONBIO)");
 }
 
-static grpc_error* set_dualstack(SOCKET sock) {
+static grpc_error_handle set_dualstack(SOCKET sock) {
   int status;
   unsigned long param = 0;
   status = setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (const char*)&param,
@@ -74,7 +74,7 @@ static grpc_error* set_dualstack(SOCKET sock) {
              : GRPC_WSA_ERROR(WSAGetLastError(), "setsockopt(IPV6_V6ONLY)");
 }
 
-static grpc_error* enable_socket_low_latency(SOCKET sock) {
+static grpc_error_handle enable_socket_low_latency(SOCKET sock) {
   int status;
   BOOL param = TRUE;
   status = ::setsockopt(sock, IPPROTO_TCP, TCP_NODELAY,
@@ -86,8 +86,8 @@ static grpc_error* enable_socket_low_latency(SOCKET sock) {
                      : GRPC_WSA_ERROR(status, "setsockopt(TCP_NODELAY)");
 }
 
-grpc_error* grpc_tcp_prepare_socket(SOCKET sock) {
-  grpc_error* err;
+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;
   err = set_dualstack(sock);
@@ -123,7 +123,7 @@ typedef struct grpc_tcp {
      to protect ourselves when requesting a shutdown. */
   gpr_mu mu;
   int shutting_down;
-  grpc_error* shutdown_error;
+  grpc_error_handle shutdown_error;
 
   std::string peer_string;
   std::string local_address;
@@ -177,7 +177,7 @@ static void tcp_ref(grpc_tcp* tcp) { gpr_ref(&tcp->refcount); }
 #endif
 
 /* Asynchronous callback from the IOCP, or the background thread. */
-static void on_read(void* tcpp, grpc_error* error) {
+static void on_read(void* tcpp, grpc_error_handle error) {
   grpc_tcp* tcp = (grpc_tcp*)tcpp;
   grpc_closure* cb = tcp->read_cb;
   grpc_winsocket* socket = tcp->socket;
@@ -313,7 +313,7 @@ static void win_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
 }
 
 /* Asynchronous callback from the IOCP, or the background thread. */
-static void on_write(void* tcpp, grpc_error* error) {
+static void on_write(void* tcpp, grpc_error_handle error) {
   grpc_tcp* tcp = (grpc_tcp*)tcpp;
   grpc_winsocket* handle = tcp->socket;
   grpc_winsocket_callback_info* info = &handle->write_info;
@@ -399,9 +399,9 @@ static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
      connection that has its send queue filled up. But if we don't, then we can
      avoid doing an async write operation at all. */
   if (info->wsa_error != WSAEWOULDBLOCK) {
-    grpc_error* error = status == 0
-                            ? GRPC_ERROR_NONE
-                            : GRPC_WSA_ERROR(info->wsa_error, "WSASend");
+    grpc_error_handle error = status == 0
+                                  ? GRPC_ERROR_NONE
+                                  : GRPC_WSA_ERROR(info->wsa_error, "WSASend");
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, cb, error);
     if (allocated) gpr_free(allocated);
     return;
@@ -454,7 +454,7 @@ static void win_delete_from_pollset_set(grpc_endpoint* ep,
    we're not going to protect against these. However the IO Completion Port
    callback will happen from another thread, so we need to protect against
    concurrent access of the data structure in that regard. */
-static void win_shutdown(grpc_endpoint* ep, grpc_error* why) {
+static void win_shutdown(grpc_endpoint* ep, grpc_error_handle why) {
   grpc_tcp* tcp = (grpc_tcp*)ep;
   gpr_mu_lock(&tcp->mu);
   /* At that point, what may happen is that we're already inside the IOCP

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

@@ -44,9 +44,9 @@ grpc_endpoint* grpc_tcp_create(grpc_winsocket* socket,
                                grpc_channel_args* channel_args,
                                const char* peer_string);
 
-grpc_error* grpc_tcp_prepare_socket(SOCKET sock);
+grpc_error_handle grpc_tcp_prepare_socket(SOCKET sock);
 
-grpc_error* grpc_tcp_set_non_block(SOCKET sock);
+grpc_error_handle grpc_tcp_set_non_block(SOCKET sock);
 
 #endif
 

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

@@ -30,7 +30,8 @@
 
 static grpc_custom_timer_vtable* custom_timer_impl;
 
-void grpc_custom_timer_callback(grpc_custom_timer* t, grpc_error* /*error*/) {
+void grpc_custom_timer_callback(grpc_custom_timer* t,
+                                grpc_error_handle /*error*/) {
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;

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

@@ -38,6 +38,6 @@ typedef struct grpc_custom_timer_vtable {
 
 void grpc_custom_timer_init(grpc_custom_timer_vtable* impl);
 
-void grpc_custom_timer_callback(grpc_custom_timer* t, grpc_error* error);
+void grpc_custom_timer_callback(grpc_custom_timer* t, grpc_error_handle error);
 
 #endif /* GRPC_CORE_LIB_IOMGR_TIMER_CUSTOM_H */

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

@@ -247,7 +247,7 @@ static grpc_millis saturating_add(grpc_millis a, grpc_millis b) {
 
 static grpc_timer_check_result run_some_expired_timers(grpc_millis now,
                                                        grpc_millis* next,
-                                                       grpc_error* error);
+                                                       grpc_error_handle error);
 
 static grpc_millis compute_min_deadline(timer_shard* shard) {
   return grpc_timer_heap_is_empty(&shard->heap)
@@ -409,7 +409,7 @@ static void timer_init(grpc_timer* timer, grpc_millis deadline,
   }
   gpr_mu_unlock(&shard->mu);
 
-  /* Deadline may have decreased, we need to adjust the master queue.  Note
+  /* Deadline may have decreased, we need to adjust the main queue.  Note
      that there is a potential racy unlocked region here.  There could be a
      reordering of multiple grpc_timer_init calls, at this point, but the < test
      below should ensure that we err on the side of caution.  There could
@@ -561,7 +561,8 @@ static grpc_timer* pop_one(timer_shard* shard, grpc_millis now) {
 
 /* REQUIRES: shard->mu unlocked */
 static size_t pop_timers(timer_shard* shard, grpc_millis now,
-                         grpc_millis* new_min_deadline, grpc_error* error) {
+                         grpc_millis* new_min_deadline,
+                         grpc_error_handle error) {
   size_t n = 0;
   grpc_timer* timer;
   gpr_mu_lock(&shard->mu);
@@ -580,9 +581,8 @@ static size_t pop_timers(timer_shard* shard, grpc_millis now,
   return n;
 }
 
-static grpc_timer_check_result run_some_expired_timers(grpc_millis now,
-                                                       grpc_millis* next,
-                                                       grpc_error* error) {
+static grpc_timer_check_result run_some_expired_timers(
+    grpc_millis now, grpc_millis* next, grpc_error_handle error) {
   grpc_timer_check_result result = GRPC_TIMERS_NOT_CHECKED;
 
 #if GPR_ARCH_64
@@ -639,7 +639,7 @@ static grpc_timer_check_result run_some_expired_timers(grpc_millis now,
 
       /* An grpc_timer_init() on the shard could intervene here, adding a new
          timer that is earlier than new_min_deadline.  However,
-         grpc_timer_init() will block on the master_lock before it can call
+         grpc_timer_init() will block on the mutex before it can call
          set_min_deadline, so this one will complete first and then the Addtimer
          will reduce the min_deadline (perhaps unnecessarily). */
       g_shard_queue[0]->min_deadline = new_min_deadline;
@@ -702,7 +702,7 @@ static grpc_timer_check_result timer_check(grpc_millis* next) {
     return GRPC_TIMERS_CHECKED_AND_EMPTY;
   }
 
-  grpc_error* shutdown_error =
+  grpc_error_handle shutdown_error =
       now != GRPC_MILLIS_INF_FUTURE
           ? GRPC_ERROR_NONE
           : GRPC_ERROR_CREATE_FROM_STATIC_STRING("Shutting down timer system");