grpc 1.8.7 → 1.9.0.pre1

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

@@ -26,10 +26,6 @@
 #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
@@ -58,6 +54,7 @@ typedef struct grpc_handshaker grpc_handshaker;
 /// For the on_handshake_done callback, all members are input arguments,
 /// which the callback takes ownership of.
 typedef struct {
+  grpc_pollset_set* interested_parties;
   grpc_endpoint* endpoint;
   grpc_channel_args* args;
   grpc_slice_buffer* read_buffer;
@@ -71,18 +68,17 @@ typedef struct {
 
 typedef struct {
   /// Destroys the handshaker.
-  void (*destroy)(grpc_exec_ctx* exec_ctx, grpc_handshaker* handshaker);
+  void (*destroy)(grpc_handshaker* handshaker);
 
   /// Shuts down the handshaker (e.g., to clean up when the operation is
   /// aborted in the middle).
-  void (*shutdown)(grpc_exec_ctx* exec_ctx, grpc_handshaker* handshaker,
-                   grpc_error* why);
+  void (*shutdown)(grpc_handshaker* handshaker, grpc_error* why);
 
   /// Performs handshaking, modifying \a args as needed (e.g., to
   /// replace \a endpoint with a wrapped endpoint).
   /// When finished, invokes \a on_handshake_done.
   /// \a acceptor will be NULL for client-side handshakers.
-  void (*do_handshake)(grpc_exec_ctx* exec_ctx, grpc_handshaker* handshaker,
+  void (*do_handshake)(grpc_handshaker* handshaker,
                        grpc_tcp_server_acceptor* acceptor,
                        grpc_closure* on_handshake_done,
                        grpc_handshaker_args* args);
@@ -98,12 +94,9 @@ struct grpc_handshaker {
 void grpc_handshaker_init(const grpc_handshaker_vtable* vtable,
                           grpc_handshaker* handshaker);
 
-void grpc_handshaker_destroy(grpc_exec_ctx* exec_ctx,
-                             grpc_handshaker* handshaker);
-void grpc_handshaker_shutdown(grpc_exec_ctx* exec_ctx,
-                              grpc_handshaker* handshaker, grpc_error* why);
-void grpc_handshaker_do_handshake(grpc_exec_ctx* exec_ctx,
-                                  grpc_handshaker* handshaker,
+void grpc_handshaker_destroy(grpc_handshaker* handshaker);
+void grpc_handshaker_shutdown(grpc_handshaker* handshaker, grpc_error* why);
+void grpc_handshaker_do_handshake(grpc_handshaker* handshaker,
                                   grpc_tcp_server_acceptor* acceptor,
                                   grpc_closure* on_handshake_done,
                                   grpc_handshaker_args* args);
@@ -123,23 +116,23 @@ void grpc_handshake_manager_add(grpc_handshake_manager* mgr,
                                 grpc_handshaker* handshaker);
 
 /// Destroys the handshake manager.
-void grpc_handshake_manager_destroy(grpc_exec_ctx* exec_ctx,
-                                    grpc_handshake_manager* mgr);
+void grpc_handshake_manager_destroy(grpc_handshake_manager* mgr);
 
 /// Shuts down the handshake manager (e.g., to clean up when the operation is
 /// aborted in the middle).
 /// The caller must still call grpc_handshake_manager_destroy() after
 /// calling this function.
-void grpc_handshake_manager_shutdown(grpc_exec_ctx* exec_ctx,
-                                     grpc_handshake_manager* mgr,
+void grpc_handshake_manager_shutdown(grpc_handshake_manager* mgr,
                                      grpc_error* why);
 
 /// Invokes handshakers in the order they were added.
+/// \a interested_parties may be non-nullptr to provide a pollset_set that
+/// may be used during handshaking. Ownership is not taken.
 /// Takes ownership of \a endpoint, and then passes that ownership to
 /// the \a on_handshake_done callback.
 /// Does NOT take ownership of \a channel_args.  Instead, makes a copy before
 /// invoking the first handshaker.
-/// \a acceptor will be NULL for client-side handshakers.
+/// \a acceptor will be nullptr for client-side handshakers.
 ///
 /// When done, invokes \a on_handshake_done with a grpc_handshaker_args
 /// object as its argument.  If the callback is invoked with error !=
@@ -147,7 +140,7 @@ void grpc_handshake_manager_shutdown(grpc_exec_ctx* exec_ctx,
 /// the necessary clean-up.  Otherwise, the callback takes ownership of
 /// the arguments.
 void grpc_handshake_manager_do_handshake(
-    grpc_exec_ctx* exec_ctx, grpc_handshake_manager* mgr,
+    grpc_handshake_manager* mgr, grpc_pollset_set* interested_parties,
     grpc_endpoint* endpoint, const grpc_channel_args* channel_args,
     grpc_millis deadline, grpc_tcp_server_acceptor* acceptor,
     grpc_iomgr_cb_func on_handshake_done, void* user_data);
@@ -166,10 +159,6 @@ void grpc_handshake_manager_pending_list_remove(grpc_handshake_manager** head,
 /// Shutdown all pending handshake managers on the server side.
 // Not thread-safe. Caller needs to synchronize.
 void grpc_handshake_manager_pending_list_shutdown_all(
-    grpc_exec_ctx* exec_ctx, grpc_handshake_manager* head, grpc_error* why);
-
-#ifdef __cplusplus
-}
-#endif
+    grpc_handshake_manager* head, grpc_error* why);
 
 #endif /* GRPC_CORE_LIB_CHANNEL_HANDSHAKER_H */

data/src/core/lib/channel/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) {
+    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);
+    handshaker_factory->vtable->add_handshakers(handshaker_factory, args,
+                                                handshake_mgr);
   }
 }
 
 void grpc_handshaker_factory_destroy(
-    grpc_exec_ctx* exec_ctx, grpc_handshaker_factory* handshaker_factory) {
+    grpc_handshaker_factory* handshaker_factory) {
   if (handshaker_factory != nullptr) {
     GPR_ASSERT(handshaker_factory->vtable != nullptr);
-    handshaker_factory->vtable->destroy(exec_ctx, handshaker_factory);
+    handshaker_factory->vtable->destroy(handshaker_factory);
   }
 }

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

@@ -24,21 +24,15 @@
 #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,
+  void (*add_handshakers)(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 (*destroy)(grpc_handshaker_factory* handshaker_factory);
 } grpc_handshaker_factory_vtable;
 
 struct grpc_handshaker_factory {
@@ -46,14 +40,10 @@ struct grpc_handshaker_factory {
 };
 
 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_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);
-
-#ifdef __cplusplus
-}
-#endif
+    grpc_handshaker_factory* handshaker_factory);
 
 #endif /* GRPC_CORE_LIB_CHANNEL_HANDSHAKER_FACTORY_H */

data/src/core/lib/channel/handshaker_registry.cc

@@ -47,18 +47,17 @@ static void grpc_handshaker_factory_list_register(
 }
 
 static void grpc_handshaker_factory_list_add_handshakers(
-    grpc_exec_ctx* exec_ctx, grpc_handshaker_factory_list* list,
-    const grpc_channel_args* args, grpc_handshake_manager* handshake_mgr) {
+    grpc_handshaker_factory_list* list, const grpc_channel_args* args,
+    grpc_handshake_manager* handshake_mgr) {
   for (size_t i = 0; i < list->num_factories; ++i) {
-    grpc_handshaker_factory_add_handshakers(exec_ctx, list->list[i], args,
-                                            handshake_mgr);
+    grpc_handshaker_factory_add_handshakers(list->list[i], args, handshake_mgr);
   }
 }
 
 static void grpc_handshaker_factory_list_destroy(
-    grpc_exec_ctx* exec_ctx, grpc_handshaker_factory_list* list) {
+    grpc_handshaker_factory_list* list) {
   for (size_t i = 0; i < list->num_factories; ++i) {
-    grpc_handshaker_factory_destroy(exec_ctx, list->list[i]);
+    grpc_handshaker_factory_destroy(list->list[i]);
   }
   gpr_free(list->list);
 }
@@ -74,10 +73,9 @@ void grpc_handshaker_factory_registry_init() {
   memset(g_handshaker_factory_lists, 0, sizeof(g_handshaker_factory_lists));
 }
 
-void grpc_handshaker_factory_registry_shutdown(grpc_exec_ctx* exec_ctx) {
+void grpc_handshaker_factory_registry_shutdown() {
   for (size_t i = 0; i < NUM_HANDSHAKER_TYPES; ++i) {
-    grpc_handshaker_factory_list_destroy(exec_ctx,
-                                         &g_handshaker_factory_lists[i]);
+    grpc_handshaker_factory_list_destroy(&g_handshaker_factory_lists[i]);
   }
 }
 
@@ -88,11 +86,9 @@ void grpc_handshaker_factory_register(bool at_start,
       &g_handshaker_factory_lists[handshaker_type], at_start, factory);
 }
 
-void grpc_handshakers_add(grpc_exec_ctx* exec_ctx,
-                          grpc_handshaker_type handshaker_type,
+void grpc_handshakers_add(grpc_handshaker_type handshaker_type,
                           const grpc_channel_args* args,
                           grpc_handshake_manager* handshake_mgr) {
   grpc_handshaker_factory_list_add_handshakers(
-      exec_ctx, &g_handshaker_factory_lists[handshaker_type], args,
-      handshake_mgr);
+      &g_handshaker_factory_lists[handshaker_type], args, handshake_mgr);
 }

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

@@ -24,10 +24,6 @@
 #include "src/core/lib/channel/handshaker_factory.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 typedef enum {
   HANDSHAKER_CLIENT = 0,
   HANDSHAKER_SERVER,
@@ -35,7 +31,7 @@ typedef enum {
 } grpc_handshaker_type;
 
 void grpc_handshaker_factory_registry_init();
-void grpc_handshaker_factory_registry_shutdown(grpc_exec_ctx* exec_ctx);
+void grpc_handshaker_factory_registry_shutdown();
 
 /// Registers a new handshaker factory.  Takes ownership.
 /// If \a at_start is true, the new handshaker will be at the beginning of
@@ -44,13 +40,8 @@ void grpc_handshaker_factory_register(bool at_start,
                                       grpc_handshaker_type handshaker_type,
                                       grpc_handshaker_factory* factory);
 
-void grpc_handshakers_add(grpc_exec_ctx* exec_ctx,
-                          grpc_handshaker_type handshaker_type,
+void grpc_handshakers_add(grpc_handshaker_type handshaker_type,
                           const grpc_channel_args* args,
                           grpc_handshake_manager* handshake_mgr);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_CHANNEL_HANDSHAKER_REGISTRY_H */

data/src/core/lib/compression/algorithm_metadata.h

@@ -22,10 +22,6 @@
 #include <grpc/compression.h>
 #include "src/core/lib/transport/metadata.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /** Return compression algorithm based metadata value */
 grpc_slice grpc_compression_algorithm_slice(
     grpc_compression_algorithm algorithm);
@@ -53,8 +49,4 @@ grpc_compression_algorithm grpc_compression_algorithm_from_slice(
 grpc_stream_compression_algorithm grpc_stream_compression_algorithm_from_slice(
     grpc_slice str);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_COMPRESSION_ALGORITHM_METADATA_H */

data/src/core/lib/compression/message_compress.cc

@@ -29,8 +29,8 @@
 
 #define OUTPUT_BLOCK_SIZE 1024
 
-static int zlib_body(grpc_exec_ctx* exec_ctx, z_stream* zs,
-                     grpc_slice_buffer* input, grpc_slice_buffer* output,
+static int zlib_body(z_stream* zs, grpc_slice_buffer* input,
+                     grpc_slice_buffer* output,
                      int (*flate)(z_stream* zs, int flush)) {
   int r;
   int flush;
@@ -74,7 +74,7 @@ static int zlib_body(grpc_exec_ctx* exec_ctx, z_stream* zs,
   return 1;
 
 error:
-  grpc_slice_unref_internal(exec_ctx, outbuf);
+  grpc_slice_unref_internal(outbuf);
   return 0;
 }
 
@@ -84,8 +84,8 @@ static void* zalloc_gpr(void* opaque, unsigned int items, unsigned int size) {
 
 static void zfree_gpr(void* opaque, void* address) { gpr_free(address); }
 
-static int zlib_compress(grpc_exec_ctx* exec_ctx, grpc_slice_buffer* input,
-                         grpc_slice_buffer* output, int gzip) {
+static int zlib_compress(grpc_slice_buffer* input, grpc_slice_buffer* output,
+                         int gzip) {
   z_stream zs;
   int r;
   size_t i;
@@ -97,11 +97,10 @@ static int zlib_compress(grpc_exec_ctx* exec_ctx, grpc_slice_buffer* input,
   r = deflateInit2(&zs, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 15 | (gzip ? 16 : 0),
                    8, Z_DEFAULT_STRATEGY);
   GPR_ASSERT(r == Z_OK);
-  r = zlib_body(exec_ctx, &zs, input, output, deflate) &&
-      output->length < input->length;
+  r = zlib_body(&zs, input, output, deflate) && output->length < input->length;
   if (!r) {
     for (i = count_before; i < output->count; i++) {
-      grpc_slice_unref_internal(exec_ctx, output->slices[i]);
+      grpc_slice_unref_internal(output->slices[i]);
     }
     output->count = count_before;
     output->length = length_before;
@@ -110,8 +109,8 @@ static int zlib_compress(grpc_exec_ctx* exec_ctx, grpc_slice_buffer* input,
   return r;
 }
 
-static int zlib_decompress(grpc_exec_ctx* exec_ctx, grpc_slice_buffer* input,
-                           grpc_slice_buffer* output, int gzip) {
+static int zlib_decompress(grpc_slice_buffer* input, grpc_slice_buffer* output,
+                           int gzip) {
   z_stream zs;
   int r;
   size_t i;
@@ -122,10 +121,10 @@ static int zlib_decompress(grpc_exec_ctx* exec_ctx, grpc_slice_buffer* input,
   zs.zfree = zfree_gpr;
   r = inflateInit2(&zs, 15 | (gzip ? 16 : 0));
   GPR_ASSERT(r == Z_OK);
-  r = zlib_body(exec_ctx, &zs, input, output, inflate);
+  r = zlib_body(&zs, input, output, inflate);
   if (!r) {
     for (i = count_before; i < output->count; i++) {
-      grpc_slice_unref_internal(exec_ctx, output->slices[i]);
+      grpc_slice_unref_internal(output->slices[i]);
     }
     output->count = count_before;
     output->length = length_before;
@@ -142,8 +141,7 @@ static int copy(grpc_slice_buffer* input, grpc_slice_buffer* output) {
   return 1;
 }
 
-static int compress_inner(grpc_exec_ctx* exec_ctx,
-                          grpc_compression_algorithm algorithm,
+static int compress_inner(grpc_compression_algorithm algorithm,
                           grpc_slice_buffer* input, grpc_slice_buffer* output) {
   switch (algorithm) {
     case GRPC_COMPRESS_NONE:
@@ -151,9 +149,9 @@ static int compress_inner(grpc_exec_ctx* exec_ctx,
          rely on that here */
       return 0;
     case GRPC_COMPRESS_DEFLATE:
-      return zlib_compress(exec_ctx, input, output, 0);
+      return zlib_compress(input, output, 0);
     case GRPC_COMPRESS_GZIP:
-      return zlib_compress(exec_ctx, input, output, 1);
+      return zlib_compress(input, output, 1);
     case GRPC_COMPRESS_ALGORITHMS_COUNT:
       break;
   }
@@ -161,26 +159,24 @@ static int compress_inner(grpc_exec_ctx* exec_ctx,
   return 0;
 }
 
-int grpc_msg_compress(grpc_exec_ctx* exec_ctx,
-                      grpc_compression_algorithm algorithm,
+int grpc_msg_compress(grpc_compression_algorithm algorithm,
                       grpc_slice_buffer* input, grpc_slice_buffer* output) {
-  if (!compress_inner(exec_ctx, algorithm, input, output)) {
+  if (!compress_inner(algorithm, input, output)) {
     copy(input, output);
     return 0;
   }
   return 1;
 }
 
-int grpc_msg_decompress(grpc_exec_ctx* exec_ctx,
-                        grpc_compression_algorithm algorithm,
+int grpc_msg_decompress(grpc_compression_algorithm algorithm,
                         grpc_slice_buffer* input, grpc_slice_buffer* output) {
   switch (algorithm) {
     case GRPC_COMPRESS_NONE:
       return copy(input, output);
     case GRPC_COMPRESS_DEFLATE:
-      return zlib_decompress(exec_ctx, input, output, 0);
+      return zlib_decompress(input, output, 0);
     case GRPC_COMPRESS_GZIP:
-      return zlib_decompress(exec_ctx, input, output, 1);
+      return zlib_decompress(input, output, 1);
     case GRPC_COMPRESS_ALGORITHMS_COUNT:
       break;
   }

data/src/core/lib/compression/message_compress.h

@@ -22,26 +22,16 @@
 #include <grpc/compression.h>
 #include <grpc/slice_buffer.h>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /* compress 'input' to 'output' using 'algorithm'.
    On success, appends compressed slices to output and returns 1.
    On failure, appends uncompressed slices to output and returns 0. */
-int grpc_msg_compress(grpc_exec_ctx* exec_ctx,
-                      grpc_compression_algorithm algorithm,
+int grpc_msg_compress(grpc_compression_algorithm algorithm,
                       grpc_slice_buffer* input, grpc_slice_buffer* output);
 
 /* decompress 'input' to 'output' using 'algorithm'.
    On success, appends slices to output and returns 1.
    On failure, output is unchanged, and returns 0. */
-int grpc_msg_decompress(grpc_exec_ctx* exec_ctx,
-                        grpc_compression_algorithm algorithm,
+int grpc_msg_decompress(grpc_compression_algorithm algorithm,
                         grpc_slice_buffer* input, grpc_slice_buffer* output);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_COMPRESSION_MESSAGE_COMPRESS_H */

data/src/core/lib/compression/stream_compression.cc

@@ -21,7 +21,7 @@
 #include "src/core/lib/compression/stream_compression.h"
 #include "src/core/lib/compression/stream_compression_gzip.h"
 
-extern "C" const grpc_stream_compression_vtable
+extern const grpc_stream_compression_vtable
     grpc_stream_compression_identity_vtable;
 
 bool grpc_stream_compress(grpc_stream_compression_context* ctx,

data/src/core/lib/compression/stream_compression.h

@@ -26,10 +26,6 @@
 
 #include "src/core/lib/transport/static_metadata.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 typedef struct grpc_stream_compression_vtable grpc_stream_compression_vtable;
 
 /* Stream compression/decompression context */
@@ -115,8 +111,4 @@ void grpc_stream_compression_context_destroy(
 int grpc_stream_compression_method_parse(
     grpc_slice value, bool is_compress, grpc_stream_compression_method* method);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif