grpc 1.30.1 → 1.40.0

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

@@ -19,13 +19,15 @@
 #ifndef GRPC_CORE_LIB_GPRPP_SYNC_H
 #define GRPC_CORE_LIB_GPRPP_SYNC_H
 
-#include <grpc/impl/codegen/port_platform.h>
+#include <grpc/support/port_platform.h>
 
-#include <grpc/impl/codegen/log.h>
-#include <grpc/impl/codegen/sync.h>
+#include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 
+#include "absl/synchronization/mutex.h"
+#include "src/core/lib/gprpp/time_util.h"
+
 // The core library is not accessible in C++ codegen headers, and vice versa.
 // Thus, we need to have duplicate headers with similar functionality.
 // Make sure any change to this file is also reflected in
@@ -37,7 +39,23 @@
 
 namespace grpc_core {
 
-class Mutex {
+#ifdef GPR_ABSEIL_SYNC
+
+using Mutex = absl::Mutex;
+using MutexLock = absl::MutexLock;
+using ReleasableMutexLock = absl::ReleasableMutexLock;
+using CondVar = absl::CondVar;
+
+// Returns the underlying gpr_mu from Mutex. This should be used only when
+// it has to like passing the C++ mutex to C-core API.
+// TODO(veblush): Remove this after C-core no longer uses gpr_mu.
+inline gpr_mu* GetUnderlyingGprMu(Mutex* mutex) {
+  return reinterpret_cast<gpr_mu*>(mutex);
+}
+
+#else
+
+class ABSL_LOCKABLE Mutex {
  public:
   Mutex() { gpr_mu_init(&mu_); }
   ~Mutex() { gpr_mu_destroy(&mu_); }
@@ -45,52 +63,59 @@ class Mutex {
   Mutex(const Mutex&) = delete;
   Mutex& operator=(const Mutex&) = delete;
 
-  gpr_mu* get() { return &mu_; }
-  const gpr_mu* get() const { return &mu_; }
+  void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() { gpr_mu_lock(&mu_); }
+  void Unlock() ABSL_UNLOCK_FUNCTION() { gpr_mu_unlock(&mu_); }
+  bool TryLock() ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true) {
+    return gpr_mu_trylock(&mu_) != 0;
+  }
 
  private:
   gpr_mu mu_;
+
+  friend class CondVar;
+  friend gpr_mu* GetUnderlyingGprMu(Mutex* mutex);
 };
 
-// MutexLock is a std::
-class MutexLock {
+// Returns the underlying gpr_mu from Mutex. This should be used only when
+// it has to like passing the C++ mutex to C-core API.
+// TODO(veblush): Remove this after C-core no longer uses gpr_mu.
+inline gpr_mu* GetUnderlyingGprMu(Mutex* mutex) { return &mutex->mu_; }
+
+class ABSL_SCOPED_LOCKABLE MutexLock {
  public:
-  explicit MutexLock(Mutex* mu) : mu_(mu->get()) { gpr_mu_lock(mu_); }
-  explicit MutexLock(gpr_mu* mu) : mu_(mu) { gpr_mu_lock(mu_); }
-  ~MutexLock() { gpr_mu_unlock(mu_); }
+  explicit MutexLock(Mutex* mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
+    mu_->Lock();
+  }
+  ~MutexLock() ABSL_UNLOCK_FUNCTION() { mu_->Unlock(); }
 
   MutexLock(const MutexLock&) = delete;
   MutexLock& operator=(const MutexLock&) = delete;
 
  private:
-  gpr_mu* const mu_;
+  Mutex* const mu_;
 };
 
-class ReleasableMutexLock {
+class ABSL_SCOPED_LOCKABLE ReleasableMutexLock {
  public:
-  explicit ReleasableMutexLock(Mutex* mu) : mu_(mu->get()) { gpr_mu_lock(mu_); }
-  explicit ReleasableMutexLock(gpr_mu* mu) : mu_(mu) { gpr_mu_lock(mu_); }
-  ~ReleasableMutexLock() {
-    if (!released_) gpr_mu_unlock(mu_);
+  explicit ReleasableMutexLock(Mutex* mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
+      : mu_(mu) {
+    mu_->Lock();
+  }
+  ~ReleasableMutexLock() ABSL_UNLOCK_FUNCTION() {
+    if (!released_) mu_->Unlock();
   }
 
   ReleasableMutexLock(const ReleasableMutexLock&) = delete;
   ReleasableMutexLock& operator=(const ReleasableMutexLock&) = delete;
 
-  void Lock() {
-    GPR_DEBUG_ASSERT(released_);
-    gpr_mu_lock(mu_);
-    released_ = false;
-  }
-
-  void Unlock() {
+  void Release() ABSL_UNLOCK_FUNCTION() {
     GPR_DEBUG_ASSERT(!released_);
     released_ = true;
-    gpr_mu_unlock(mu_);
+    mu_->Unlock();
   }
 
  private:
-  gpr_mu* const mu_;
+  Mutex* const mu_;
   bool released_ = false;
 };
 
@@ -103,31 +128,67 @@ class CondVar {
   CondVar& operator=(const CondVar&) = delete;
 
   void Signal() { gpr_cv_signal(&cv_); }
-  void Broadcast() { gpr_cv_broadcast(&cv_); }
+  void SignalAll() { gpr_cv_broadcast(&cv_); }
+
+  void Wait(Mutex* mu) { WaitWithDeadline(mu, absl::InfiniteFuture()); }
+  bool WaitWithTimeout(Mutex* mu, absl::Duration timeout) {
+    return gpr_cv_wait(&cv_, &mu->mu_, ToGprTimeSpec(timeout)) != 0;
+  }
+  bool WaitWithDeadline(Mutex* mu, absl::Time deadline) {
+    return gpr_cv_wait(&cv_, &mu->mu_, ToGprTimeSpec(deadline)) != 0;
+  }
+
+ private:
+  gpr_cv cv_;
+};
+
+#endif  // GPR_ABSEIL_SYNC
+
+// Deprecated. Prefer MutexLock
+class MutexLockForGprMu {
+ public:
+  explicit MutexLockForGprMu(gpr_mu* mu) : mu_(mu) { gpr_mu_lock(mu_); }
+  ~MutexLockForGprMu() { gpr_mu_unlock(mu_); }
+
+  MutexLockForGprMu(const MutexLock&) = delete;
+  MutexLockForGprMu& operator=(const MutexLock&) = delete;
+
+ private:
+  gpr_mu* const mu_;
+};
 
-  int Wait(Mutex* mu) { return Wait(mu, gpr_inf_future(GPR_CLOCK_REALTIME)); }
-  int Wait(Mutex* mu, const gpr_timespec& deadline) {
-    return gpr_cv_wait(&cv_, mu->get(), deadline);
+// Deprecated. Prefer MutexLock or ReleasableMutexLock
+class ABSL_SCOPED_LOCKABLE LockableAndReleasableMutexLock {
+ public:
+  explicit LockableAndReleasableMutexLock(Mutex* mu)
+      ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
+      : mu_(mu) {
+    mu_->Lock();
+  }
+  ~LockableAndReleasableMutexLock() ABSL_UNLOCK_FUNCTION() {
+    if (!released_) mu_->Unlock();
   }
 
-  template <typename Predicate>
-  void WaitUntil(Mutex* mu, Predicate pred) {
-    while (!pred()) {
-      Wait(mu, gpr_inf_future(GPR_CLOCK_REALTIME));
-    }
+  LockableAndReleasableMutexLock(const LockableAndReleasableMutexLock&) =
+      delete;
+  LockableAndReleasableMutexLock& operator=(
+      const LockableAndReleasableMutexLock&) = delete;
+
+  void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() {
+    GPR_DEBUG_ASSERT(released_);
+    mu_->Lock();
+    released_ = false;
   }
 
-  // Returns true iff we timed-out
-  template <typename Predicate>
-  bool WaitUntil(Mutex* mu, Predicate pred, const gpr_timespec& deadline) {
-    while (!pred()) {
-      if (Wait(mu, deadline)) return true;
-    }
-    return false;
+  void Release() ABSL_UNLOCK_FUNCTION() {
+    GPR_DEBUG_ASSERT(!released_);
+    released_ = true;
+    mu_->Unlock();
   }
 
  private:
-  gpr_cv cv_;
+  Mutex* const mu_;
+  bool released_ = false;
 };
 
 }  // namespace grpc_core

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

@@ -91,7 +91,7 @@ class Thread {
 
   /// Move constructor for thread. After this is called, the other thread
   /// no longer represents a living thread object
-  Thread(Thread&& other)
+  Thread(Thread&& other) noexcept
       : state_(other.state_), impl_(other.impl_), options_(other.options_) {
     other.state_ = MOVED;
     other.impl_ = nullptr;
@@ -101,7 +101,7 @@ class Thread {
   /// Move assignment operator for thread. After this is called, the other
   /// thread no longer represents a living thread object. Not allowed if this
   /// thread actually exists
-  Thread& operator=(Thread&& other) {
+  Thread& operator=(Thread&& other) noexcept {
     if (this != &other) {
       // TODO(vjpai): if we can be sure that all Thread's are actually
       // constructed, then we should assert GPR_ASSERT(impl_ == nullptr) here.
@@ -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

@@ -105,45 +105,45 @@ class ThreadInternalsPosix : public internal::ThreadInternalsInterface {
       GPR_ASSERT(pthread_attr_setstacksize(&attr, stack_size) == 0);
     }
 
-    *success =
-        (pthread_create(&pthread_id_, &attr,
-                        [](void* v) -> void* {
-                          thd_arg arg = *static_cast<thd_arg*>(v);
-                          free(v);
-                          if (arg.name != nullptr) {
+    *success = (pthread_create(
+                    &pthread_id_, &attr,
+                    [](void* v) -> void* {
+                      thd_arg arg = *static_cast<thd_arg*>(v);
+                      free(v);
+                      if (arg.name != nullptr) {
 #if GPR_APPLE_PTHREAD_NAME
-                            /* Apple supports 64 characters, and will
-                             * truncate if it's longer. */
-                            pthread_setname_np(arg.name);
+                        /* Apple supports 64 characters, and will
+                         * truncate if it's longer. */
+                        pthread_setname_np(arg.name);
 #elif GPR_LINUX_PTHREAD_NAME
-                            /* Linux supports 16 characters max, and will
-                             * error if it's longer. */
-                            char buf[16];
-                            size_t buf_len = GPR_ARRAY_SIZE(buf) - 1;
-                            strncpy(buf, arg.name, buf_len);
-                            buf[buf_len] = '\0';
-                            pthread_setname_np(pthread_self(), buf);
+                        /* Linux supports 16 characters max, and will
+                         * error if it's longer. */
+                        char buf[16];
+                        size_t buf_len = GPR_ARRAY_SIZE(buf) - 1;
+                        strncpy(buf, arg.name, buf_len);
+                        buf[buf_len] = '\0';
+                        pthread_setname_np(pthread_self(), buf);
 #endif  // GPR_APPLE_PTHREAD_NAME
-                          }
-
-                          gpr_mu_lock(&arg.thread->mu_);
-                          while (!arg.thread->started_) {
-                            gpr_cv_wait(&arg.thread->ready_, &arg.thread->mu_,
-                                        gpr_inf_future(GPR_CLOCK_MONOTONIC));
-                          }
-                          gpr_mu_unlock(&arg.thread->mu_);
-
-                          if (!arg.joinable) {
-                            delete arg.thread;
-                          }
-
-                          (*arg.body)(arg.arg);
-                          if (arg.tracked) {
-                            Fork::DecThreadCount();
-                          }
-                          return nullptr;
-                        },
-                        info) == 0);
+                      }
+
+                      gpr_mu_lock(&arg.thread->mu_);
+                      while (!arg.thread->started_) {
+                        gpr_cv_wait(&arg.thread->ready_, &arg.thread->mu_,
+                                    gpr_inf_future(GPR_CLOCK_MONOTONIC));
+                      }
+                      gpr_mu_unlock(&arg.thread->mu_);
+
+                      if (!arg.joinable) {
+                        delete arg.thread;
+                      }
+
+                      (*arg.body)(arg.arg);
+                      if (arg.tracked) {
+                        Fork::DecThreadCount();
+                      }
+                      return nullptr;
+                    },
+                    info) == 0);
 
     GPR_ASSERT(pthread_attr_destroy(&attr) == 0);
 
@@ -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

@@ -22,10 +22,15 @@
 
 #include <string.h>
 
+#include <string>
+
+#include "absl/strings/str_format.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/memory.h"
@@ -34,7 +39,6 @@
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/slice/slice_internal.h"
 
@@ -58,7 +62,7 @@ struct internal_request {
   grpc_closure on_read;
   grpc_closure done_write;
   grpc_closure connected;
-  grpc_error* overall_error;
+  grpc_error_handle overall_error;
   grpc_resource_quota* resource_quota;
 };
 static grpc_httpcli_get_override g_get_override = nullptr;
@@ -82,9 +86,9 @@ void grpc_httpcli_context_destroy(grpc_httpcli_context* context) {
   grpc_pollset_set_destroy(context->pollset_set);
 }
 
-static void next_address(internal_request* req, grpc_error* due_to_error);
+static void next_address(internal_request* req, grpc_error_handle due_to_error);
 
-static void finish(internal_request* req, grpc_error* error) {
+static void finish(internal_request* req, grpc_error_handle error) {
   grpc_polling_entity_del_from_pollset_set(req->pollent,
                                            req->context->pollset_set);
   grpc_core::ExecCtx::Run(DEBUG_LOCATION, req->on_done, error);
@@ -106,31 +110,31 @@ static void finish(internal_request* req, grpc_error* error) {
   gpr_free(req);
 }
 
-static void append_error(internal_request* req, grpc_error* error) {
+static void append_error(internal_request* req, grpc_error_handle error) {
   if (req->overall_error == GRPC_ERROR_NONE) {
     req->overall_error =
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed HTTP/1 client request");
   }
   grpc_resolved_address* addr = &req->addresses->addrs[req->next_address - 1];
-  grpc_core::UniquePtr<char> addr_text(grpc_sockaddr_to_uri(addr));
+  std::string addr_text = grpc_sockaddr_to_uri(addr);
   req->overall_error = grpc_error_add_child(
       req->overall_error,
       grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS,
-                         grpc_slice_from_moved_string(std::move(addr_text))));
+                         grpc_slice_from_cpp_string(std::move(addr_text))));
 }
 
 static void do_read(internal_request* req) {
   grpc_endpoint_read(req->ep, &req->incoming, &req->on_read, /*urgent=*/true);
 }
 
-static void on_read(void* user_data, grpc_error* error) {
+static void on_read(void* user_data, grpc_error_handle error) {
   internal_request* req = static_cast<internal_request*>(user_data);
   size_t i;
 
   for (i = 0; i < req->incoming.count; i++) {
     if (GRPC_SLICE_LENGTH(req->incoming.slices[i])) {
       req->have_read_byte = 1;
-      grpc_error* err = grpc_http_parser_parse(
+      grpc_error_handle err = grpc_http_parser_parse(
           &req->parser, req->incoming.slices[i], nullptr);
       if (err != GRPC_ERROR_NONE) {
         finish(req, err);
@@ -150,7 +154,7 @@ static void on_read(void* user_data, grpc_error* error) {
 
 static void on_written(internal_request* req) { do_read(req); }
 
-static void done_write(void* arg, grpc_error* error) {
+static void done_write(void* arg, grpc_error_handle error) {
   internal_request* req = static_cast<internal_request*>(arg);
   if (error == GRPC_ERROR_NONE) {
     on_written(req);
@@ -178,7 +182,7 @@ static void on_handshake_done(void* arg, grpc_endpoint* ep) {
   start_write(req);
 }
 
-static void on_connected(void* arg, grpc_error* error) {
+static void on_connected(void* arg, grpc_error_handle error) {
   internal_request* req = static_cast<internal_request*>(arg);
 
   if (!req->ep) {
@@ -190,7 +194,7 @@ static void on_connected(void* arg, grpc_error* error) {
       req->deadline, on_handshake_done);
 }
 
-static void next_address(internal_request* req, grpc_error* error) {
+static void next_address(internal_request* req, grpc_error_handle error) {
   grpc_resolved_address* addr;
   if (error != GRPC_ERROR_NONE) {
     append_error(req, error);
@@ -205,14 +209,14 @@ 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,
                           &args, addr, req->deadline);
 }
 
-static void on_resolved(void* arg, grpc_error* error) {
+static void on_resolved(void* arg, grpc_error_handle error) {
   internal_request* req = static_cast<internal_request*>(arg);
   if (error != GRPC_ERROR_NONE) {
     finish(req, GRPC_ERROR_REF(error));
@@ -266,15 +270,14 @@ void grpc_httpcli_get(grpc_httpcli_context* context,
                       grpc_resource_quota* resource_quota,
                       const grpc_httpcli_request* request, grpc_millis deadline,
                       grpc_closure* on_done, grpc_httpcli_response* response) {
-  char* name;
   if (g_get_override && g_get_override(request, deadline, on_done, response)) {
     return;
   }
-  gpr_asprintf(&name, "HTTP:GET:%s:%s", request->host, request->http.path);
+  std::string name =
+      absl::StrFormat("HTTP:GET:%s:%s", request->host, request->http.path);
   internal_request_begin(context, pollent, resource_quota, request, deadline,
-                         on_done, response, name,
+                         on_done, response, name.c_str(),
                          grpc_httpcli_format_get_request(request));
-  gpr_free(name);
 }
 
 void grpc_httpcli_post(grpc_httpcli_context* context,
@@ -284,16 +287,16 @@ void grpc_httpcli_post(grpc_httpcli_context* context,
                        const char* body_bytes, size_t body_size,
                        grpc_millis deadline, grpc_closure* on_done,
                        grpc_httpcli_response* response) {
-  char* name;
   if (g_post_override && g_post_override(request, body_bytes, body_size,
                                          deadline, on_done, response)) {
     return;
   }
-  gpr_asprintf(&name, "HTTP:POST:%s:%s", request->host, request->http.path);
+  std::string name =
+      absl::StrFormat("HTTP:POST:%s:%s", request->host, request->http.path);
   internal_request_begin(
       context, pollent, resource_quota, request, deadline, on_done, response,
-      name, grpc_httpcli_format_post_request(request, body_bytes, body_size));
-  gpr_free(name);
+      name.c_str(),
+      grpc_httpcli_format_post_request(request, body_bytes, body_size));
 }
 
 void grpc_httpcli_set_override(grpc_httpcli_get_override get,

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 */