From d1297bcc173da4d83926bb72bfd98d1984bb4582 Mon Sep 17 00:00:00 2001 From: Esun Kim Date: Thu, 14 Oct 2021 12:48:07 -0700 Subject: [PATCH] C++ struct-ify httpcli/internal_request and credential_test/request_metadata_state (#27618) * httpcli.request * credential tests request_metadata_state struct * Update by review * more c++ify * fix asan error * update by review * Update by review 2 * Fix sanity test --- src/core/lib/http/httpcli.cc | 381 ++++++++-------- test/core/security/credentials_test.cc | 582 +++++++++++++------------ 2 files changed, 504 insertions(+), 459 deletions(-) diff --git a/src/core/lib/http/httpcli.cc b/src/core/lib/http/httpcli.cc index 9a98d69144a..ab4431e3153 100644 --- a/src/core/lib/http/httpcli.cc +++ b/src/core/lib/http/httpcli.cc @@ -25,6 +25,7 @@ #include #include "absl/strings/str_format.h" +#include "absl/strings/string_view.h" #include #include @@ -41,186 +42,228 @@ #include "src/core/lib/iomgr/tcp_client.h" #include "src/core/lib/slice/slice_internal.h" -struct internal_request { - grpc_slice request_text; - grpc_http_parser parser; - grpc_resolved_addresses* addresses; - size_t next_address; - grpc_endpoint* ep; - grpc_resource_quota* resource_quota; - char* host; - char* ssl_host_override; - grpc_millis deadline; - int have_read_byte; - const grpc_httpcli_handshaker* handshaker; - grpc_closure* on_done; - grpc_httpcli_context* context; - grpc_polling_entity* pollent; - grpc_iomgr_object iomgr_obj; - grpc_slice_buffer incoming; - grpc_slice_buffer outgoing; - grpc_closure on_read; - grpc_closure done_write; - grpc_closure connected; - grpc_error_handle overall_error; -}; -static grpc_httpcli_get_override g_get_override = nullptr; -static grpc_httpcli_post_override g_post_override = nullptr; - -static void plaintext_handshake(void* arg, grpc_endpoint* endpoint, - const char* /*host*/, grpc_millis /*deadline*/, - void (*on_done)(void* arg, - grpc_endpoint* endpoint)) { - on_done(arg, endpoint); -} - -const grpc_httpcli_handshaker grpc_httpcli_plaintext = {"http", - plaintext_handshake}; +namespace grpc_core { +namespace { + +class InternalRequest { + public: + InternalRequest(const grpc_slice& request_text, + grpc_httpcli_response* response, + grpc_resource_quota* resource_quota, absl::string_view host, + absl::string_view ssl_host_override, grpc_millis deadline, + const grpc_httpcli_handshaker* handshaker, + grpc_closure* on_done, grpc_httpcli_context* context, + grpc_polling_entity* pollent, const char* name) + : request_text_(request_text), + resource_quota_(resource_quota), + host_(host), + ssl_host_override_(ssl_host_override), + deadline_(deadline), + handshaker_(handshaker), + on_done_(on_done), + context_(context), + pollent_(pollent) { + grpc_http_parser_init(&parser_, GRPC_HTTP_RESPONSE, response); + grpc_slice_buffer_init(&incoming_); + grpc_slice_buffer_init(&outgoing_); + grpc_iomgr_register_object(&iomgr_obj_, name); + + GRPC_CLOSURE_INIT(&on_read_, OnRead, this, grpc_schedule_on_exec_ctx); + GRPC_CLOSURE_INIT(&done_write_, DoneWrite, this, grpc_schedule_on_exec_ctx); + GPR_ASSERT(pollent); + grpc_polling_entity_add_to_pollset_set(pollent_, context->pollset_set); + grpc_resolve_address( + host_.c_str(), handshaker_->default_port, context_->pollset_set, + GRPC_CLOSURE_CREATE(OnResolved, this, grpc_schedule_on_exec_ctx), + &addresses_); + } -void grpc_httpcli_context_init(grpc_httpcli_context* context) { - context->pollset_set = grpc_pollset_set_create(); -} + ~InternalRequest() { + grpc_http_parser_destroy(&parser_); + if (addresses_ != nullptr) { + grpc_resolved_addresses_destroy(addresses_); + } + if (ep_ != nullptr) { + grpc_endpoint_destroy(ep_); + } + grpc_slice_unref_internal(request_text_); + grpc_iomgr_unregister_object(&iomgr_obj_); + grpc_slice_buffer_destroy_internal(&incoming_); + grpc_slice_buffer_destroy_internal(&outgoing_); + GRPC_ERROR_UNREF(overall_error_); + grpc_resource_quota_unref_internal(resource_quota_); + } -void grpc_httpcli_context_destroy(grpc_httpcli_context* context) { - grpc_pollset_set_destroy(context->pollset_set); -} + private: + void Finish(grpc_error_handle error) { + grpc_polling_entity_del_from_pollset_set(pollent_, context_->pollset_set); + grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_done_, error); + delete this; + } -static void next_address(internal_request* req, grpc_error_handle due_to_error); + void AppendError(grpc_error_handle error) { + if (overall_error_ == GRPC_ERROR_NONE) { + overall_error_ = + GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed HTTP/1 client request"); + } + grpc_resolved_address* addr = &addresses_->addrs[next_address_ - 1]; + std::string addr_text = grpc_sockaddr_to_uri(addr); + overall_error_ = grpc_error_add_child( + overall_error_, + grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS, addr_text)); + } -static void finish(internal_request* req, grpc_error_handle error) { - grpc_polling_entity_del_from_pollset_set(req->pollent, - req->context->pollset_set); - grpc_core::ExecCtx::Run(DEBUG_LOCATION, req->on_done, error); - grpc_http_parser_destroy(&req->parser); - if (req->addresses != nullptr) { - grpc_resolved_addresses_destroy(req->addresses); + void DoRead() { + grpc_endpoint_read(ep_, &incoming_, &on_read_, /*urgent=*/true); } - if (req->ep != nullptr) { - grpc_endpoint_destroy(req->ep); + + static void OnRead(void* user_data, grpc_error_handle error) { + InternalRequest* req = static_cast(user_data); + req->OnReadInternal(error); } - grpc_slice_unref_internal(req->request_text); - gpr_free(req->host); - gpr_free(req->ssl_host_override); - grpc_iomgr_unregister_object(&req->iomgr_obj); - grpc_slice_buffer_destroy_internal(&req->incoming); - grpc_slice_buffer_destroy_internal(&req->outgoing); - GRPC_ERROR_UNREF(req->overall_error); - grpc_resource_quota_unref_internal(req->resource_quota); - gpr_free(req); -} -static void append_error(internal_request* req, grpc_error_handle error) { - if (req->overall_error == GRPC_ERROR_NONE) { - req->overall_error = - GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed HTTP/1 client request"); + void OnReadInternal(grpc_error_handle error) { + size_t i; + + for (i = 0; i < incoming_.count; i++) { + if (GRPC_SLICE_LENGTH(incoming_.slices[i])) { + have_read_byte_ = 1; + grpc_error_handle err = + grpc_http_parser_parse(&parser_, incoming_.slices[i], nullptr); + if (err != GRPC_ERROR_NONE) { + Finish(err); + return; + } + } + } + + if (error == GRPC_ERROR_NONE) { + DoRead(); + } else if (!have_read_byte_) { + NextAddress(GRPC_ERROR_REF(error)); + } else { + Finish(grpc_http_parser_eof(&parser_)); + } } - grpc_resolved_address* addr = &req->addresses->addrs[req->next_address - 1]; - std::string addr_text = grpc_sockaddr_to_uri(addr); - req->overall_error = grpc_error_add_child( - req->overall_error, - grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS, addr_text)); -} -static void do_read(internal_request* req) { - grpc_endpoint_read(req->ep, &req->incoming, &req->on_read, /*urgent=*/true); -} + void OnWritten() { DoRead(); } -static void on_read(void* user_data, grpc_error_handle error) { - internal_request* req = static_cast(user_data); - size_t i; - - for (i = 0; i < req->incoming.count; i++) { - if (GRPC_SLICE_LENGTH(req->incoming.slices[i])) { - req->have_read_byte = 1; - grpc_error_handle err = grpc_http_parser_parse( - &req->parser, req->incoming.slices[i], nullptr); - if (err != GRPC_ERROR_NONE) { - finish(req, err); - return; - } + static void DoneWrite(void* arg, grpc_error_handle error) { + InternalRequest* req = static_cast(arg); + if (error == GRPC_ERROR_NONE) { + req->OnWritten(); + } else { + req->NextAddress(GRPC_ERROR_REF(error)); } } - if (error == GRPC_ERROR_NONE) { - do_read(req); - } else if (!req->have_read_byte) { - next_address(req, GRPC_ERROR_REF(error)); - } else { - finish(req, grpc_http_parser_eof(&req->parser)); + void StartWrite() { + grpc_slice_ref_internal(request_text_); + grpc_slice_buffer_add(&outgoing_, request_text_); + grpc_endpoint_write(ep_, &outgoing_, &done_write_, nullptr); } -} -static void on_written(internal_request* req) { do_read(req); } + static void OnHandshakeDone(void* arg, grpc_endpoint* ep) { + InternalRequest* req = static_cast(arg); -static void done_write(void* arg, grpc_error_handle error) { - internal_request* req = static_cast(arg); - if (error == GRPC_ERROR_NONE) { - on_written(req); - } else { - next_address(req, GRPC_ERROR_REF(error)); + if (!ep) { + req->NextAddress(GRPC_ERROR_CREATE_FROM_STATIC_STRING( + "Unexplained handshake failure")); + return; + } + + req->ep_ = ep; + req->StartWrite(); } -} -static void start_write(internal_request* req) { - grpc_slice_ref_internal(req->request_text); - grpc_slice_buffer_add(&req->outgoing, req->request_text); - grpc_endpoint_write(req->ep, &req->outgoing, &req->done_write, nullptr); -} + static void OnConnected(void* arg, grpc_error_handle error) { + InternalRequest* req = static_cast(arg); -static void on_handshake_done(void* arg, grpc_endpoint* ep) { - internal_request* req = static_cast(arg); + if (!req->ep_) { + req->NextAddress(GRPC_ERROR_REF(error)); + return; + } + req->handshaker_->handshake(req, req->ep_, + req->ssl_host_override_.empty() + ? req->host_.c_str() + : req->ssl_host_override_.c_str(), + req->deadline_, OnHandshakeDone); + } - if (!ep) { - next_address(req, GRPC_ERROR_CREATE_FROM_STATIC_STRING( - "Unexplained handshake failure")); - return; + void NextAddress(grpc_error_handle error) { + grpc_resolved_address* addr; + if (error != GRPC_ERROR_NONE) { + AppendError(error); + } + if (next_address_ == addresses_->naddrs) { + Finish(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING( + "Failed HTTP requests to all targets", &overall_error_, 1)); + return; + } + addr = &addresses_->addrs[next_address_++]; + GRPC_CLOSURE_INIT(&connected_, OnConnected, this, + grpc_schedule_on_exec_ctx); + grpc_tcp_client_connect(&connected_, &ep_, + grpc_slice_allocator_create( + resource_quota_, grpc_sockaddr_to_uri(addr)), + context_->pollset_set, nullptr, addr, deadline_); } - req->ep = ep; - start_write(req); -} + static void OnResolved(void* arg, grpc_error_handle error) { + InternalRequest* req = static_cast(arg); + if (error != GRPC_ERROR_NONE) { + req->Finish(GRPC_ERROR_REF(error)); + return; + } + req->next_address_ = 0; + req->NextAddress(GRPC_ERROR_NONE); + } -static void on_connected(void* arg, grpc_error_handle error) { - internal_request* req = static_cast(arg); + grpc_slice request_text_; + grpc_http_parser parser_; + grpc_resolved_addresses* addresses_ = nullptr; + size_t next_address_ = 0; + grpc_endpoint* ep_ = nullptr; + grpc_resource_quota* resource_quota_; + std::string host_; + std::string ssl_host_override_; + grpc_millis deadline_; + int have_read_byte_ = 0; + const grpc_httpcli_handshaker* handshaker_; + grpc_closure* on_done_; + grpc_httpcli_context* context_; + grpc_polling_entity* pollent_; + grpc_iomgr_object iomgr_obj_; + grpc_slice_buffer incoming_; + grpc_slice_buffer outgoing_; + grpc_closure on_read_; + grpc_closure done_write_; + grpc_closure connected_; + grpc_error_handle overall_error_ = GRPC_ERROR_NONE; +}; - if (!req->ep) { - next_address(req, GRPC_ERROR_REF(error)); - return; - } - req->handshaker->handshake( - req, req->ep, req->ssl_host_override ? req->ssl_host_override : req->host, - req->deadline, on_handshake_done); +} // namespace +} // namespace grpc_core + +static grpc_httpcli_get_override g_get_override = nullptr; +static grpc_httpcli_post_override g_post_override = nullptr; + +static void plaintext_handshake(void* arg, grpc_endpoint* endpoint, + const char* /*host*/, grpc_millis /*deadline*/, + void (*on_done)(void* arg, + grpc_endpoint* endpoint)) { + on_done(arg, endpoint); } -static void next_address(internal_request* req, grpc_error_handle error) { - grpc_resolved_address* addr; - if (error != GRPC_ERROR_NONE) { - append_error(req, error); - } - if (req->next_address == req->addresses->naddrs) { - finish(req, - GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING( - "Failed HTTP requests to all targets", &req->overall_error, 1)); - return; - } - addr = &req->addresses->addrs[req->next_address++]; - GRPC_CLOSURE_INIT(&req->connected, on_connected, req, - grpc_schedule_on_exec_ctx); - grpc_tcp_client_connect(&req->connected, &req->ep, - grpc_slice_allocator_create( - req->resource_quota, grpc_sockaddr_to_uri(addr)), - req->context->pollset_set, nullptr, addr, - req->deadline); +const grpc_httpcli_handshaker grpc_httpcli_plaintext = {"http", + plaintext_handshake}; + +void grpc_httpcli_context_init(grpc_httpcli_context* context) { + context->pollset_set = grpc_pollset_set_create(); } -static void on_resolved(void* arg, grpc_error_handle error) { - internal_request* req = static_cast(arg); - if (error != GRPC_ERROR_NONE) { - finish(req, GRPC_ERROR_REF(error)); - return; - } - req->next_address = 0; - next_address(req, GRPC_ERROR_NONE); +void grpc_httpcli_context_destroy(grpc_httpcli_context* context) { + grpc_pollset_set_destroy(context->pollset_set); } static void internal_request_begin(grpc_httpcli_context* context, @@ -231,35 +274,11 @@ static void internal_request_begin(grpc_httpcli_context* context, grpc_httpcli_response* response, const char* name, const grpc_slice& request_text) { - internal_request* req = - static_cast(gpr_malloc(sizeof(internal_request))); - memset(req, 0, sizeof(*req)); - req->request_text = request_text; - grpc_http_parser_init(&req->parser, GRPC_HTTP_RESPONSE, response); - req->on_done = on_done; - req->deadline = deadline; - req->handshaker = - request->handshaker ? request->handshaker : &grpc_httpcli_plaintext; - req->context = context; - req->pollent = pollent; - req->overall_error = GRPC_ERROR_NONE; - req->resource_quota = resource_quota; - GRPC_CLOSURE_INIT(&req->on_read, on_read, req, grpc_schedule_on_exec_ctx); - GRPC_CLOSURE_INIT(&req->done_write, done_write, req, - grpc_schedule_on_exec_ctx); - grpc_slice_buffer_init(&req->incoming); - grpc_slice_buffer_init(&req->outgoing); - grpc_iomgr_register_object(&req->iomgr_obj, name); - req->host = gpr_strdup(request->host); - req->ssl_host_override = gpr_strdup(request->ssl_host_override); - - GPR_ASSERT(pollent); - grpc_polling_entity_add_to_pollset_set(req->pollent, - req->context->pollset_set); - grpc_resolve_address( - request->host, req->handshaker->default_port, req->context->pollset_set, - GRPC_CLOSURE_CREATE(on_resolved, req, grpc_schedule_on_exec_ctx), - &req->addresses); + new grpc_core::InternalRequest( + request_text, response, resource_quota, request->host, + request->ssl_host_override, deadline, + request->handshaker ? request->handshaker : &grpc_httpcli_plaintext, + on_done, context, pollent, name); } void grpc_httpcli_get(grpc_httpcli_context* context, diff --git a/test/core/security/credentials_test.cc b/test/core/security/credentials_test.cc index 9e9abf8ec03..5f1e2f1dacd 100644 --- a/test/core/security/credentials_test.cc +++ b/test/core/security/credentials_test.cc @@ -449,102 +449,116 @@ static void test_oauth2_token_fetcher_creds_parsing_missing_token_lifetime( grpc_http_response_destroy(&response); } -typedef struct { - const char* key; - const char* value; -} expected_md; +namespace { -typedef struct { - grpc_error_handle expected_error; - const expected_md* expected; - size_t expected_size; - grpc_credentials_mdelem_array md_array; - grpc_closure on_request_metadata; - grpc_call_credentials* creds; - grpc_polling_entity pollent; -} request_metadata_state; - -static void check_metadata(const expected_md* expected, - grpc_credentials_mdelem_array* md_array) { - for (size_t i = 0; i < md_array->size; ++i) { - size_t j; - for (j = 0; j < md_array->size; ++j) { - if (0 == - grpc_slice_str_cmp(GRPC_MDKEY(md_array->md[j]), expected[i].key)) { - GPR_ASSERT(grpc_slice_str_cmp(GRPC_MDVALUE(md_array->md[j]), - expected[i].value) == 0); - break; - } - } - if (j == md_array->size) { - gpr_log(GPR_ERROR, "key %s not found", expected[i].key); - GPR_ASSERT(0); +class RequestMetadataState { + public: + static RequestMetadataState* NewInstance( + grpc_error_handle expected_error, + std::map expected) { + RequestMetadataState* state = new RequestMetadataState( + expected_error, std::move(expected), + grpc_polling_entity_create_from_pollset_set(grpc_pollset_set_create())); + return state; + } + + private: + RequestMetadataState(grpc_error_handle expected_error, + std::map expected, + grpc_polling_entity pollent) + : expected_error_(expected_error), + expected_(expected), + pollent_(pollent) { + GRPC_CLOSURE_INIT(&on_request_metadata_, OnRequestMetadata, this, + grpc_schedule_on_exec_ctx); + } + + public: + ~RequestMetadataState() { + grpc_credentials_mdelem_array_destroy(&md_array_); + grpc_pollset_set_destroy(grpc_polling_entity_pollset_set(&pollent_)); + } + + void RunRequestMetadataTest(grpc_call_credentials* creds, + grpc_auth_metadata_context auth_md_ctx) { + grpc_error_handle error = GRPC_ERROR_NONE; + if (creds->get_request_metadata(&pollent_, auth_md_ctx, &md_array_, + &on_request_metadata_, &error)) { + // Synchronous result. Invoke the callback directly. + CheckRequestMetadata(error); + GRPC_ERROR_UNREF(error); } } -} -static void check_request_metadata(void* arg, grpc_error_handle error) { - request_metadata_state* state = static_cast(arg); - gpr_log(GPR_INFO, "expected_error: %s", - grpc_error_std_string(state->expected_error).c_str()); - gpr_log(GPR_INFO, "actual_error: %s", grpc_error_std_string(error).c_str()); - if (state->expected_error == GRPC_ERROR_NONE) { - GPR_ASSERT(error == GRPC_ERROR_NONE); - } else { - std::string expected_error; - GPR_ASSERT(grpc_error_get_str(state->expected_error, - GRPC_ERROR_STR_DESCRIPTION, &expected_error)); - std::string actual_error; - GPR_ASSERT( - grpc_error_get_str(error, GRPC_ERROR_STR_DESCRIPTION, &actual_error)); - GPR_ASSERT(expected_error == actual_error); - GRPC_ERROR_UNREF(state->expected_error); + private: + static void OnRequestMetadata(void* arg, grpc_error_handle error) { + RequestMetadataState* state = static_cast(arg); + state->CheckRequestMetadata(error); } - gpr_log(GPR_INFO, "expected_size=%" PRIdPTR " actual_size=%" PRIdPTR, - state->expected_size, state->md_array.size); - GPR_ASSERT(state->md_array.size == state->expected_size); - check_metadata(state->expected, &state->md_array); - grpc_credentials_mdelem_array_destroy(&state->md_array); - grpc_pollset_set_destroy(grpc_polling_entity_pollset_set(&state->pollent)); - gpr_free(state); -} - -static request_metadata_state* make_request_metadata_state( - grpc_error_handle expected_error, const expected_md* expected, - size_t expected_size) { - request_metadata_state* state = - static_cast(gpr_zalloc(sizeof(*state))); - state->expected_error = expected_error; - state->expected = expected; - state->expected_size = expected_size; - state->pollent = - grpc_polling_entity_create_from_pollset_set(grpc_pollset_set_create()); - GRPC_CLOSURE_INIT(&state->on_request_metadata, check_request_metadata, state, - grpc_schedule_on_exec_ctx); - return state; -} - -static void run_request_metadata_test(grpc_call_credentials* creds, - grpc_auth_metadata_context auth_md_ctx, - request_metadata_state* state) { - grpc_error_handle error = GRPC_ERROR_NONE; - if (creds->get_request_metadata(&state->pollent, auth_md_ctx, - &state->md_array, &state->on_request_metadata, - &error)) { - // Synchronous result. Invoke the callback directly. - check_request_metadata(state, error); - GRPC_ERROR_UNREF(error); + + void CheckRequestMetadata(grpc_error_handle error) { + gpr_log(GPR_INFO, "expected_error: %s", + grpc_error_std_string(expected_error_).c_str()); + gpr_log(GPR_INFO, "actual_error: %s", grpc_error_std_string(error).c_str()); + if (expected_error_ == GRPC_ERROR_NONE) { + GPR_ASSERT(error == GRPC_ERROR_NONE); + } else { + std::string expected_error; + GPR_ASSERT(grpc_error_get_str(expected_error_, GRPC_ERROR_STR_DESCRIPTION, + &expected_error)); + std::string actual_error; + GPR_ASSERT( + grpc_error_get_str(error, GRPC_ERROR_STR_DESCRIPTION, &actual_error)); + GPR_ASSERT(expected_error == actual_error); + GRPC_ERROR_UNREF(expected_error_); + } + gpr_log(GPR_INFO, "expected_size=%" PRIdPTR " actual_size=%" PRIdPTR, + expected_.size(), md_array_.size); + GPR_ASSERT(md_array_.size == expected_.size()); + CheckMetadata(expected_, &md_array_); + delete this; } -} + + static void CheckMetadata(const std::map& expected, + grpc_credentials_mdelem_array* md_array) { + for (auto const& i : expected) { + size_t j; + for (j = 0; j < md_array->size; ++j) { + absl::string_view actual_key = + grpc_core::StringViewFromSlice(GRPC_MDKEY(md_array->md[j])); + if (actual_key == i.first) { + absl::string_view actual_value = + grpc_core::StringViewFromSlice(GRPC_MDVALUE(md_array->md[j])); + GPR_ASSERT(actual_value == i.second); + break; + } + } + if (j == md_array->size) { + gpr_log(GPR_ERROR, "key %s not found", i.first.c_str()); + GPR_ASSERT(0); + } + } + } + + private: + grpc_error_handle expected_error_; + std::map expected_; + grpc_credentials_mdelem_array md_array_; + grpc_closure on_request_metadata_; + grpc_polling_entity pollent_; +}; + +} // namespace static void test_google_iam_creds(void) { grpc_core::ExecCtx exec_ctx; - expected_md emd[] = {{GRPC_IAM_AUTHORIZATION_TOKEN_METADATA_KEY, - test_google_iam_authorization_token}, - {GRPC_IAM_AUTHORITY_SELECTOR_METADATA_KEY, - test_google_iam_authority_selector}}; - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + std::map emd = { + {GRPC_IAM_AUTHORIZATION_TOKEN_METADATA_KEY, + test_google_iam_authorization_token}, + {GRPC_IAM_AUTHORITY_SELECTOR_METADATA_KEY, + test_google_iam_authority_selector}}; + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_call_credentials* creds = grpc_google_iam_credentials_create( test_google_iam_authorization_token, test_google_iam_authority_selector, nullptr); @@ -552,15 +566,16 @@ static void test_google_iam_creds(void) { GPR_ASSERT(creds->min_security_level() == GRPC_PRIVACY_AND_INTEGRITY); grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; - run_request_metadata_test(creds, auth_md_ctx, state); + state->RunRequestMetadataTest(creds, auth_md_ctx); creds->Unref(); } static void test_access_token_creds(void) { grpc_core::ExecCtx exec_ctx; - expected_md emd[] = {{GRPC_AUTHORIZATION_METADATA_KEY, "Bearer blah"}}; - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + std::map emd = { + {GRPC_AUTHORIZATION_METADATA_KEY, "Bearer blah"}}; + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_call_credentials* creds = grpc_access_token_credentials_create("blah", nullptr); grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, @@ -568,7 +583,7 @@ static void test_access_token_creds(void) { GPR_ASSERT(strcmp(creds->type(), GRPC_CALL_CREDENTIALS_TYPE_OAUTH2) == 0); /* Check security level. */ GPR_ASSERT(creds->min_security_level() == GRPC_PRIVACY_AND_INTEGRITY); - run_request_metadata_test(creds, auth_md_ctx, state); + state->RunRequestMetadataTest(creds, auth_md_ctx); creds->Unref(); } @@ -610,14 +625,14 @@ static void test_channel_oauth2_composite_creds(void) { static void test_oauth2_google_iam_composite_creds(void) { grpc_core::ExecCtx exec_ctx; - expected_md emd[] = { + std::map emd = { {GRPC_AUTHORIZATION_METADATA_KEY, test_oauth2_bearer_token}, {GRPC_IAM_AUTHORIZATION_TOKEN_METADATA_KEY, test_google_iam_authorization_token}, {GRPC_IAM_AUTHORITY_SELECTOR_METADATA_KEY, test_google_iam_authority_selector}}; - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; grpc_call_credentials* oauth2_creds = grpc_md_only_test_credentials_create( @@ -648,7 +663,7 @@ static void test_oauth2_google_iam_composite_creds(void) { 0); GPR_ASSERT(strcmp(creds_list[1]->type(), GRPC_CALL_CREDENTIALS_TYPE_IAM) == 0); - run_request_metadata_test(composite_creds, auth_md_ctx, state); + state->RunRequestMetadataTest(composite_creds, auth_md_ctx); composite_creds->Unref(); } @@ -755,7 +770,7 @@ static int httpcli_get_should_not_be_called( static void test_compute_engine_creds_success() { grpc_core::ExecCtx exec_ctx; - expected_md emd[] = { + std::map emd = { {"authorization", "Bearer ya29.AHES6ZRN3-HlhAPya30GnW_bHSb_"}}; const char expected_creds_debug_string[] = "GoogleComputeEngineTokenFetcherCredentials{" @@ -768,19 +783,18 @@ static void test_compute_engine_creds_success() { GPR_ASSERT(creds->min_security_level() == GRPC_PRIVACY_AND_INTEGRITY); /* First request: http get should be called. */ - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(compute_engine_httpcli_get_success_override, httpcli_post_should_not_be_called); - run_request_metadata_test(creds, auth_md_ctx, state); + state->RunRequestMetadataTest(creds, auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); /* Second request: the cached token should be served directly. */ - state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + state = RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(httpcli_get_should_not_be_called, httpcli_post_should_not_be_called); - run_request_metadata_test(creds, auth_md_ctx, state); + state->RunRequestMetadataTest(creds, auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); GPR_ASSERT( @@ -794,17 +808,17 @@ static void test_compute_engine_creds_failure(void) { const char expected_creds_debug_string[] = "GoogleComputeEngineTokenFetcherCredentials{" "OAuth2TokenFetcherCredentials}"; - request_metadata_state* state = make_request_metadata_state( + RequestMetadataState* state = RequestMetadataState::NewInstance( GRPC_ERROR_CREATE_FROM_STATIC_STRING( "Error occurred when fetching oauth2 token."), - nullptr, 0); + {}); grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; grpc_call_credentials* creds = grpc_google_compute_engine_credentials_create(nullptr); grpc_httpcli_set_override(compute_engine_httpcli_get_failure_override, httpcli_post_should_not_be_called); - run_request_metadata_test(creds, auth_md_ctx, state); + state->RunRequestMetadataTest(creds, auth_md_ctx); GPR_ASSERT( strcmp(creds->debug_string().c_str(), expected_creds_debug_string) == 0); creds->Unref(); @@ -855,7 +869,7 @@ static int token_httpcli_post_failure(const grpc_httpcli_request* /*request*/, static void test_refresh_token_creds_success(void) { grpc_core::ExecCtx exec_ctx; - expected_md emd[] = { + std::map emd = { {"authorization", "Bearer ya29.AHES6ZRN3-HlhAPya30GnW_bHSb_"}}; const char expected_creds_debug_string[] = "GoogleRefreshToken{ClientID:32555999999.apps.googleusercontent.com," @@ -869,19 +883,18 @@ static void test_refresh_token_creds_success(void) { GPR_ASSERT(creds->min_security_level() == GRPC_PRIVACY_AND_INTEGRITY); /* First request: http put should be called. */ - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(httpcli_get_should_not_be_called, refresh_token_httpcli_post_success); - run_request_metadata_test(creds, auth_md_ctx, state); + state->RunRequestMetadataTest(creds, auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); /* Second request: the cached token should be served directly. */ - state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + state = RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(httpcli_get_should_not_be_called, httpcli_post_should_not_be_called); - run_request_metadata_test(creds, auth_md_ctx, state); + state->RunRequestMetadataTest(creds, auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); GPR_ASSERT( strcmp(creds->debug_string().c_str(), expected_creds_debug_string) == 0); @@ -895,17 +908,17 @@ static void test_refresh_token_creds_failure(void) { const char expected_creds_debug_string[] = "GoogleRefreshToken{ClientID:32555999999.apps.googleusercontent.com," "OAuth2TokenFetcherCredentials}"; - request_metadata_state* state = make_request_metadata_state( + RequestMetadataState* state = RequestMetadataState::NewInstance( GRPC_ERROR_CREATE_FROM_STATIC_STRING( "Error occurred when fetching oauth2 token."), - nullptr, 0); + {}); grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; grpc_call_credentials* creds = grpc_google_refresh_token_credentials_create( test_refresh_token_str, nullptr); grpc_httpcli_set_override(httpcli_get_should_not_be_called, token_httpcli_post_failure); - run_request_metadata_test(creds, auth_md_ctx, state); + state->RunRequestMetadataTest(creds, auth_md_ctx); GPR_ASSERT( strcmp(creds->debug_string().c_str(), expected_creds_debug_string) == 0); @@ -1100,7 +1113,7 @@ static char* write_tmp_jwt_file(const char* jwt_contents) { static void test_sts_creds_success(void) { grpc_core::ExecCtx exec_ctx; - expected_md emd[] = { + std::map emd = { {"authorization", "Bearer ya29.AHES6ZRN3-HlhAPya30GnW_bHSb_"}}; const char expected_creds_debug_string[] = "StsTokenFetcherCredentials{Path:/v1/" @@ -1127,19 +1140,18 @@ static void test_sts_creds_success(void) { GPR_ASSERT(creds->min_security_level() == GRPC_PRIVACY_AND_INTEGRITY); /* First request: http put should be called. */ - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(httpcli_get_should_not_be_called, sts_token_httpcli_post_success); - run_request_metadata_test(creds, auth_md_ctx, state); + state->RunRequestMetadataTest(creds, auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); /* Second request: the cached token should be served directly. */ - state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + state = RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(httpcli_get_should_not_be_called, httpcli_post_should_not_be_called); - run_request_metadata_test(creds, auth_md_ctx, state); + state->RunRequestMetadataTest(creds, auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); GPR_ASSERT( strcmp(creds->debug_string().c_str(), expected_creds_debug_string) == 0); @@ -1171,13 +1183,13 @@ static void test_sts_creds_token_file_not_found(void) { /* Check security level. */ GPR_ASSERT(creds->min_security_level() == GRPC_PRIVACY_AND_INTEGRITY); - request_metadata_state* state = make_request_metadata_state( + RequestMetadataState* state = RequestMetadataState::NewInstance( GRPC_ERROR_CREATE_FROM_STATIC_STRING( "Error occurred when fetching oauth2 token."), - nullptr, 0); + {}); grpc_httpcli_set_override(httpcli_get_should_not_be_called, httpcli_post_should_not_be_called); - run_request_metadata_test(creds, auth_md_ctx, state); + state->RunRequestMetadataTest(creds, auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); /* Cleanup. */ @@ -1187,7 +1199,7 @@ static void test_sts_creds_token_file_not_found(void) { static void test_sts_creds_no_actor_token_success(void) { grpc_core::ExecCtx exec_ctx; - expected_md emd[] = { + std::map emd = { {"authorization", "Bearer ya29.AHES6ZRN3-HlhAPya30GnW_bHSb_"}}; const char expected_creds_debug_string[] = "StsTokenFetcherCredentials{Path:/v1/" @@ -1213,19 +1225,18 @@ static void test_sts_creds_no_actor_token_success(void) { GPR_ASSERT(creds->min_security_level() == GRPC_PRIVACY_AND_INTEGRITY); /* First request: http put should be called. */ - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(httpcli_get_should_not_be_called, sts_token_httpcli_post_success_no_actor_token); - run_request_metadata_test(creds, auth_md_ctx, state); + state->RunRequestMetadataTest(creds, auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); /* Second request: the cached token should be served directly. */ - state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + state = RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(httpcli_get_should_not_be_called, httpcli_post_should_not_be_called); - run_request_metadata_test(creds, auth_md_ctx, state); + state->RunRequestMetadataTest(creds, auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); GPR_ASSERT( strcmp(creds->debug_string().c_str(), expected_creds_debug_string) == 0); @@ -1240,10 +1251,10 @@ static void test_sts_creds_load_token_failure(void) { "StsTokenFetcherCredentials{Path:/v1/" "token-exchange,Authority:foo.com:5555,OAuth2TokenFetcherCredentials}"; grpc_core::ExecCtx exec_ctx; - request_metadata_state* state = make_request_metadata_state( + RequestMetadataState* state = RequestMetadataState::NewInstance( GRPC_ERROR_CREATE_FROM_STATIC_STRING( "Error occurred when fetching oauth2 token."), - nullptr, 0); + {}); grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; char* test_signed_jwt_path = write_tmp_jwt_file(test_signed_jwt); @@ -1261,7 +1272,7 @@ static void test_sts_creds_load_token_failure(void) { grpc_call_credentials* creds = grpc_sts_credentials_create(&options, nullptr); grpc_httpcli_set_override(httpcli_get_should_not_be_called, httpcli_post_should_not_be_called); - run_request_metadata_test(creds, auth_md_ctx, state); + state->RunRequestMetadataTest(creds, auth_md_ctx); GPR_ASSERT( strcmp(creds->debug_string().c_str(), expected_creds_debug_string) == 0); @@ -1275,10 +1286,10 @@ static void test_sts_creds_http_failure(void) { "StsTokenFetcherCredentials{Path:/v1/" "token-exchange,Authority:foo.com:5555,OAuth2TokenFetcherCredentials}"; grpc_core::ExecCtx exec_ctx; - request_metadata_state* state = make_request_metadata_state( + RequestMetadataState* state = RequestMetadataState::NewInstance( GRPC_ERROR_CREATE_FROM_STATIC_STRING( "Error occurred when fetching oauth2 token."), - nullptr, 0); + {}); grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; char* test_signed_jwt_path = write_tmp_jwt_file(test_signed_jwt); @@ -1297,7 +1308,7 @@ static void test_sts_creds_http_failure(void) { grpc_sts_credentials_create(&valid_options, nullptr); grpc_httpcli_set_override(httpcli_get_should_not_be_called, token_httpcli_post_failure); - run_request_metadata_test(creds, auth_md_ctx, state); + state->RunRequestMetadataTest(creds, auth_md_ctx); GPR_ASSERT( strcmp(creds->debug_string().c_str(), expected_creds_debug_string) == 0); creds->Unref(); @@ -1425,33 +1436,32 @@ static void test_jwt_creds_success(void) { grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; std::string expected_md_value = absl::StrCat("Bearer ", test_signed_jwt); - expected_md emd[] = {{"authorization", expected_md_value.c_str()}}; + std::map emd = { + {"authorization", expected_md_value.c_str()}}; grpc_call_credentials* creds = grpc_service_account_jwt_access_credentials_create( json_key_string, grpc_max_auth_token_lifetime(), nullptr); /* First request: jwt_encode_and_sign should be called. */ - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_jwt_encode_and_sign_set_override(encode_and_sign_jwt_success); - run_request_metadata_test(creds, auth_md_ctx, state); + state->RunRequestMetadataTest(creds, auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); /* Second request: the cached token should be served directly. */ - state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + state = RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_jwt_encode_and_sign_set_override( encode_and_sign_jwt_should_not_be_called); - run_request_metadata_test(creds, auth_md_ctx, state); + state->RunRequestMetadataTest(creds, auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); /* Third request: Different service url so jwt_encode_and_sign should be called again (no caching). */ - state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + state = RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); auth_md_ctx.service_url = other_test_service_url; grpc_jwt_encode_and_sign_set_override(encode_and_sign_jwt_success); - run_request_metadata_test(creds, auth_md_ctx, state); + state->RunRequestMetadataTest(creds, auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); GPR_ASSERT(strncmp(expected_creds_debug_string_prefix, creds->debug_string().c_str(), @@ -1469,15 +1479,14 @@ static void test_jwt_creds_signing_failure(void) { grpc_core::ExecCtx exec_ctx; grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; - request_metadata_state* state = make_request_metadata_state( - GRPC_ERROR_CREATE_FROM_STATIC_STRING("Could not generate JWT."), nullptr, - 0); + RequestMetadataState* state = RequestMetadataState::NewInstance( + GRPC_ERROR_CREATE_FROM_STATIC_STRING("Could not generate JWT."), {}); grpc_call_credentials* creds = grpc_service_account_jwt_access_credentials_create( json_key_string, grpc_max_auth_token_lifetime(), nullptr); grpc_jwt_encode_and_sign_set_override(encode_and_sign_jwt_failure); - run_request_metadata_test(creds, auth_md_ctx, state); + state->RunRequestMetadataTest(creds, auth_md_ctx); gpr_free(json_key_string); GPR_ASSERT(strncmp(expected_creds_debug_string_prefix, @@ -1641,10 +1650,10 @@ static std::string null_well_known_creds_path_getter(void) { return ""; } static void test_google_default_creds_gce(void) { grpc_core::ExecCtx exec_ctx; - expected_md emd[] = { + std::map emd = { {"authorization", "Bearer ya29.AHES6ZRN3-HlhAPya30GnW_bHSb_"}}; - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; grpc_flush_cached_google_default_credentials(); @@ -1665,7 +1674,7 @@ static void test_google_default_creds_gce(void) { GPR_ASSERT(creds->call_creds() != nullptr); grpc_httpcli_set_override(compute_engine_httpcli_get_success_override, httpcli_post_should_not_be_called); - run_request_metadata_test(creds->mutable_call_creds(), auth_md_ctx, state); + state->RunRequestMetadataTest(creds->mutable_call_creds(), auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); GPR_ASSERT(g_test_gce_tenancy_checker_called == true); @@ -1678,10 +1687,10 @@ static void test_google_default_creds_gce(void) { static void test_google_default_creds_non_gce(void) { grpc_core::ExecCtx exec_ctx; - expected_md emd[] = { + std::map emd = { {"authorization", "Bearer ya29.AHES6ZRN3-HlhAPya30GnW_bHSb_"}}; - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; grpc_flush_cached_google_default_credentials(); @@ -1703,7 +1712,7 @@ static void test_google_default_creds_non_gce(void) { GPR_ASSERT(creds->call_creds() != nullptr); grpc_httpcli_set_override(compute_engine_httpcli_get_success_override, httpcli_post_should_not_be_called); - run_request_metadata_test(creds->mutable_call_creds(), auth_md_ctx, state); + state->RunRequestMetadataTest(creds->mutable_call_creds(), auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); GPR_ASSERT(g_test_gce_tenancy_checker_called == true); /* Cleanup. */ @@ -1746,10 +1755,10 @@ static void test_no_google_default_creds(void) { } static void test_google_default_creds_call_creds_specified(void) { - expected_md emd[] = { + std::map emd = { {"authorization", "Bearer ya29.AHES6ZRN3-HlhAPya30GnW_bHSb_"}}; - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; grpc_core::ExecCtx exec_ctx; @@ -1770,8 +1779,9 @@ static void test_google_default_creds_call_creds_specified(void) { GPR_ASSERT(channel_creds->call_creds() != nullptr); grpc_httpcli_set_override(compute_engine_httpcli_get_success_override, httpcli_post_should_not_be_called); - run_request_metadata_test(channel_creds->mutable_call_creds(), auth_md_ctx, - state); + state->RunRequestMetadataTest(channel_creds->mutable_call_creds(), + auth_md_ctx); + grpc_core::ExecCtx::Get()->Flush(); channel_creds->Unref(); grpc_httpcli_set_override(nullptr, nullptr); @@ -1806,9 +1816,9 @@ struct fake_call_creds : public grpc_call_credentials { }; static void test_google_default_creds_not_default(void) { - expected_md emd[] = {{"foo", "oof"}}; - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + std::map emd = {{"foo", "oof"}}; + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; grpc_core::ExecCtx exec_ctx; @@ -1827,8 +1837,8 @@ static void test_google_default_creds_not_default(void) { GPR_ASSERT(g_test_gce_tenancy_checker_called == false); GPR_ASSERT(channel_creds != nullptr); GPR_ASSERT(channel_creds->call_creds() != nullptr); - run_request_metadata_test(channel_creds->mutable_call_creds(), auth_md_ctx, - state); + state->RunRequestMetadataTest(channel_creds->mutable_call_creds(), + auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); channel_creds->Unref(); grpc_httpcli_set_override(nullptr, nullptr); @@ -1840,7 +1850,8 @@ typedef enum { PLUGIN_DESTROY_CALLED_STATE } plugin_state; -static const expected_md plugin_md[] = {{"foo", "bar"}, {"hi", "there"}}; +static const std::map plugin_md = {{"foo", "bar"}, + {"hi", "there"}}; static int plugin_get_metadata_success( void* state, grpc_auth_metadata_context context, @@ -1852,16 +1863,17 @@ static int plugin_get_metadata_success( GPR_ASSERT(strcmp(context.method_name, test_method) == 0); GPR_ASSERT(context.channel_auth_context == nullptr); GPR_ASSERT(context.reserved == nullptr); - GPR_ASSERT(GPR_ARRAY_SIZE(plugin_md) < - GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX); + GPR_ASSERT(plugin_md.size() < GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX); plugin_state* s = static_cast(state); *s = PLUGIN_GET_METADATA_CALLED_STATE; - for (size_t i = 0; i < GPR_ARRAY_SIZE(plugin_md); ++i) { + size_t i = 0; + for (auto const& md : plugin_md) { memset(&creds_md[i], 0, sizeof(grpc_metadata)); - creds_md[i].key = grpc_slice_from_copied_string(plugin_md[i].key); - creds_md[i].value = grpc_slice_from_copied_string(plugin_md[i].value); + creds_md[i].key = grpc_slice_from_copied_string(md.first.c_str()); + creds_md[i].value = grpc_slice_from_copied_string(md.second.c_str()); + i += 1; } - *num_creds_md = GPR_ARRAY_SIZE(plugin_md); + *num_creds_md = plugin_md.size(); return true; // Synchronous return. } @@ -1917,8 +1929,8 @@ static void test_metadata_plugin_success(void) { grpc_core::ExecCtx exec_ctx; grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; - request_metadata_state* md_state = make_request_metadata_state( - GRPC_ERROR_NONE, plugin_md, GPR_ARRAY_SIZE(plugin_md)); + RequestMetadataState* md_state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, plugin_md); plugin.state = &state; plugin.get_metadata = plugin_get_metadata_success; @@ -1930,7 +1942,7 @@ static void test_metadata_plugin_success(void) { /* Check security level. */ GPR_ASSERT(creds->min_security_level() == GRPC_PRIVACY_AND_INTEGRITY); GPR_ASSERT(state == PLUGIN_INITIAL_STATE); - run_request_metadata_test(creds, auth_md_ctx, md_state); + md_state->RunRequestMetadataTest(creds, auth_md_ctx); GPR_ASSERT(state == PLUGIN_GET_METADATA_CALLED_STATE); GPR_ASSERT( strcmp(creds->debug_string().c_str(), expected_creds_debug_string) == 0); @@ -1948,11 +1960,11 @@ static void test_metadata_plugin_failure(void) { grpc_core::ExecCtx exec_ctx; grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; - request_metadata_state* md_state = make_request_metadata_state( + RequestMetadataState* md_state = RequestMetadataState::NewInstance( GRPC_ERROR_CREATE_FROM_CPP_STRING( absl::StrCat("Getting metadata from plugin failed with error: ", plugin_error_details)), - nullptr, 0); + {}); plugin.state = &state; plugin.get_metadata = plugin_get_metadata_failure; @@ -1962,7 +1974,7 @@ static void test_metadata_plugin_failure(void) { grpc_call_credentials* creds = grpc_metadata_credentials_create_from_plugin( plugin, GRPC_PRIVACY_AND_INTEGRITY, nullptr); GPR_ASSERT(state == PLUGIN_INITIAL_STATE); - run_request_metadata_test(creds, auth_md_ctx, md_state); + md_state->RunRequestMetadataTest(creds, auth_md_ctx); GPR_ASSERT(state == PLUGIN_GET_METADATA_CALLED_STATE); GPR_ASSERT( strcmp(creds->debug_string().c_str(), expected_creds_debug_string) == 0); @@ -2342,7 +2354,8 @@ class TestExternalAccountCredentials final }; static void test_external_account_creds_success(void) { - expected_md emd[] = {{"authorization", "Bearer token_exchange_access_token"}}; + std::map emd = { + {"authorization", "Bearer token_exchange_access_token"}}; grpc_core::ExecCtx exec_ctx; grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; @@ -2363,24 +2376,24 @@ static void test_external_account_creds_success(void) { /* Check security level. */ GPR_ASSERT(creds.min_security_level() == GRPC_PRIVACY_AND_INTEGRITY); /* First request: http put should be called. */ - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(httpcli_get_should_not_be_called, external_account_creds_httpcli_post_success); - run_request_metadata_test(&creds, auth_md_ctx, state); + state->RunRequestMetadataTest(&creds, auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); /* Second request: the cached token should be served directly. */ - state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + state = RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(httpcli_get_should_not_be_called, httpcli_post_should_not_be_called); - run_request_metadata_test(&creds, auth_md_ctx, state); + state->RunRequestMetadataTest(&creds, auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); } static void test_external_account_creds_success_with_url_encode(void) { - expected_md emd[] = {{"authorization", "Bearer token_exchange_access_token"}}; + std::map emd = { + {"authorization", "Bearer token_exchange_access_token"}}; grpc_core::ExecCtx exec_ctx; grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; @@ -2398,18 +2411,18 @@ static void test_external_account_creds_success_with_url_encode(void) { "client_secret", // client_secret; }; TestExternalAccountCredentials creds(options, {}); - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(httpcli_get_should_not_be_called, external_account_creds_httpcli_post_success); - run_request_metadata_test(&creds, auth_md_ctx, state); + state->RunRequestMetadataTest(&creds, auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); } static void test_external_account_creds_success_with_service_account_impersonation(void) { - expected_md emd[] = { + std::map emd = { {"authorization", "Bearer service_account_impersonation_access_token"}}; grpc_core::ExecCtx exec_ctx; grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, @@ -2431,11 +2444,11 @@ test_external_account_creds_success_with_service_account_impersonation(void) { /* Check security level. */ GPR_ASSERT(creds.min_security_level() == GRPC_PRIVACY_AND_INTEGRITY); /* First request: http put should be called. */ - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(httpcli_get_should_not_be_called, external_account_creds_httpcli_post_success); - run_request_metadata_test(&creds, auth_md_ctx, state); + state->RunRequestMetadataTest(&creds, auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); } @@ -2465,9 +2478,9 @@ static void test_external_account_creds_failure_invalid_token_url(void) { grpc_error_handle expected_error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING( "Error occurred when fetching oauth2 token.", &error, 1); - request_metadata_state* state = - make_request_metadata_state(expected_error, nullptr, 0); - run_request_metadata_test(&creds, auth_md_ctx, state); + RequestMetadataState* state = + RequestMetadataState::NewInstance(expected_error, {}); + state->RunRequestMetadataTest(&creds, auth_md_ctx); GRPC_ERROR_UNREF(error); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); @@ -2501,9 +2514,9 @@ test_external_account_creds_failure_invalid_service_account_impersonation_url( grpc_error_handle expected_error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING( "Error occurred when fetching oauth2 token.", &error, 1); - request_metadata_state* state = - make_request_metadata_state(expected_error, nullptr, 0); - run_request_metadata_test(&creds, auth_md_ctx, state); + RequestMetadataState* state = + RequestMetadataState::NewInstance(expected_error, {}); + state->RunRequestMetadataTest(&creds, auth_md_ctx); GRPC_ERROR_UNREF(error); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); @@ -2539,16 +2552,17 @@ test_external_account_creds_failure_token_exchange_response_missing_access_token grpc_error_handle expected_error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING( "Error occurred when fetching oauth2 token.", &error, 1); - request_metadata_state* state = - make_request_metadata_state(expected_error, nullptr, 0); - run_request_metadata_test(&creds, auth_md_ctx, state); + RequestMetadataState* state = + RequestMetadataState::NewInstance(expected_error, {}); + state->RunRequestMetadataTest(&creds, auth_md_ctx); GRPC_ERROR_UNREF(error); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); } static void test_url_external_account_creds_success_format_text(void) { - expected_md emd[] = {{"authorization", "Bearer token_exchange_access_token"}}; + std::map emd = { + {"authorization", "Bearer token_exchange_access_token"}}; grpc_core::ExecCtx exec_ctx; grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; @@ -2574,18 +2588,19 @@ static void test_url_external_account_creds_success_format_text(void) { GPR_ASSERT(creds != nullptr); GPR_ASSERT(error == GRPC_ERROR_NONE); GPR_ASSERT(creds->min_security_level() == GRPC_PRIVACY_AND_INTEGRITY); - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(url_external_account_creds_httpcli_get_success, external_account_creds_httpcli_post_success); - run_request_metadata_test(creds.get(), auth_md_ctx, state); + state->RunRequestMetadataTest(creds.get(), auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); } static void test_url_external_account_creds_success_with_qurey_params_format_text(void) { - expected_md emd[] = {{"authorization", "Bearer token_exchange_access_token"}}; + std::map emd = { + {"authorization", "Bearer token_exchange_access_token"}}; grpc_core::ExecCtx exec_ctx; grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; @@ -2611,17 +2626,18 @@ test_url_external_account_creds_success_with_qurey_params_format_text(void) { GPR_ASSERT(creds != nullptr); GPR_ASSERT(error == GRPC_ERROR_NONE); GPR_ASSERT(creds->min_security_level() == GRPC_PRIVACY_AND_INTEGRITY); - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(url_external_account_creds_httpcli_get_success, external_account_creds_httpcli_post_success); - run_request_metadata_test(creds.get(), auth_md_ctx, state); + state->RunRequestMetadataTest(creds.get(), auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); } static void test_url_external_account_creds_success_format_json(void) { - expected_md emd[] = {{"authorization", "Bearer token_exchange_access_token"}}; + std::map emd = { + {"authorization", "Bearer token_exchange_access_token"}}; grpc_core::ExecCtx exec_ctx; grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; @@ -2647,11 +2663,11 @@ static void test_url_external_account_creds_success_format_json(void) { GPR_ASSERT(creds != nullptr); GPR_ASSERT(error == GRPC_ERROR_NONE); GPR_ASSERT(creds->min_security_level() == GRPC_PRIVACY_AND_INTEGRITY); - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(url_external_account_creds_httpcli_get_success, external_account_creds_httpcli_post_success); - run_request_metadata_test(creds.get(), auth_md_ctx, state); + state->RunRequestMetadataTest(creds.get(), auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); } @@ -2685,7 +2701,8 @@ test_url_external_account_creds_failure_invalid_credential_source_url(void) { } static void test_file_external_account_creds_success_format_text(void) { - expected_md emd[] = {{"authorization", "Bearer token_exchange_access_token"}}; + std::map emd = { + {"authorization", "Bearer token_exchange_access_token"}}; grpc_core::ExecCtx exec_ctx; grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; @@ -2714,11 +2731,11 @@ static void test_file_external_account_creds_success_format_text(void) { GPR_ASSERT(creds != nullptr); GPR_ASSERT(error == GRPC_ERROR_NONE); GPR_ASSERT(creds->min_security_level() == GRPC_PRIVACY_AND_INTEGRITY); - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(httpcli_get_should_not_be_called, external_account_creds_httpcli_post_success); - run_request_metadata_test(creds.get(), auth_md_ctx, state); + state->RunRequestMetadataTest(creds.get(), auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); GRPC_ERROR_UNREF(error); @@ -2726,7 +2743,8 @@ static void test_file_external_account_creds_success_format_text(void) { } static void test_file_external_account_creds_success_format_json(void) { - expected_md emd[] = {{"authorization", "Bearer token_exchange_access_token"}}; + std::map emd = { + {"authorization", "Bearer token_exchange_access_token"}}; grpc_core::ExecCtx exec_ctx; grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; @@ -2763,11 +2781,11 @@ static void test_file_external_account_creds_success_format_json(void) { GPR_ASSERT(creds != nullptr); GPR_ASSERT(error == GRPC_ERROR_NONE); GPR_ASSERT(creds->min_security_level() == GRPC_PRIVACY_AND_INTEGRITY); - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(httpcli_get_should_not_be_called, external_account_creds_httpcli_post_success); - run_request_metadata_test(creds.get(), auth_md_ctx, state); + state->RunRequestMetadataTest(creds.get(), auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); GRPC_ERROR_UNREF(error); @@ -2804,9 +2822,9 @@ static void test_file_external_account_creds_failure_file_not_found(void) { grpc_error_handle expected_error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING( "Error occurred when fetching oauth2 token.", &error, 1); - request_metadata_state* state = - make_request_metadata_state(expected_error, nullptr, 0); - run_request_metadata_test(creds.get(), auth_md_ctx, state); + RequestMetadataState* state = + RequestMetadataState::NewInstance(expected_error, {}); + state->RunRequestMetadataTest(creds.get(), auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); GRPC_ERROR_UNREF(error); @@ -2855,9 +2873,9 @@ static void test_file_external_account_creds_failure_invalid_json_content( grpc_error_handle expected_error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING( "Error occurred when fetching oauth2 token.", &error, 1); - request_metadata_state* state = - make_request_metadata_state(expected_error, nullptr, 0); - run_request_metadata_test(creds.get(), auth_md_ctx, state); + RequestMetadataState* state = + RequestMetadataState::NewInstance(expected_error, {}); + state->RunRequestMetadataTest(creds.get(), auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); GRPC_ERROR_UNREF(error); @@ -2865,7 +2883,8 @@ static void test_file_external_account_creds_failure_invalid_json_content( } static void test_aws_external_account_creds_success(void) { - expected_md emd[] = {{"authorization", "Bearer token_exchange_access_token"}}; + std::map emd = { + {"authorization", "Bearer token_exchange_access_token"}}; grpc_core::ExecCtx exec_ctx; grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; @@ -2890,18 +2909,19 @@ static void test_aws_external_account_creds_success(void) { GPR_ASSERT(creds != nullptr); GPR_ASSERT(error == GRPC_ERROR_NONE); GPR_ASSERT(creds->min_security_level() == GRPC_PRIVACY_AND_INTEGRITY); - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(aws_external_account_creds_httpcli_get_success, aws_external_account_creds_httpcli_post_success); - run_request_metadata_test(creds.get(), auth_md_ctx, state); + state->RunRequestMetadataTest(creds.get(), auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); } static void test_aws_external_account_creds_success_path_region_env_keys_url( void) { - expected_md emd[] = {{"authorization", "Bearer token_exchange_access_token"}}; + std::map emd = { + {"authorization", "Bearer token_exchange_access_token"}}; grpc_core::ExecCtx exec_ctx; grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; @@ -2927,11 +2947,11 @@ static void test_aws_external_account_creds_success_path_region_env_keys_url( GPR_ASSERT(creds != nullptr); GPR_ASSERT(error == GRPC_ERROR_NONE); GPR_ASSERT(creds->min_security_level() == GRPC_PRIVACY_AND_INTEGRITY); - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(aws_external_account_creds_httpcli_get_success, aws_external_account_creds_httpcli_post_success); - run_request_metadata_test(creds.get(), auth_md_ctx, state); + state->RunRequestMetadataTest(creds.get(), auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); gpr_unsetenv("AWS_REGION"); @@ -2939,7 +2959,8 @@ static void test_aws_external_account_creds_success_path_region_env_keys_url( static void test_aws_external_account_creds_success_path_default_region_env_keys_url(void) { - expected_md emd[] = {{"authorization", "Bearer token_exchange_access_token"}}; + std::map emd = { + {"authorization", "Bearer token_exchange_access_token"}}; grpc_core::ExecCtx exec_ctx; grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; @@ -2965,11 +2986,11 @@ test_aws_external_account_creds_success_path_default_region_env_keys_url(void) { GPR_ASSERT(creds != nullptr); GPR_ASSERT(error == GRPC_ERROR_NONE); GPR_ASSERT(creds->min_security_level() == GRPC_PRIVACY_AND_INTEGRITY); - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(aws_external_account_creds_httpcli_get_success, aws_external_account_creds_httpcli_post_success); - run_request_metadata_test(creds.get(), auth_md_ctx, state); + state->RunRequestMetadataTest(creds.get(), auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); gpr_unsetenv("AWS_DEFAULT_REGION"); @@ -2978,7 +2999,8 @@ test_aws_external_account_creds_success_path_default_region_env_keys_url(void) { static void test_aws_external_account_creds_success_path_duplicate_region_env_keys_url( void) { - expected_md emd[] = {{"authorization", "Bearer token_exchange_access_token"}}; + std::map emd = { + {"authorization", "Bearer token_exchange_access_token"}}; grpc_core::ExecCtx exec_ctx; grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; @@ -3006,11 +3028,11 @@ test_aws_external_account_creds_success_path_duplicate_region_env_keys_url( GPR_ASSERT(creds != nullptr); GPR_ASSERT(error == GRPC_ERROR_NONE); GPR_ASSERT(creds->min_security_level() == GRPC_PRIVACY_AND_INTEGRITY); - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(aws_external_account_creds_httpcli_get_success, aws_external_account_creds_httpcli_post_success); - run_request_metadata_test(creds.get(), auth_md_ctx, state); + state->RunRequestMetadataTest(creds.get(), auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); gpr_unsetenv("AWS_REGION"); @@ -3019,7 +3041,8 @@ test_aws_external_account_creds_success_path_duplicate_region_env_keys_url( static void test_aws_external_account_creds_success_path_region_url_keys_env( void) { - expected_md emd[] = {{"authorization", "Bearer token_exchange_access_token"}}; + std::map emd = { + {"authorization", "Bearer token_exchange_access_token"}}; grpc_core::ExecCtx exec_ctx; grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; @@ -3047,11 +3070,11 @@ static void test_aws_external_account_creds_success_path_region_url_keys_env( GPR_ASSERT(creds != nullptr); GPR_ASSERT(error == GRPC_ERROR_NONE); GPR_ASSERT(creds->min_security_level() == GRPC_PRIVACY_AND_INTEGRITY); - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(aws_external_account_creds_httpcli_get_success, aws_external_account_creds_httpcli_post_success); - run_request_metadata_test(creds.get(), auth_md_ctx, state); + state->RunRequestMetadataTest(creds.get(), auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); gpr_unsetenv("AWS_ACCESS_KEY_ID"); @@ -3061,7 +3084,8 @@ static void test_aws_external_account_creds_success_path_region_url_keys_env( static void test_aws_external_account_creds_success_path_region_env_keys_env( void) { - expected_md emd[] = {{"authorization", "Bearer token_exchange_access_token"}}; + std::map emd = { + {"authorization", "Bearer token_exchange_access_token"}}; grpc_core::ExecCtx exec_ctx; grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; @@ -3090,11 +3114,11 @@ static void test_aws_external_account_creds_success_path_region_env_keys_env( GPR_ASSERT(creds != nullptr); GPR_ASSERT(error == GRPC_ERROR_NONE); GPR_ASSERT(creds->min_security_level() == GRPC_PRIVACY_AND_INTEGRITY); - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(aws_external_account_creds_httpcli_get_success, aws_external_account_creds_httpcli_post_success); - run_request_metadata_test(creds.get(), auth_md_ctx, state); + state->RunRequestMetadataTest(creds.get(), auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); gpr_unsetenv("AWS_REGION"); @@ -3105,7 +3129,8 @@ static void test_aws_external_account_creds_success_path_region_env_keys_env( static void test_aws_external_account_creds_success_path_default_region_env_keys_env(void) { - expected_md emd[] = {{"authorization", "Bearer token_exchange_access_token"}}; + std::map emd = { + {"authorization", "Bearer token_exchange_access_token"}}; grpc_core::ExecCtx exec_ctx; grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; @@ -3134,11 +3159,11 @@ test_aws_external_account_creds_success_path_default_region_env_keys_env(void) { GPR_ASSERT(creds != nullptr); GPR_ASSERT(error == GRPC_ERROR_NONE); GPR_ASSERT(creds->min_security_level() == GRPC_PRIVACY_AND_INTEGRITY); - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(aws_external_account_creds_httpcli_get_success, aws_external_account_creds_httpcli_post_success); - run_request_metadata_test(creds.get(), auth_md_ctx, state); + state->RunRequestMetadataTest(creds.get(), auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); gpr_unsetenv("AWS_DEFAULT_REGION"); @@ -3150,7 +3175,8 @@ test_aws_external_account_creds_success_path_default_region_env_keys_env(void) { static void test_aws_external_account_creds_success_path_duplicate_region_env_keys_env( void) { - expected_md emd[] = {{"authorization", "Bearer token_exchange_access_token"}}; + std::map emd = { + {"authorization", "Bearer token_exchange_access_token"}}; grpc_core::ExecCtx exec_ctx; grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, nullptr, nullptr}; @@ -3181,11 +3207,11 @@ test_aws_external_account_creds_success_path_duplicate_region_env_keys_env( GPR_ASSERT(creds != nullptr); GPR_ASSERT(error == GRPC_ERROR_NONE); GPR_ASSERT(creds->min_security_level() == GRPC_PRIVACY_AND_INTEGRITY); - request_metadata_state* state = - make_request_metadata_state(GRPC_ERROR_NONE, emd, GPR_ARRAY_SIZE(emd)); + RequestMetadataState* state = + RequestMetadataState::NewInstance(GRPC_ERROR_NONE, emd); grpc_httpcli_set_override(aws_external_account_creds_httpcli_get_success, aws_external_account_creds_httpcli_post_success); - run_request_metadata_test(creds.get(), auth_md_ctx, state); + state->RunRequestMetadataTest(creds.get(), auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); gpr_unsetenv("AWS_REGION"); @@ -3256,11 +3282,11 @@ static void test_aws_external_account_creds_failure_invalid_region_url(void) { grpc_error_handle expected_error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING( "Error occurred when fetching oauth2 token.", &error, 1); - request_metadata_state* state = - make_request_metadata_state(expected_error, nullptr, 0); + RequestMetadataState* state = + RequestMetadataState::NewInstance(expected_error, {}); grpc_httpcli_set_override(aws_external_account_creds_httpcli_get_success, aws_external_account_creds_httpcli_post_success); - run_request_metadata_test(creds.get(), auth_md_ctx, state); + state->RunRequestMetadataTest(creds.get(), auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); GRPC_ERROR_UNREF(error); @@ -3296,11 +3322,11 @@ static void test_aws_external_account_creds_failure_invalid_url(void) { grpc_error_handle expected_error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING( "Error occurred when fetching oauth2 token.", &error, 1); - request_metadata_state* state = - make_request_metadata_state(expected_error, nullptr, 0); + RequestMetadataState* state = + RequestMetadataState::NewInstance(expected_error, {}); grpc_httpcli_set_override(aws_external_account_creds_httpcli_get_success, aws_external_account_creds_httpcli_post_success); - run_request_metadata_test(creds.get(), auth_md_ctx, state); + state->RunRequestMetadataTest(creds.get(), auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); GRPC_ERROR_UNREF(error); @@ -3337,11 +3363,11 @@ static void test_aws_external_account_creds_failure_missing_role_name(void) { grpc_error_handle expected_error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING( "Error occurred when fetching oauth2 token.", &error, 1); - request_metadata_state* state = - make_request_metadata_state(expected_error, nullptr, 0); + RequestMetadataState* state = + RequestMetadataState::NewInstance(expected_error, {}); grpc_httpcli_set_override(aws_external_account_creds_httpcli_get_success, aws_external_account_creds_httpcli_post_success); - run_request_metadata_test(creds.get(), auth_md_ctx, state); + state->RunRequestMetadataTest(creds.get(), auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); GRPC_ERROR_UNREF(error); @@ -3380,11 +3406,11 @@ test_aws_external_account_creds_failure_invalid_regional_cred_verification_url( grpc_error_handle expected_error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING( "Error occurred when fetching oauth2 token.", &error, 1); - request_metadata_state* state = - make_request_metadata_state(expected_error, nullptr, 0); + RequestMetadataState* state = + RequestMetadataState::NewInstance(expected_error, {}); grpc_httpcli_set_override(aws_external_account_creds_httpcli_get_success, aws_external_account_creds_httpcli_post_success); - run_request_metadata_test(creds.get(), auth_md_ctx, state); + state->RunRequestMetadataTest(creds.get(), auth_md_ctx); grpc_core::ExecCtx::Get()->Flush(); grpc_httpcli_set_override(nullptr, nullptr); GRPC_ERROR_UNREF(error);