grpc 1.8.7 → 1.9.0.pre1

data/src/core/lib/surface/server.h

@@ -24,10 +24,6 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/transport/transport.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 extern const grpc_channel_filter grpc_server_top_filter;
 
 /** Lightweight tracing of server channel state */
@@ -35,17 +31,16 @@ extern grpc_core::TraceFlag grpc_server_channel_trace;
 
 /* Add a listener to the server: when the server starts, it will call start,
    and when it shuts down, it will call destroy */
-void grpc_server_add_listener(
-    grpc_exec_ctx* exec_ctx, grpc_server* server, void* listener,
-    void (*start)(grpc_exec_ctx* exec_ctx, grpc_server* server, void* arg,
-                  grpc_pollset** pollsets, size_t npollsets),
-    void (*destroy)(grpc_exec_ctx* exec_ctx, grpc_server* server, void* arg,
-                    grpc_closure* on_done));
+void grpc_server_add_listener(grpc_server* server, void* listener,
+                              void (*start)(grpc_server* server, void* arg,
+                                            grpc_pollset** pollsets,
+                                            size_t npollsets),
+                              void (*destroy)(grpc_server* server, void* arg,
+                                              grpc_closure* on_done));
 
 /* Setup a transport - creates a channel stack, binds the transport to the
    server */
-void grpc_server_setup_transport(grpc_exec_ctx* exec_ctx, grpc_server* server,
-                                 grpc_transport* transport,
+void grpc_server_setup_transport(grpc_server* server, grpc_transport* transport,
                                  grpc_pollset* accepting_pollset,
                                  const grpc_channel_args* args);
 
@@ -58,8 +53,4 @@ int grpc_server_has_open_connections(grpc_server* server);
 void grpc_server_get_pollsets(grpc_server* server, grpc_pollset*** pollsets,
                               size_t* pollset_count);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_SURFACE_SERVER_H */

data/src/core/lib/surface/validate_metadata.h

@@ -22,15 +22,7 @@
 #include <grpc/slice.h>
 #include "src/core/lib/iomgr/error.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 grpc_error* grpc_validate_header_key_is_legal(grpc_slice slice);
 grpc_error* grpc_validate_header_nonbin_value_is_legal(grpc_slice slice);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_SURFACE_VALIDATE_METADATA_H */

data/src/core/lib/surface/version.cc

@@ -21,6 +21,6 @@
 
 #include <grpc/grpc.h>
 
-const char* grpc_version_string(void) { return "5.0.0"; }
+const char* grpc_version_string(void) { return "5.0.0-pre1"; }
 
-const char* grpc_g_stands_for(void) { return "generous"; }
+const char* grpc_g_stands_for(void) { return "glossy"; }

data/src/core/lib/transport/bdp_estimator.cc

@@ -37,7 +37,7 @@ BdpEstimator::BdpEstimator(const char* name)
       bw_est_(0),
       name_(name) {}
 
-grpc_millis BdpEstimator::CompletePing(grpc_exec_ctx* exec_ctx) {
+grpc_millis BdpEstimator::CompletePing() {
   gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC);
   gpr_timespec dt_ts = gpr_time_sub(now, ping_start_time_);
   double dt = (double)dt_ts.tv_sec + 1e-9 * (double)dt_ts.tv_nsec;
@@ -78,7 +78,7 @@ grpc_millis BdpEstimator::CompletePing(grpc_exec_ctx* exec_ctx) {
   }
   ping_state_ = PingState::UNSCHEDULED;
   accumulator_ = 0;
-  return grpc_exec_ctx_now(exec_ctx) + inter_ping_delay_;
+  return grpc_core::ExecCtx::Get()->Now() + inter_ping_delay_;
 }
 
 }  // namespace grpc_core

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

@@ -73,7 +73,7 @@ class BdpEstimator {
   }
 
   // Completes a previously started ping, returns when to schedule the next one
-  grpc_millis CompletePing(grpc_exec_ctx* exec_ctx);
+  grpc_millis CompletePing();
 
  private:
   enum class PingState { UNSCHEDULED, SCHEDULED, STARTED };

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

@@ -25,34 +25,28 @@
 
 #include "src/core/lib/slice/slice_internal.h"
 
