grpc 1.8.7 → 1.9.0.pre1

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

@@ -31,11 +31,11 @@ extern "C" {
 #include <openssl/pem.h>
 }
 
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/http/httpcli.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/slice/b64.h"
 #include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/support/string.h"
 #include "src/core/tsi/ssl_types.h"
 
 /* --- Utils. --- */
@@ -74,12 +74,11 @@ static const EVP_MD* evp_md_from_alg(const char* alg) {
   }
 }
 
-static grpc_json* parse_json_part_from_jwt(grpc_exec_ctx* exec_ctx,
-                                           const char* str, size_t len,
+static grpc_json* parse_json_part_from_jwt(const char* str, size_t len,
                                            grpc_slice* buffer) {
   grpc_json* json;
 
-  *buffer = grpc_base64_decode_with_len(exec_ctx, str, len, 1);
+  *buffer = grpc_base64_decode_with_len(str, len, 1);
   if (GRPC_SLICE_IS_EMPTY(*buffer)) {
     gpr_log(GPR_ERROR, "Invalid base64.");
     return nullptr;
@@ -87,7 +86,7 @@ static grpc_json* parse_json_part_from_jwt(grpc_exec_ctx* exec_ctx,
   json = grpc_json_parse_string_with_len((char*)GRPC_SLICE_START_PTR(*buffer),
                                          GRPC_SLICE_LENGTH(*buffer));
   if (json == nullptr) {
-    grpc_slice_unref_internal(exec_ctx, *buffer);
+    grpc_slice_unref_internal(*buffer);
     gpr_log(GPR_ERROR, "JSON parsing error.");
   }
   return json;
@@ -123,14 +122,13 @@ typedef struct {
   grpc_slice buffer;
 } jose_header;
 
-static void jose_header_destroy(grpc_exec_ctx* exec_ctx, jose_header* h) {
-  grpc_slice_unref_internal(exec_ctx, h->buffer);
+static void jose_header_destroy(jose_header* h) {
+  grpc_slice_unref_internal(h->buffer);
   gpr_free(h);
 }
 
 /* Takes ownership of json and buffer. */
-static jose_header* jose_header_from_json(grpc_exec_ctx* exec_ctx,
-                                          grpc_json* json, grpc_slice buffer) {
+static jose_header* jose_header_from_json(grpc_json* json, grpc_slice buffer) {
   grpc_json* cur;
   jose_header* h = (jose_header*)gpr_zalloc(sizeof(jose_header));
   h->buffer = buffer;
@@ -164,7 +162,7 @@ static jose_header* jose_header_from_json(grpc_exec_ctx* exec_ctx,
 
 error:
   grpc_json_destroy(json);
-  jose_header_destroy(exec_ctx, h);
+  jose_header_destroy(h);
   return nullptr;
 }
 
@@ -184,9 +182,9 @@ struct grpc_jwt_claims {
   grpc_slice buffer;
 };
 
-void grpc_jwt_claims_destroy(grpc_exec_ctx* exec_ctx, grpc_jwt_claims* claims) {
+void grpc_jwt_claims_destroy(grpc_jwt_claims* claims) {
   grpc_json_destroy(claims->json);
-  grpc_slice_unref_internal(exec_ctx, claims->buffer);
+  grpc_slice_unref_internal(claims->buffer);
   gpr_free(claims);
 }
 
@@ -231,8 +229,7 @@ gpr_timespec grpc_jwt_claims_not_before(const grpc_jwt_claims* claims) {
 }
 
 /* Takes ownership of json and buffer even in case of failure. */
-grpc_jwt_claims* grpc_jwt_claims_from_json(grpc_exec_ctx* exec_ctx,
-                                           grpc_json* json, grpc_slice buffer) {
+grpc_jwt_claims* grpc_jwt_claims_from_json(grpc_json* json, grpc_slice buffer) {
   grpc_json* cur;
   grpc_jwt_claims* claims =
       (grpc_jwt_claims*)gpr_malloc(sizeof(grpc_jwt_claims));
@@ -274,7 +271,7 @@ grpc_jwt_claims* grpc_jwt_claims_from_json(grpc_exec_ctx* exec_ctx,
   return claims;
 
 error:
-  grpc_jwt_claims_destroy(exec_ctx, claims);
+  grpc_jwt_claims_destroy(claims);
   return nullptr;
 }
 
@@ -350,7 +347,7 @@ static verifier_cb_ctx* verifier_cb_ctx_create(
     grpc_jwt_claims* claims, const char* audience, grpc_slice signature,
     const char* signed_jwt, size_t signed_jwt_len, void* user_data,
     grpc_jwt_verification_done_cb cb) {
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_core::ExecCtx exec_ctx;
   verifier_cb_ctx* ctx = (verifier_cb_ctx*)gpr_zalloc(sizeof(verifier_cb_ctx));
   ctx->verifier = verifier;
   ctx->pollent = grpc_polling_entity_create_from_pollset(pollset);
@@ -361,16 +358,16 @@ static verifier_cb_ctx* verifier_cb_ctx_create(
   ctx->signed_data = grpc_slice_from_copied_buffer(signed_jwt, signed_jwt_len);
   ctx->user_data = user_data;
   ctx->user_cb = cb;
-  grpc_exec_ctx_finish(&exec_ctx);
+
   return ctx;
 }
 
-void verifier_cb_ctx_destroy(grpc_exec_ctx* exec_ctx, verifier_cb_ctx* ctx) {
+void verifier_cb_ctx_destroy(verifier_cb_ctx* ctx) {
   if (ctx->audience != nullptr) gpr_free(ctx->audience);
-  if (ctx->claims != nullptr) grpc_jwt_claims_destroy(exec_ctx, ctx->claims);
-  grpc_slice_unref_internal(exec_ctx, ctx->signature);
-  grpc_slice_unref_internal(exec_ctx, ctx->signed_data);
-  jose_header_destroy(exec_ctx, ctx->header);
+  if (ctx->claims != nullptr) grpc_jwt_claims_destroy(ctx->claims);
+  grpc_slice_unref_internal(ctx->signature);
+  grpc_slice_unref_internal(ctx->signed_data);
+  jose_header_destroy(ctx->header);
   for (size_t i = 0; i < HTTP_RESPONSE_COUNT; i++) {
     grpc_http_response_destroy(&ctx->responses[i]);
   }
@@ -450,19 +447,19 @@ end:
   return result;
 }
 
-static BIGNUM* bignum_from_base64(grpc_exec_ctx* exec_ctx, const char* b64) {
+static BIGNUM* bignum_from_base64(const char* b64) {
   BIGNUM* result = nullptr;
   grpc_slice bin;
 
   if (b64 == nullptr) return nullptr;
-  bin = grpc_base64_decode(exec_ctx, b64, 1);
+  bin = grpc_base64_decode(b64, 1);
   if (GRPC_SLICE_IS_EMPTY(bin)) {
     gpr_log(GPR_ERROR, "Invalid base64 for big num.");
     return nullptr;
   }
   result = BN_bin2bn(GRPC_SLICE_START_PTR(bin),
                      TSI_SIZE_AS_SIZE(GRPC_SLICE_LENGTH(bin)), nullptr);
-  grpc_slice_unref_internal(exec_ctx, bin);
+  grpc_slice_unref_internal(bin);
   return result;
 }
 
@@ -495,8 +492,7 @@ static int RSA_set0_key(RSA* r, BIGNUM* n, BIGNUM* e, BIGNUM* d) {
 }
 #endif  // OPENSSL_VERSION_NUMBER < 0x10100000L
 
-static EVP_PKEY* pkey_from_jwk(grpc_exec_ctx* exec_ctx, const grpc_json* json,
-                               const char* kty) {
+static EVP_PKEY* pkey_from_jwk(const grpc_json* json, const char* kty) {
   const grpc_json* key_prop;
   RSA* rsa = nullptr;
   EVP_PKEY* result = nullptr;
@@ -515,12 +511,10 @@ static EVP_PKEY* pkey_from_jwk(grpc_exec_ctx* exec_ctx, const grpc_json* json,
   }
   for (key_prop = json->child; key_prop != nullptr; key_prop = key_prop->next) {
     if (strcmp(key_prop->key, "n") == 0) {
-      tmp_n =
-          bignum_from_base64(exec_ctx, validate_string_field(key_prop, "n"));
+      tmp_n = bignum_from_base64(validate_string_field(key_prop, "n"));
       if (tmp_n == nullptr) goto end;
     } else if (strcmp(key_prop->key, "e") == 0) {
-      tmp_e =
-          bignum_from_base64(exec_ctx, validate_string_field(key_prop, "e"));
+      tmp_e = bignum_from_base64(validate_string_field(key_prop, "e"));
       if (tmp_e == nullptr) goto end;
     }
   }
@@ -545,8 +539,7 @@ end:
   return result;
 }
 
-static EVP_PKEY* find_verification_key(grpc_exec_ctx* exec_ctx,
-                                       const grpc_json* json,
+static EVP_PKEY* find_verification_key(const grpc_json* json,
                                        const char* header_alg,
                                        const char* header_kid) {
   const grpc_json* jkey;
@@ -591,7 +584,7 @@ static EVP_PKEY* find_verification_key(grpc_exec_ctx* exec_ctx,
     }
     if (alg != nullptr && kid != nullptr && kty != nullptr &&
         strcmp(kid, header_kid) == 0 && strcmp(alg, header_alg) == 0) {
-      return pkey_from_jwk(exec_ctx, jkey, kty);
+      return pkey_from_jwk(jkey, kty);
     }
   }
   gpr_log(GPR_ERROR,
@@ -632,8 +625,7 @@ end:
   return result;
 }
 
-static void on_keys_retrieved(grpc_exec_ctx* exec_ctx, void* user_data,
-                              grpc_error* error) {
+static void on_keys_retrieved(void* user_data, grpc_error* error) {
   verifier_cb_ctx* ctx = (verifier_cb_ctx*)user_data;
   grpc_json* json = json_from_http(&ctx->responses[HTTP_RESPONSE_KEYS]);
   EVP_PKEY* verification_key = nullptr;
@@ -645,7 +637,7 @@ static void on_keys_retrieved(grpc_exec_ctx* exec_ctx, void* user_data,
     goto end;
   }
   verification_key =
-      find_verification_key(exec_ctx, json, ctx->header->alg, ctx->header->kid);
+      find_verification_key(json, ctx->header->alg, ctx->header->kid);
   if (verification_key == nullptr) {
     gpr_log(GPR_ERROR, "Could not find verification key with kid %s.",
             ctx->header->kid);
@@ -669,12 +661,11 @@ static void on_keys_retrieved(grpc_exec_ctx* exec_ctx, void* user_data,
 end:
   if (json != nullptr) grpc_json_destroy(json);
   EVP_PKEY_free(verification_key);
-  ctx->user_cb(exec_ctx, ctx->user_data, status, claims);
-  verifier_cb_ctx_destroy(exec_ctx, ctx);
+  ctx->user_cb(ctx->user_data, status, claims);
+  verifier_cb_ctx_destroy(ctx);
 }
 
-static void on_openid_config_retrieved(grpc_exec_ctx* exec_ctx, void* user_data,
-                                       grpc_error* error) {
+static void on_openid_config_retrieved(void* user_data, grpc_error* error) {
   const grpc_json* cur;
   verifier_cb_ctx* ctx = (verifier_cb_ctx*)user_data;
   const grpc_http_response* response = &ctx->responses[HTTP_RESPONSE_OPENID];
@@ -711,20 +702,19 @@ static void on_openid_config_retrieved(grpc_exec_ctx* exec_ctx, void* user_data,
      extreme memory pressure. */
   resource_quota = grpc_resource_quota_create("jwt_verifier");
   grpc_httpcli_get(
-      exec_ctx, &ctx->verifier->http_ctx, &ctx->pollent, resource_quota, &req,
-      grpc_exec_ctx_now(exec_ctx) + grpc_jwt_verifier_max_delay,
+      &ctx->verifier->http_ctx, &ctx->pollent, resource_quota, &req,
+      grpc_core::ExecCtx::Get()->Now() + grpc_jwt_verifier_max_delay,
       GRPC_CLOSURE_CREATE(on_keys_retrieved, ctx, grpc_schedule_on_exec_ctx),
       &ctx->responses[HTTP_RESPONSE_KEYS]);
-  grpc_resource_quota_unref_internal(exec_ctx, resource_quota);
+  grpc_resource_quota_unref_internal(resource_quota);
   grpc_json_destroy(json);
   gpr_free(req.host);
   return;
 
 error:
   if (json != nullptr) grpc_json_destroy(json);
-  ctx->user_cb(exec_ctx, ctx->user_data, GRPC_JWT_VERIFIER_KEY_RETRIEVAL_ERROR,
-               nullptr);
-  verifier_cb_ctx_destroy(exec_ctx, ctx);
+  ctx->user_cb(ctx->user_data, GRPC_JWT_VERIFIER_KEY_RETRIEVAL_ERROR, nullptr);
+  verifier_cb_ctx_destroy(ctx);
 }
 
 static email_key_mapping* verifier_get_mapping(grpc_jwt_verifier* v,
@@ -772,8 +762,7 @@ const char* grpc_jwt_issuer_email_domain(const char* issuer) {
 }
 
 /* Takes ownership of ctx. */
-static void retrieve_key_and_verify(grpc_exec_ctx* exec_ctx,
-                                    verifier_cb_ctx* ctx) {
+static void retrieve_key_and_verify(verifier_cb_ctx* ctx) {
   const char* email_domain;
   grpc_closure* http_cb;
   char* path_prefix = nullptr;
@@ -840,23 +829,21 @@ static void retrieve_key_and_verify(grpc_exec_ctx* exec_ctx,
      channel. This would allow us to cancel an authentication query when under
      extreme memory pressure. */
   resource_quota = grpc_resource_quota_create("jwt_verifier");
-  grpc_httpcli_get(exec_ctx, &ctx->verifier->http_ctx, &ctx->pollent,
-                   resource_quota, &req,
-                   grpc_exec_ctx_now(exec_ctx) + grpc_jwt_verifier_max_delay,
-                   http_cb, &ctx->responses[rsp_idx]);
-  grpc_resource_quota_unref_internal(exec_ctx, resource_quota);
+  grpc_httpcli_get(
+      &ctx->verifier->http_ctx, &ctx->pollent, resource_quota, &req,
+      grpc_core::ExecCtx::Get()->Now() + grpc_jwt_verifier_max_delay, http_cb,
+      &ctx->responses[rsp_idx]);
+  grpc_resource_quota_unref_internal(resource_quota);
   gpr_free(req.host);
   gpr_free(req.http.path);
   return;
 
 error:
-  ctx->user_cb(exec_ctx, ctx->user_data, GRPC_JWT_VERIFIER_KEY_RETRIEVAL_ERROR,
-               nullptr);
-  verifier_cb_ctx_destroy(exec_ctx, ctx);
+  ctx->user_cb(ctx->user_data, GRPC_JWT_VERIFIER_KEY_RETRIEVAL_ERROR, nullptr);
+  verifier_cb_ctx_destroy(ctx);
 }
 
-void grpc_jwt_verifier_verify(grpc_exec_ctx* exec_ctx,
-                              grpc_jwt_verifier* verifier,
+void grpc_jwt_verifier_verify(grpc_jwt_verifier* verifier,
                               grpc_pollset* pollset, const char* jwt,
                               const char* audience,
                               grpc_jwt_verification_done_cb cb,
@@ -875,35 +862,32 @@ void grpc_jwt_verifier_verify(grpc_exec_ctx* exec_ctx,
              cb != nullptr);
   dot = strchr(cur, '.');
   if (dot == nullptr) goto error;
-  json = parse_json_part_from_jwt(exec_ctx, cur, (size_t)(dot - cur),
-                                  &header_buffer);
+  json = parse_json_part_from_jwt(cur, (size_t)(dot - cur), &header_buffer);
   if (json == nullptr) goto error;
-  header = jose_header_from_json(exec_ctx, json, header_buffer);
+  header = jose_header_from_json(json, header_buffer);
   if (header == nullptr) goto error;
 
   cur = dot + 1;
   dot = strchr(cur, '.');
   if (dot == nullptr) goto error;
-  json = parse_json_part_from_jwt(exec_ctx, cur, (size_t)(dot - cur),
-                                  &claims_buffer);
+  json = parse_json_part_from_jwt(cur, (size_t)(dot - cur), &claims_buffer);
   if (json == nullptr) goto error;
-  claims = grpc_jwt_claims_from_json(exec_ctx, json, claims_buffer);
+  claims = grpc_jwt_claims_from_json(json, claims_buffer);
   if (claims == nullptr) goto error;
 
   signed_jwt_len = (size_t)(dot - jwt);
   cur = dot + 1;
-  signature = grpc_base64_decode(exec_ctx, cur, 1);
+  signature = grpc_base64_decode(cur, 1);
   if (GRPC_SLICE_IS_EMPTY(signature)) goto error;
   retrieve_key_and_verify(
-      exec_ctx,
       verifier_cb_ctx_create(verifier, pollset, header, claims, audience,
                              signature, jwt, signed_jwt_len, user_data, cb));
   return;
 
 error:
-  if (header != nullptr) jose_header_destroy(exec_ctx, header);
-  if (claims != nullptr) grpc_jwt_claims_destroy(exec_ctx, claims);
-  cb(exec_ctx, user_data, GRPC_JWT_VERIFIER_BAD_FORMAT, nullptr);
+  if (header != nullptr) jose_header_destroy(header);
+  if (claims != nullptr) grpc_jwt_claims_destroy(claims);
+  cb(user_data, GRPC_JWT_VERIFIER_BAD_FORMAT, nullptr);
 }
 
 grpc_jwt_verifier* grpc_jwt_verifier_create(
@@ -930,10 +914,10 @@ grpc_jwt_verifier* grpc_jwt_verifier_create(
   return v;
 }
 
-void grpc_jwt_verifier_destroy(grpc_exec_ctx* exec_ctx, grpc_jwt_verifier* v) {
+void grpc_jwt_verifier_destroy(grpc_jwt_verifier* v) {
   size_t i;
   if (v == nullptr) return;
-  grpc_httpcli_context_destroy(exec_ctx, &v->http_ctx);
+  grpc_httpcli_context_destroy(&v->http_ctx);
   if (v->mappings != nullptr) {
     for (i = 0; i < v->num_mappings; i++) {
       gpr_free(v->mappings[i].email_domain);

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

@@ -32,10 +32,6 @@
 #define GRPC_GOOGLE_SERVICE_ACCOUNTS_KEY_URL_PREFIX \
   "www.googleapis.com/robot/v1/metadata/x509"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /* --- grpc_jwt_verifier_status. --- */
 
 typedef enum {
@@ -55,7 +51,7 @@ const char* grpc_jwt_verifier_status_to_string(grpc_jwt_verifier_status status);
 
 typedef struct grpc_jwt_claims grpc_jwt_claims;
 
-void grpc_jwt_claims_destroy(grpc_exec_ctx* exec_ctx, grpc_jwt_claims* claims);
+void grpc_jwt_claims_destroy(grpc_jwt_claims* claims);
 
 /* Returns the whole JSON tree of the claims. */
 const grpc_json* grpc_jwt_claims_json(const grpc_jwt_claims* claims);
@@ -98,21 +94,18 @@ grpc_jwt_verifier* grpc_jwt_verifier_create(
     size_t num_mappings);
 
 /*The verifier must not be destroyed if there are still outstanding callbacks.*/
-void grpc_jwt_verifier_destroy(grpc_exec_ctx* exec_ctx,
-                               grpc_jwt_verifier* verifier);
+void grpc_jwt_verifier_destroy(grpc_jwt_verifier* verifier);
 
 /* User provided callback that will be called when the verification of the JWT
    is done (maybe in another thread).
    It is the responsibility of the callee to call grpc_jwt_claims_destroy on
    the claims. */
-typedef void (*grpc_jwt_verification_done_cb)(grpc_exec_ctx* exec_ctx,
-                                              void* user_data,
+typedef void (*grpc_jwt_verification_done_cb)(void* user_data,
                                               grpc_jwt_verifier_status status,
                                               grpc_jwt_claims* claims);
 
 /* Verifies for the JWT for the given expected audience. */
-void grpc_jwt_verifier_verify(grpc_exec_ctx* exec_ctx,
-                              grpc_jwt_verifier* verifier,
+void grpc_jwt_verifier_verify(grpc_jwt_verifier* verifier,
                               grpc_pollset* pollset, const char* jwt,
                               const char* audience,
                               grpc_jwt_verification_done_cb cb,
@@ -120,14 +113,9 @@ void grpc_jwt_verifier_verify(grpc_exec_ctx* exec_ctx,
 
 /* --- TESTING ONLY exposed functions. --- */
 
-grpc_jwt_claims* grpc_jwt_claims_from_json(grpc_exec_ctx* exec_ctx,
-                                           grpc_json* json, grpc_slice buffer);
+grpc_jwt_claims* grpc_jwt_claims_from_json(grpc_json* json, grpc_slice buffer);
 grpc_jwt_verifier_status grpc_jwt_claims_check(const grpc_jwt_claims* claims,
                                                const char* audience);
 const char* grpc_jwt_issuer_email_domain(const char* issuer);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_SECURITY_CREDENTIALS_JWT_JWT_VERIFIER_H */

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

@@ -103,21 +103,19 @@ void grpc_auth_refresh_token_destruct(grpc_auth_refresh_token* refresh_token) {
 // Oauth2 Token Fetcher credentials.
 //
 
-static void oauth2_token_fetcher_destruct(grpc_exec_ctx* exec_ctx,
-                                          grpc_call_credentials* creds) {
+static void oauth2_token_fetcher_destruct(grpc_call_credentials* creds) {
   grpc_oauth2_token_fetcher_credentials* c =
       (grpc_oauth2_token_fetcher_credentials*)creds;
-  GRPC_MDELEM_UNREF(exec_ctx, c->access_token_md);
+  GRPC_MDELEM_UNREF(c->access_token_md);
   gpr_mu_destroy(&c->mu);
-  grpc_pollset_set_destroy(exec_ctx,
-                           grpc_polling_entity_pollset_set(&c->pollent));
-  grpc_httpcli_context_destroy(exec_ctx, &c->httpcli_context);
+  grpc_pollset_set_destroy(grpc_polling_entity_pollset_set(&c->pollent));
+  grpc_httpcli_context_destroy(&c->httpcli_context);
 }
 
 grpc_credentials_status
 grpc_oauth2_token_fetcher_credentials_parse_server_response(
-    grpc_exec_ctx* exec_ctx, const grpc_http_response* response,
-    grpc_mdelem* token_md, grpc_millis* token_lifetime) {
+    const grpc_http_response* response, grpc_mdelem* token_md,
+    grpc_millis* token_lifetime) {
   char* null_terminated_body = nullptr;
   char* new_access_token = nullptr;
   grpc_credentials_status status = GRPC_CREDENTIALS_OK;
@@ -184,9 +182,8 @@ grpc_oauth2_token_fetcher_credentials_parse_server_response(
     gpr_asprintf(&new_access_token, "%s %s", token_type->value,
                  access_token->value);
     *token_lifetime = strtol(expires_in->value, nullptr, 10) * GPR_MS_PER_SEC;
-    if (!GRPC_MDISNULL(*token_md)) GRPC_MDELEM_UNREF(exec_ctx, *token_md);
+    if (!GRPC_MDISNULL(*token_md)) GRPC_MDELEM_UNREF(*token_md);
     *token_md = grpc_mdelem_from_slices(
-        exec_ctx,
         grpc_slice_from_static_string(GRPC_AUTHORIZATION_METADATA_KEY),
         grpc_slice_from_copied_string(new_access_token));
     status = GRPC_CREDENTIALS_OK;
@@ -194,7 +191,7 @@ grpc_oauth2_token_fetcher_credentials_parse_server_response(
 
 end:
   if (status != GRPC_CREDENTIALS_OK && !GRPC_MDISNULL(*token_md)) {
-    GRPC_MDELEM_UNREF(exec_ctx, *token_md);
+    GRPC_MDELEM_UNREF(*token_md);
     *token_md = GRPC_MDNULL;
   }
   if (null_terminated_body != nullptr) gpr_free(null_terminated_body);
@@ -203,8 +200,7 @@ end:
   return status;
 }
 
-static void on_oauth2_token_fetcher_http_response(grpc_exec_ctx* exec_ctx,
-                                                  void* user_data,
+static void on_oauth2_token_fetcher_http_response(void* user_data,
                                                   grpc_error* error) {
   GRPC_LOG_IF_ERROR("oauth_fetch", GRPC_ERROR_REF(error));
   grpc_credentials_metadata_request* r =
@@ -215,13 +211,13 @@ static void on_oauth2_token_fetcher_http_response(grpc_exec_ctx* exec_ctx,
   grpc_millis token_lifetime;
   grpc_credentials_status status =
       grpc_oauth2_token_fetcher_credentials_parse_server_response(
-          exec_ctx, &r->response, &access_token_md, &token_lifetime);
+          &r->response, &access_token_md, &token_lifetime);
   // Update cache and grab list of pending requests.
   gpr_mu_lock(&c->mu);
   c->token_fetch_pending = false;
   c->access_token_md = GRPC_MDELEM_REF(access_token_md);
   c->token_expiration = status == GRPC_CREDENTIALS_OK
-                            ? grpc_exec_ctx_now(exec_ctx) + token_lifetime
+                            ? grpc_core::ExecCtx::Get()->Now() + token_lifetime
                             : 0;
   grpc_oauth2_pending_get_request_metadata* pending_request =
       c->pending_requests;
@@ -236,24 +232,22 @@ static void on_oauth2_token_fetcher_http_response(grpc_exec_ctx* exec_ctx,
       error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
           "Error occured when fetching oauth2 token.", &error, 1);
     }
-    GRPC_CLOSURE_SCHED(exec_ctx, pending_request->on_request_metadata, error);
+    GRPC_CLOSURE_SCHED(pending_request->on_request_metadata, error);
     grpc_polling_entity_del_from_pollset_set(
-        exec_ctx, pending_request->pollent,
-        grpc_polling_entity_pollset_set(&c->pollent));
+        pending_request->pollent, grpc_polling_entity_pollset_set(&c->pollent));
     grpc_oauth2_pending_get_request_metadata* prev = pending_request;
     pending_request = pending_request->next;
     gpr_free(prev);
   }
-  GRPC_MDELEM_UNREF(exec_ctx, access_token_md);
-  grpc_call_credentials_unref(exec_ctx, r->creds);
-  grpc_credentials_metadata_request_destroy(exec_ctx, r);
+  GRPC_MDELEM_UNREF(access_token_md);
+  grpc_call_credentials_unref(r->creds);
+  grpc_credentials_metadata_request_destroy(r);
 }
 
 static bool oauth2_token_fetcher_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_oauth2_token_fetcher_credentials* c =
       (grpc_oauth2_token_fetcher_credentials*)creds;
   // Check if we can use the cached token.
@@ -262,13 +256,14 @@ static bool oauth2_token_fetcher_get_request_metadata(
   grpc_mdelem cached_access_token_md = GRPC_MDNULL;
   gpr_mu_lock(&c->mu);
   if (!GRPC_MDISNULL(c->access_token_md) &&
-      (c->token_expiration - grpc_exec_ctx_now(exec_ctx) > refresh_threshold)) {
+      (c->token_expiration - grpc_core::ExecCtx::Get()->Now() >
+       refresh_threshold)) {
     cached_access_token_md = GRPC_MDELEM_REF(c->access_token_md);
   }
   if (!GRPC_MDISNULL(cached_access_token_md)) {
     gpr_mu_unlock(&c->mu);
     grpc_credentials_mdelem_array_add(md_array, cached_access_token_md);
-    GRPC_MDELEM_UNREF(exec_ctx, cached_access_token_md);
+    GRPC_MDELEM_UNREF(cached_access_token_md);
     return true;
   }
   // Couldn't get the token from the cache.
@@ -280,7 +275,7 @@ static bool oauth2_token_fetcher_get_request_metadata(
   pending_request->on_request_metadata = on_request_metadata;
   pending_request->pollent = pollent;
   grpc_polling_entity_add_to_pollset_set(
-      exec_ctx, pollent, grpc_polling_entity_pollset_set(&c->pollent));
+      pollent, grpc_polling_entity_pollset_set(&c->pollent));
   pending_request->next = c->pending_requests;
   c->pending_requests = pending_request;
   bool start_fetch = false;
@@ -291,17 +286,17 @@ static bool oauth2_token_fetcher_get_request_metadata(
   gpr_mu_unlock(&c->mu);
   if (start_fetch) {
     grpc_call_credentials_ref(creds);
-    c->fetch_func(exec_ctx, grpc_credentials_metadata_request_create(creds),
+    c->fetch_func(grpc_credentials_metadata_request_create(creds),
                   &c->httpcli_context, &c->pollent,
                   on_oauth2_token_fetcher_http_response,
-                  grpc_exec_ctx_now(exec_ctx) + refresh_threshold);
+                  grpc_core::ExecCtx::Get()->Now() + refresh_threshold);
   }
   return false;
 }
 
 static void oauth2_token_fetcher_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) {
   grpc_oauth2_token_fetcher_credentials* c =
       (grpc_oauth2_token_fetcher_credentials*)creds;
   gpr_mu_lock(&c->mu);
@@ -317,7 +312,7 @@ static void oauth2_token_fetcher_cancel_get_request_metadata(
         c->pending_requests = pending_request->next;
       }
       // Invoke the callback immediately with an error.
-      GRPC_CLOSURE_SCHED(exec_ctx, pending_request->on_request_metadata,
+      GRPC_CLOSURE_SCHED(pending_request->on_request_metadata,
                          GRPC_ERROR_REF(error));
       gpr_free(pending_request);
       break;
@@ -351,7 +346,7 @@ static grpc_call_credentials_vtable compute_engine_vtable = {
     oauth2_token_fetcher_cancel_get_request_metadata};
 
 static void compute_engine_fetch_oauth2(
-    grpc_exec_ctx* exec_ctx, grpc_credentials_metadata_request* metadata_req,
+    grpc_credentials_metadata_request* metadata_req,
     grpc_httpcli_context* httpcli_context, grpc_polling_entity* pollent,
     grpc_iomgr_cb_func response_cb, grpc_millis deadline) {
   grpc_http_header header = {(char*)"Metadata-Flavor", (char*)"Google"};
@@ -367,10 +362,10 @@ static void compute_engine_fetch_oauth2(
   grpc_resource_quota* resource_quota =
       grpc_resource_quota_create("oauth2_credentials");
   grpc_httpcli_get(
-      exec_ctx, httpcli_context, pollent, resource_quota, &request, deadline,
+      httpcli_context, pollent, resource_quota, &request, deadline,
       GRPC_CLOSURE_CREATE(response_cb, metadata_req, grpc_schedule_on_exec_ctx),
       &metadata_req->response);
-  grpc_resource_quota_unref_internal(exec_ctx, resource_quota);
+  grpc_resource_quota_unref_internal(resource_quota);
 }
 
 grpc_call_credentials* grpc_google_compute_engine_credentials_create(
@@ -390,12 +385,11 @@ grpc_call_credentials* grpc_google_compute_engine_credentials_create(
 // Google Refresh Token credentials.
 //
 
-static void refresh_token_destruct(grpc_exec_ctx* exec_ctx,
-                                   grpc_call_credentials* creds) {
+static void refresh_token_destruct(grpc_call_credentials* creds) {
   grpc_google_refresh_token_credentials* c =
       (grpc_google_refresh_token_credentials*)creds;
   grpc_auth_refresh_token_destruct(&c->refresh_token);
-  oauth2_token_fetcher_destruct(exec_ctx, &c->base.base);
+  oauth2_token_fetcher_destruct(&c->base.base);
 }
 
 static grpc_call_credentials_vtable refresh_token_vtable = {
@@ -403,7 +397,7 @@ static grpc_call_credentials_vtable refresh_token_vtable = {
     oauth2_token_fetcher_cancel_get_request_metadata};
 
 static void refresh_token_fetch_oauth2(
-    grpc_exec_ctx* exec_ctx, grpc_credentials_metadata_request* metadata_req,
+    grpc_credentials_metadata_request* metadata_req,
     grpc_httpcli_context* httpcli_context, grpc_polling_entity* pollent,
     grpc_iomgr_cb_func response_cb, grpc_millis deadline) {
   grpc_google_refresh_token_credentials* c =
@@ -427,11 +421,11 @@ static void refresh_token_fetch_oauth2(
   grpc_resource_quota* resource_quota =
       grpc_resource_quota_create("oauth2_credentials_refresh");
   grpc_httpcli_post(
-      exec_ctx, httpcli_context, pollent, resource_quota, &request, body,
-      strlen(body), deadline,
+      httpcli_context, pollent, resource_quota, &request, body, strlen(body),
+      deadline,
       GRPC_CLOSURE_CREATE(response_cb, metadata_req, grpc_schedule_on_exec_ctx),
       &metadata_req->response);
-  grpc_resource_quota_unref_internal(exec_ctx, resource_quota);
+  grpc_resource_quota_unref_internal(resource_quota);
   gpr_free(body);
 }
 
@@ -483,25 +477,23 @@ grpc_call_credentials* grpc_google_refresh_token_credentials_create(
 // Oauth2 Access Token credentials.
 //
 
-static void access_token_destruct(grpc_exec_ctx* exec_ctx,
-                                  grpc_call_credentials* creds) {
+static void access_token_destruct(grpc_call_credentials* creds) {
   grpc_access_token_credentials* c = (grpc_access_token_credentials*)creds;
-  GRPC_MDELEM_UNREF(exec_ctx, c->access_token_md);
+  GRPC_MDELEM_UNREF(c->access_token_md);
 }
 
 static bool access_token_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_access_token_credentials* c = (grpc_access_token_credentials*)creds;
   grpc_credentials_mdelem_array_add(md_array, c->access_token_md);
   return true;
 }
 
 static void access_token_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);
 }
 
@@ -523,11 +515,11 @@ grpc_call_credentials* grpc_access_token_credentials_create(
   gpr_ref_init(&c->base.refcount, 1);
   char* token_md_value;
   gpr_asprintf(&token_md_value, "Bearer %s", access_token);
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_core::ExecCtx exec_ctx;
   c->access_token_md = grpc_mdelem_from_slices(
-      &exec_ctx, grpc_slice_from_static_string(GRPC_AUTHORIZATION_METADATA_KEY),
+      grpc_slice_from_static_string(GRPC_AUTHORIZATION_METADATA_KEY),
       grpc_slice_from_copied_string(token_md_value));
-  grpc_exec_ctx_finish(&exec_ctx);
+
   gpr_free(token_md_value);
   return &c->base;
 }