grpc 1.7.3 → 1.8.0

data/src/core/lib/debug/trace.cc

@@ -0,0 +1,142 @@
+/*
+ *
+ * Copyright 2015 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 "src/core/lib/debug/trace.h"
+
+#include <string.h>
+
+#include <grpc/grpc.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include "src/core/lib/support/env.h"
+
+int grpc_tracer_set_enabled(const char* name, int enabled);
+
+namespace grpc_core {
+
+TraceFlag* TraceFlagList::root_tracer_ = nullptr;
+
+bool TraceFlagList::Set(const char* name, bool enabled) {
+  TraceFlag* t;
+  if (0 == strcmp(name, "all")) {
+    for (t = root_tracer_; t; t = t->next_tracer_) {
+      t->set_enabled(enabled);
+    }
+  } else if (0 == strcmp(name, "list_tracers")) {
+    LogAllTracers();
+  } else if (0 == strcmp(name, "refcount")) {
+    for (t = root_tracer_; t; t = t->next_tracer_) {
+      if (strstr(t->name_, "refcount") != nullptr) {
+        t->set_enabled(enabled);
+      }
+    }
+  } else {
+    bool found = false;
+    for (t = root_tracer_; t; t = t->next_tracer_) {
+      if (0 == strcmp(name, t->name_)) {
+        t->set_enabled(enabled);
+        found = true;
+      }
+    }
+    if (!found) {
+      gpr_log(GPR_ERROR, "Unknown trace var: '%s'", name);
+      return false; /* early return */
+    }
+  }
+  return true;
+}
+
+void TraceFlagList::Add(TraceFlag* flag) {
+  flag->next_tracer_ = root_tracer_;
+  root_tracer_ = flag;
+}
+
+void TraceFlagList::LogAllTracers() {
+  gpr_log(GPR_DEBUG, "available tracers:");
+  TraceFlag* t;
+  for (t = root_tracer_; t != nullptr; t = t->next_tracer_) {
+    gpr_log(GPR_DEBUG, "\t%s", t->name_);
+  }
+}
+
+// Flags register themselves on the list during construction
+TraceFlag::TraceFlag(bool default_enabled, const char* name) : name_(name) {
+  set_enabled(default_enabled);
+  TraceFlagList::Add(this);
+}
+
+}  // namespace grpc_core
+
+static void add(const char* beg, const char* end, char*** ss, size_t* ns) {
+  size_t n = *ns;
+  size_t np = n + 1;
+  char* s;
+  size_t len;
+  GPR_ASSERT(end >= beg);
+  len = (size_t)(end - beg);
+  s = (char*)gpr_malloc(len + 1);
+  memcpy(s, beg, len);
+  s[len] = 0;
+  *ss = (char**)gpr_realloc(*ss, sizeof(char**) * np);
+  (*ss)[n] = s;
+  *ns = np;
+}
+
+static void split(const char* s, char*** ss, size_t* ns) {
+  const char* c = strchr(s, ',');
+  if (c == nullptr) {
+    add(s, s + strlen(s), ss, ns);
+  } else {
+    add(s, c, ss, ns);
+    split(c + 1, ss, ns);
+  }
+}
+
+static void parse(const char* s) {
+  char** strings = nullptr;
+  size_t nstrings = 0;
+  size_t i;
+  split(s, &strings, &nstrings);
+
+  for (i = 0; i < nstrings; i++) {
+    if (strings[i][0] == '-') {
+      grpc_core::TraceFlagList::Set(strings[i] + 1, false);
+    } else {
+      grpc_core::TraceFlagList::Set(strings[i], true);
+    }
+  }
+
+  for (i = 0; i < nstrings; i++) {
+    gpr_free(strings[i]);
+  }
+  gpr_free(strings);
+}
+
+void grpc_tracer_init(const char* env_var) {
+  char* e = gpr_getenv(env_var);
+  if (e != nullptr) {
+    parse(e);
+    gpr_free(e);
+  }
+}
+
+void grpc_tracer_shutdown(void) {}
+
+int grpc_tracer_set_enabled(const char* name, int enabled) {
+  return grpc_core::TraceFlagList::Set(name, enabled != 0);
+}

