Merge with master

4 files changed, 105 insertions, 100 deletions

diff --git a/src/core/ext/transport/chttp2/client/chttp2_connector.cc b/src/core/ext/transport/chttp2/client/chttp2_connector.cc
index edeb59a702..6c91e381a0 100644
--- a/src/core/ext/transport/chttp2/client/chttp2_connector.cc
+++ b/src/core/ext/transport/chttp2/client/chttp2_connector.cc
@@ -45,24 +45,24 @@ 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_connector *con) {
-  chttp2_connector *c = (chttp2_connector *)con;
+static void chttp2_connector_unref(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.
@@ -72,8 +72,8 @@ static void chttp2_connector_unref(grpc_connector *con) {
   }
 }
 
-static void chttp2_connector_shutdown(grpc_connector *con, grpc_error *why) {
-  chttp2_connector *c = (chttp2_connector *)con;
+static void chttp2_connector_shutdown(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) {
@@ -88,9 +88,9 @@ static void chttp2_connector_shutdown(grpc_connector *con, grpc_error *why) {
   GRPC_ERROR_UNREF(why);
 }
 
-static void on_handshake_done(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(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) {
@@ -111,6 +111,8 @@ static void on_handshake_done(void *arg, grpc_error *error) {
     }
     memset(c->result, 0, sizeof(*c->result));
   } else {
+    grpc_endpoint_delete_from_pollset_set(args->endpoint,
+                                          c->args.interested_parties);
     c->result->transport =
         grpc_create_chttp2_transport(args->args, args->endpoint, 1);
     GPR_ASSERT(c->result->transport);
@@ -118,27 +120,28 @@ static void on_handshake_done(void *arg, grpc_error *error) {
                                         args->read_buffer);
     c->result->channel_args = args->args;
   }
-  grpc_closure *notify = c->notify;
+  grpc_closure* notify = c->notify;
   c->notify = NULL;
   GRPC_CLOSURE_SCHED(notify, error);
   grpc_handshake_manager_destroy(c->handshake_mgr);
   c->handshake_mgr = NULL;
   gpr_mu_unlock(&c->mu);
-  chttp2_connector_unref((grpc_connector *)c);
+  chttp2_connector_unref((grpc_connector*)c);
 }
 
-static void start_handshake_locked(chttp2_connector *c) {
+static void start_handshake_locked(chttp2_connector* c) {
   c->handshake_mgr = grpc_handshake_manager_create();
   grpc_handshakers_add(HANDSHAKER_CLIENT, c->args.channel_args,
                        c->handshake_mgr);
+  grpc_endpoint_add_to_pollset_set(c->endpoint, c->args.interested_parties);
   grpc_handshake_manager_do_handshake(
       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.
 }
 
-static void connected(void *arg, grpc_error *error) {
-  chttp2_connector *c = (chttp2_connector *)arg;
+static void connected(void* arg, grpc_error* error) {
+  chttp2_connector* c = (chttp2_connector*)arg;
   gpr_mu_lock(&c->mu);
   GPR_ASSERT(c->connecting);
   c->connecting = false;
@@ -149,14 +152,14 @@ static void connected(void *arg, grpc_error *error) {
       error = GRPC_ERROR_REF(error);
     }
     memset(c->result, 0, sizeof(*c->result));
-    grpc_closure *notify = c->notify;
+    grpc_closure* notify = c->notify;
     c->notify = NULL;
     GRPC_CLOSURE_SCHED(notify, error);
     if (c->endpoint != NULL) {
       grpc_endpoint_shutdown(c->endpoint, GRPC_ERROR_REF(error));
     }
     gpr_mu_unlock(&c->mu);
-    chttp2_connector_unref((grpc_connector *)arg);
+    chttp2_connector_unref((grpc_connector*)arg);
   } else {
     GPR_ASSERT(c->endpoint != NULL);
     start_handshake_locked(c);
@@ -164,11 +167,11 @@ static void connected(void *arg, grpc_error *error) {
   }
 }
 
-static void chttp2_connector_connect(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_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(args->channel_args, &addr);
   gpr_mu_lock(&c->mu);
@@ -190,8 +193,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);
diff --git a/src/core/ext/transport/chttp2/client/insecure/channel_create.cc b/src/core/ext/transport/chttp2/client/insecure/channel_create.cc
index b23c58d1c6..e7741f97d4 100644
--- a/src/core/ext/transport/chttp2/client/insecure/channel_create.cc
+++ b/src/core/ext/transport/chttp2/client/insecure/channel_create.cc
@@ -31,35 +31,35 @@
 #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_client_channel_factory *cc_factory) {}
+    grpc_client_channel_factory* cc_factory) {}
 
-static grpc_subchannel *client_channel_factory_create_subchannel(
-    grpc_client_channel_factory *cc_factory, const grpc_subchannel_args *args) {
-  grpc_connector *connector = grpc_chttp2_connector_create();
-  grpc_subchannel *s = grpc_subchannel_create(connector, args);
+static grpc_subchannel* client_channel_factory_create_subchannel(
+    grpc_client_channel_factory* cc_factory, const grpc_subchannel_args* args) {
+  grpc_connector* connector = grpc_chttp2_connector_create();
+  grpc_subchannel* s = grpc_subchannel_create(connector, args);
   grpc_connector_unref(connector);
   return s;
 }
 
-static grpc_channel *client_channel_factory_create_channel(
-    grpc_client_channel_factory *cc_factory, const char *target,
-    grpc_client_channel_type type, const grpc_channel_args *args) {
+static grpc_channel* client_channel_factory_create_channel(
+    grpc_client_channel_factory* cc_factory, const char* target,
+    grpc_client_channel_type type, const grpc_channel_args* args) {
   if (target == NULL) {
     gpr_log(GPR_ERROR, "cannot create channel with NULL target name");
     return NULL;
   }
   // 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(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* channel =
       grpc_channel_create(target, new_args, GRPC_CLIENT_CHANNEL, NULL);
   grpc_channel_args_destroy(new_args);
   return channel;
@@ -77,9 +77,9 @@ 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) {
   ExecCtx _local_exec_ctx;
   GRPC_API_TRACE(
       "grpc_insecure_channel_create(target=%s, args=%p, reserved=%p)", 3,
@@ -88,15 +88,16 @@ grpc_channel *grpc_insecure_channel_create(const char *target,
   // 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(
       &client_channel_factory, target, GRPC_CLIENT_CHANNEL_TYPE_REGULAR,
       new_args);
   // Clean up.
   grpc_channel_args_destroy(new_args);
   grpc_exec_ctx_finish();
-  return channel != NULL ? channel : grpc_lame_client_channel_create(
-                                         target, GRPC_STATUS_INTERNAL,
-                                         "Failed to create client channel");
+  return channel != NULL ? channel
+                         : grpc_lame_client_channel_create(
+                               target, GRPC_STATUS_INTERNAL,
+                               "Failed to create client channel");
 }
diff --git a/src/core/ext/transport/chttp2/client/insecure/channel_create_posix.cc b/src/core/ext/transport/chttp2/client/insecure/channel_create_posix.cc
index c438413961..37e6f1f30d 100644
--- a/src/core/ext/transport/chttp2/client/insecure/channel_create_posix.cc
+++ b/src/core/ext/transport/chttp2/client/insecure/channel_create_posix.cc
@@ -35,42 +35,43 @@
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/transport/transport.h"
 
-grpc_channel *grpc_insecure_channel_create_from_fd(
-    const char *target, int fd, const grpc_channel_args *args) {
+grpc_channel* grpc_insecure_channel_create_from_fd(
+    const char* target, int fd, const grpc_channel_args* args) {
   ExecCtx _local_exec_ctx;
   GRPC_API_TRACE("grpc_insecure_channel_create(target=%p, fd=%d, args=%p)", 3,
                  (target, fd, args));
 
   grpc_arg default_authority_arg = grpc_channel_arg_string_create(
-      (char *)GRPC_ARG_DEFAULT_AUTHORITY, (char *)"test.authority");
-  grpc_channel_args *final_args =
+      (char*)GRPC_ARG_DEFAULT_AUTHORITY, (char*)"test.authority");
+  grpc_channel_args* final_args =
       grpc_channel_args_copy_and_add(args, &default_authority_arg, 1);
 
   int flags = fcntl(fd, F_GETFL, 0);
   GPR_ASSERT(fcntl(fd, F_SETFL, flags | O_NONBLOCK) == 0);
 
-  grpc_endpoint *client = grpc_tcp_client_create_from_fd(
+  grpc_endpoint* client = grpc_tcp_client_create_from_fd(
       grpc_fd_create(fd, "client"), args, "fd-client");
 
-  grpc_transport *transport =
+  grpc_transport* transport =
       grpc_create_chttp2_transport(final_args, client, 1);
   GPR_ASSERT(transport);
-  grpc_channel *channel = grpc_channel_create(
+  grpc_channel* channel = grpc_channel_create(
       target, final_args, GRPC_CLIENT_DIRECT_CHANNEL, transport);
   grpc_channel_args_destroy(final_args);
   grpc_chttp2_transport_start_reading(transport, NULL);
 
   grpc_exec_ctx_finish();
 
-  return channel != NULL ? channel : grpc_lame_client_channel_create(
-                                         target, GRPC_STATUS_INTERNAL,
-                                         "Failed to create client channel");
+  return channel != NULL ? channel
+                         : grpc_lame_client_channel_create(
+                               target, GRPC_STATUS_INTERNAL,
+                               "Failed to create client channel");
 }
 
 #else  // !GPR_SUPPORT_CHANNELS_FROM_FD
 
-grpc_channel *grpc_insecure_channel_create_from_fd(
-    const char *target, int fd, const grpc_channel_args *args) {
+grpc_channel* grpc_insecure_channel_create_from_fd(
+    const char* target, int fd, const grpc_channel_args* args) {
   GPR_ASSERT(0);
   return NULL;
 }
diff --git a/src/core/ext/transport/chttp2/client/secure/secure_channel_create.cc b/src/core/ext/transport/chttp2/client/secure/secure_channel_create.cc
index 8d975cbfcd..a5da71a67c 100644
--- a/src/core/ext/transport/chttp2/client/secure/secure_channel_create.cc
+++ b/src/core/ext/transport/chttp2/client/secure/secure_channel_create.cc
@@ -38,14 +38,14 @@
 #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_client_channel_factory *cc_factory) {}
+    grpc_client_channel_factory* cc_factory) {}
 
-static grpc_subchannel_args *get_secure_naming_subchannel_args(
-    const grpc_subchannel_args *args) {
-  grpc_channel_credentials *channel_credentials =
+static grpc_subchannel_args* get_secure_naming_subchannel_args(
+    const grpc_subchannel_args* args) {
+  grpc_channel_credentials* channel_credentials =
       grpc_channel_credentials_find_in_args(args->args);
   if (channel_credentials == NULL) {
     gpr_log(GPR_ERROR,
@@ -61,33 +61,33 @@ static grpc_subchannel_args *get_secure_naming_subchannel_args(
     return NULL;
   }
   // To which address are we connecting? By default, use the server URI.
-  const grpc_arg *server_uri_arg =
+  const grpc_arg* server_uri_arg =
       grpc_channel_args_find(args->args, GRPC_ARG_SERVER_URI);
   GPR_ASSERT(server_uri_arg != NULL);
   GPR_ASSERT(server_uri_arg->type == GRPC_ARG_STRING);
-  const char *server_uri_str = server_uri_arg->value.string;
+  const char* server_uri_str = server_uri_arg->value.string;
   GPR_ASSERT(server_uri_str != NULL);
-  grpc_uri *server_uri =
+  grpc_uri* server_uri =
       grpc_uri_parse(server_uri_str, true /* supress errors */);
   GPR_ASSERT(server_uri != NULL);
-  const char *server_uri_path;
+  const char* server_uri_path;
   server_uri_path =
       server_uri->path[0] == '/' ? server_uri->path + 1 : server_uri->path;
-  const grpc_slice_hash_table *targets_info =
+  const grpc_slice_hash_table* targets_info =
       grpc_lb_targets_info_find_in_args(args->args);
-  char *target_name_to_check = NULL;
+  char* target_name_to_check = NULL;
   if (targets_info != NULL) {  // LB channel
     // Find the balancer name for the target.
-    const char *target_uri_str =
+    const char* target_uri_str =
         grpc_get_subchannel_address_uri_arg(args->args);
-    grpc_uri *target_uri =
+    grpc_uri* target_uri =
         grpc_uri_parse(target_uri_str, false /* suppress errors */);
     GPR_ASSERT(target_uri != NULL);
     if (target_uri->path[0] != '\0') {  // "path" may be empty
       const grpc_slice key = grpc_slice_from_static_string(
           target_uri->path[0] == '/' ? target_uri->path + 1 : target_uri->path);
-      const char *value =
-          (const char *)grpc_slice_hash_table_get(targets_info, key);
+      const char* value =
+          (const char*)grpc_slice_hash_table_get(targets_info, key);
       if (value != NULL) target_name_to_check = gpr_strdup(value);
       grpc_slice_unref_internal(key);
     }
@@ -102,9 +102,9 @@ static grpc_subchannel_args *get_secure_naming_subchannel_args(
   }
   grpc_uri_destroy(server_uri);
   GPR_ASSERT(target_name_to_check != NULL);
-  grpc_channel_security_connector *subchannel_security_connector = NULL;
+  grpc_channel_security_connector* subchannel_security_connector = NULL;
   // Create the security connector using the credentials and target name.
-  grpc_channel_args *new_args_from_connector = NULL;
+  grpc_channel_args* new_args_from_connector = NULL;
   const grpc_security_status security_status =
       grpc_channel_credentials_create_security_connector(
           channel_credentials, target_name_to_check, args->args,
@@ -120,7 +120,7 @@ static grpc_subchannel_args *get_secure_naming_subchannel_args(
   grpc_arg new_security_connector_arg =
       grpc_security_connector_to_arg(&subchannel_security_connector->base);
 
-  grpc_channel_args *new_args = grpc_channel_args_copy_and_add(
+  grpc_channel_args* new_args = grpc_channel_args_copy_and_add(
       new_args_from_connector != NULL ? new_args_from_connector : args->args,
       &new_security_connector_arg, 1);
   GRPC_SECURITY_CONNECTOR_UNREF(&subchannel_security_connector->base,
@@ -128,16 +128,16 @@ static grpc_subchannel_args *get_secure_naming_subchannel_args(
   if (new_args_from_connector != NULL) {
     grpc_channel_args_destroy(new_args_from_connector);
   }
-  grpc_subchannel_args *final_sc_args =
-      (grpc_subchannel_args *)gpr_malloc(sizeof(*final_sc_args));
+  grpc_subchannel_args* final_sc_args =
+      (grpc_subchannel_args*)gpr_malloc(sizeof(*final_sc_args));
   memcpy(final_sc_args, args, sizeof(*args));
   final_sc_args->args = new_args;
   return final_sc_args;
 }
 
-static grpc_subchannel *client_channel_factory_create_subchannel(
-    grpc_client_channel_factory *cc_factory, const grpc_subchannel_args *args) {
-  grpc_subchannel_args *subchannel_args =
+static grpc_subchannel* client_channel_factory_create_subchannel(
+    grpc_client_channel_factory* cc_factory, const grpc_subchannel_args* args) {
+  grpc_subchannel_args* subchannel_args =
       get_secure_naming_subchannel_args(args);
   if (subchannel_args == NULL) {
     gpr_log(
@@ -145,30 +145,30 @@ static grpc_subchannel *client_channel_factory_create_subchannel(
         "Failed to create subchannel arguments during subchannel creation.");
     return NULL;
   }
-  grpc_connector *connector = grpc_chttp2_connector_create();
-  grpc_subchannel *s = grpc_subchannel_create(connector, subchannel_args);
+  grpc_connector* connector = grpc_chttp2_connector_create();
+  grpc_subchannel* s = grpc_subchannel_create(connector, subchannel_args);
   grpc_connector_unref(connector);
-  grpc_channel_args_destroy((grpc_channel_args *)subchannel_args->args);
+  grpc_channel_args_destroy((grpc_channel_args*)subchannel_args->args);
   gpr_free(subchannel_args);
   return s;
 }
 
-static grpc_channel *client_channel_factory_create_channel(
-    grpc_client_channel_factory *cc_factory, const char *target,
-    grpc_client_channel_type type, const grpc_channel_args *args) {
+static grpc_channel* client_channel_factory_create_channel(
+    grpc_client_channel_factory* cc_factory, const char* target,
+    grpc_client_channel_type type, const grpc_channel_args* args) {
   if (target == NULL) {
     gpr_log(GPR_ERROR, "cannot create channel with NULL target name");
     return NULL;
   }
   // 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(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* channel =
       grpc_channel_create(target, new_args, GRPC_CLIENT_CHANNEL, NULL);
   grpc_channel_args_destroy(new_args);
   return channel;
@@ -186,24 +186,24 @@ static grpc_client_channel_factory client_channel_factory = {
 //   Asynchronously: - resolve target
 //                   - connect to it (trying alternatives as presented)
 //                   - perform handshakes
-grpc_channel *grpc_secure_channel_create(grpc_channel_credentials *creds,
-                                         const char *target,
-                                         const grpc_channel_args *args,
-                                         void *reserved) {
+grpc_channel* grpc_secure_channel_create(grpc_channel_credentials* creds,
+                                         const char* target,
+                                         const grpc_channel_args* args,
+                                         void* reserved) {
   ExecCtx _local_exec_ctx;
   GRPC_API_TRACE(
       "grpc_secure_channel_create(creds=%p, target=%s, args=%p, "
       "reserved=%p)",
-      4, ((void *)creds, target, (void *)args, (void *)reserved));
+      4, ((void*)creds, target, (void*)args, (void*)reserved));
   GPR_ASSERT(reserved == NULL);
-  grpc_channel *channel = NULL;
+  grpc_channel* channel = NULL;
   if (creds != NULL) {
     // Add channel args containing the client channel factory and channel
     // credentials.
     grpc_arg args_to_add[] = {
         grpc_client_channel_factory_create_channel_arg(&client_channel_factory),
         grpc_channel_credentials_to_arg(creds)};
-    grpc_channel_args *new_args = grpc_channel_args_copy_and_add(
+    grpc_channel_args* new_args = grpc_channel_args_copy_and_add(
         args, args_to_add, GPR_ARRAY_SIZE(args_to_add));
     // Create channel.
     channel = client_channel_factory_create_channel(