grpc 1.7.3 → 1.8.0

data/src/core/lib/transport/byte_stream.h

@@ -28,22 +28,26 @@
 /** Mask of all valid internal flags. */
 #define GRPC_WRITE_INTERNAL_USED_MASK (GRPC_WRITE_INTERNAL_COMPRESS)
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct grpc_byte_stream grpc_byte_stream;
 
 typedef struct {
-  bool (*next)(grpc_exec_ctx *exec_ctx, grpc_byte_stream *byte_stream,
-               size_t max_size_hint, grpc_closure *on_complete);
-  grpc_error *(*pull)(grpc_exec_ctx *exec_ctx, grpc_byte_stream *byte_stream,
-                      grpc_slice *slice);
-  void (*shutdown)(grpc_exec_ctx *exec_ctx, grpc_byte_stream *byte_stream,
-                   grpc_error *error);
-  void (*destroy)(grpc_exec_ctx *exec_ctx, grpc_byte_stream *byte_stream);
+  bool (*next)(grpc_exec_ctx* exec_ctx, grpc_byte_stream* byte_stream,
+               size_t max_size_hint, grpc_closure* on_complete);
+  grpc_error* (*pull)(grpc_exec_ctx* exec_ctx, grpc_byte_stream* byte_stream,
+                      grpc_slice* slice);
+  void (*shutdown)(grpc_exec_ctx* exec_ctx, grpc_byte_stream* byte_stream,
+                   grpc_error* error);
+  void (*destroy)(grpc_exec_ctx* exec_ctx, grpc_byte_stream* byte_stream);
 } grpc_byte_stream_vtable;
 
 struct grpc_byte_stream {
   uint32_t length;
   uint32_t flags;
-  const grpc_byte_stream_vtable *vtable;
+  const grpc_byte_stream_vtable* vtable;
 };
 
 // Returns true if the bytes are available immediately (in which case