data/src/core/lib/debug/trace.h

@@ -23,33 +23,93 @@
 #include <grpc/support/port_platform.h>
 #include <stdbool.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void grpc_tracer_init(const char* env_var_name);
+void grpc_tracer_shutdown(void);
+
+#ifdef __cplusplus
+}
+#endif
+
 #if defined(__has_feature)
 #if __has_feature(thread_sanitizer)
 #define GRPC_THREADSAFE_TRACER
 #endif
 #endif
 
-typedef struct {
+#ifdef __cplusplus
+
+namespace grpc_core {
+
+class TraceFlag;
+class TraceFlagList {
+ public:
+  static bool Set(const char* name, bool enabled);
+  static void Add(TraceFlag* flag);
+
+ private:
+  static void LogAllTracers();
+  static TraceFlag* root_tracer_;
+};
+
+namespace testing {
+void grpc_tracer_enable_flag(grpc_core::TraceFlag* flag);
+}
+
+class TraceFlag {
+ public:
+  TraceFlag(bool default_enabled, const char* name);
+  ~TraceFlag() {}
+
+  const char* name() const { return name_; }
+
+  bool enabled() {
+#ifdef GRPC_THREADSAFE_TRACER
+    return gpr_atm_no_barrier_load(&value_) != 0;
+#else
+    return value_;
+#endif
+  }
+
+ private:
+  friend void grpc_core::testing::grpc_tracer_enable_flag(TraceFlag* flag);
+  friend class TraceFlagList;
+
+  void set_enabled(bool enabled) {
 #ifdef GRPC_THREADSAFE_TRACER
-  gpr_atm value;
+    gpr_atm_no_barrier_store(&value_, enabled);
 #else
-  bool value;
+    value_ = enabled;
 #endif
-  const char *name;
-} grpc_tracer_flag;
+  }
 
+  TraceFlag* next_tracer_;
+  const char* const name_;
 #ifdef GRPC_THREADSAFE_TRACER
-#define GRPC_TRACER_ON(flag) (gpr_atm_no_barrier_load(&(flag).value) != 0)
-#define GRPC_TRACER_INITIALIZER(on, name) \
-  { (gpr_atm)(on), (name) }
+  gpr_atm value_;
 #else
-#define GRPC_TRACER_ON(flag) ((flag).value)
-#define GRPC_TRACER_INITIALIZER(on, name) \
-  { (on), (name) }
+  bool value_;
 #endif
+};
 
-void grpc_register_tracer(grpc_tracer_flag *flag);
-void grpc_tracer_init(const char *env_var_name);
-void grpc_tracer_shutdown(void);
+#ifndef NDEBUG
+typedef TraceFlag DebugOnlyTraceFlag;
+#else
+class DebugOnlyTraceFlag {
+ public:
+  DebugOnlyTraceFlag(bool default_enabled, const char* name) {}
+  bool enabled() { return false; }
+
+ private:
+  void set_enabled(bool enabled) {}
+};
+#endif
+
+}  // namespace grpc_core
+
+#endif  // __cplusplus
 
 #endif /* GRPC_CORE_LIB_DEBUG_TRACE_H */

data/src/core/lib/http/{format_request.c → format_request.cc}

@@ -28,8 +28,8 @@
 #include <grpc/support/useful.h>
 #include "src/core/lib/support/string.h"
 
