grpc 1.8.7 → 1.9.0.pre1

data/src/core/lib/security/credentials/composite/composite_credentials.h

@@ -21,10 +21,6 @@
 
 #include "src/core/lib/security/credentials/credentials.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 typedef struct {
   grpc_call_credentials** creds_array;
   size_t num_creds;
@@ -57,9 +53,5 @@ typedef struct {
   grpc_call_credentials_array inner;
 } grpc_composite_call_credentials;
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_SECURITY_CREDENTIALS_COMPOSITE_COMPOSITE_CREDENTIALS_H \
         */

data/src/core/lib/security/credentials/credentials.cc

@@ -22,11 +22,11 @@
 #include <string.h>
 
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/http/httpcli.h"
 #include "src/core/lib/http/parser.h"
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/json/json.h"
-#include "src/core/lib/support/string.h"
 #include "src/core/lib/surface/api_trace.h"
 
 #include <grpc/support/alloc.h>
@@ -47,8 +47,8 @@ grpc_credentials_metadata_request* grpc_credentials_metadata_request_create(
 }
 
 void grpc_credentials_metadata_request_destroy(
-    grpc_exec_ctx* exec_ctx, grpc_credentials_metadata_request* r) {
-  grpc_call_credentials_unref(exec_ctx, r->creds);
+    grpc_credentials_metadata_request* r) {
+  grpc_call_credentials_unref(r->creds);
   grpc_http_response_destroy(&r->response);
   gpr_free(r);
 }
@@ -60,12 +60,11 @@ grpc_channel_credentials* grpc_channel_credentials_ref(
   return creds;
 }
 
