grpc 1.8.7 → 1.9.0.pre1

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

@@ -21,10 +21,6 @@
 
 #include "src/core/lib/transport/transport.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 typedef struct grpc_transport_vtable {
   /* Memory required for a single stream element - this is allocated by upper
      layers and initialized by the transport */
@@ -34,37 +30,34 @@ typedef struct grpc_transport_vtable {
   const char* name;
 
   /* implementation of grpc_transport_init_stream */
-  int (*init_stream)(grpc_exec_ctx* exec_ctx, grpc_transport* self,
-                     grpc_stream* stream, grpc_stream_refcount* refcount,
-                     const void* server_data, gpr_arena* arena);
+  int (*init_stream)(grpc_transport* self, grpc_stream* stream,
+                     grpc_stream_refcount* refcount, const void* server_data,
+                     gpr_arena* arena);
 
   /* implementation of grpc_transport_set_pollset */
-  void (*set_pollset)(grpc_exec_ctx* exec_ctx, grpc_transport* self,
-                      grpc_stream* stream, grpc_pollset* pollset);
+  void (*set_pollset)(grpc_transport* self, grpc_stream* stream,
+                      grpc_pollset* pollset);
 
   /* implementation of grpc_transport_set_pollset */
-  void (*set_pollset_set)(grpc_exec_ctx* exec_ctx, grpc_transport* self,
-                          grpc_stream* stream, grpc_pollset_set* pollset_set);
+  void (*set_pollset_set)(grpc_transport* self, grpc_stream* stream,
+                          grpc_pollset_set* pollset_set);
 
   /* implementation of grpc_transport_perform_stream_op */
-  void (*perform_stream_op)(grpc_exec_ctx* exec_ctx, grpc_transport* self,
-                            grpc_stream* stream,
+  void (*perform_stream_op)(grpc_transport* self, grpc_stream* stream,
                             grpc_transport_stream_op_batch* op);
 
   /* implementation of grpc_transport_perform_op */
-  void (*perform_op)(grpc_exec_ctx* exec_ctx, grpc_transport* self,
-                     grpc_transport_op* op);
+  void (*perform_op)(grpc_transport* self, grpc_transport_op* op);
 
   /* implementation of grpc_transport_destroy_stream */
-  void (*destroy_stream)(grpc_exec_ctx* exec_ctx, grpc_transport* self,
-                         grpc_stream* stream,
+  void (*destroy_stream)(grpc_transport* self, grpc_stream* stream,
                          grpc_closure* then_schedule_closure);
 
   /* implementation of grpc_transport_destroy */
-  void (*destroy)(grpc_exec_ctx* exec_ctx, grpc_transport* self);
+  void (*destroy)(grpc_transport* self);
 
   /* implementation of grpc_transport_get_endpoint */
-  grpc_endpoint* (*get_endpoint)(grpc_exec_ctx* exec_ctx, grpc_transport* self);
+  grpc_endpoint* (*get_endpoint)(grpc_transport* self);
 } grpc_transport_vtable;
 
 /* an instance of a grpc transport */
@@ -73,8 +66,4 @@ struct grpc_transport {
   const grpc_transport_vtable* vtable;
 };
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_TRANSPORT_TRANSPORT_IMPL_H */

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

@@ -28,8 +28,8 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 #include <grpc/support/useful.h>
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
-#include "src/core/lib/support/string.h"
 #include "src/core/lib/transport/connectivity_state.h"
 
 /* These routines are here to facilitate debugging - they produce string
@@ -187,7 +187,7 @@ char* grpc_transport_op_string(grpc_transport_op* op) {
     gpr_strvec_add(&b, gpr_strdup("BIND_POLLSET_SET"));
   }
 
-  if (op->send_ping != nullptr) {
+  if (op->send_ping.on_initiate != nullptr || op->send_ping.on_ack != nullptr) {
     if (!first) gpr_strvec_add(&b, gpr_strdup(" "));
     // first = false;
     gpr_strvec_add(&b, gpr_strdup("SEND_PING"));

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -18,40 +18,40 @@
 
 #include <grpc/grpc.h>
 
-extern "C" void grpc_http_filters_init(void);
-extern "C" void grpc_http_filters_shutdown(void);
-extern "C" void grpc_chttp2_plugin_init(void);
-extern "C" void grpc_chttp2_plugin_shutdown(void);
-extern "C" void grpc_tsi_gts_init(void);
-extern "C" void grpc_tsi_gts_shutdown(void);
-extern "C" void grpc_deadline_filter_init(void);
-extern "C" void grpc_deadline_filter_shutdown(void);
-extern "C" void grpc_client_channel_init(void);
-extern "C" void grpc_client_channel_shutdown(void);
-extern "C" void grpc_inproc_plugin_init(void);
-extern "C" void grpc_inproc_plugin_shutdown(void);
-extern "C" void grpc_resolver_fake_init(void);
-extern "C" void grpc_resolver_fake_shutdown(void);
-extern "C" void grpc_lb_policy_grpclb_init(void);
-extern "C" void grpc_lb_policy_grpclb_shutdown(void);
-extern "C" void grpc_lb_policy_pick_first_init(void);
-extern "C" void grpc_lb_policy_pick_first_shutdown(void);
-extern "C" void grpc_lb_policy_round_robin_init(void);
-extern "C" void grpc_lb_policy_round_robin_shutdown(void);
-extern "C" void grpc_resolver_dns_ares_init(void);
-extern "C" void grpc_resolver_dns_ares_shutdown(void);
-extern "C" void grpc_resolver_dns_native_init(void);
-extern "C" void grpc_resolver_dns_native_shutdown(void);
-extern "C" void grpc_resolver_sockaddr_init(void);
-extern "C" void grpc_resolver_sockaddr_shutdown(void);
-extern "C" void grpc_server_load_reporting_plugin_init(void);
-extern "C" void grpc_server_load_reporting_plugin_shutdown(void);
-extern "C" void grpc_max_age_filter_init(void);
-extern "C" void grpc_max_age_filter_shutdown(void);
-extern "C" void grpc_message_size_filter_init(void);
-extern "C" void grpc_message_size_filter_shutdown(void);
-extern "C" void grpc_workaround_cronet_compression_filter_init(void);
-extern "C" void grpc_workaround_cronet_compression_filter_shutdown(void);
+void grpc_http_filters_init(void);
+void grpc_http_filters_shutdown(void);
+void grpc_chttp2_plugin_init(void);
+void grpc_chttp2_plugin_shutdown(void);
+void grpc_tsi_gts_init(void);
+void grpc_tsi_gts_shutdown(void);
+void grpc_deadline_filter_init(void);
+void grpc_deadline_filter_shutdown(void);
+void grpc_client_channel_init(void);
+void grpc_client_channel_shutdown(void);
+void grpc_inproc_plugin_init(void);
+void grpc_inproc_plugin_shutdown(void);
+void grpc_resolver_fake_init(void);
+void grpc_resolver_fake_shutdown(void);
+void grpc_lb_policy_grpclb_init(void);
+void grpc_lb_policy_grpclb_shutdown(void);
+void grpc_lb_policy_pick_first_init(void);
+void grpc_lb_policy_pick_first_shutdown(void);
+void grpc_lb_policy_round_robin_init(void);
+void grpc_lb_policy_round_robin_shutdown(void);
+void grpc_resolver_dns_ares_init(void);
+void grpc_resolver_dns_ares_shutdown(void);
+void grpc_resolver_dns_native_init(void);
+void grpc_resolver_dns_native_shutdown(void);
+void grpc_resolver_sockaddr_init(void);
+void grpc_resolver_sockaddr_shutdown(void);
+void grpc_server_load_reporting_plugin_init(void);
+void grpc_server_load_reporting_plugin_shutdown(void);
+void grpc_max_age_filter_init(void);
+void grpc_max_age_filter_shutdown(void);
+void grpc_message_size_filter_init(void);
+void grpc_message_size_filter_shutdown(void);
+void grpc_workaround_cronet_compression_filter_init(void);
+void grpc_workaround_cronet_compression_filter_shutdown(void);
 
 void grpc_register_built_in_plugins(void) {
   grpc_register_plugin(grpc_http_filters_init,

data/src/core/tsi/fake_transport_security.cc

@@ -399,8 +399,7 @@ static const tsi_frame_protector_vtable frame_protector_vtable = {
 /* --- tsi_zero_copy_grpc_protector methods implementation. ---*/
 
 static tsi_result fake_zero_copy_grpc_protector_protect(
-    grpc_exec_ctx* exec_ctx, tsi_zero_copy_grpc_protector* self,
-    grpc_slice_buffer* unprotected_slices,
+    tsi_zero_copy_grpc_protector* self, grpc_slice_buffer* unprotected_slices,
     grpc_slice_buffer* protected_slices) {
   if (self == nullptr || unprotected_slices == nullptr ||
       protected_slices == nullptr) {
@@ -424,8 +423,7 @@ static tsi_result fake_zero_copy_grpc_protector_protect(
 }
 
 static tsi_result fake_zero_copy_grpc_protector_unprotect(
-    grpc_exec_ctx* exec_ctx, tsi_zero_copy_grpc_protector* self,
-    grpc_slice_buffer* protected_slices,
+    tsi_zero_copy_grpc_protector* self, grpc_slice_buffer* protected_slices,
     grpc_slice_buffer* unprotected_slices) {
   if (self == nullptr || unprotected_slices == nullptr ||
       protected_slices == nullptr) {
@@ -454,18 +452,18 @@ static tsi_result fake_zero_copy_grpc_protector_unprotect(
         impl->parsed_frame_size - TSI_FAKE_FRAME_HEADER_SIZE,
         unprotected_slices);
     impl->parsed_frame_size = 0;
-    grpc_slice_buffer_reset_and_unref_internal(exec_ctx, &impl->header_sb);
+    grpc_slice_buffer_reset_and_unref_internal(&impl->header_sb);
   }
   return TSI_OK;
 }
 
 static void fake_zero_copy_grpc_protector_destroy(
-    grpc_exec_ctx* exec_ctx, tsi_zero_copy_grpc_protector* self) {
+    tsi_zero_copy_grpc_protector* self) {
   if (self == nullptr) return;
   tsi_fake_zero_copy_grpc_protector* impl =
       (tsi_fake_zero_copy_grpc_protector*)self;
-  grpc_slice_buffer_destroy_internal(exec_ctx, &impl->header_sb);
-  grpc_slice_buffer_destroy_internal(exec_ctx, &impl->protected_sb);
+  grpc_slice_buffer_destroy_internal(&impl->header_sb);
+  grpc_slice_buffer_destroy_internal(&impl->protected_sb);
   gpr_free(impl);
 }
 
@@ -497,8 +495,7 @@ static tsi_result fake_handshaker_result_extract_peer(
 }
 
 static tsi_result fake_handshaker_result_create_zero_copy_grpc_protector(
-    void* exec_ctx, const tsi_handshaker_result* self,
-    size_t* max_output_protected_frame_size,
+    const tsi_handshaker_result* self, size_t* max_output_protected_frame_size,
     tsi_zero_copy_grpc_protector** protector) {
   *protector =
       tsi_create_fake_zero_copy_grpc_protector(max_output_protected_frame_size);

data/src/core/tsi/fake_transport_security.h

@@ -21,10 +21,6 @@
 
 #include "src/core/tsi/transport_security_interface.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /* Value for the TSI_CERTIFICATE_TYPE_PEER_PROPERTY property for FAKE certs. */
 #define TSI_FAKE_CERTIFICATE_TYPE "FAKE"
 
@@ -44,8 +40,4 @@ tsi_frame_protector* tsi_create_fake_frame_protector(
 tsi_zero_copy_grpc_protector* tsi_create_fake_zero_copy_grpc_protector(
     size_t* max_protected_frame_size);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_TSI_FAKE_TRANSPORT_SECURITY_H */

data/src/core/tsi/gts_transport_security.cc

@@ -24,12 +24,12 @@ static gts_shared_resource g_gts_resource;
 
 gts_shared_resource* gts_get_shared_resource(void) { return &g_gts_resource; }
 
-extern "C" void grpc_tsi_gts_init() {
+void grpc_tsi_gts_init() {
   memset(&g_gts_resource, 0, sizeof(gts_shared_resource));
   gpr_mu_init(&g_gts_resource.mu);
 }
 
-extern "C" void grpc_tsi_gts_shutdown() {
+void grpc_tsi_gts_shutdown() {
   gpr_mu_destroy(&g_gts_resource.mu);
   if (g_gts_resource.cq == nullptr) {
     return;

data/src/core/tsi/gts_transport_security.h

@@ -23,10 +23,6 @@
 #include <grpc/support/sync.h>
 #include <grpc/support/thd.h>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 typedef struct gts_shared_resource {
   gpr_thd_id thread_id;
   grpc_channel* channel;
@@ -38,8 +34,4 @@ typedef struct gts_shared_resource {
  *    TSI handshakes. */
 gts_shared_resource* gts_get_shared_resource(void);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_TSI_GTS_TRANSPORT_SECURITY_H */

data/src/core/tsi/ssl_transport_security.cc

@@ -116,6 +116,9 @@ typedef struct {
 
 static gpr_once init_openssl_once = GPR_ONCE_INIT;
 static gpr_mu* openssl_mutexes = nullptr;
+static void openssl_locking_cb(int mode, int type, const char* file,
+                               int line) GRPC_UNUSED;
+static unsigned long openssl_thread_id_cb(void) GRPC_UNUSED;
 
 static void openssl_locking_cb(int mode, int type, const char* file, int line) {
   if (mode & CRYPTO_LOCK) {

data/src/core/tsi/ssl_transport_security.h

@@ -21,10 +21,6 @@
 
 #include "src/core/tsi/transport_security_interface.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /* Value for the TSI_CERTIFICATE_TYPE_PEER_PROPERTY property for X509 certs. */
 #define TSI_X509_CERTIFICATE_TYPE "X509"
 
@@ -193,8 +189,4 @@ const tsi_ssl_handshaker_factory_vtable* tsi_ssl_handshaker_factory_swap_vtable(
     tsi_ssl_handshaker_factory* factory,
     tsi_ssl_handshaker_factory_vtable* new_vtable);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_TSI_SSL_TRANSPORT_SECURITY_H */

data/src/core/tsi/ssl_types.h

@@ -19,10 +19,6 @@
 #ifndef GRPC_CORE_TSI_SSL_TYPES_H
 #define GRPC_CORE_TSI_SSL_TYPES_H
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /* A collection of macros to cast between various integer types that are
  * used differently between BoringSSL and OpenSSL:
  * TSI_INT_AS_SIZE(x):  convert 'int x' to a length parameter for an OpenSSL
@@ -41,8 +37,4 @@ extern "C" {
 #define TSI_SIZE_AS_SIZE(x) ((int)(x))
 #endif
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_TSI_SSL_TYPES_H */

data/src/core/tsi/transport_security.h

@@ -24,10 +24,6 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/tsi/transport_security_interface.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 extern grpc_core::TraceFlag tsi_tracing_enabled;
 
 /* Base for tsi_frame_protector implementations.
@@ -94,7 +90,7 @@ struct tsi_handshaker {
 typedef struct {
   tsi_result (*extract_peer)(const tsi_handshaker_result* self, tsi_peer* peer);
   tsi_result (*create_zero_copy_grpc_protector)(
-      void* exec_ctx, const tsi_handshaker_result* self,
+      const tsi_handshaker_result* self,
       size_t* max_output_protected_frame_size,
       tsi_zero_copy_grpc_protector** protector);
   tsi_result (*create_frame_protector)(const tsi_handshaker_result* self,
@@ -126,8 +122,4 @@ tsi_result tsi_construct_string_peer_property_from_cstring(
 /* Utils. */
 char* tsi_strdup(const char* src); /* Sadly, no strdup in C89. */
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_TSI_TRANSPORT_SECURITY_H */

data/src/core/tsi/transport_security_adapter.h

@@ -21,10 +21,6 @@
 
 #include "src/core/tsi/transport_security_interface.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /* Create a tsi handshaker that takes an implementation of old interface and
    converts into an implementation of new interface. In the old interface,
    there are get_bytes_to_send_to_peer, process_bytes_from_peer, get_result,
@@ -40,8 +36,4 @@ tsi_handshaker* tsi_create_adapter_handshaker(tsi_handshaker* wrapped);
    the caller. */
 tsi_handshaker* tsi_adapter_handshaker_get_wrapped(tsi_handshaker* adapter);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_TSI_TRANSPORT_SECURITY_ADAPTER_H */

data/src/core/tsi/transport_security_grpc.cc

@@ -20,18 +20,16 @@
 
 /* This method creates a tsi_zero_copy_grpc_protector object.  */
 tsi_result tsi_handshaker_result_create_zero_copy_grpc_protector(
-    grpc_exec_ctx* exec_ctx, const tsi_handshaker_result* self,
-    size_t* max_output_protected_frame_size,
+    const tsi_handshaker_result* self, size_t* max_output_protected_frame_size,
     tsi_zero_copy_grpc_protector** protector) {
-  if (exec_ctx == nullptr || self == nullptr || self->vtable == nullptr ||
-      protector == nullptr) {
+  if (self == nullptr || self->vtable == nullptr || protector == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
   if (self->vtable->create_zero_copy_grpc_protector == nullptr) {
     return TSI_UNIMPLEMENTED;
   }
   return self->vtable->create_zero_copy_grpc_protector(
-      exec_ctx, self, max_output_protected_frame_size, protector);
+      self, max_output_protected_frame_size, protector);
 }
 
 /* --- tsi_zero_copy_grpc_protector common implementation. ---
@@ -39,33 +37,28 @@ tsi_result tsi_handshaker_result_create_zero_copy_grpc_protector(
    Calls specific implementation after state/input validation. */
 
 tsi_result tsi_zero_copy_grpc_protector_protect(
-    grpc_exec_ctx* exec_ctx, tsi_zero_copy_grpc_protector* self,
-    grpc_slice_buffer* unprotected_slices,
+    tsi_zero_copy_grpc_protector* self, grpc_slice_buffer* unprotected_slices,
     grpc_slice_buffer* protected_slices) {
-  if (exec_ctx == nullptr || self == nullptr || self->vtable == nullptr ||
+  if (self == nullptr || self->vtable == nullptr ||
       unprotected_slices == nullptr || protected_slices == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
   if (self->vtable->protect == nullptr) return TSI_UNIMPLEMENTED;
-  return self->vtable->protect(exec_ctx, self, unprotected_slices,
-                               protected_slices);
+  return self->vtable->protect(self, unprotected_slices, protected_slices);
 }
 
 tsi_result tsi_zero_copy_grpc_protector_unprotect(
-    grpc_exec_ctx* exec_ctx, tsi_zero_copy_grpc_protector* self,
-    grpc_slice_buffer* protected_slices,
+    tsi_zero_copy_grpc_protector* self, grpc_slice_buffer* protected_slices,
     grpc_slice_buffer* unprotected_slices) {
-  if (exec_ctx == nullptr || self == nullptr || self->vtable == nullptr ||
+  if (self == nullptr || self->vtable == nullptr ||
       protected_slices == nullptr || unprotected_slices == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
   if (self->vtable->unprotect == nullptr) return TSI_UNIMPLEMENTED;
-  return self->vtable->unprotect(exec_ctx, self, protected_slices,
-                                 unprotected_slices);
+  return self->vtable->unprotect(self, protected_slices, unprotected_slices);
 }
 
-void tsi_zero_copy_grpc_protector_destroy(grpc_exec_ctx* exec_ctx,
-                                          tsi_zero_copy_grpc_protector* self) {
+void tsi_zero_copy_grpc_protector_destroy(tsi_zero_copy_grpc_protector* self) {
   if (self == nullptr) return;
-  self->vtable->destroy(exec_ctx, self);
+  self->vtable->destroy(self);
 }

data/src/core/tsi/transport_security_grpc.h

@@ -22,16 +22,11 @@
 #include <grpc/slice_buffer.h>
 #include "src/core/tsi/transport_security.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /* This method creates a tsi_zero_copy_grpc_protector object. It return TSI_OK
    assuming there is no fatal error.
    The caller is responsible for destroying the protector.  */
 tsi_result tsi_handshaker_result_create_zero_copy_grpc_protector(
-    grpc_exec_ctx* exec_ctx, const tsi_handshaker_result* self,
-    size_t* max_output_protected_frame_size,
+    const tsi_handshaker_result* self, size_t* max_output_protected_frame_size,
     tsi_zero_copy_grpc_protector** protector);
 
 /* -- tsi_zero_copy_grpc_protector object --  */
@@ -43,8 +38,8 @@ tsi_result tsi_handshaker_result_create_zero_copy_grpc_protector(
    - This method returns TSI_OK in case of success or a specific error code in
      case of failure.  */
 tsi_result tsi_zero_copy_grpc_protector_protect(
-    grpc_exec_ctx* exec_ctx, tsi_zero_copy_grpc_protector* self,
-    grpc_slice_buffer* unprotected_slices, grpc_slice_buffer* protected_slices);
+    tsi_zero_copy_grpc_protector* self, grpc_slice_buffer* unprotected_slices,
+    grpc_slice_buffer* protected_slices);
 
 /* Outputs unprotected bytes.
    - protected_slices is the bytes of protected frames.
@@ -53,32 +48,25 @@ tsi_result tsi_zero_copy_grpc_protector_protect(
      there is not enough data to output in which case unprotected_slices has 0
      bytes.  */
 tsi_result tsi_zero_copy_grpc_protector_unprotect(
-    grpc_exec_ctx* exec_ctx, tsi_zero_copy_grpc_protector* self,
-    grpc_slice_buffer* protected_slices, grpc_slice_buffer* unprotected_slices);
+    tsi_zero_copy_grpc_protector* self, grpc_slice_buffer* protected_slices,
+    grpc_slice_buffer* unprotected_slices);
 
 /* Destroys the tsi_zero_copy_grpc_protector object.  */
-void tsi_zero_copy_grpc_protector_destroy(grpc_exec_ctx* exec_ctx,
-                                          tsi_zero_copy_grpc_protector* self);
+void tsi_zero_copy_grpc_protector_destroy(tsi_zero_copy_grpc_protector* self);
 
 /* Base for tsi_zero_copy_grpc_protector implementations.  */
 typedef struct {
-  tsi_result (*protect)(grpc_exec_ctx* exec_ctx,
-                        tsi_zero_copy_grpc_protector* self,
+  tsi_result (*protect)(tsi_zero_copy_grpc_protector* self,
                         grpc_slice_buffer* unprotected_slices,
                         grpc_slice_buffer* protected_slices);
-  tsi_result (*unprotect)(grpc_exec_ctx* exec_ctx,
-                          tsi_zero_copy_grpc_protector* self,
+  tsi_result (*unprotect)(tsi_zero_copy_grpc_protector* self,
                           grpc_slice_buffer* protected_slices,
                           grpc_slice_buffer* unprotected_slices);
-  void (*destroy)(grpc_exec_ctx* exec_ctx, tsi_zero_copy_grpc_protector* self);
+  void (*destroy)(tsi_zero_copy_grpc_protector* self);
 } tsi_zero_copy_grpc_protector_vtable;
 
 struct tsi_zero_copy_grpc_protector {
   const tsi_zero_copy_grpc_protector_vtable* vtable;
 };
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_TSI_TRANSPORT_SECURITY_GRPC_H */