-static void fill_common_header(const grpc_httpcli_request *request,
-                               gpr_strvec *buf, bool connection_close) {
+static void fill_common_header(const grpc_httpcli_request* request,
+                               gpr_strvec* buf, bool connection_close) {
   size_t i;
   gpr_strvec_add(buf, gpr_strdup(request->http.path));
   gpr_strvec_add(buf, gpr_strdup(" HTTP/1.0\r\n"));
@@ -51,9 +51,9 @@ static void fill_common_header(const grpc_httpcli_request *request,
 }
 
 grpc_slice grpc_httpcli_format_get_request(
-    const grpc_httpcli_request *request) {
+    const grpc_httpcli_request* request) {
   gpr_strvec out;
-  char *flat;
+  char* flat;
   size_t flat_len;
 
   gpr_strvec_init(&out);
@@ -67,11 +67,11 @@ grpc_slice grpc_httpcli_format_get_request(
   return grpc_slice_new(flat, flat_len, gpr_free);
 }
 
-grpc_slice grpc_httpcli_format_post_request(const grpc_httpcli_request *request,
-                                            const char *body_bytes,
+grpc_slice grpc_httpcli_format_post_request(const grpc_httpcli_request* request,
+                                            const char* body_bytes,
                                             size_t body_size) {
   gpr_strvec out;
-  char *tmp;
+  char* tmp;
   size_t out_len;
   size_t i;
 
@@ -98,7 +98,7 @@ grpc_slice grpc_httpcli_format_post_request(const grpc_httpcli_request *request,
   gpr_strvec_destroy(&out);
 
   if (body_bytes) {
-    tmp = (char *)gpr_realloc(tmp, out_len + body_size);
+    tmp = (char*)gpr_realloc(tmp, out_len + body_size);
     memcpy(tmp + out_len, body_bytes, body_size);
     out_len += body_size;
   }
@@ -107,14 +107,14 @@ grpc_slice grpc_httpcli_format_post_request(const grpc_httpcli_request *request,
 }
 
 grpc_slice grpc_httpcli_format_connect_request(
-    const grpc_httpcli_request *request) {
+    const grpc_httpcli_request* request) {
   gpr_strvec out;
   gpr_strvec_init(&out);
   gpr_strvec_add(&out, gpr_strdup("CONNECT "));
   fill_common_header(request, &out, false);
   gpr_strvec_add(&out, gpr_strdup("\r\n"));
   size_t flat_len;
-  char *flat = gpr_strvec_flatten(&out, &flat_len);
+  char* flat = gpr_strvec_flatten(&out, &flat_len);
   gpr_strvec_destroy(&out);
   return grpc_slice_new(flat, flat_len, gpr_free);
 }

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

@@ -22,11 +22,19 @@
 #include <grpc/slice.h>
 #include "src/core/lib/http/httpcli.h"
 
-grpc_slice grpc_httpcli_format_get_request(const grpc_httpcli_request *request);
-grpc_slice grpc_httpcli_format_post_request(const grpc_httpcli_request *request,
-                                            const char *body_bytes,
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+grpc_slice grpc_httpcli_format_get_request(const grpc_httpcli_request* request);
+grpc_slice grpc_httpcli_format_post_request(const grpc_httpcli_request* request,
+                                            const char* body_bytes,
                                             size_t body_size);
 grpc_slice grpc_httpcli_format_connect_request(
-    const grpc_httpcli_request *request);
+    const grpc_httpcli_request* request);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_HTTP_FORMAT_REQUEST_H */

data/src/core/lib/http/{httpcli.c → httpcli.cc}

@@ -39,64 +39,64 @@
 typedef struct {
   grpc_slice request_text;
   grpc_http_parser parser;
-  grpc_resolved_addresses *addresses;
+  grpc_resolved_addresses* addresses;
   size_t next_address;
-  grpc_endpoint *ep;
-  char *host;
-  char *ssl_host_override;
-  gpr_timespec deadline;
+  grpc_endpoint* ep;
+  char* host;
+  char* ssl_host_override;
+  grpc_millis deadline;
   int have_read_byte;
-  const grpc_httpcli_handshaker *handshaker;
-  grpc_closure *on_done;
-  grpc_httpcli_context *context;
-  grpc_polling_entity *pollent;
+  const grpc_httpcli_handshaker* handshaker;
+  grpc_closure* on_done;
+  grpc_httpcli_context* context;
+  grpc_polling_entity* pollent;
   grpc_iomgr_object iomgr_obj;
   grpc_slice_buffer incoming;
   grpc_slice_buffer outgoing;
   grpc_closure on_read;
   grpc_closure done_write;
   grpc_closure connected;
-  grpc_error *overall_error;
-  grpc_resource_quota *resource_quota;
+  grpc_error* overall_error;
+  grpc_resource_quota* resource_quota;
 } internal_request;
 
-static grpc_httpcli_get_override g_get_override = NULL;
-static grpc_httpcli_post_override g_post_override = NULL;
+static grpc_httpcli_get_override g_get_override = nullptr;
+static grpc_httpcli_post_override g_post_override = nullptr;
 
-static void plaintext_handshake(grpc_exec_ctx *exec_ctx, void *arg,
-                                grpc_endpoint *endpoint, const char *host,
-                                gpr_timespec deadline,
-                                void (*on_done)(grpc_exec_ctx *exec_ctx,
-                                                void *arg,
-                                                grpc_endpoint *endpoint)) {
+static void plaintext_handshake(grpc_exec_ctx* exec_ctx, void* arg,
+                                grpc_endpoint* endpoint, const char* host,
+                                grpc_millis deadline,
+                                void (*on_done)(grpc_exec_ctx* exec_ctx,
+                                                void* arg,
+                                                grpc_endpoint* endpoint)) {
   on_done(exec_ctx, arg, endpoint);
 }
 
 const grpc_httpcli_handshaker grpc_httpcli_plaintext = {"http",
                                                         plaintext_handshake};
 
-void grpc_httpcli_context_init(grpc_httpcli_context *context) {
+void grpc_httpcli_context_init(grpc_httpcli_context* context) {
   context->pollset_set = grpc_pollset_set_create();
 }
 
-void grpc_httpcli_context_destroy(grpc_exec_ctx *exec_ctx,
-                                  grpc_httpcli_context *context) {
+void grpc_httpcli_context_destroy(grpc_exec_ctx* exec_ctx,
+                                  grpc_httpcli_context* context) {
   grpc_pollset_set_destroy(exec_ctx, context->pollset_set);
 }
 
-static void next_address(grpc_exec_ctx *exec_ctx, internal_request *req,
-                         grpc_error *due_to_error);
+static void next_address(grpc_exec_ctx* exec_ctx, internal_request* req,
+                         grpc_error* due_to_error);
 
-static void finish(grpc_exec_ctx *exec_ctx, internal_request *req,
-                   grpc_error *error) {
+static void finish(grpc_exec_ctx* exec_ctx, internal_request* req,
+                   grpc_error* error) {
   grpc_polling_entity_del_from_pollset_set(exec_ctx, req->pollent,
                                            req->context->pollset_set);
   GRPC_CLOSURE_SCHED(exec_ctx, req->on_done, error);
   grpc_http_parser_destroy(&req->parser);
-  if (req->addresses != NULL) {
+  if (req->addresses != nullptr) {
     grpc_resolved_addresses_destroy(req->addresses);
   }
-  if (req->ep != NULL) {
+  if (req->ep != nullptr) {
     grpc_endpoint_destroy(exec_ctx, req->ep);
   }
   grpc_slice_unref_internal(exec_ctx, req->request_text);
@@ -110,13 +110,13 @@ static void finish(grpc_exec_ctx *exec_ctx, internal_request *req,
   gpr_free(req);
 }
 
-static void append_error(internal_request *req, grpc_error *error) {
+static void append_error(internal_request* req, grpc_error* 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];
-  char *addr_text = grpc_sockaddr_to_uri(addr);
+  grpc_resolved_address* addr = &req->addresses->addrs[req->next_address - 1];
+  char* 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,
@@ -124,20 +124,20 @@ static void append_error(internal_request *req, grpc_error *error) {
   gpr_free(addr_text);
 }
 
-static void do_read(grpc_exec_ctx *exec_ctx, internal_request *req) {
+static void do_read(grpc_exec_ctx* exec_ctx, internal_request* req) {
   grpc_endpoint_read(exec_ctx, req->ep, &req->incoming, &req->on_read);
 }
 
-static void on_read(grpc_exec_ctx *exec_ctx, void *user_data,
-                    grpc_error *error) {
-  internal_request *req = (internal_request *)user_data;
+static void on_read(grpc_exec_ctx* exec_ctx, void* user_data,
+                    grpc_error* error) {
+  internal_request* req = (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(&req->parser, req->incoming.slices[i], NULL);
+      grpc_error* err = grpc_http_parser_parse(
+          &req->parser, req->incoming.slices[i], nullptr);
       if (err != GRPC_ERROR_NONE) {
         finish(exec_ctx, req, err);
         return;
@@ -154,12 +154,12 @@ static void on_read(grpc_exec_ctx *exec_ctx, void *user_data,
   }
 }
 
-static void on_written(grpc_exec_ctx *exec_ctx, internal_request *req) {
+static void on_written(grpc_exec_ctx* exec_ctx, internal_request* req) {
   do_read(exec_ctx, req);
 }
 
-static void done_write(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  internal_request *req = (internal_request *)arg;
+static void done_write(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+  internal_request* req = (internal_request*)arg;
   if (error == GRPC_ERROR_NONE) {
     on_written(exec_ctx, req);
   } else {
@@ -167,19 +167,20 @@ static void done_write(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
   }
 }
 
-static void start_write(grpc_exec_ctx *exec_ctx, internal_request *req) {
+static void start_write(grpc_exec_ctx* exec_ctx, internal_request* req) {
   grpc_slice_ref_internal(req->request_text);
   grpc_slice_buffer_add(&req->outgoing, req->request_text);
   grpc_endpoint_write(exec_ctx, req->ep, &req->outgoing, &req->done_write);
 }
 
-static void on_handshake_done(grpc_exec_ctx *exec_ctx, void *arg,
-                              grpc_endpoint *ep) {
-  internal_request *req = (internal_request *)arg;
+static void on_handshake_done(grpc_exec_ctx* exec_ctx, void* arg,
+                              grpc_endpoint* ep) {
+  internal_request* req = (internal_request*)arg;
 
   if (!ep) {
-    next_address(exec_ctx, req, GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                                    "Unexplained handshake failure"));
+    next_address(
+        exec_ctx, req,
+        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Unexplained handshake failure"));
     return;
   }
 
@@ -187,9 +188,9 @@ static void on_handshake_done(grpc_exec_ctx *exec_ctx, void *arg,
   start_write(exec_ctx, req);
 }
 
-static void on_connected(grpc_exec_ctx *exec_ctx, void *arg,
-                         grpc_error *error) {
-  internal_request *req = (internal_request *)arg;
+static void on_connected(grpc_exec_ctx* exec_ctx, void* arg,
+                         grpc_error* error) {
+  internal_request* req = (internal_request*)arg;
 
   if (!req->ep) {
     next_address(exec_ctx, req, GRPC_ERROR_REF(error));
@@ -201,9 +202,9 @@ static void on_connected(grpc_exec_ctx *exec_ctx, void *arg,
       req->deadline, on_handshake_done);
 }
 
-static void next_address(grpc_exec_ctx *exec_ctx, internal_request *req,
-                         grpc_error *error) {
-  grpc_resolved_address *addr;
+static void next_address(grpc_exec_ctx* exec_ctx, internal_request* req,
+                         grpc_error* error) {
+  grpc_resolved_address* addr;
   if (error != GRPC_ERROR_NONE) {
     append_error(req, error);
   }
@@ -217,7 +218,7 @@ static void next_address(grpc_exec_ctx *exec_ctx, internal_request *req,
   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,
+      (char*)GRPC_ARG_RESOURCE_QUOTA, req->resource_quota,
       grpc_resource_quota_arg_vtable());
   grpc_channel_args args = {1, &arg};
   grpc_tcp_client_connect(exec_ctx, &req->connected, &req->ep,
@@ -225,8 +226,8 @@ static void next_address(grpc_exec_ctx *exec_ctx, internal_request *req,
                           req->deadline);
 }
 
-static void on_resolved(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  internal_request *req = (internal_request *)arg;
+static void on_resolved(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+  internal_request* req = (internal_request*)arg;
   if (error != GRPC_ERROR_NONE) {
     finish(exec_ctx, req, GRPC_ERROR_REF(error));
     return;
@@ -235,16 +236,16 @@ static void on_resolved(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
   next_address(exec_ctx, req, GRPC_ERROR_NONE);
 }
 
-static void internal_request_begin(grpc_exec_ctx *exec_ctx,
-                                   grpc_httpcli_context *context,
-                                   grpc_polling_entity *pollent,
-                                   grpc_resource_quota *resource_quota,
-                                   const grpc_httpcli_request *request,
-                                   gpr_timespec deadline, grpc_closure *on_done,
-                                   grpc_httpcli_response *response,
-                                   const char *name, grpc_slice request_text) {
-  internal_request *req =
-      (internal_request *)gpr_malloc(sizeof(internal_request));
+static void internal_request_begin(grpc_exec_ctx* exec_ctx,
+                                   grpc_httpcli_context* context,
+                                   grpc_polling_entity* pollent,
+                                   grpc_resource_quota* resource_quota,
+                                   const grpc_httpcli_request* request,
+                                   grpc_millis deadline, grpc_closure* on_done,
+                                   grpc_httpcli_response* response,
+                                   const char* name, grpc_slice request_text) {
+  internal_request* req =
+      (internal_request*)gpr_malloc(sizeof(internal_request));
   memset(req, 0, sizeof(*req));
   req->request_text = request_text;
   grpc_http_parser_init(&req->parser, GRPC_HTTP_RESPONSE, response);
@@ -275,13 +276,12 @@ static void internal_request_begin(grpc_exec_ctx *exec_ctx,
       &req->addresses);
 }
 
-void grpc_httpcli_get(grpc_exec_ctx *exec_ctx, grpc_httpcli_context *context,
-                      grpc_polling_entity *pollent,
-                      grpc_resource_quota *resource_quota,
-                      const grpc_httpcli_request *request,
-                      gpr_timespec deadline, grpc_closure *on_done,
-                      grpc_httpcli_response *response) {
-  char *name;
+void grpc_httpcli_get(grpc_exec_ctx* exec_ctx, grpc_httpcli_context* context,
+                      grpc_polling_entity* pollent,
+                      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(exec_ctx, request, deadline, on_done, response)) {
     return;
@@ -293,14 +293,14 @@ void grpc_httpcli_get(grpc_exec_ctx *exec_ctx, grpc_httpcli_context *context,
   gpr_free(name);
 }
 
-void grpc_httpcli_post(grpc_exec_ctx *exec_ctx, grpc_httpcli_context *context,
-                       grpc_polling_entity *pollent,
-                       grpc_resource_quota *resource_quota,
-                       const grpc_httpcli_request *request,
-                       const char *body_bytes, size_t body_size,
-                       gpr_timespec deadline, grpc_closure *on_done,
-                       grpc_httpcli_response *response) {
-  char *name;
+void grpc_httpcli_post(grpc_exec_ctx* exec_ctx, grpc_httpcli_context* context,
+                       grpc_polling_entity* pollent,
+                       grpc_resource_quota* resource_quota,
+                       const grpc_httpcli_request* request,
+                       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(exec_ctx, request, body_bytes, body_size, deadline,
                       on_done, response)) {