grpc 1.7.3 → 1.8.0

data/src/core/ext/filters/message_size/message_size_filter.h

@@ -19,6 +19,14 @@
 
 #include "src/core/lib/channel/channel_stack.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 extern const grpc_channel_filter grpc_message_size_filter;
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_EXT_FILTERS_MESSAGE_SIZE_MESSAGE_SIZE_FILTER_H */

data/src/core/ext/filters/workarounds/{workaround_cronet_compression_filter.c → workaround_cronet_compression_filter.cc}

@@ -42,7 +42,7 @@ typedef struct call_data {
 // Find the user agent metadata element in the batch
 static bool get_user_agent_mdelem(const grpc_metadata_batch* batch,
                                   grpc_mdelem* md) {
-  if (batch->idx.named.user_agent != NULL) {
+  if (batch->idx.named.user_agent != nullptr) {
     *md = batch->idx.named.user_agent->md;
     return true;
   }
@@ -104,7 +104,7 @@ static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx,
                                   grpc_call_element* elem,
                                   const grpc_call_element_args* args) {
   call_data* calld = (call_data*)elem->call_data;
-  calld->next_recv_initial_metadata_ready = NULL;
+  calld->next_recv_initial_metadata_ready = nullptr;
   calld->workaround_active = false;
   GRPC_CLOSURE_INIT(&calld->recv_initial_metadata_ready,
                     recv_initial_metadata_ready, elem,
@@ -139,10 +139,10 @@ static bool parse_user_agent(grpc_mdelem md) {
   bool grpc_objc_specifier_seen = false;
   bool cronet_specifier_seen = false;
   char *major_version_str = user_agent_str, *minor_version_str;
-  long major_version, minor_version;
+  long major_version = 0, minor_version = 0;
 
   char* head = strtok(user_agent_str, " ");
-  while (head != NULL) {
+  while (head != nullptr) {
     if (!grpc_objc_specifier_seen &&
         0 == strncmp(head, grpc_objc_specifier, grpc_objc_specifier_len)) {
       major_version_str = head + grpc_objc_specifier_len;
@@ -153,11 +153,11 @@ static bool parse_user_agent(grpc_mdelem md) {
       break;
     }
 
-    head = strtok(NULL, " ");
+    head = strtok(nullptr, " ");
   }
   if (grpc_objc_specifier_seen) {
     major_version_str = strtok(major_version_str, ".");
-    minor_version_str = strtok(NULL, ".");
+    minor_version_str = strtok(nullptr, ".");
     major_version = atol(major_version_str);
     minor_version = atol(minor_version_str);
   }
@@ -186,22 +186,22 @@ static bool register_workaround_cronet_compression(
       grpc_channel_stack_builder_get_channel_arguments(builder);
   const grpc_arg* a = grpc_channel_args_find(
       channel_args, GRPC_ARG_WORKAROUND_CRONET_COMPRESSION);
-  if (a == NULL) {
+  if (a == nullptr) {
     return true;
   }
   if (grpc_channel_arg_get_bool(a, false) == false) {
     return true;
   }
   return grpc_channel_stack_builder_prepend_filter(
-      builder, &grpc_workaround_cronet_compression_filter, NULL, NULL);
+      builder, &grpc_workaround_cronet_compression_filter, nullptr, nullptr);
 }
 
-void grpc_workaround_cronet_compression_filter_init(void) {
+extern "C" void grpc_workaround_cronet_compression_filter_init(void) {
   grpc_channel_init_register_stage(
       GRPC_SERVER_CHANNEL, GRPC_WORKAROUND_PRIORITY_HIGH,
-      register_workaround_cronet_compression, NULL);
+      register_workaround_cronet_compression, nullptr);
   grpc_register_workaround(GRPC_WORKAROUND_ID_CRONET_COMPRESSION,
                            parse_user_agent);
 }
 
-void grpc_workaround_cronet_compression_filter_shutdown(void) {}
+extern "C" void grpc_workaround_cronet_compression_filter_shutdown(void) {}

data/src/core/ext/filters/workarounds/workaround_cronet_compression_filter.h

@@ -19,7 +19,15 @@
 
 #include "src/core/lib/channel/channel_stack.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 extern const grpc_channel_filter grpc_workaround_cronet_compression_filter;
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_EXT_FILTERS_WORKAROUNDS_WORKAROUND_CRONET_COMPRESSION_FILTER_H \
         */

data/src/core/ext/filters/workarounds/{workaround_utils.c → workaround_utils.cc}

@@ -21,26 +21,26 @@
 
 user_agent_parser ua_parser[GRPC_MAX_WORKAROUND_ID];
 
-static void destroy_user_agent_md(void *user_agent_md) {
+static void destroy_user_agent_md(void* user_agent_md) {
   gpr_free(user_agent_md);
 }
 
-grpc_workaround_user_agent_md *grpc_parse_user_agent(grpc_mdelem md) {
-  grpc_workaround_user_agent_md *user_agent_md =
-      (grpc_workaround_user_agent_md *)grpc_mdelem_get_user_data(
+grpc_workaround_user_agent_md* grpc_parse_user_agent(grpc_mdelem md) {
+  grpc_workaround_user_agent_md* user_agent_md =
+      (grpc_workaround_user_agent_md*)grpc_mdelem_get_user_data(
           md, destroy_user_agent_md);
 
-  if (NULL != user_agent_md) {
+  if (nullptr != user_agent_md) {
     return user_agent_md;
   }
-  user_agent_md = (grpc_workaround_user_agent_md *)gpr_malloc(
+  user_agent_md = (grpc_workaround_user_agent_md*)gpr_malloc(
       sizeof(grpc_workaround_user_agent_md));
   for (int i = 0; i < GRPC_MAX_WORKAROUND_ID; i++) {
     if (ua_parser[i]) {
       user_agent_md->workaround_active[i] = ua_parser[i](md);
     }
   }
-  grpc_mdelem_set_user_data(md, destroy_user_agent_md, (void *)user_agent_md);
+  grpc_mdelem_set_user_data(md, destroy_user_agent_md, (void*)user_agent_md);
 
   return user_agent_md;
 }

data/src/core/ext/filters/workarounds/workaround_utils.h

@@ -24,14 +24,22 @@
 #define GRPC_WORKAROUND_PRIORITY_HIGH 10001
 #define GRPC_WORKAROUND_PROIRITY_LOW 9999
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct grpc_workaround_user_agent_md {
   bool workaround_active[GRPC_MAX_WORKAROUND_ID];
 } grpc_workaround_user_agent_md;
 
-grpc_workaround_user_agent_md *grpc_parse_user_agent(grpc_mdelem md);
+grpc_workaround_user_agent_md* grpc_parse_user_agent(grpc_mdelem md);
 
 typedef bool (*user_agent_parser)(grpc_mdelem);
 
 void grpc_register_workaround(uint32_t id, user_agent_parser parser);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_EXT_FILTERS_WORKAROUNDS_WORKAROUND_UTILS_H */

data/src/core/ext/transport/chttp2/alpn/{alpn.c → alpn.cc}

@@ -21,9 +21,9 @@
 #include <grpc/support/useful.h>
 
 /* in order of preference */
-static const char *const supported_versions[] = {"grpc-exp", "h2"};
+static const char* const supported_versions[] = {"grpc-exp", "h2"};
 
-int grpc_chttp2_is_alpn_version_supported(const char *version, size_t size) {
+int grpc_chttp2_is_alpn_version_supported(const char* version, size_t size) {
   size_t i;
   for (i = 0; i < GPR_ARRAY_SIZE(supported_versions); i++) {
     if (!strncmp(version, supported_versions[i], size)) return 1;
@@ -35,7 +35,7 @@ size_t grpc_chttp2_num_alpn_versions(void) {
   return GPR_ARRAY_SIZE(supported_versions);
 }
 
-const char *grpc_chttp2_get_alpn_version_index(size_t i) {
+const char* grpc_chttp2_get_alpn_version_index(size_t i) {
   GPR_ASSERT(i < GPR_ARRAY_SIZE(supported_versions));
   return supported_versions[i];
 }

data/src/core/ext/transport/chttp2/alpn/alpn.h

@@ -21,14 +21,22 @@
 
 #include <string.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* Retuns 1 if the version is supported, 0 otherwise. */
-int grpc_chttp2_is_alpn_version_supported(const char *version, size_t size);
+int grpc_chttp2_is_alpn_version_supported(const char* version, size_t size);
 
 /* Returns the number of protocol versions to advertise */
 size_t grpc_chttp2_num_alpn_versions(void);
 
 /* Returns the protocol version at index i (0 <= i <
  * grpc_chttp2_num_alpn_versions()) */
-const char *grpc_chttp2_get_alpn_version_index(size_t i);
+const char* grpc_chttp2_get_alpn_version_index(size_t i);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_ALPN_ALPN_H */

data/src/core/ext/transport/chttp2/client/{chttp2_connector.c → chttp2_connector.cc}

@@ -45,56 +45,56 @@ typedef struct {
   bool shutdown;
   bool connecting;
 
-  grpc_closure *notify;
+  grpc_closure* notify;
   grpc_connect_in_args args;
-  grpc_connect_out_args *result;
+  grpc_connect_out_args* result;
 
-  grpc_endpoint *endpoint;  // Non-NULL until handshaking starts.
+  grpc_endpoint* endpoint;  // Non-NULL until handshaking starts.
 
   grpc_closure connected;
 
-  grpc_handshake_manager *handshake_mgr;
+  grpc_handshake_manager* handshake_mgr;
 } chttp2_connector;
 
-static void chttp2_connector_ref(grpc_connector *con) {
-  chttp2_connector *c = (chttp2_connector *)con;
+static void chttp2_connector_ref(grpc_connector* con) {
+  chttp2_connector* c = (chttp2_connector*)con;
   gpr_ref(&c->refs);
 }
 
-static void chttp2_connector_unref(grpc_exec_ctx *exec_ctx,
-                                   grpc_connector *con) {
-  chttp2_connector *c = (chttp2_connector *)con;
+static void chttp2_connector_unref(grpc_exec_ctx* exec_ctx,
+                                   grpc_connector* con) {
+  chttp2_connector* c = (chttp2_connector*)con;
   if (gpr_unref(&c->refs)) {
     gpr_mu_destroy(&c->mu);
     // If handshaking is not yet in progress, destroy the endpoint.
     // Otherwise, the handshaker will do this for us.
-    if (c->endpoint != NULL) grpc_endpoint_destroy(exec_ctx, c->endpoint);
+    if (c->endpoint != nullptr) grpc_endpoint_destroy(exec_ctx, c->endpoint);
     gpr_free(c);
   }
 }
 
-static void chttp2_connector_shutdown(grpc_exec_ctx *exec_ctx,
-                                      grpc_connector *con, grpc_error *why) {
-  chttp2_connector *c = (chttp2_connector *)con;
+static void chttp2_connector_shutdown(grpc_exec_ctx* exec_ctx,
+                                      grpc_connector* con, grpc_error* why) {
+  chttp2_connector* c = (chttp2_connector*)con;
   gpr_mu_lock(&c->mu);
   c->shutdown = true;
-  if (c->handshake_mgr != NULL) {
+  if (c->handshake_mgr != nullptr) {
     grpc_handshake_manager_shutdown(exec_ctx, c->handshake_mgr,
                                     GRPC_ERROR_REF(why));
   }
   // If handshaking is not yet in progress, shutdown the endpoint.
   // Otherwise, the handshaker will do this for us.
-  if (!c->connecting && c->endpoint != NULL) {
+  if (!c->connecting && c->endpoint != nullptr) {
     grpc_endpoint_shutdown(exec_ctx, c->endpoint, GRPC_ERROR_REF(why));
   }
   gpr_mu_unlock(&c->mu);
   GRPC_ERROR_UNREF(why);
 }
 
-static void on_handshake_done(grpc_exec_ctx *exec_ctx, void *arg,
-                              grpc_error *error) {
-  grpc_handshaker_args *args = (grpc_handshaker_args *)arg;
-  chttp2_connector *c = (chttp2_connector *)args->user_data;
+static void on_handshake_done(grpc_exec_ctx* exec_ctx, void* arg,
+                              grpc_error* error) {
+  grpc_handshaker_args* args = (grpc_handshaker_args*)arg;
+  chttp2_connector* c = (chttp2_connector*)args->user_data;
   gpr_mu_lock(&c->mu);
   if (error != GRPC_ERROR_NONE || c->shutdown) {
     if (error == GRPC_ERROR_NONE) {
@@ -115,6 +115,8 @@ static void on_handshake_done(grpc_exec_ctx *exec_ctx, void *arg,
     }
     memset(c->result, 0, sizeof(*c->result));
   } else {
+    grpc_endpoint_delete_from_pollset_set(exec_ctx, args->endpoint,
+                                          c->args.interested_parties);
     c->result->transport = grpc_create_chttp2_transport(exec_ctx, args->args,
                                                         args->endpoint, true);
     GPR_ASSERT(c->result->transport);
@@ -143,31 +145,33 @@ static void on_handshake_done(grpc_exec_ctx *exec_ctx, void *arg,
     // RPC that we attempt to send on the connection before the timeout
     // would fail instead of being retried on a subsequent attempt.
     grpc_chttp2_transport_start_reading(exec_ctx, c->result->transport,
-                                        args->read_buffer, NULL);
+                                        args->read_buffer, nullptr);
     c->result->channel_args = args->args;
   }
-  grpc_closure *notify = c->notify;
-  c->notify = NULL;
+  grpc_closure* notify = c->notify;
+  c->notify = nullptr;
   GRPC_CLOSURE_SCHED(exec_ctx, notify, error);
   grpc_handshake_manager_destroy(exec_ctx, c->handshake_mgr);
-  c->handshake_mgr = NULL;
+  c->handshake_mgr = nullptr;
   gpr_mu_unlock(&c->mu);
-  chttp2_connector_unref(exec_ctx, (grpc_connector *)c);
+  chttp2_connector_unref(exec_ctx, (grpc_connector*)c);
 }
 
-static void start_handshake_locked(grpc_exec_ctx *exec_ctx,
-                                   chttp2_connector *c) {
+static void start_handshake_locked(grpc_exec_ctx* exec_ctx,
+                                   chttp2_connector* c) {
   c->handshake_mgr = grpc_handshake_manager_create();
   grpc_handshakers_add(exec_ctx, HANDSHAKER_CLIENT, c->args.channel_args,
                        c->handshake_mgr);
+  grpc_endpoint_add_to_pollset_set(exec_ctx, c->endpoint,
+                                   c->args.interested_parties);
   grpc_handshake_manager_do_handshake(
       exec_ctx, c->handshake_mgr, c->endpoint, c->args.channel_args,
-      c->args.deadline, NULL /* acceptor */, on_handshake_done, c);
-  c->endpoint = NULL;  // Endpoint handed off to handshake manager.
+      c->args.deadline, nullptr /* acceptor */, on_handshake_done, c);
+  c->endpoint = nullptr;  // Endpoint handed off to handshake manager.
 }
 
-static void connected(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  chttp2_connector *c = (chttp2_connector *)arg;
+static void connected(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+  chttp2_connector* c = (chttp2_connector*)arg;
   gpr_mu_lock(&c->mu);
   GPR_ASSERT(c->connecting);
   c->connecting = false;
@@ -178,35 +182,35 @@ static void connected(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
       error = GRPC_ERROR_REF(error);
     }
     memset(c->result, 0, sizeof(*c->result));
-    grpc_closure *notify = c->notify;
-    c->notify = NULL;
+    grpc_closure* notify = c->notify;
+    c->notify = nullptr;
     GRPC_CLOSURE_SCHED(exec_ctx, notify, error);
-    if (c->endpoint != NULL) {
+    if (c->endpoint != nullptr) {
       grpc_endpoint_shutdown(exec_ctx, c->endpoint, GRPC_ERROR_REF(error));
     }
     gpr_mu_unlock(&c->mu);
-    chttp2_connector_unref(exec_ctx, (grpc_connector *)arg);
+    chttp2_connector_unref(exec_ctx, (grpc_connector*)arg);
   } else {
-    GPR_ASSERT(c->endpoint != NULL);
+    GPR_ASSERT(c->endpoint != nullptr);
     start_handshake_locked(exec_ctx, c);
     gpr_mu_unlock(&c->mu);
   }
 }
 
-static void chttp2_connector_connect(grpc_exec_ctx *exec_ctx,
-                                     grpc_connector *con,
-                                     const grpc_connect_in_args *args,
-                                     grpc_connect_out_args *result,
-                                     grpc_closure *notify) {
-  chttp2_connector *c = (chttp2_connector *)con;
+static void chttp2_connector_connect(grpc_exec_ctx* exec_ctx,
+                                     grpc_connector* con,
+                                     const grpc_connect_in_args* args,
+                                     grpc_connect_out_args* result,
+                                     grpc_closure* notify) {
+  chttp2_connector* c = (chttp2_connector*)con;
   grpc_resolved_address addr;
   grpc_get_subchannel_address_arg(exec_ctx, args->channel_args, &addr);
   gpr_mu_lock(&c->mu);
-  GPR_ASSERT(c->notify == NULL);
+  GPR_ASSERT(c->notify == nullptr);
   c->notify = notify;
   c->args = *args;
   c->result = result;
-  GPR_ASSERT(c->endpoint == NULL);
+  GPR_ASSERT(c->endpoint == nullptr);
   chttp2_connector_ref(con);  // Ref taken for callback.
   GRPC_CLOSURE_INIT(&c->connected, connected, c, grpc_schedule_on_exec_ctx);
   GPR_ASSERT(!c->connecting);
@@ -221,8 +225,8 @@ static const grpc_connector_vtable chttp2_connector_vtable = {
     chttp2_connector_ref, chttp2_connector_unref, chttp2_connector_shutdown,
     chttp2_connector_connect};
 
-grpc_connector *grpc_chttp2_connector_create() {
-  chttp2_connector *c = (chttp2_connector *)gpr_zalloc(sizeof(*c));
+grpc_connector* grpc_chttp2_connector_create() {
+  chttp2_connector* c = (chttp2_connector*)gpr_zalloc(sizeof(*c));
   c->base.vtable = &chttp2_connector_vtable;
   gpr_mu_init(&c->mu);
   gpr_ref_init(&c->refs, 1);

data/src/core/ext/transport/chttp2/client/chttp2_connector.h

@@ -19,8 +19,16 @@
 #ifndef GRPC_CORE_EXT_TRANSPORT_CHTTP2_CLIENT_CHTTP2_CONNECTOR_H
 #define GRPC_CORE_EXT_TRANSPORT_CHTTP2_CLIENT_CHTTP2_CONNECTOR_H
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include "src/core/ext/filters/client_channel/connector.h"
 
 grpc_connector* grpc_chttp2_connector_create();
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_CLIENT_CHTTP2_CONNECTOR_H */

data/src/core/ext/transport/chttp2/client/insecure/{channel_create.c → channel_create.cc}

@@ -31,38 +31,38 @@
 #include "src/core/lib/surface/channel.h"
 
 static void client_channel_factory_ref(
-    grpc_client_channel_factory *cc_factory) {}
+    grpc_client_channel_factory* cc_factory) {}
 
 static void client_channel_factory_unref(
-    grpc_exec_ctx *exec_ctx, grpc_client_channel_factory *cc_factory) {}
+    grpc_exec_ctx* exec_ctx, grpc_client_channel_factory* cc_factory) {}
 
-static grpc_subchannel *client_channel_factory_create_subchannel(
-    grpc_exec_ctx *exec_ctx, grpc_client_channel_factory *cc_factory,
-    const grpc_subchannel_args *args) {
-  grpc_connector *connector = grpc_chttp2_connector_create();
-  grpc_subchannel *s = grpc_subchannel_create(exec_ctx, connector, args);
+static grpc_subchannel* client_channel_factory_create_subchannel(
+    grpc_exec_ctx* exec_ctx, grpc_client_channel_factory* cc_factory,
+    const grpc_subchannel_args* args) {
+  grpc_connector* connector = grpc_chttp2_connector_create();
+  grpc_subchannel* s = grpc_subchannel_create(exec_ctx, connector, args);
   grpc_connector_unref(exec_ctx, connector);
   return s;
 }
 
-static grpc_channel *client_channel_factory_create_channel(
-    grpc_exec_ctx *exec_ctx, grpc_client_channel_factory *cc_factory,
-    const char *target, grpc_client_channel_type type,
-    const grpc_channel_args *args) {
-  if (target == NULL) {
+static grpc_channel* client_channel_factory_create_channel(
+    grpc_exec_ctx* exec_ctx, grpc_client_channel_factory* cc_factory,
+    const char* target, grpc_client_channel_type type,
+    const grpc_channel_args* args) {
+  if (target == nullptr) {
     gpr_log(GPR_ERROR, "cannot create channel with NULL target name");
-    return NULL;
+    return nullptr;
   }
   // Add channel arg containing the server URI.
   grpc_arg arg = grpc_channel_arg_string_create(
-      (char *)GRPC_ARG_SERVER_URI,
+      (char*)GRPC_ARG_SERVER_URI,
       grpc_resolver_factory_add_default_prefix_if_needed(exec_ctx, target));
-  const char *to_remove[] = {GRPC_ARG_SERVER_URI};
-  grpc_channel_args *new_args =
+  const char* to_remove[] = {GRPC_ARG_SERVER_URI};
+  grpc_channel_args* new_args =
       grpc_channel_args_copy_and_add_and_remove(args, to_remove, 1, &arg, 1);
   gpr_free(arg.value.string);
-  grpc_channel *channel = grpc_channel_create(exec_ctx, target, new_args,
-                                              GRPC_CLIENT_CHANNEL, NULL);
+  grpc_channel* channel = grpc_channel_create(exec_ctx, target, new_args,
+                                              GRPC_CLIENT_CHANNEL, nullptr);
   grpc_channel_args_destroy(exec_ctx, new_args);
   return channel;
 }
@@ -79,26 +79,27 @@ static grpc_client_channel_factory client_channel_factory = {
    Asynchronously: - resolve target
                    - connect to it (trying alternatives as presented)
                    - perform handshakes */
-grpc_channel *grpc_insecure_channel_create(const char *target,
-                                           const grpc_channel_args *args,
-                                           void *reserved) {
+grpc_channel* grpc_insecure_channel_create(const char* target,
+                                           const grpc_channel_args* args,
+                                           void* reserved) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   GRPC_API_TRACE(
       "grpc_insecure_channel_create(target=%s, args=%p, reserved=%p)", 3,
       (target, args, reserved));
-  GPR_ASSERT(reserved == NULL);
+  GPR_ASSERT(reserved == nullptr);
   // Add channel arg containing the client channel factory.
   grpc_arg arg =
       grpc_client_channel_factory_create_channel_arg(&client_channel_factory);
-  grpc_channel_args *new_args = grpc_channel_args_copy_and_add(args, &arg, 1);
+  grpc_channel_args* new_args = grpc_channel_args_copy_and_add(args, &arg, 1);
   // Create channel.
-  grpc_channel *channel = client_channel_factory_create_channel(
+  grpc_channel* channel = client_channel_factory_create_channel(
       &exec_ctx, &client_channel_factory, target,
       GRPC_CLIENT_CHANNEL_TYPE_REGULAR, new_args);
   // Clean up.
   grpc_channel_args_destroy(&exec_ctx, new_args);
   grpc_exec_ctx_finish(&exec_ctx);
-  return channel != NULL ? channel : grpc_lame_client_channel_create(
-                                         target, GRPC_STATUS_INTERNAL,
-                                         "Failed to create client channel");
+  return channel != nullptr ? channel
+                            : grpc_lame_client_channel_create(
+                                  target, GRPC_STATUS_INTERNAL,
+                                  "Failed to create client channel");
 }