-void grpc_channel_credentials_unref(grpc_exec_ctx* exec_ctx,
-                                    grpc_channel_credentials* creds) {
+void grpc_channel_credentials_unref(grpc_channel_credentials* creds) {
   if (creds == nullptr) return;
   if (gpr_unref(&creds->refcount)) {
     if (creds->vtable->destruct != nullptr) {
-      creds->vtable->destruct(exec_ctx, creds);
+      creds->vtable->destruct(creds);
     }
     gpr_free(creds);
   }
@@ -73,9 +72,8 @@ void grpc_channel_credentials_unref(grpc_exec_ctx* exec_ctx,
 
 void grpc_channel_credentials_release(grpc_channel_credentials* creds) {
   GRPC_API_TRACE("grpc_channel_credentials_release(creds=%p)", 1, (creds));
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_channel_credentials_unref(&exec_ctx, creds);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_core::ExecCtx exec_ctx;
+  grpc_channel_credentials_unref(creds);
 }
 
 grpc_call_credentials* grpc_call_credentials_ref(grpc_call_credentials* creds) {
@@ -84,12 +82,11 @@ grpc_call_credentials* grpc_call_credentials_ref(grpc_call_credentials* creds) {
   return creds;
 }
 
-void grpc_call_credentials_unref(grpc_exec_ctx* exec_ctx,
-                                 grpc_call_credentials* creds) {
+void grpc_call_credentials_unref(grpc_call_credentials* creds) {
   if (creds == nullptr) return;
   if (gpr_unref(&creds->refcount)) {
     if (creds->vtable->destruct != nullptr) {
-      creds->vtable->destruct(exec_ctx, creds);
+      creds->vtable->destruct(creds);
     }
     gpr_free(creds);
   }
@@ -97,44 +94,42 @@ void grpc_call_credentials_unref(grpc_exec_ctx* exec_ctx,
 
 void grpc_call_credentials_release(grpc_call_credentials* creds) {
   GRPC_API_TRACE("grpc_call_credentials_release(creds=%p)", 1, (creds));
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_call_credentials_unref(&exec_ctx, creds);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_core::ExecCtx exec_ctx;
+  grpc_call_credentials_unref(creds);
 }
 
 bool grpc_call_credentials_get_request_metadata(
-    grpc_exec_ctx* exec_ctx, grpc_call_credentials* creds,
-    grpc_polling_entity* pollent, grpc_auth_metadata_context context,
-    grpc_credentials_mdelem_array* md_array, grpc_closure* on_request_metadata,
-    grpc_error** error) {
+    grpc_call_credentials* creds, grpc_polling_entity* pollent,
+    grpc_auth_metadata_context context, grpc_credentials_mdelem_array* md_array,
+    grpc_closure* on_request_metadata, grpc_error** error) {
   if (creds == nullptr || creds->vtable->get_request_metadata == nullptr) {
     return true;
   }
-  return creds->vtable->get_request_metadata(
-      exec_ctx, creds, pollent, context, md_array, on_request_metadata, error);
+  return creds->vtable->get_request_metadata(creds, pollent, context, md_array,
+                                             on_request_metadata, error);
 }
 
 void grpc_call_credentials_cancel_get_request_metadata(
-    grpc_exec_ctx* exec_ctx, grpc_call_credentials* creds,
-    grpc_credentials_mdelem_array* md_array, grpc_error* error) {
+    grpc_call_credentials* creds, grpc_credentials_mdelem_array* md_array,
+    grpc_error* error) {
   if (creds == nullptr ||
       creds->vtable->cancel_get_request_metadata == nullptr) {
     return;
   }
-  creds->vtable->cancel_get_request_metadata(exec_ctx, creds, md_array, error);
+  creds->vtable->cancel_get_request_metadata(creds, md_array, error);
 }
 
 grpc_security_status grpc_channel_credentials_create_security_connector(
-    grpc_exec_ctx* exec_ctx, grpc_channel_credentials* channel_creds,
-    const char* target, const grpc_channel_args* args,
-    grpc_channel_security_connector** sc, grpc_channel_args** new_args) {
+    grpc_channel_credentials* channel_creds, const char* target,
+    const grpc_channel_args* args, grpc_channel_security_connector** sc,
+    grpc_channel_args** new_args) {
   *new_args = nullptr;
   if (channel_creds == nullptr) {
     return GRPC_SECURITY_ERROR;
   }
   GPR_ASSERT(channel_creds->vtable->create_security_connector != nullptr);
   return channel_creds->vtable->create_security_connector(
-      exec_ctx, channel_creds, nullptr, target, args, sc, new_args);
+      channel_creds, nullptr, target, args, sc, new_args);
 }
 
 grpc_channel_credentials*
@@ -149,8 +144,8 @@ grpc_channel_credentials_duplicate_without_call_credentials(
   }
 }
 
-static void credentials_pointer_arg_destroy(grpc_exec_ctx* exec_ctx, void* p) {
-  grpc_channel_credentials_unref(exec_ctx, (grpc_channel_credentials*)p);
+static void credentials_pointer_arg_destroy(void* p) {
+  grpc_channel_credentials_unref((grpc_channel_credentials*)p);
 }
 
 static void* credentials_pointer_arg_copy(void* p) {
@@ -200,12 +195,11 @@ grpc_server_credentials* grpc_server_credentials_ref(
   return creds;
 }
 
-void grpc_server_credentials_unref(grpc_exec_ctx* exec_ctx,
-                                   grpc_server_credentials* creds) {
+void grpc_server_credentials_unref(grpc_server_credentials* creds) {
   if (creds == nullptr) return;
   if (gpr_unref(&creds->refcount)) {
     if (creds->vtable->destruct != nullptr) {
-      creds->vtable->destruct(exec_ctx, creds);
+      creds->vtable->destruct(creds);
     }
     if (creds->processor.destroy != nullptr &&
         creds->processor.state != nullptr) {
@@ -217,19 +211,17 @@ void grpc_server_credentials_unref(grpc_exec_ctx* exec_ctx,
 
 void grpc_server_credentials_release(grpc_server_credentials* creds) {
   GRPC_API_TRACE("grpc_server_credentials_release(creds=%p)", 1, (creds));
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_server_credentials_unref(&exec_ctx, creds);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_core::ExecCtx exec_ctx;
+  grpc_server_credentials_unref(creds);
 }
 
 grpc_security_status grpc_server_credentials_create_security_connector(
-    grpc_exec_ctx* exec_ctx, grpc_server_credentials* creds,
-    grpc_server_security_connector** sc) {
+    grpc_server_credentials* creds, grpc_server_security_connector** sc) {
   if (creds == nullptr || creds->vtable->create_security_connector == nullptr) {
     gpr_log(GPR_ERROR, "Server credentials cannot create security context.");
     return GRPC_SECURITY_ERROR;
   }
-  return creds->vtable->create_security_connector(exec_ctx, creds, sc);
+  return creds->vtable->create_security_connector(creds, sc);
 }
 
 void grpc_server_credentials_set_auth_metadata_processor(
@@ -247,9 +239,8 @@ void grpc_server_credentials_set_auth_metadata_processor(
   creds->processor = processor;
 }
 
-static void server_credentials_pointer_arg_destroy(grpc_exec_ctx* exec_ctx,
-                                                   void* p) {
-  grpc_server_credentials_unref(exec_ctx, (grpc_server_credentials*)p);
+static void server_credentials_pointer_arg_destroy(void* p) {
+  grpc_server_credentials_unref((grpc_server_credentials*)p);
 }
 
 static void* server_credentials_pointer_arg_copy(void* p) {

data/src/core/lib/security/credentials/credentials.h

@@ -29,10 +29,6 @@
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/security/transport/security_connector.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 struct grpc_http_response;
 
 /* --- Constants. --- */
@@ -92,13 +88,12 @@ void grpc_override_well_known_credentials_path_getter(
 #define GRPC_ARG_CHANNEL_CREDENTIALS "grpc.channel_credentials"
 
 typedef struct {
-  void (*destruct)(grpc_exec_ctx* exec_ctx, grpc_channel_credentials* c);
+  void (*destruct)(grpc_channel_credentials* c);
 
   grpc_security_status (*create_security_connector)(
-      grpc_exec_ctx* exec_ctx, grpc_channel_credentials* c,
-      grpc_call_credentials* call_creds, const char* target,
-      const grpc_channel_args* args, grpc_channel_security_connector** sc,
-      grpc_channel_args** new_args);
+      grpc_channel_credentials* c, grpc_call_credentials* call_creds,
+      const char* target, const grpc_channel_args* args,
+      grpc_channel_security_connector** sc, grpc_channel_args** new_args);
 
   grpc_channel_credentials* (*duplicate_without_call_credentials)(
       grpc_channel_credentials* c);
@@ -112,17 +107,16 @@ struct grpc_channel_credentials {
 
 grpc_channel_credentials* grpc_channel_credentials_ref(
     grpc_channel_credentials* creds);
-void grpc_channel_credentials_unref(grpc_exec_ctx* exec_ctx,
-                                    grpc_channel_credentials* creds);
+void grpc_channel_credentials_unref(grpc_channel_credentials* creds);
 
 /* Creates a security connector for the channel. May also create new channel
    args for the channel to be used in place of the passed in const args if
    returned non NULL. In that case the caller is responsible for destroying
    new_args after channel creation. */
 grpc_security_status grpc_channel_credentials_create_security_connector(
-    grpc_exec_ctx* exec_ctx, grpc_channel_credentials* creds,
-    const char* target, const grpc_channel_args* args,
-    grpc_channel_security_connector** sc, grpc_channel_args** new_args);
+    grpc_channel_credentials* creds, const char* target,
+    const grpc_channel_args* args, grpc_channel_security_connector** sc,
+    grpc_channel_args** new_args);
 
 /* Creates a version of the channel credentials without any attached call
    credentials. This can be used in order to open a channel to a non-trusted
@@ -157,22 +151,19 @@ void grpc_credentials_mdelem_array_add(grpc_credentials_mdelem_array* list,
 void grpc_credentials_mdelem_array_append(grpc_credentials_mdelem_array* dst,
                                           grpc_credentials_mdelem_array* src);
 
-void grpc_credentials_mdelem_array_destroy(grpc_exec_ctx* exec_ctx,
-                                           grpc_credentials_mdelem_array* list);
+void grpc_credentials_mdelem_array_destroy(grpc_credentials_mdelem_array* list);
 
 /* --- grpc_call_credentials. --- */
 
 typedef struct {
-  void (*destruct)(grpc_exec_ctx* exec_ctx, grpc_call_credentials* c);
-  bool (*get_request_metadata)(grpc_exec_ctx* exec_ctx,
-                               grpc_call_credentials* c,
+  void (*destruct)(grpc_call_credentials* c);
+  bool (*get_request_metadata)(grpc_call_credentials* c,
                                grpc_polling_entity* pollent,
                                grpc_auth_metadata_context context,
                                grpc_credentials_mdelem_array* md_array,
                                grpc_closure* on_request_metadata,
                                grpc_error** error);
-  void (*cancel_get_request_metadata)(grpc_exec_ctx* exec_ctx,
-                                      grpc_call_credentials* c,
+  void (*cancel_get_request_metadata)(grpc_call_credentials* c,
                                       grpc_credentials_mdelem_array* md_array,
                                       grpc_error* error);
 } grpc_call_credentials_vtable;
@@ -184,39 +175,35 @@ struct grpc_call_credentials {
 };
 
 grpc_call_credentials* grpc_call_credentials_ref(grpc_call_credentials* creds);
-void grpc_call_credentials_unref(grpc_exec_ctx* exec_ctx,
-                                 grpc_call_credentials* creds);
+void grpc_call_credentials_unref(grpc_call_credentials* creds);
 
 /// Returns true if completed synchronously, in which case \a error will
 /// be set to indicate the result.  Otherwise, \a on_request_metadata will
 /// be invoked asynchronously when complete.  \a md_array will be populated
 /// with the resulting metadata once complete.
 bool grpc_call_credentials_get_request_metadata(
-    grpc_exec_ctx* exec_ctx, grpc_call_credentials* creds,
-    grpc_polling_entity* pollent, grpc_auth_metadata_context context,
-    grpc_credentials_mdelem_array* md_array, grpc_closure* on_request_metadata,
-    grpc_error** error);
+    grpc_call_credentials* creds, grpc_polling_entity* pollent,
+    grpc_auth_metadata_context context, grpc_credentials_mdelem_array* md_array,
+    grpc_closure* on_request_metadata, grpc_error** error);
 
 /// Cancels a pending asynchronous operation started by
 /// grpc_call_credentials_get_request_metadata() with the corresponding
 /// value of \a md_array.
 void grpc_call_credentials_cancel_get_request_metadata(
-    grpc_exec_ctx* exec_ctx, grpc_call_credentials* c,
-    grpc_credentials_mdelem_array* md_array, grpc_error* error);
+    grpc_call_credentials* c, grpc_credentials_mdelem_array* md_array,
+    grpc_error* error);
 
 /* Metadata-only credentials with the specified key and value where
    asynchronicity can be simulated for testing. */
 grpc_call_credentials* grpc_md_only_test_credentials_create(
-    grpc_exec_ctx* exec_ctx, const char* md_key, const char* md_value,
-    bool is_async);
+    const char* md_key, const char* md_value, bool is_async);
 
 /* --- grpc_server_credentials. --- */
 
 typedef struct {
-  void (*destruct)(grpc_exec_ctx* exec_ctx, grpc_server_credentials* c);
+  void (*destruct)(grpc_server_credentials* c);
   grpc_security_status (*create_security_connector)(
-      grpc_exec_ctx* exec_ctx, grpc_server_credentials* c,
-      grpc_server_security_connector** sc);
+      grpc_server_credentials* c, grpc_server_security_connector** sc);
 } grpc_server_credentials_vtable;
 
 struct grpc_server_credentials {
@@ -227,14 +214,12 @@ struct grpc_server_credentials {
 };
 
 grpc_security_status grpc_server_credentials_create_security_connector(
-    grpc_exec_ctx* exec_ctx, grpc_server_credentials* creds,
-    grpc_server_security_connector** sc);
+    grpc_server_credentials* creds, grpc_server_security_connector** sc);
 
 grpc_server_credentials* grpc_server_credentials_ref(
     grpc_server_credentials* creds);
 
-void grpc_server_credentials_unref(grpc_exec_ctx* exec_ctx,
-                                   grpc_server_credentials* creds);
+void grpc_server_credentials_unref(grpc_server_credentials* creds);
 
 #define GRPC_SERVER_CREDENTIALS_ARG "grpc.server_credentials"
 
@@ -254,10 +239,6 @@ grpc_credentials_metadata_request* grpc_credentials_metadata_request_create(
     grpc_call_credentials* creds);
 
 void grpc_credentials_metadata_request_destroy(
-    grpc_exec_ctx* exec_ctx, grpc_credentials_metadata_request* r);
-
-#ifdef __cplusplus
-}
-#endif
+    grpc_credentials_metadata_request* r);
 
 #endif /* GRPC_CORE_LIB_SECURITY_CREDENTIALS_CREDENTIALS_H */

data/src/core/lib/security/credentials/credentials_metadata.cc

@@ -52,9 +52,9 @@ void grpc_credentials_mdelem_array_append(grpc_credentials_mdelem_array* dst,
 }
 
 void grpc_credentials_mdelem_array_destroy(
-    grpc_exec_ctx* exec_ctx, grpc_credentials_mdelem_array* list) {
+    grpc_credentials_mdelem_array* list) {
   for (size_t i = 0; i < list->size; ++i) {
-    GRPC_MDELEM_UNREF(exec_ctx, list->md[i]);
+    GRPC_MDELEM_UNREF(list->md[i]);
   }
   gpr_free(list->md);
 }

data/src/core/lib/security/credentials/fake/fake_credentials.cc

@@ -25,8 +25,8 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/executor.h"
-#include "src/core/lib/support/string.h"
 
 /* -- Fake transport security credentials. -- */
 
@@ -34,10 +34,9 @@
   "grpc.fake_security.expected_targets"
 
 static grpc_security_status fake_transport_security_create_security_connector(
-    grpc_exec_ctx* exec_ctx, grpc_channel_credentials* c,
-    grpc_call_credentials* call_creds, const char* target,
-    const grpc_channel_args* args, grpc_channel_security_connector** sc,
-    grpc_channel_args** new_args) {
+    grpc_channel_credentials* c, grpc_call_credentials* call_creds,
+    const char* target, const grpc_channel_args* args,
+    grpc_channel_security_connector** sc, grpc_channel_args** new_args) {
   *sc =
       grpc_fake_channel_security_connector_create(c, call_creds, target, args);
   return GRPC_SECURITY_OK;
@@ -45,8 +44,7 @@ static grpc_security_status fake_transport_security_create_security_connector(
 
 static grpc_security_status
 fake_transport_security_server_create_security_connector(
-    grpc_exec_ctx* exec_ctx, grpc_server_credentials* c,
-    grpc_server_security_connector** sc) {
+    grpc_server_credentials* c, grpc_server_security_connector** sc) {
   *sc = grpc_fake_server_security_connector_create(c);
   return GRPC_SECURITY_OK;
 }
@@ -98,29 +96,27 @@ const char* grpc_fake_transport_get_expected_targets(
 
 /* -- Metadata-only test credentials. -- */
 
-static void md_only_test_destruct(grpc_exec_ctx* exec_ctx,
-                                  grpc_call_credentials* creds) {
+static void md_only_test_destruct(grpc_call_credentials* creds) {
   grpc_md_only_test_credentials* c = (grpc_md_only_test_credentials*)creds;
-  GRPC_MDELEM_UNREF(exec_ctx, c->md);
+  GRPC_MDELEM_UNREF(c->md);
 }
 
 static bool md_only_test_get_request_metadata(
-    grpc_exec_ctx* exec_ctx, grpc_call_credentials* creds,
-    grpc_polling_entity* pollent, grpc_auth_metadata_context context,
-    grpc_credentials_mdelem_array* md_array, grpc_closure* on_request_metadata,
-    grpc_error** error) {
+    grpc_call_credentials* creds, grpc_polling_entity* pollent,
+    grpc_auth_metadata_context context, grpc_credentials_mdelem_array* md_array,
+    grpc_closure* on_request_metadata, grpc_error** error) {
   grpc_md_only_test_credentials* c = (grpc_md_only_test_credentials*)creds;
   grpc_credentials_mdelem_array_add(md_array, c->md);
   if (c->is_async) {
-    GRPC_CLOSURE_SCHED(exec_ctx, on_request_metadata, GRPC_ERROR_NONE);
+    GRPC_CLOSURE_SCHED(on_request_metadata, GRPC_ERROR_NONE);
     return false;
   }
   return true;
 }
 
 static void md_only_test_cancel_get_request_metadata(
-    grpc_exec_ctx* exec_ctx, grpc_call_credentials* c,
-    grpc_credentials_mdelem_array* md_array, grpc_error* error) {
+    grpc_call_credentials* c, grpc_credentials_mdelem_array* md_array,
+    grpc_error* error) {
   GRPC_ERROR_UNREF(error);
 }
 
@@ -129,16 +125,14 @@ static grpc_call_credentials_vtable md_only_test_vtable = {
     md_only_test_cancel_get_request_metadata};
 
 grpc_call_credentials* grpc_md_only_test_credentials_create(
-    grpc_exec_ctx* exec_ctx, const char* md_key, const char* md_value,
-    bool is_async) {
+    const char* md_key, const char* md_value, bool is_async) {
   grpc_md_only_test_credentials* c = (grpc_md_only_test_credentials*)gpr_zalloc(
       sizeof(grpc_md_only_test_credentials));
   c->base.type = GRPC_CALL_CREDENTIALS_TYPE_OAUTH2;
   c->base.vtable = &md_only_test_vtable;
   gpr_ref_init(&c->base.refcount, 1);
-  c->md =
-      grpc_mdelem_from_slices(exec_ctx, grpc_slice_from_copied_string(md_key),
-                              grpc_slice_from_copied_string(md_value));
+  c->md = grpc_mdelem_from_slices(grpc_slice_from_copied_string(md_key),
+                                  grpc_slice_from_copied_string(md_value));
   c->is_async = is_async;
   return &c->base;
 }