grpc 1.34.0 → 1.37.0

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

@@ -157,7 +157,7 @@ class Thread {
   Thread& operator=(const Thread&) = delete;
 
   /// The thread states are as follows:
-  /// FAKE -- just a dummy placeholder Thread created by the default constructor
+  /// FAKE -- just a phony placeholder Thread created by the default constructor
   /// ALIVE -- an actual thread of control exists associated with this thread
   /// STARTED -- the thread of control has been started
   /// DONE -- the thread of control has completed and been joined

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

@@ -199,6 +199,11 @@ Thread::Thread(const char* thd_name, void (*thd_body)(void* arg), void* arg,
 }  // namespace grpc_core
 
 // The following is in the external namespace as it is exposed as C89 API
-gpr_thd_id gpr_thd_currentid(void) { return (gpr_thd_id)pthread_self(); }
+gpr_thd_id gpr_thd_currentid(void) {
+  // Use C-style casting because Linux and OSX have different definitions
+  // of pthread_t so that a single C++ cast doesn't handle it.
+  // NOLINTNEXTLINE(google-readability-casting)
+  return (gpr_thd_id)pthread_self();
+}
 
 #endif /* GPR_POSIX_SYNC */

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

@@ -171,6 +171,8 @@ Thread::Thread(const char* thd_name, void (*thd_body)(void* arg), void* arg,
 
 }  // namespace grpc_core
 
-gpr_thd_id gpr_thd_currentid(void) { return (gpr_thd_id)g_thd_info; }
+gpr_thd_id gpr_thd_currentid(void) {
+  return reinterpret_cast<gpr_thd_id>(g_thd_info);
+}
 
 #endif /* GPR_WINDOWS */

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

@@ -0,0 +1,77 @@
+//
+// Copyright 2021 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.
+//
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/gprpp/time_util.h"
+
+namespace grpc_core {
+
+gpr_timespec ToGprTimeSpec(absl::Duration duration) {
+  if (duration == absl::InfiniteDuration()) {
+    return gpr_inf_future(GPR_TIMESPAN);
+  } else if (duration == -absl::InfiniteDuration()) {
+    return gpr_inf_past(GPR_TIMESPAN);
+  } else {
+    int64_t s = absl::IDivDuration(duration, absl::Seconds(1), &duration);
+    int64_t n = absl::IDivDuration(duration, absl::Nanoseconds(1), &duration);
+    return gpr_time_add(gpr_time_from_seconds(s, GPR_TIMESPAN),
+                        gpr_time_from_nanos(n, GPR_TIMESPAN));
+  }
+}
+
+gpr_timespec ToGprTimeSpec(absl::Time time) {
+  if (time == absl::InfiniteFuture()) {
+    return gpr_inf_future(GPR_CLOCK_REALTIME);
+  } else if (time == absl::InfinitePast()) {
+    return gpr_inf_past(GPR_CLOCK_REALTIME);
+  } else {
+    timespec ts = absl::ToTimespec(time);
+    gpr_timespec out;
+    out.tv_sec = static_cast<decltype(out.tv_sec)>(ts.tv_sec);
+    out.tv_nsec = static_cast<decltype(out.tv_nsec)>(ts.tv_nsec);
+    out.clock_type = GPR_CLOCK_REALTIME;
+    return out;
+  }
+}
+
+absl::Duration ToAbslDuration(gpr_timespec ts) {
+  GPR_ASSERT(ts.clock_type == GPR_TIMESPAN);
+  if (gpr_time_cmp(ts, gpr_inf_future(GPR_TIMESPAN)) == 0) {
+    return absl::InfiniteDuration();
+  } else if (gpr_time_cmp(ts, gpr_inf_past(GPR_TIMESPAN)) == 0) {
+    return -absl::InfiniteDuration();
+  } else {
+    return absl::Seconds(ts.tv_sec) + absl::Nanoseconds(ts.tv_nsec);
+  }
+}
+
+absl::Time ToAbslTime(gpr_timespec ts) {
+  GPR_ASSERT(ts.clock_type != GPR_TIMESPAN);
+  gpr_timespec rts = gpr_convert_clock_type(ts, GPR_CLOCK_REALTIME);
+  if (gpr_time_cmp(rts, gpr_inf_future(GPR_CLOCK_REALTIME)) == 0) {
+    return absl::InfiniteFuture();
+  } else if (gpr_time_cmp(rts, gpr_inf_past(GPR_CLOCK_REALTIME)) == 0) {
+    return absl::InfinitePast();
+  } else {
+    return absl::UnixEpoch() + absl::Seconds(rts.tv_sec) +
+           absl::Nanoseconds(rts.tv_nsec);
+  }
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,42 @@
+//
+// Copyright 2021 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_GPRPP_TIME_UTIL_H
+#define GRPC_CORE_LIB_GPRPP_TIME_UTIL_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/support/time.h>
+
+#include "absl/time/time.h"
+
+namespace grpc_core {
+
+// Converts absl::Duration to gpr_timespec(GPR_TIMESPAN)
+gpr_timespec ToGprTimeSpec(absl::Duration duration);
+
+// Converts absl::Time to gpr_timespec(GPR_CLOCK_REALTIME)
+gpr_timespec ToGprTimeSpec(absl::Time time);
+
+// Converts gpr_timespec(GPR_TIMESPAN) to absl::Duration
+absl::Duration ToAbslDuration(gpr_timespec ts);
+
+// Converts gpr_timespec(GPR_CLOCK_[MONOTONIC|REALTIME|PRECISE]) to absl::Time
+absl::Time ToAbslTime(gpr_timespec ts);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_TIME_UTIL_H

data/src/core/lib/http/httpcli.cc

@@ -209,7 +209,7 @@ static void next_address(internal_request* req, grpc_error* error) {
   GRPC_CLOSURE_INIT(&req->connected, on_connected, req,
                     grpc_schedule_on_exec_ctx);
   grpc_arg arg = grpc_channel_arg_pointer_create(
-      (char*)GRPC_ARG_RESOURCE_QUOTA, req->resource_quota,
+      const_cast<char*>(GRPC_ARG_RESOURCE_QUOTA), req->resource_quota,
       grpc_resource_quota_arg_vtable());
   grpc_channel_args args = {1, &arg};
   grpc_tcp_client_connect(&req->connected, &req->ep, req->context->pollset_set,

data/src/core/lib/http/httpcli.h

@@ -83,8 +83,7 @@ void grpc_httpcli_get(grpc_httpcli_context* context,
                       grpc_polling_entity* pollent,
                       grpc_resource_quota* resource_quota,
                       const grpc_httpcli_request* request, grpc_millis deadline,
-                      grpc_closure* on_complete,
-                      grpc_httpcli_response* response);
+                      grpc_closure* on_done, grpc_httpcli_response* response);
 
 /* Asynchronously perform a HTTP POST.
    'context' specifies the http context under which to do the post
@@ -105,7 +104,7 @@ void grpc_httpcli_post(grpc_httpcli_context* context,
                        grpc_resource_quota* resource_quota,
                        const grpc_httpcli_request* request,
                        const char* body_bytes, size_t body_size,
-                       grpc_millis deadline, grpc_closure* on_complete,
+                       grpc_millis deadline, grpc_closure* on_done,
                        grpc_httpcli_response* response);
 
 /* override functions return 1 if they handled the request, 0 otherwise */

data/src/core/lib/http/httpcli_security_connector.cc

@@ -43,7 +43,7 @@
 class grpc_httpcli_ssl_channel_security_connector final
     : public grpc_channel_security_connector {
  public:
-  grpc_httpcli_ssl_channel_security_connector(char* secure_peer_name)
+  explicit grpc_httpcli_ssl_channel_security_connector(char* secure_peer_name)
       : grpc_channel_security_connector(
             /*url_scheme=*/nullptr,
             /*channel_creds=*/nullptr,
@@ -203,8 +203,8 @@ static void ssl_handshake(void* arg, grpc_endpoint* tcp, const char* host,
   grpc_channel_args args = {1, &channel_arg};
   c->handshake_mgr = grpc_core::MakeRefCounted<grpc_core::HandshakeManager>();
   grpc_core::HandshakerRegistry::AddHandshakers(
-      grpc_core::HANDSHAKER_CLIENT, &args, /*interested_parties=*/nullptr,
-      c->handshake_mgr.get());
+      grpc_core::HANDSHAKER_CLIENT, &args,
+      /*interested_parties=*/nullptr, c->handshake_mgr.get());
   c->handshake_mgr->DoHandshake(tcp, /*channel_args=*/nullptr, deadline,
                                 /*acceptor=*/nullptr, on_handshake_done,
                                 /*user_data=*/c);

data/src/core/lib/http/parser.cc

@@ -281,8 +281,7 @@ static grpc_error* addbyte_body(grpc_http_parser* parser, uint8_t byte) {
 
   if (*body_length == parser->body_capacity) {
     parser->body_capacity = GPR_MAX(8, parser->body_capacity * 3 / 2);
-    *body =
-        static_cast<char*>(gpr_realloc((void*)*body, parser->body_capacity));
+    *body = static_cast<char*>(gpr_realloc(*body, parser->body_capacity));
   }
   (*body)[*body_length] = static_cast<char>(byte);
   (*body_length)++;

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

@@ -146,7 +146,7 @@ class TracedBuffer {
 #else  /* GRPC_LINUX_ERRQUEUE */
 class TracedBuffer {
  public:
-  /* Dummy shutdown function */
+  /* Phony shutdown function */
   static void Shutdown(grpc_core::TracedBuffer** /*head*/, void* /*remaining*/,
                        grpc_error* shutdown_err) {
     GRPC_ERROR_UNREF(shutdown_err);

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

@@ -34,13 +34,14 @@ namespace {
 
 grpc_error* DecodeCancelStateError(gpr_atm cancel_state) {
   if (cancel_state & 1) {
-    return (grpc_error*)(cancel_state & ~static_cast<gpr_atm>(1));
+    return reinterpret_cast<grpc_error*>(cancel_state &
+                                         ~static_cast<gpr_atm>(1));
   }
   return GRPC_ERROR_NONE;
 }
 
 gpr_atm EncodeCancelStateError(grpc_error* error) {
-  return static_cast<gpr_atm>(1) | (gpr_atm)error;
+  return static_cast<gpr_atm>(1) | reinterpret_cast<gpr_atm>(error);
 }
 
 }  // namespace
@@ -203,7 +204,8 @@ void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
       ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_REF(original_error));
       break;
     } else {
-      if (gpr_atm_full_cas(&cancel_state_, original_state, (gpr_atm)closure)) {
+      if (gpr_atm_full_cas(&cancel_state_, original_state,
+                           reinterpret_cast<gpr_atm>(closure))) {
         if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
           gpr_log(GPR_INFO, "call_combiner=%p: setting notify_on_cancel=%p",
                   this, closure);
@@ -212,7 +214,7 @@ void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
         // closure with GRPC_ERROR_NONE.  This allows callers to clean
         // up any resources they may be holding for the callback.
         if (original_state != 0) {
-          closure = (grpc_closure*)original_state;
+          closure = reinterpret_cast<grpc_closure*>(original_state);
           if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
             gpr_log(GPR_INFO,
                     "call_combiner=%p: scheduling old cancel callback=%p", this,
@@ -239,7 +241,8 @@ void CallCombiner::Cancel(grpc_error* error) {
     if (gpr_atm_full_cas(&cancel_state_, original_state,
                          EncodeCancelStateError(error))) {
       if (original_state != 0) {
-        grpc_closure* notify_on_cancel = (grpc_closure*)original_state;
+        grpc_closure* notify_on_cancel =
+            reinterpret_cast<grpc_closure*>(original_state);
         if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
           gpr_log(GPR_INFO,
                   "call_combiner=%p: scheduling notify_on_cancel callback=%p",

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

@@ -202,9 +202,9 @@ void CFStreamHandle::Unref(const char* file, int line, const char* reason) {
 
 #else
 
-/* Creating a dummy function so that the grpc_cfstream library will be
+/* Creating a phony function so that the grpc_cfstream library will be
  * non-empty.
  */
-void CFStreamDummy() {}
+void CFStreamPhony() {}
 
 #endif

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

@@ -146,7 +146,8 @@ static void combiner_exec(grpc_core::Combiner* lock, grpc_closure* cl,
     // offload for one or two actions, and that's fine
     gpr_atm initiator =
         gpr_atm_no_barrier_load(&lock->initiating_exec_ctx_or_null);
-    if (initiator != 0 && initiator != (gpr_atm)grpc_core::ExecCtx::Get()) {
+    if (initiator != 0 &&
+        initiator != reinterpret_cast<gpr_atm>(grpc_core::ExecCtx::Get())) {
       gpr_atm_no_barrier_store(&lock->initiating_exec_ctx_or_null, 0);
     }
   }

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

@@ -99,7 +99,7 @@ void grpc_endpoint_add_to_pollset_set(grpc_endpoint* ep,
 void grpc_endpoint_delete_from_pollset_set(grpc_endpoint* ep,
                                            grpc_pollset_set* pollset_set);
 
-grpc_resource_user* grpc_endpoint_get_resource_user(grpc_endpoint* endpoint);
+grpc_resource_user* grpc_endpoint_get_resource_user(grpc_endpoint* ep);
 
 bool grpc_endpoint_can_track_err(grpc_endpoint* ep);
 

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

@@ -166,7 +166,8 @@ static void error_destroy(grpc_error* err) {
   GPR_ASSERT(!grpc_error_is_special(err));
   unref_errs(err);
   unref_strs(err);
-  gpr_free((void*)gpr_atm_acq_load(&err->atomics.error_string));
+  gpr_free(
+      reinterpret_cast<void*>(gpr_atm_acq_load(&err->atomics.error_string)));
   gpr_free(err);
 }
 
@@ -237,10 +238,10 @@ static void internal_set_str(grpc_error** err, grpc_error_strs which,
   if (slot == UINT8_MAX) {
     slot = get_placement(err, sizeof(value));
     if (slot == UINT8_MAX) {
-      const char* str = grpc_slice_to_c_string(value);
+      char* str = grpc_slice_to_c_string(value);
       gpr_log(GPR_ERROR, "Error %p is full, dropping string {\"%s\":\"%s\"}",
               *err, error_str_name(which), str);
-      gpr_free((void*)str);
+      gpr_free(str);
       return;
     }
   } else {
@@ -258,10 +259,10 @@ static void internal_set_time(grpc_error** err, grpc_error_times which,
   if (slot == UINT8_MAX) {
     slot = get_placement(err, sizeof(value));
     if (slot == UINT8_MAX) {
-      const char* time_str = fmt_time(value);
+      char* time_str = fmt_time(value);
       gpr_log(GPR_ERROR, "Error %p is full, dropping \"%s\":\"%s\"}", *err,
               error_time_name(which), time_str);
-      gpr_free((void*)time_str);
+      gpr_free(time_str);
       return;
     }
   }
@@ -426,7 +427,8 @@ static grpc_error* copy_error_and_unref(grpc_error* in) {
     // bulk memcpy of the rest of the struct.
     // NOLINTNEXTLINE(bugprone-sizeof-expression)
     size_t skip = sizeof(&out->atomics);
-    memcpy((void*)((uintptr_t)out + skip), (void*)((uintptr_t)in + skip),
+    memcpy(reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(out) + skip),
+           reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(in) + skip),
            sizeof(*in) + (in->arena_size * sizeof(intptr_t)) - skip);
     // manually set the atomics and the new capacity
     gpr_atm_no_barrier_store(&out->atomics.error_string, 0);
@@ -632,8 +634,8 @@ static char* fmt_str(const grpc_slice& slice) {
   char* s = nullptr;
   size_t sz = 0;
   size_t cap = 0;
-  append_esc_str((const uint8_t*)GRPC_SLICE_START_PTR(slice),
-                 GRPC_SLICE_LENGTH(slice), &s, &sz, &cap);
+  append_esc_str(GRPC_SLICE_START_PTR(slice), GRPC_SLICE_LENGTH(slice), &s, &sz,
+                 &cap);
   append_chr(0, &s, &sz, &cap);
   return s;
 }
@@ -744,7 +746,8 @@ const char* grpc_error_string(grpc_error* err) {
   if (err == GRPC_ERROR_OOM) return oom_error_string;
   if (err == GRPC_ERROR_CANCELLED) return cancelled_error_string;
 
-  void* p = (void*)gpr_atm_acq_load(&err->atomics.error_string);
+  void* p =
+      reinterpret_cast<void*>(gpr_atm_acq_load(&err->atomics.error_string));
   if (p != nullptr) {
     return static_cast<const char*>(p);
   }
@@ -763,9 +766,10 @@ const char* grpc_error_string(grpc_error* err) {
 
   char* out = finish_kvs(&kvs);
 
-  if (!gpr_atm_rel_cas(&err->atomics.error_string, 0, (gpr_atm)out)) {
+  if (!gpr_atm_rel_cas(&err->atomics.error_string, 0,
+                       reinterpret_cast<gpr_atm>(out))) {
     gpr_free(out);
-    out = (char*)gpr_atm_acq_load(&err->atomics.error_string);
+    out = reinterpret_cast<char*>(gpr_atm_acq_load(&err->atomics.error_string));
   }
 
   return out;

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

@@ -219,7 +219,7 @@ static grpc_error* grpc_error_create_from_vector(const char* file, int line,
 
 grpc_error* grpc_error_set_int(grpc_error* src, grpc_error_ints which,
                                intptr_t value) GRPC_MUST_USE_RESULT;
-/// It is an error to pass nullptr as `p`. Caller should allocate a dummy
+/// It is an error to pass nullptr as `p`. Caller should allocate a phony
 /// intptr_t for `p`, even if the value of `p` is not used.
 bool grpc_error_get_int(grpc_error* error, grpc_error_ints which, intptr_t* p);
 /// This call takes ownership of the slice; the error is responsible for

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

@@ -22,7 +22,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <inttypes.h>
-#include <stdbool.h>  // TODO, do we need this?
+#include <stdbool.h>  // TODO(unknown): , do we need this?
 
 #include <grpc/support/sync.h>
 #include "src/core/lib/iomgr/error.h"

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

@@ -20,7 +20,7 @@
 /// is enabled (see iomgr_posix_cfstream.cc), a global thread is started to
 /// handle and trigger all the CFStream events. The CFStream streams register
 /// themselves with the run loop with functions grpc_apple_register_read_stream
-/// and grpc_apple_register_read_stream. Pollsets are dummy and block on a
+/// and grpc_apple_register_read_stream. Pollsets are phony and block on a
 /// condition variable in pollset_work().
 
 #include <grpc/support/port_platform.h>
@@ -33,7 +33,10 @@
 
 #include <list>
 
+#include "absl/time/time.h"
+
 #include "src/core/lib/gprpp/thd.h"
+#include "src/core/lib/gprpp/time_util.h"
 #include "src/core/lib/iomgr/ev_apple.h"
 
 grpc_core::DebugOnlyTraceFlag grpc_apple_polling_trace(false, "apple_polling");
@@ -161,7 +164,7 @@ void grpc_apple_register_write_stream(CFWriteStreamRef write_stream,
 /// Drive the run loop in a global singleton thread until the global run loop is
 /// shutdown.
 static void GlobalRunLoopFunc(void* arg) {
-  grpc_core::ReleasableMutexLock lock(&gGlobalRunLoopContext->mu);
+  grpc_core::LockableAndReleasableMutexLock lock(&gGlobalRunLoopContext->mu);
   gGlobalRunLoopContext->run_loop = CFRunLoopGetCurrent();
   gGlobalRunLoopContext->init_cv.Signal();
 
@@ -173,11 +176,11 @@ static void GlobalRunLoopFunc(void* arg) {
       gGlobalRunLoopContext->input_source_cv.Wait(&gGlobalRunLoopContext->mu);
     }
     gGlobalRunLoopContext->input_source_registered = false;
-    lock.Unlock();
+    lock.Release();
     CFRunLoopRun();
     lock.Lock();
   }
-  lock.Unlock();
+  lock.Release();
 }
 
 // pollset implementation
@@ -237,9 +240,9 @@ static grpc_error* pollset_work(grpc_pollset* pollset,
     auto it = apple_pollset->workers.begin();
 
     while (!actual_worker.kicked && !apple_pollset->is_shutdown) {
-      if (actual_worker.cv.Wait(
-              &apple_pollset->mu,
-              grpc_millis_to_timespec(deadline, GPR_CLOCK_REALTIME))) {
+      if (actual_worker.cv.WaitWithDeadline(
+              &apple_pollset->mu, grpc_core::ToAbslTime(grpc_millis_to_timespec(
+                                      deadline, GPR_CLOCK_REALTIME)))) {
         // timed out
         break;
       }
@@ -299,7 +302,7 @@ static grpc_error* pollset_kick(grpc_pollset* pollset,
 static void pollset_init(grpc_pollset* pollset, gpr_mu** mu) {
   GRPC_POLLING_TRACE("pollset init: %p", pollset);
   GrpcApplePollset* apple_pollset = new (pollset) GrpcApplePollset();
-  *mu = apple_pollset->mu.get();
+  *mu = grpc_core::GetUnderlyingGprMu(&apple_pollset->mu);
 }
 
 /// The caller must acquire the lock GrpcApplePollset.mu before calling this