-bool grpc_byte_stream_next(grpc_exec_ctx* exec_ctx,
-                           grpc_byte_stream* byte_stream, size_t max_size_hint,
+bool grpc_byte_stream_next(grpc_byte_stream* byte_stream, size_t max_size_hint,
                            grpc_closure* on_complete) {
-  return byte_stream->vtable->next(exec_ctx, byte_stream, max_size_hint,
-                                   on_complete);
+  return byte_stream->vtable->next(byte_stream, max_size_hint, on_complete);
 }
 
-grpc_error* grpc_byte_stream_pull(grpc_exec_ctx* exec_ctx,
-                                  grpc_byte_stream* byte_stream,
+grpc_error* grpc_byte_stream_pull(grpc_byte_stream* byte_stream,
                                   grpc_slice* slice) {
-  return byte_stream->vtable->pull(exec_ctx, byte_stream, slice);
+  return byte_stream->vtable->pull(byte_stream, slice);
 }
 
-void grpc_byte_stream_shutdown(grpc_exec_ctx* exec_ctx,
-                               grpc_byte_stream* byte_stream,
+void grpc_byte_stream_shutdown(grpc_byte_stream* byte_stream,
                                grpc_error* error) {
-  byte_stream->vtable->shutdown(exec_ctx, byte_stream, error);
+  byte_stream->vtable->shutdown(byte_stream, error);
 }
 
-void grpc_byte_stream_destroy(grpc_exec_ctx* exec_ctx,
-                              grpc_byte_stream* byte_stream) {
-  byte_stream->vtable->destroy(exec_ctx, byte_stream);
+void grpc_byte_stream_destroy(grpc_byte_stream* byte_stream) {
+  byte_stream->vtable->destroy(byte_stream);
 }
 
 // grpc_slice_buffer_stream
 
-static bool slice_buffer_stream_next(grpc_exec_ctx* exec_ctx,
-                                     grpc_byte_stream* byte_stream,
+static bool slice_buffer_stream_next(grpc_byte_stream* byte_stream,
                                      size_t max_size_hint,
                                      grpc_closure* on_complete) {
   grpc_slice_buffer_stream* stream = (grpc_slice_buffer_stream*)byte_stream;
@@ -60,8 +54,7 @@ static bool slice_buffer_stream_next(grpc_exec_ctx* exec_ctx,
   return true;
 }
 
-static grpc_error* slice_buffer_stream_pull(grpc_exec_ctx* exec_ctx,
-                                            grpc_byte_stream* byte_stream,
+static grpc_error* slice_buffer_stream_pull(grpc_byte_stream* byte_stream,
                                             grpc_slice* slice) {
   grpc_slice_buffer_stream* stream = (grpc_slice_buffer_stream*)byte_stream;
   if (stream->shutdown_error != GRPC_ERROR_NONE) {
@@ -74,18 +67,16 @@ static grpc_error* slice_buffer_stream_pull(grpc_exec_ctx* exec_ctx,
   return GRPC_ERROR_NONE;
 }
 
-static void slice_buffer_stream_shutdown(grpc_exec_ctx* exec_ctx,
-                                         grpc_byte_stream* byte_stream,
+static void slice_buffer_stream_shutdown(grpc_byte_stream* byte_stream,
                                          grpc_error* error) {
   grpc_slice_buffer_stream* stream = (grpc_slice_buffer_stream*)byte_stream;
   GRPC_ERROR_UNREF(stream->shutdown_error);
   stream->shutdown_error = error;
 }
 
-static void slice_buffer_stream_destroy(grpc_exec_ctx* exec_ctx,
-                                        grpc_byte_stream* byte_stream) {
+static void slice_buffer_stream_destroy(grpc_byte_stream* byte_stream) {
   grpc_slice_buffer_stream* stream = (grpc_slice_buffer_stream*)byte_stream;
-  grpc_slice_buffer_reset_and_unref_internal(exec_ctx, stream->backing_buffer);
+  grpc_slice_buffer_reset_and_unref_internal(stream->backing_buffer);
   GRPC_ERROR_UNREF(stream->shutdown_error);
 }
 
@@ -113,25 +104,22 @@ void grpc_byte_stream_cache_init(grpc_byte_stream_cache* cache,
   grpc_slice_buffer_init(&cache->cache_buffer);
 }
 
-void grpc_byte_stream_cache_destroy(grpc_exec_ctx* exec_ctx,
-                                    grpc_byte_stream_cache* cache) {
-  grpc_byte_stream_destroy(exec_ctx, cache->underlying_stream);
-  grpc_slice_buffer_destroy_internal(exec_ctx, &cache->cache_buffer);
+void grpc_byte_stream_cache_destroy(grpc_byte_stream_cache* cache) {
+  grpc_byte_stream_destroy(cache->underlying_stream);
+  grpc_slice_buffer_destroy_internal(&cache->cache_buffer);
 }
 
-static bool caching_byte_stream_next(grpc_exec_ctx* exec_ctx,
-                                     grpc_byte_stream* byte_stream,
+static bool caching_byte_stream_next(grpc_byte_stream* byte_stream,
                                      size_t max_size_hint,
                                      grpc_closure* on_complete) {
   grpc_caching_byte_stream* stream = (grpc_caching_byte_stream*)byte_stream;
   if (stream->shutdown_error != GRPC_ERROR_NONE) return true;
   if (stream->cursor < stream->cache->cache_buffer.count) return true;
-  return grpc_byte_stream_next(exec_ctx, stream->cache->underlying_stream,
-                               max_size_hint, on_complete);
+  return grpc_byte_stream_next(stream->cache->underlying_stream, max_size_hint,
+                               on_complete);
 }
 
-static grpc_error* caching_byte_stream_pull(grpc_exec_ctx* exec_ctx,
-                                            grpc_byte_stream* byte_stream,
+static grpc_error* caching_byte_stream_pull(grpc_byte_stream* byte_stream,
                                             grpc_slice* slice) {
   grpc_caching_byte_stream* stream = (grpc_caching_byte_stream*)byte_stream;
   if (stream->shutdown_error != GRPC_ERROR_NONE) {
@@ -144,7 +132,7 @@ static grpc_error* caching_byte_stream_pull(grpc_exec_ctx* exec_ctx,
     return GRPC_ERROR_NONE;
   }
   grpc_error* error =
-      grpc_byte_stream_pull(exec_ctx, stream->cache->underlying_stream, slice);
+      grpc_byte_stream_pull(stream->cache->underlying_stream, slice);
   if (error == GRPC_ERROR_NONE) {
     ++stream->cursor;
     grpc_slice_buffer_add(&stream->cache->cache_buffer,
@@ -153,17 +141,15 @@ static grpc_error* caching_byte_stream_pull(grpc_exec_ctx* exec_ctx,
   return error;
 }
 
-static void caching_byte_stream_shutdown(grpc_exec_ctx* exec_ctx,
-                                         grpc_byte_stream* byte_stream,
+static void caching_byte_stream_shutdown(grpc_byte_stream* byte_stream,
                                          grpc_error* error) {
   grpc_caching_byte_stream* stream = (grpc_caching_byte_stream*)byte_stream;
   GRPC_ERROR_UNREF(stream->shutdown_error);
   stream->shutdown_error = GRPC_ERROR_REF(error);
-  grpc_byte_stream_shutdown(exec_ctx, stream->cache->underlying_stream, error);
+  grpc_byte_stream_shutdown(stream->cache->underlying_stream, error);
 }
 
-static void caching_byte_stream_destroy(grpc_exec_ctx* exec_ctx,
-                                        grpc_byte_stream* byte_stream) {
+static void caching_byte_stream_destroy(grpc_byte_stream* byte_stream) {
   grpc_caching_byte_stream* stream = (grpc_caching_byte_stream*)byte_stream;
   GRPC_ERROR_UNREF(stream->shutdown_error);
 }

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

@@ -28,20 +28,14 @@
 /** 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_byte_stream* byte_stream, size_t max_size_hint,
+               grpc_closure* on_complete);
+  grpc_error* (*pull)(grpc_byte_stream* byte_stream, grpc_slice* slice);
+  void (*shutdown)(grpc_byte_stream* byte_stream, grpc_error* error);
+  void (*destroy)(grpc_byte_stream* byte_stream);
 } grpc_byte_stream_vtable;
 
 struct grpc_byte_stream {
@@ -56,8 +50,7 @@ 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,
+bool grpc_byte_stream_next(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
@@ -65,8 +58,7 @@ bool grpc_byte_stream_next(grpc_exec_ctx* exec_ctx,
 // 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_error* grpc_byte_stream_pull(grpc_byte_stream* byte_stream,
                                   grpc_slice* slice);
 
 // Shuts down the byte stream.
@@ -76,12 +68,10 @@ 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,
+void grpc_byte_stream_shutdown(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_byte_stream* byte_stream);
 
 // grpc_slice_buffer_stream
 //
@@ -123,8 +113,7 @@ 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_byte_stream_cache* cache);
 
 typedef struct {
   grpc_byte_stream base;
@@ -139,8 +128,4 @@ void grpc_caching_byte_stream_init(grpc_caching_byte_stream* stream,
 // Resets the byte stream to the start of the underlying 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.cc

@@ -51,8 +51,7 @@ void grpc_connectivity_state_init(grpc_connectivity_state_tracker* tracker,
   tracker->name = gpr_strdup(name);
 }
 
-void grpc_connectivity_state_destroy(grpc_exec_ctx* exec_ctx,
-                                     grpc_connectivity_state_tracker* tracker) {
+void grpc_connectivity_state_destroy(grpc_connectivity_state_tracker* tracker) {
   grpc_error* error;
   grpc_connectivity_state_watcher* w;
   while ((w = tracker->watchers)) {
@@ -65,7 +64,7 @@ void grpc_connectivity_state_destroy(grpc_exec_ctx* exec_ctx,
       error =
           GRPC_ERROR_CREATE_FROM_STATIC_STRING("Shutdown connectivity owner");
     }
-    GRPC_CLOSURE_SCHED(exec_ctx, w->notify, error);
+    GRPC_CLOSURE_SCHED(w->notify, error);
     gpr_free(w);
   }
   GRPC_ERROR_UNREF(tracker->current_error);
@@ -105,8 +104,8 @@ bool grpc_connectivity_state_has_watchers(
 }
 
 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_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);
@@ -123,7 +122,7 @@ bool grpc_connectivity_state_notify_on_state_change(
   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);
+      GRPC_CLOSURE_SCHED(notify, GRPC_ERROR_CANCELLED);
       tracker->watchers = w->next;
       gpr_free(w);
       return false;
@@ -131,7 +130,7 @@ bool grpc_connectivity_state_notify_on_state_change(
     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);
+        GRPC_CLOSURE_SCHED(notify, GRPC_ERROR_CANCELLED);
         w->next = w->next->next;
         gpr_free(rm_candidate);
         return false;
@@ -142,8 +141,7 @@ bool grpc_connectivity_state_notify_on_state_change(
   } else {
     if (cur != *current) {
       *current = cur;
-      GRPC_CLOSURE_SCHED(exec_ctx, notify,
-                         GRPC_ERROR_REF(tracker->current_error));
+      GRPC_CLOSURE_SCHED(notify, GRPC_ERROR_REF(tracker->current_error));
     } else {
       grpc_connectivity_state_watcher* w =
           (grpc_connectivity_state_watcher*)gpr_malloc(sizeof(*w));
@@ -156,8 +154,7 @@ 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_connectivity_state_tracker* tracker,
                                  grpc_connectivity_state state,
                                  grpc_error* error, const char* reason) {
   grpc_connectivity_state cur =
@@ -195,8 +192,7 @@ void grpc_connectivity_state_set(grpc_exec_ctx* exec_ctx,
       gpr_log(GPR_DEBUG, "NOTIFY: %p %s: %p", tracker, tracker->name,
               w->notify);
     }
-    GRPC_CLOSURE_SCHED(exec_ctx, w->notify,
-                       GRPC_ERROR_REF(tracker->current_error));
+    GRPC_CLOSURE_SCHED(w->notify, GRPC_ERROR_REF(tracker->current_error));
     gpr_free(w);
   }
 }

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

@@ -23,10 +23,6 @@
 #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;
@@ -55,13 +51,11 @@ const char* grpc_connectivity_state_name(grpc_connectivity_state state);
 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);
+void grpc_connectivity_state_destroy(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_connectivity_state_tracker* tracker,
                                  grpc_connectivity_state state,
                                  grpc_error* associated_error,
                                  const char* reason);
@@ -85,11 +79,7 @@ grpc_connectivity_state grpc_connectivity_state_get(
     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);
-
-#ifdef __cplusplus
-}
-#endif
+    grpc_connectivity_state_tracker* tracker, grpc_connectivity_state* current,
+    grpc_closure* notify);
 
 #endif /* GRPC_CORE_LIB_TRANSPORT_CONNECTIVITY_STATE_H */

data/src/core/lib/transport/error_utils.cc

@@ -40,9 +40,9 @@ static grpc_error* recursively_find_error_with_field(grpc_error* error,
   return nullptr;
 }
 
-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,
+void grpc_error_get_status(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.
@@ -65,12 +65,12 @@ void grpc_error_get_status(grpc_exec_ctx* exec_ctx, grpc_error* error,
     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(
-        exec_ctx, (grpc_http2_error_code)integer, deadline);
+    status = grpc_http2_error_to_grpc_status((grpc_http2_error_code)integer,
+                                             deadline);
   }
   if (code != nullptr) *code = status;
 
-  if (error_string != NULL && status != GRPC_STATUS_OK) {
+  if (error_string != nullptr && status != GRPC_STATUS_OK) {
     *error_string = gpr_strdup(grpc_error_string(error));
   }