grpc 1.7.3 → 1.8.0

data/src/core/lib/channel/{connected_channel.c → connected_channel.cc}

@@ -33,41 +33,41 @@
 #define MAX_BUFFER_LENGTH 8192
 
 typedef struct connected_channel_channel_data {
-  grpc_transport *transport;
+  grpc_transport* transport;
 } channel_data;
 
 typedef struct {
   grpc_closure closure;
-  grpc_closure *original_closure;
-  grpc_call_combiner *call_combiner;
-  const char *reason;
+  grpc_closure* original_closure;
+  grpc_call_combiner* call_combiner;
+  const char* reason;
 } callback_state;
 
 typedef struct connected_channel_call_data {
-  grpc_call_combiner *call_combiner;
+  grpc_call_combiner* call_combiner;
   // Closures used for returning results on the call combiner.
   callback_state on_complete[6];  // Max number of pending batches.
   callback_state recv_initial_metadata_ready;
   callback_state recv_message_ready;
 } call_data;
 
-static void run_in_call_combiner(grpc_exec_ctx *exec_ctx, void *arg,
-                                 grpc_error *error) {
-  callback_state *state = (callback_state *)arg;
+static void run_in_call_combiner(grpc_exec_ctx* exec_ctx, void* arg,
+                                 grpc_error* error) {
+  callback_state* state = (callback_state*)arg;
   GRPC_CALL_COMBINER_START(exec_ctx, state->call_combiner,
                            state->original_closure, GRPC_ERROR_REF(error),
                            state->reason);
 }
 
-static void run_cancel_in_call_combiner(grpc_exec_ctx *exec_ctx, void *arg,
-                                        grpc_error *error) {
+static void run_cancel_in_call_combiner(grpc_exec_ctx* exec_ctx, void* arg,
+                                        grpc_error* error) {
   run_in_call_combiner(exec_ctx, arg, error);
   gpr_free(arg);
 }
 
-static void intercept_callback(call_data *calld, callback_state *state,
-                               bool free_when_done, const char *reason,
-                               grpc_closure **original_closure) {
+static void intercept_callback(call_data* calld, callback_state* state,
+                               bool free_when_done, const char* reason,
+                               grpc_closure** original_closure) {
   state->original_closure = *original_closure;
   state->call_combiner = calld->call_combiner;
   state->reason = reason;
@@ -77,39 +77,39 @@ static void intercept_callback(call_data *calld, callback_state *state,
       state, grpc_schedule_on_exec_ctx);
 }
 
-static callback_state *get_state_for_batch(
-    call_data *calld, grpc_transport_stream_op_batch *batch) {
+static callback_state* get_state_for_batch(
+    call_data* calld, grpc_transport_stream_op_batch* batch) {
   if (batch->send_initial_metadata) return &calld->on_complete[0];
   if (batch->send_message) return &calld->on_complete[1];
   if (batch->send_trailing_metadata) return &calld->on_complete[2];
   if (batch->recv_initial_metadata) return &calld->on_complete[3];
   if (batch->recv_message) return &calld->on_complete[4];
   if (batch->recv_trailing_metadata) return &calld->on_complete[5];
-  GPR_UNREACHABLE_CODE(return NULL);
+  GPR_UNREACHABLE_CODE(return nullptr);
 }
 
 /* We perform a small hack to locate transport data alongside the connected
    channel data in call allocations, to allow everything to be pulled in minimal
    cache line requests */
-#define TRANSPORT_STREAM_FROM_CALL_DATA(calld) ((grpc_stream *)((calld) + 1))
+#define TRANSPORT_STREAM_FROM_CALL_DATA(calld) ((grpc_stream*)((calld) + 1))
 #define CALL_DATA_FROM_TRANSPORT_STREAM(transport_stream) \
-  (((call_data *)(transport_stream)) - 1)
+  (((call_data*)(transport_stream)) - 1)
 
 /* Intercept a call operation and either push it directly up or translate it
    into transport stream operations */
 static void con_start_transport_stream_op_batch(
-    grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
-    grpc_transport_stream_op_batch *batch) {
-  call_data *calld = (call_data *)elem->call_data;
-  channel_data *chand = (channel_data *)elem->channel_data;
+    grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+    grpc_transport_stream_op_batch* batch) {
+  call_data* calld = (call_data*)elem->call_data;
+  channel_data* chand = (channel_data*)elem->channel_data;
   if (batch->recv_initial_metadata) {
-    callback_state *state = &calld->recv_initial_metadata_ready;
+    callback_state* state = &calld->recv_initial_metadata_ready;
     intercept_callback(
         calld, state, false, "recv_initial_metadata_ready",
         &batch->payload->recv_initial_metadata.recv_initial_metadata_ready);
   }
   if (batch->recv_message) {
-    callback_state *state = &calld->recv_message_ready;
+    callback_state* state = &calld->recv_message_ready;
     intercept_callback(calld, state, false, "recv_message_ready",
                        &batch->payload->recv_message.recv_message_ready);
   }
@@ -119,11 +119,11 @@ static void con_start_transport_stream_op_batch(
     // calld->on_complete like we can for the other ops.  However,
     // cancellation isn't in the fast path, so we just allocate a new
     // closure for each one.
-    callback_state *state = (callback_state *)gpr_malloc(sizeof(*state));
+    callback_state* state = (callback_state*)gpr_malloc(sizeof(*state));
     intercept_callback(calld, state, true, "on_complete (cancel_stream)",
                        &batch->on_complete);
   } else {
-    callback_state *state = get_state_for_batch(calld, batch);
+    callback_state* state = get_state_for_batch(calld, batch);
     intercept_callback(calld, state, false, "on_complete", &batch->on_complete);
   }
   grpc_transport_perform_stream_op(exec_ctx, chand->transport,
@@ -133,19 +133,19 @@ static void con_start_transport_stream_op_batch(
                           "passed batch to transport");
 }
 
-static void con_start_transport_op(grpc_exec_ctx *exec_ctx,
-                                   grpc_channel_element *elem,
-                                   grpc_transport_op *op) {
-  channel_data *chand = (channel_data *)elem->channel_data;
+static void con_start_transport_op(grpc_exec_ctx* exec_ctx,
+                                   grpc_channel_element* elem,
+                                   grpc_transport_op* op) {
+  channel_data* chand = (channel_data*)elem->channel_data;
   grpc_transport_perform_op(exec_ctx, chand->transport, op);
 }
 
 /* Constructor for call_data */
-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;
-  channel_data *chand = (channel_data *)elem->channel_data;
+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;
+  channel_data* chand = (channel_data*)elem->channel_data;
   calld->call_combiner = args->call_combiner;
   int r = grpc_transport_init_stream(
       exec_ctx, chand->transport, TRANSPORT_STREAM_FROM_CALL_DATA(calld),
@@ -155,49 +155,49 @@ static grpc_error *init_call_elem(grpc_exec_ctx *exec_ctx,
                       "transport stream initialization failed");
 }
 
-static void set_pollset_or_pollset_set(grpc_exec_ctx *exec_ctx,
-                                       grpc_call_element *elem,
-                                       grpc_polling_entity *pollent) {
-  call_data *calld = (call_data *)elem->call_data;
-  channel_data *chand = (channel_data *)elem->channel_data;
+static void set_pollset_or_pollset_set(grpc_exec_ctx* exec_ctx,
+                                       grpc_call_element* elem,
+                                       grpc_polling_entity* pollent) {
+  call_data* calld = (call_data*)elem->call_data;
+  channel_data* chand = (channel_data*)elem->channel_data;
   grpc_transport_set_pops(exec_ctx, chand->transport,
                           TRANSPORT_STREAM_FROM_CALL_DATA(calld), pollent);
 }
 
 /* Destructor for call_data */
-static void destroy_call_elem(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
-                              const grpc_call_final_info *final_info,
-                              grpc_closure *then_schedule_closure) {
-  call_data *calld = (call_data *)elem->call_data;
-  channel_data *chand = (channel_data *)elem->channel_data;
+static void destroy_call_elem(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+                              const grpc_call_final_info* final_info,
+                              grpc_closure* then_schedule_closure) {
+  call_data* calld = (call_data*)elem->call_data;
+  channel_data* chand = (channel_data*)elem->channel_data;
   grpc_transport_destroy_stream(exec_ctx, chand->transport,
                                 TRANSPORT_STREAM_FROM_CALL_DATA(calld),
                                 then_schedule_closure);
 }
 
 /* Constructor for channel_data */
-static grpc_error *init_channel_elem(grpc_exec_ctx *exec_ctx,
-                                     grpc_channel_element *elem,
-                                     grpc_channel_element_args *args) {
-  channel_data *cd = (channel_data *)elem->channel_data;
+static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx,
+                                     grpc_channel_element* elem,
+                                     grpc_channel_element_args* args) {
+  channel_data* cd = (channel_data*)elem->channel_data;
   GPR_ASSERT(args->is_last);
-  cd->transport = NULL;
+  cd->transport = nullptr;
   return GRPC_ERROR_NONE;
 }
 
 /* Destructor for channel_data */
-static void destroy_channel_elem(grpc_exec_ctx *exec_ctx,
-                                 grpc_channel_element *elem) {
-  channel_data *cd = (channel_data *)elem->channel_data;
+static void destroy_channel_elem(grpc_exec_ctx* exec_ctx,
+                                 grpc_channel_element* elem) {
+  channel_data* cd = (channel_data*)elem->channel_data;
   if (cd->transport) {
     grpc_transport_destroy(exec_ctx, cd->transport);
   }
 }
 
 /* No-op. */
-static void con_get_channel_info(grpc_exec_ctx *exec_ctx,
-                                 grpc_channel_element *elem,
-                                 const grpc_channel_info *channel_info) {}
+static void con_get_channel_info(grpc_exec_ctx* exec_ctx,
+                                 grpc_channel_element* elem,
+                                 const grpc_channel_info* channel_info) {}
 
 const grpc_channel_filter grpc_connected_filter = {
     con_start_transport_stream_op_batch,
@@ -213,12 +213,12 @@ const grpc_channel_filter grpc_connected_filter = {
     "connected",
 };
 
-static void bind_transport(grpc_channel_stack *channel_stack,
-                           grpc_channel_element *elem, void *t) {
-  channel_data *cd = (channel_data *)elem->channel_data;
+static void bind_transport(grpc_channel_stack* channel_stack,
+                           grpc_channel_element* elem, void* t) {
+  channel_data* cd = (channel_data*)elem->channel_data;
   GPR_ASSERT(elem->filter == &grpc_connected_filter);
-  GPR_ASSERT(cd->transport == NULL);
-  cd->transport = (grpc_transport *)t;
+  GPR_ASSERT(cd->transport == nullptr);
+  cd->transport = (grpc_transport*)t;
 
   /* HACK(ctiller): increase call stack size for the channel to make space
      for channel data. We need a cleaner (but performant) way to do this,
@@ -227,20 +227,20 @@ static void bind_transport(grpc_channel_stack *channel_stack,
      the last call element, and the last call element MUST be the connected
      channel. */
   channel_stack->call_stack_size +=
-      grpc_transport_stream_size((grpc_transport *)t);
+      grpc_transport_stream_size((grpc_transport*)t);
 }
 
-bool grpc_add_connected_filter(grpc_exec_ctx *exec_ctx,
-                               grpc_channel_stack_builder *builder,
-                               void *arg_must_be_null) {
-  GPR_ASSERT(arg_must_be_null == NULL);
-  grpc_transport *t = grpc_channel_stack_builder_get_transport(builder);
-  GPR_ASSERT(t != NULL);
+bool grpc_add_connected_filter(grpc_exec_ctx* exec_ctx,
+                               grpc_channel_stack_builder* builder,
+                               void* arg_must_be_null) {
+  GPR_ASSERT(arg_must_be_null == nullptr);
+  grpc_transport* t = grpc_channel_stack_builder_get_transport(builder);
+  GPR_ASSERT(t != nullptr);
   return grpc_channel_stack_builder_append_filter(
       builder, &grpc_connected_filter, bind_transport, t);
 }
 
-grpc_stream *grpc_connected_channel_get_stream(grpc_call_element *elem) {
-  call_data *calld = (call_data *)elem->call_data;
+grpc_stream* grpc_connected_channel_get_stream(grpc_call_element* elem) {
+  call_data* calld = (call_data*)elem->call_data;
   return TRANSPORT_STREAM_FROM_CALL_DATA(calld);
 }

data/src/core/lib/channel/connected_channel.h

@@ -21,13 +21,21 @@
 
 #include "src/core/lib/channel/channel_stack_builder.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 extern const grpc_channel_filter grpc_connected_filter;
 
-bool grpc_add_connected_filter(grpc_exec_ctx *exec_ctx,
-                               grpc_channel_stack_builder *builder,
-                               void *arg_must_be_null);
+bool grpc_add_connected_filter(grpc_exec_ctx* exec_ctx,
+                               grpc_channel_stack_builder* builder,
+                               void* arg_must_be_null);
 
 /* Debug helper to dig the transport stream out of a call element */
-grpc_stream *grpc_connected_channel_get_stream(grpc_call_element *elem);
+grpc_stream* grpc_connected_channel_get_stream(grpc_call_element* elem);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_CHANNEL_CONNECTED_CHANNEL_H */

data/src/core/lib/channel/context.h

@@ -42,8 +42,8 @@ typedef enum {
 } grpc_context_index;
 
 typedef struct {
-  void *value;
-  void (*destroy)(void *);
+  void* value;
+  void (*destroy)(void*);
 } grpc_call_context_element;
 
 #endif /* GRPC_CORE_LIB_CHANNEL_CONTEXT_H */

data/src/core/lib/channel/{handshaker.c → handshaker.cc}

@@ -93,8 +93,8 @@ grpc_handshake_manager* grpc_handshake_manager_create() {
 
 void grpc_handshake_manager_pending_list_add(grpc_handshake_manager** head,
                                              grpc_handshake_manager* mgr) {
-  GPR_ASSERT(mgr->prev == NULL);
-  GPR_ASSERT(mgr->next == NULL);
+  GPR_ASSERT(mgr->prev == nullptr);
+  GPR_ASSERT(mgr->next == nullptr);
   mgr->next = *head;
   if (*head) {
     (*head)->prev = mgr;
@@ -104,10 +104,10 @@ void grpc_handshake_manager_pending_list_add(grpc_handshake_manager** head,
 
 void grpc_handshake_manager_pending_list_remove(grpc_handshake_manager** head,
                                                 grpc_handshake_manager* mgr) {
-  if (mgr->next != NULL) {
+  if (mgr->next != nullptr) {
     mgr->next->prev = mgr->prev;
   }
-  if (mgr->prev != NULL) {
+  if (mgr->prev != nullptr) {
     mgr->prev->next = mgr->next;
   } else {
     GPR_ASSERT(*head == mgr);
@@ -117,7 +117,7 @@ void grpc_handshake_manager_pending_list_remove(grpc_handshake_manager** head,
 
 void grpc_handshake_manager_pending_list_shutdown_all(
     grpc_exec_ctx* exec_ctx, grpc_handshake_manager* head, grpc_error* why) {
-  while (head != NULL) {
+  while (head != nullptr) {
     grpc_handshake_manager_shutdown(exec_ctx, head, GRPC_ERROR_REF(why));
     head = head->next;
   }
@@ -232,7 +232,7 @@ static void on_timeout(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
 void grpc_handshake_manager_do_handshake(
     grpc_exec_ctx* exec_ctx, grpc_handshake_manager* mgr,
     grpc_endpoint* endpoint, const grpc_channel_args* channel_args,
-    gpr_timespec deadline, grpc_tcp_server_acceptor* acceptor,
+    grpc_millis deadline, grpc_tcp_server_acceptor* acceptor,
     grpc_iomgr_cb_func on_handshake_done, void* user_data) {
   gpr_mu_lock(&mgr->mu);
   GPR_ASSERT(mgr->index == 0);
@@ -255,9 +255,7 @@ void grpc_handshake_manager_do_handshake(
   gpr_ref(&mgr->refs);
   GRPC_CLOSURE_INIT(&mgr->on_timeout, on_timeout, mgr,
                     grpc_schedule_on_exec_ctx);
-  grpc_timer_init(exec_ctx, &mgr->deadline_timer,
-                  gpr_convert_clock_type(deadline, GPR_CLOCK_MONOTONIC),
-                  &mgr->on_timeout, gpr_now(GPR_CLOCK_MONOTONIC));
+  grpc_timer_init(exec_ctx, &mgr->deadline_timer, deadline, &mgr->on_timeout);
   // Start first handshaker, which also owns a ref.
   gpr_ref(&mgr->refs);
   bool done = call_next_handshaker_locked(exec_ctx, mgr, GRPC_ERROR_NONE);

data/src/core/lib/channel/handshaker.h

@@ -26,6 +26,10 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/tcp_server.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /// Handshakers are used to perform initial handshakes on a connection
 /// before the client sends the initial request.  Some examples of what
 /// a handshaker can be used for includes support for HTTP CONNECT on
@@ -145,7 +149,7 @@ void grpc_handshake_manager_shutdown(grpc_exec_ctx* exec_ctx,
 void grpc_handshake_manager_do_handshake(
     grpc_exec_ctx* exec_ctx, grpc_handshake_manager* mgr,
     grpc_endpoint* endpoint, const grpc_channel_args* channel_args,
-    gpr_timespec deadline, grpc_tcp_server_acceptor* acceptor,
+    grpc_millis deadline, grpc_tcp_server_acceptor* acceptor,
     grpc_iomgr_cb_func on_handshake_done, void* user_data);
 
 /// Add \a mgr to the server side list of all pending handshake managers, the
@@ -164,4 +168,8 @@ void grpc_handshake_manager_pending_list_remove(grpc_handshake_manager** head,
 void grpc_handshake_manager_pending_list_shutdown_all(
     grpc_exec_ctx* exec_ctx, grpc_handshake_manager* head, grpc_error* why);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_CHANNEL_HANDSHAKER_H */

data/src/core/lib/channel/{handshaker_factory.c → handshaker_factory.cc}

@@ -21,19 +21,19 @@
 #include <grpc/support/log.h>
 
 void grpc_handshaker_factory_add_handshakers(
-    grpc_exec_ctx *exec_ctx, grpc_handshaker_factory *handshaker_factory,
-    const grpc_channel_args *args, grpc_handshake_manager *handshake_mgr) {
-  if (handshaker_factory != NULL) {
-    GPR_ASSERT(handshaker_factory->vtable != NULL);
+    grpc_exec_ctx* exec_ctx, grpc_handshaker_factory* handshaker_factory,
+    const grpc_channel_args* args, grpc_handshake_manager* handshake_mgr) {
+  if (handshaker_factory != nullptr) {
+    GPR_ASSERT(handshaker_factory->vtable != nullptr);
     handshaker_factory->vtable->add_handshakers(exec_ctx, handshaker_factory,
                                                 args, handshake_mgr);
   }
 }
 
 void grpc_handshaker_factory_destroy(
-    grpc_exec_ctx *exec_ctx, grpc_handshaker_factory *handshaker_factory) {
-  if (handshaker_factory != NULL) {
-    GPR_ASSERT(handshaker_factory->vtable != NULL);
+    grpc_exec_ctx* exec_ctx, grpc_handshaker_factory* handshaker_factory) {
+  if (handshaker_factory != nullptr) {
+    GPR_ASSERT(handshaker_factory->vtable != nullptr);
     handshaker_factory->vtable->destroy(exec_ctx, handshaker_factory);
   }
 }

data/src/core/lib/channel/handshaker_factory.h

@@ -24,28 +24,36 @@
 #include "src/core/lib/channel/handshaker.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 // A handshaker factory is used to create handshakers.
 
 typedef struct grpc_handshaker_factory grpc_handshaker_factory;
 
 typedef struct {
-  void (*add_handshakers)(grpc_exec_ctx *exec_ctx,
-                          grpc_handshaker_factory *handshaker_factory,
-                          const grpc_channel_args *args,
-                          grpc_handshake_manager *handshake_mgr);
-  void (*destroy)(grpc_exec_ctx *exec_ctx,
-                  grpc_handshaker_factory *handshaker_factory);
+  void (*add_handshakers)(grpc_exec_ctx* exec_ctx,
+                          grpc_handshaker_factory* handshaker_factory,
+                          const grpc_channel_args* args,
+                          grpc_handshake_manager* handshake_mgr);
+  void (*destroy)(grpc_exec_ctx* exec_ctx,
+                  grpc_handshaker_factory* handshaker_factory);
 } grpc_handshaker_factory_vtable;
 
 struct grpc_handshaker_factory {
-  const grpc_handshaker_factory_vtable *vtable;
+  const grpc_handshaker_factory_vtable* vtable;
 };
 
 void grpc_handshaker_factory_add_handshakers(
-    grpc_exec_ctx *exec_ctx, grpc_handshaker_factory *handshaker_factory,
-    const grpc_channel_args *args, grpc_handshake_manager *handshake_mgr);
+    grpc_exec_ctx* exec_ctx, grpc_handshaker_factory* handshaker_factory,
+    const grpc_channel_args* args, grpc_handshake_manager* handshake_mgr);
 
 void grpc_handshaker_factory_destroy(
-    grpc_exec_ctx *exec_ctx, grpc_handshaker_factory *handshaker_factory);
+    grpc_exec_ctx* exec_ctx, grpc_handshaker_factory* handshaker_factory);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_CHANNEL_HANDSHAKER_FACTORY_H */