@@ -52,18 +56,18 @@ struct grpc_byte_stream {
 //
 // max_size_hint can be set as a hint as to the maximum number
 // of bytes that would be acceptable to read.
-bool grpc_byte_stream_next(grpc_exec_ctx *exec_ctx,
-                           grpc_byte_stream *byte_stream, size_t max_size_hint,
-                           grpc_closure *on_complete);
+bool grpc_byte_stream_next(grpc_exec_ctx* exec_ctx,
+                           grpc_byte_stream* byte_stream, size_t max_size_hint,
+                           grpc_closure* on_complete);
 
 // Returns the next slice in the byte stream when it is ready (indicated by
 // either grpc_byte_stream_next returning true or on_complete passed to
 // grpc_byte_stream_next is called).
 //
 // Once a slice is returned into *slice, it is owned by the caller.
-grpc_error *grpc_byte_stream_pull(grpc_exec_ctx *exec_ctx,
-                                  grpc_byte_stream *byte_stream,
-                                  grpc_slice *slice);
+grpc_error* grpc_byte_stream_pull(grpc_exec_ctx* exec_ctx,
+                                  grpc_byte_stream* byte_stream,
+                                  grpc_slice* slice);
 
 // Shuts down the byte stream.
 //
@@ -72,12 +76,12 @@ grpc_error *grpc_byte_stream_pull(grpc_exec_ctx *exec_ctx,
 //
 // The next call to grpc_byte_stream_pull() (if any) will return the error
 // passed to grpc_byte_stream_shutdown().
-void grpc_byte_stream_shutdown(grpc_exec_ctx *exec_ctx,
-                               grpc_byte_stream *byte_stream,
-                               grpc_error *error);
+void grpc_byte_stream_shutdown(grpc_exec_ctx* exec_ctx,
+                               grpc_byte_stream* byte_stream,
+                               grpc_error* error);
 
-void grpc_byte_stream_destroy(grpc_exec_ctx *exec_ctx,
-                              grpc_byte_stream *byte_stream);
+void grpc_byte_stream_destroy(grpc_exec_ctx* exec_ctx,
+                              grpc_byte_stream* byte_stream);
 
 // grpc_slice_buffer_stream
 //
@@ -87,13 +91,13 @@ void grpc_byte_stream_destroy(grpc_exec_ctx *exec_ctx,
 
 typedef struct grpc_slice_buffer_stream {
   grpc_byte_stream base;
-  grpc_slice_buffer *backing_buffer;
+  grpc_slice_buffer* backing_buffer;
   size_t cursor;
-  grpc_error *shutdown_error;
+  grpc_error* shutdown_error;
 } grpc_slice_buffer_stream;
 
-void grpc_slice_buffer_stream_init(grpc_slice_buffer_stream *stream,
-                                   grpc_slice_buffer *slice_buffer,
+void grpc_slice_buffer_stream_init(grpc_slice_buffer_stream* stream,
+                                   grpc_slice_buffer* slice_buffer,
                                    uint32_t flags);
 
 // grpc_caching_byte_stream
@@ -110,29 +114,33 @@ void grpc_slice_buffer_stream_init(grpc_slice_buffer_stream *stream,
 // grpc_byte_stream_cache at the same time.
 
 typedef struct {
-  grpc_byte_stream *underlying_stream;
+  grpc_byte_stream* underlying_stream;
   grpc_slice_buffer cache_buffer;
 } grpc_byte_stream_cache;
 
 // Takes ownership of underlying_stream.
-void grpc_byte_stream_cache_init(grpc_byte_stream_cache *cache,
-                                 grpc_byte_stream *underlying_stream);
+void grpc_byte_stream_cache_init(grpc_byte_stream_cache* cache,
+                                 grpc_byte_stream* underlying_stream);
 
 // Must not be called while still in use by a grpc_caching_byte_stream.
-void grpc_byte_stream_cache_destroy(grpc_exec_ctx *exec_ctx,
-                                    grpc_byte_stream_cache *cache);
+void grpc_byte_stream_cache_destroy(grpc_exec_ctx* exec_ctx,
+                                    grpc_byte_stream_cache* cache);
 
 typedef struct {
   grpc_byte_stream base;
-  grpc_byte_stream_cache *cache;
+  grpc_byte_stream_cache* cache;
   size_t cursor;
-  grpc_error *shutdown_error;
+  grpc_error* shutdown_error;
 } grpc_caching_byte_stream;
 
-void grpc_caching_byte_stream_init(grpc_caching_byte_stream *stream,
-                                   grpc_byte_stream_cache *cache);
+void grpc_caching_byte_stream_init(grpc_caching_byte_stream* stream,
+                                   grpc_byte_stream_cache* cache);
 
 // Resets the byte stream to the start of the underlying stream.
-void grpc_caching_byte_stream_reset(grpc_caching_byte_stream *stream);
+void grpc_caching_byte_stream_reset(grpc_caching_byte_stream* stream);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_TRANSPORT_BYTE_STREAM_H */

data/src/core/lib/transport/{connectivity_state.c → connectivity_state.cc}

@@ -24,13 +24,10 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-grpc_tracer_flag grpc_connectivity_state_trace =
-    GRPC_TRACER_INITIALIZER(false, "connectivity_state");
+grpc_core::TraceFlag grpc_connectivity_state_trace(false, "connectivity_state");
 
-const char *grpc_connectivity_state_name(grpc_connectivity_state state) {
+const char* grpc_connectivity_state_name(grpc_connectivity_state state) {
   switch (state) {
-    case GRPC_CHANNEL_INIT:
-      return "INIT";
     case GRPC_CHANNEL_IDLE:
       return "IDLE";
     case GRPC_CHANNEL_CONNECTING:
@@ -45,19 +42,19 @@ const char *grpc_connectivity_state_name(grpc_connectivity_state state) {
   GPR_UNREACHABLE_CODE(return "UNKNOWN");
 }
 
-void grpc_connectivity_state_init(grpc_connectivity_state_tracker *tracker,
+void grpc_connectivity_state_init(grpc_connectivity_state_tracker* tracker,
                                   grpc_connectivity_state init_state,
-                                  const char *name) {
+                                  const char* name) {
   gpr_atm_no_barrier_store(&tracker->current_state_atm, init_state);
   tracker->current_error = GRPC_ERROR_NONE;
-  tracker->watchers = NULL;
+  tracker->watchers = nullptr;
   tracker->name = gpr_strdup(name);
 }
 
-void grpc_connectivity_state_destroy(grpc_exec_ctx *exec_ctx,
-                                     grpc_connectivity_state_tracker *tracker) {
-  grpc_error *error;
-  grpc_connectivity_state_watcher *w;
+void grpc_connectivity_state_destroy(grpc_exec_ctx* exec_ctx,
+                                     grpc_connectivity_state_tracker* tracker) {
+  grpc_error* error;
+  grpc_connectivity_state_watcher* w;
   while ((w = tracker->watchers)) {
     tracker->watchers = w->next;
 
@@ -76,11 +73,11 @@ void grpc_connectivity_state_destroy(grpc_exec_ctx *exec_ctx,
 }
 
 grpc_connectivity_state grpc_connectivity_state_check(
-    grpc_connectivity_state_tracker *tracker) {
+    grpc_connectivity_state_tracker* tracker) {
   grpc_connectivity_state cur =
       (grpc_connectivity_state)gpr_atm_no_barrier_load(
           &tracker->current_state_atm);
-  if (GRPC_TRACER_ON(grpc_connectivity_state_trace)) {
+  if (grpc_connectivity_state_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CONWATCH: %p %s: get %s", tracker, tracker->name,
             grpc_connectivity_state_name(cur));
   }
@@ -88,33 +85,33 @@ grpc_connectivity_state grpc_connectivity_state_check(
 }
 
 grpc_connectivity_state grpc_connectivity_state_get(
-    grpc_connectivity_state_tracker *tracker, grpc_error **error) {
+    grpc_connectivity_state_tracker* tracker, grpc_error** error) {
   grpc_connectivity_state cur =
       (grpc_connectivity_state)gpr_atm_no_barrier_load(
           &tracker->current_state_atm);
-  if (GRPC_TRACER_ON(grpc_connectivity_state_trace)) {
+  if (grpc_connectivity_state_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CONWATCH: %p %s: get %s", tracker, tracker->name,
             grpc_connectivity_state_name(cur));
   }
-  if (error != NULL) {
+  if (error != nullptr) {
     *error = GRPC_ERROR_REF(tracker->current_error);
   }
   return cur;
 }
 
 bool grpc_connectivity_state_has_watchers(
-    grpc_connectivity_state_tracker *connectivity_state) {
-  return connectivity_state->watchers != NULL;
+    grpc_connectivity_state_tracker* connectivity_state) {
+  return connectivity_state->watchers != nullptr;
 }
 
 bool grpc_connectivity_state_notify_on_state_change(
-    grpc_exec_ctx *exec_ctx, grpc_connectivity_state_tracker *tracker,
-    grpc_connectivity_state *current, grpc_closure *notify) {
+    grpc_exec_ctx* exec_ctx, grpc_connectivity_state_tracker* tracker,
+    grpc_connectivity_state* current, grpc_closure* notify) {
   grpc_connectivity_state cur =
       (grpc_connectivity_state)gpr_atm_no_barrier_load(
           &tracker->current_state_atm);
-  if (GRPC_TRACER_ON(grpc_connectivity_state_trace)) {
-    if (current == NULL) {
+  if (grpc_connectivity_state_trace.enabled()) {
+    if (current == nullptr) {
       gpr_log(GPR_DEBUG, "CONWATCH: %p %s: unsubscribe notify=%p", tracker,
               tracker->name, notify);
     } else {
@@ -123,17 +120,17 @@ bool grpc_connectivity_state_notify_on_state_change(
               grpc_connectivity_state_name(cur), notify);
     }
   }
-  if (current == NULL) {
-    grpc_connectivity_state_watcher *w = tracker->watchers;
-    if (w != NULL && w->notify == notify) {
+  if (current == nullptr) {
+    grpc_connectivity_state_watcher* w = tracker->watchers;
+    if (w != nullptr && w->notify == notify) {
       GRPC_CLOSURE_SCHED(exec_ctx, notify, GRPC_ERROR_CANCELLED);
       tracker->watchers = w->next;
       gpr_free(w);
       return false;
     }
-    while (w != NULL) {
-      grpc_connectivity_state_watcher *rm_candidate = w->next;
-      if (rm_candidate != NULL && rm_candidate->notify == notify) {
+    while (w != nullptr) {
+      grpc_connectivity_state_watcher* rm_candidate = w->next;
+      if (rm_candidate != nullptr && rm_candidate->notify == notify) {
         GRPC_CLOSURE_SCHED(exec_ctx, notify, GRPC_ERROR_CANCELLED);
         w->next = w->next->next;
         gpr_free(rm_candidate);
@@ -148,8 +145,8 @@ bool grpc_connectivity_state_notify_on_state_change(
       GRPC_CLOSURE_SCHED(exec_ctx, notify,
                          GRPC_ERROR_REF(tracker->current_error));
     } else {
-      grpc_connectivity_state_watcher *w =
-          (grpc_connectivity_state_watcher *)gpr_malloc(sizeof(*w));
+      grpc_connectivity_state_watcher* w =
+          (grpc_connectivity_state_watcher*)gpr_malloc(sizeof(*w));
       w->current = current;
       w->notify = notify;
       w->next = tracker->watchers;
@@ -159,22 +156,21 @@ bool grpc_connectivity_state_notify_on_state_change(
   }
 }
 
-void grpc_connectivity_state_set(grpc_exec_ctx *exec_ctx,
-                                 grpc_connectivity_state_tracker *tracker,
+void grpc_connectivity_state_set(grpc_exec_ctx* exec_ctx,
+                                 grpc_connectivity_state_tracker* tracker,
                                  grpc_connectivity_state state,
-                                 grpc_error *error, const char *reason) {
+                                 grpc_error* error, const char* reason) {
   grpc_connectivity_state cur =
       (grpc_connectivity_state)gpr_atm_no_barrier_load(
           &tracker->current_state_atm);
-  grpc_connectivity_state_watcher *w;
-  if (GRPC_TRACER_ON(grpc_connectivity_state_trace)) {
-    const char *error_string = grpc_error_string(error);
+  grpc_connectivity_state_watcher* w;
+  if (grpc_connectivity_state_trace.enabled()) {
+    const char* error_string = grpc_error_string(error);
     gpr_log(GPR_DEBUG, "SET: %p %s: %s --> %s [%s] error=%p %s", tracker,
             tracker->name, grpc_connectivity_state_name(cur),
             grpc_connectivity_state_name(state), reason, error, error_string);
   }
   switch (state) {
-    case GRPC_CHANNEL_INIT:
     case GRPC_CHANNEL_CONNECTING:
     case GRPC_CHANNEL_IDLE:
     case GRPC_CHANNEL_READY:
@@ -192,10 +188,10 @@ void grpc_connectivity_state_set(grpc_exec_ctx *exec_ctx,
   }
   GPR_ASSERT(cur != GRPC_CHANNEL_SHUTDOWN);
   gpr_atm_no_barrier_store(&tracker->current_state_atm, state);
-  while ((w = tracker->watchers) != NULL) {
+  while ((w = tracker->watchers) != nullptr) {
     *w->current = state;
     tracker->watchers = w->next;
-    if (GRPC_TRACER_ON(grpc_connectivity_state_trace)) {
+    if (grpc_connectivity_state_trace.enabled()) {
       gpr_log(GPR_DEBUG, "NOTIFY: %p %s: %p", tracker, tracker->name,
               w->notify);
     }

data/src/core/lib/transport/connectivity_state.h

@@ -23,65 +23,73 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct grpc_connectivity_state_watcher {
   /** we keep watchers in a linked list */
-  struct grpc_connectivity_state_watcher *next;
+  struct grpc_connectivity_state_watcher* next;
   /** closure to notify on change */
-  grpc_closure *notify;
+  grpc_closure* notify;
   /** the current state as believed by the watcher */
-  grpc_connectivity_state *current;
+  grpc_connectivity_state* current;
 } grpc_connectivity_state_watcher;
 
 typedef struct {
   /** current grpc_connectivity_state */
   gpr_atm current_state_atm;
   /** error associated with state */
-  grpc_error *current_error;
+  grpc_error* current_error;
   /** all our watchers */
-  grpc_connectivity_state_watcher *watchers;
+  grpc_connectivity_state_watcher* watchers;
   /** a name to help debugging */
-  char *name;
+  char* name;
 } grpc_connectivity_state_tracker;
 
-extern grpc_tracer_flag grpc_connectivity_state_trace;
+extern grpc_core::TraceFlag grpc_connectivity_state_trace;
 
 /** enum --> string conversion */
-const char *grpc_connectivity_state_name(grpc_connectivity_state state);
+const char* grpc_connectivity_state_name(grpc_connectivity_state state);
 
-void grpc_connectivity_state_init(grpc_connectivity_state_tracker *tracker,
+void grpc_connectivity_state_init(grpc_connectivity_state_tracker* tracker,
                                   grpc_connectivity_state init_state,
-                                  const char *name);
-void grpc_connectivity_state_destroy(grpc_exec_ctx *exec_ctx,
-                                     grpc_connectivity_state_tracker *tracker);
+                                  const char* name);
+void grpc_connectivity_state_destroy(grpc_exec_ctx* exec_ctx,
+                                     grpc_connectivity_state_tracker* tracker);
 
 /** Set connectivity state; not thread safe; access must be serialized with an
  *  external lock */
-void grpc_connectivity_state_set(grpc_exec_ctx *exec_ctx,
-                                 grpc_connectivity_state_tracker *tracker,
+void grpc_connectivity_state_set(grpc_exec_ctx* exec_ctx,
+                                 grpc_connectivity_state_tracker* tracker,
                                  grpc_connectivity_state state,
-                                 grpc_error *associated_error,
-                                 const char *reason);
+                                 grpc_error* associated_error,
+                                 const char* reason);
 
 /** Return true if this connectivity state has watchers.
     Access must be serialized with an external lock. */
 bool grpc_connectivity_state_has_watchers(
-    grpc_connectivity_state_tracker *tracker);
+    grpc_connectivity_state_tracker* tracker);
 
 /** Return the last seen connectivity state. No need to synchronize access. */
 grpc_connectivity_state grpc_connectivity_state_check(
-    grpc_connectivity_state_tracker *tracker);
+    grpc_connectivity_state_tracker* tracker);
 
 /** Return the last seen connectivity state, and the associated error.
     Access must be serialized with an external lock. */
 grpc_connectivity_state grpc_connectivity_state_get(
-    grpc_connectivity_state_tracker *tracker, grpc_error **error);
+    grpc_connectivity_state_tracker* tracker, grpc_error** error);
 
 /** Return 1 if the channel should start connecting, 0 otherwise.
     If current==NULL cancel notify if it is already queued (success==0 in that
     case).
     Access must be serialized with an external lock. */
 bool grpc_connectivity_state_notify_on_state_change(
-    grpc_exec_ctx *exec_ctx, grpc_connectivity_state_tracker *tracker,
-    grpc_connectivity_state *current, grpc_closure *notify);
+    grpc_exec_ctx* exec_ctx, grpc_connectivity_state_tracker* tracker,
+    grpc_connectivity_state* current, grpc_closure* notify);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_TRANSPORT_CONNECTIVITY_STATE_H */

data/src/core/lib/transport/{error_utils.c → error_utils.cc}

@@ -18,35 +18,37 @@
 
 #include "src/core/lib/transport/error_utils.h"
 
+#include <grpc/support/string_util.h>
 #include "src/core/lib/iomgr/error_internal.h"
 #include "src/core/lib/transport/status_conversion.h"
 
-static grpc_error *recursively_find_error_with_field(grpc_error *error,
+static grpc_error* recursively_find_error_with_field(grpc_error* error,
                                                      grpc_error_ints which) {
   // If the error itself has a status code, return it.
-  if (grpc_error_get_int(error, which, NULL)) {
+  if (grpc_error_get_int(error, which, nullptr)) {
     return error;
   }
-  if (grpc_error_is_special(error)) return NULL;
+  if (grpc_error_is_special(error)) return nullptr;
   // Otherwise, search through its children.
   uint8_t slot = error->first_err;
   while (slot != UINT8_MAX) {
-    grpc_linked_error *lerr = (grpc_linked_error *)(error->arena + slot);
-    grpc_error *result = recursively_find_error_with_field(lerr->err, which);
+    grpc_linked_error* lerr = (grpc_linked_error*)(error->arena + slot);
+    grpc_error* result = recursively_find_error_with_field(lerr->err, which);
     if (result) return result;
     slot = lerr->next;
   }
-  return NULL;
+  return nullptr;
 }
 
-void grpc_error_get_status(grpc_error *error, gpr_timespec deadline,
-                           grpc_status_code *code, grpc_slice *slice,
-                           grpc_http2_error_code *http_error) {
+void grpc_error_get_status(grpc_exec_ctx* exec_ctx, grpc_error* error,
+                           grpc_millis deadline, grpc_status_code* code,
+                           grpc_slice* slice, grpc_http2_error_code* http_error,
+                           const char** error_string) {
   // Start with the parent error and recurse through the tree of children
   // until we find the first one that has a status code.
-  grpc_error *found_error =
+  grpc_error* found_error =
       recursively_find_error_with_field(error, GRPC_ERROR_INT_GRPC_STATUS);
-  if (found_error == NULL) {
+  if (found_error == nullptr) {
     /// If no grpc-status exists, retry through the tree to find a http2 error
     /// code
     found_error =
@@ -55,7 +57,7 @@ void grpc_error_get_status(grpc_error *error, gpr_timespec deadline,
 
   // If we found an error with a status code above, use that; otherwise,
   // fall back to using the parent error.
-  if (found_error == NULL) found_error = error;
+  if (found_error == nullptr) found_error = error;
 
   grpc_status_code status = GRPC_STATUS_UNKNOWN;
   intptr_t integer;
@@ -63,12 +65,16 @@ void grpc_error_get_status(grpc_error *error, gpr_timespec deadline,
     status = (grpc_status_code)integer;
   } else if (grpc_error_get_int(found_error, GRPC_ERROR_INT_HTTP2_ERROR,
                                 &integer)) {
-    status = grpc_http2_error_to_grpc_status((grpc_http2_error_code)integer,
-                                             deadline);
+    status = grpc_http2_error_to_grpc_status(
+        exec_ctx, (grpc_http2_error_code)integer, deadline);
   }
-  if (code != NULL) *code = status;
+  if (code != nullptr) *code = status;
 
-  if (http_error != NULL) {
+  if (error_string != NULL && status != GRPC_STATUS_OK) {
+    *error_string = gpr_strdup(grpc_error_string(error));
+  }
+
+  if (http_error != nullptr) {
     if (grpc_error_get_int(found_error, GRPC_ERROR_INT_HTTP2_ERROR, &integer)) {
       *http_error = (grpc_http2_error_code)integer;
     } else if (grpc_error_get_int(found_error, GRPC_ERROR_INT_GRPC_STATUS,
@@ -82,24 +88,22 @@ void grpc_error_get_status(grpc_error *error, gpr_timespec deadline,
 
   // If the error has a status message, use it.  Otherwise, fall back to
   // the error description.
-  if (slice != NULL) {
+  if (slice != nullptr) {
     if (!grpc_error_get_str(found_error, GRPC_ERROR_STR_GRPC_MESSAGE, slice)) {
       if (!grpc_error_get_str(found_error, GRPC_ERROR_STR_DESCRIPTION, slice)) {
         *slice = grpc_slice_from_static_string("unknown error");
       }
     }
   }
-
-  if (found_error == NULL) found_error = error;
 }
 
-bool grpc_error_has_clear_grpc_status(grpc_error *error) {
-  if (grpc_error_get_int(error, GRPC_ERROR_INT_GRPC_STATUS, NULL)) {
+bool grpc_error_has_clear_grpc_status(grpc_error* error) {
+  if (grpc_error_get_int(error, GRPC_ERROR_INT_GRPC_STATUS, nullptr)) {
     return true;
   }
   uint8_t slot = error->first_err;
   while (slot != UINT8_MAX) {
-    grpc_linked_error *lerr = (grpc_linked_error *)(error->arena + slot);
+    grpc_linked_error* lerr = (grpc_linked_error*)(error->arena + slot);
     if (grpc_error_has_clear_grpc_status(lerr->err)) {
       return true;
     }