From 4d20a666850b732cf1562487fb5f46ab9654105f Mon Sep 17 00:00:00 2001 From: Noah Eisen Date: Fri, 9 Feb 2018 09:34:04 -0800 Subject: Run clang fmt --- src/core/lib/backoff/backoff.cc | 9 +-- src/core/lib/channel/channel_args.cc | 9 ++- src/core/lib/channel/channel_stack.cc | 15 +++-- src/core/lib/channel/channel_stack_builder.cc | 13 +++-- src/core/lib/channel/connected_channel.cc | 3 +- src/core/lib/channel/handshaker.cc | 8 +-- src/core/lib/channel/handshaker_registry.cc | 3 +- src/core/lib/compression/compression_internal.cc | 3 +- src/core/lib/compression/message_compress.cc | 6 +- .../lib/compression/stream_compression_gzip.cc | 6 +- src/core/lib/debug/stats.cc | 10 ++-- src/core/lib/gpr/arena.cc | 20 ++++--- src/core/lib/gpr/log.cc | 3 +- src/core/lib/gpr/string.cc | 6 +- src/core/lib/gpr/thd_posix.cc | 8 ++- src/core/lib/gpr/time.cc | 8 ++- src/core/lib/http/format_request.cc | 3 +- src/core/lib/http/httpcli_security_connector.cc | 4 +- src/core/lib/http/parser.cc | 13 +++-- src/core/lib/iomgr/call_combiner.cc | 15 ++--- src/core/lib/iomgr/combiner.cc | 3 +- src/core/lib/iomgr/error.cc | 38 ++++++------ src/core/lib/iomgr/ev_epoll1_linux.cc | 4 +- src/core/lib/iomgr/ev_epollex_linux.cc | 24 ++++---- src/core/lib/iomgr/ev_epollsig_linux.cc | 10 ++-- src/core/lib/iomgr/ev_poll_posix.cc | 47 ++++++++------- src/core/lib/iomgr/exec_ctx.cc | 7 ++- src/core/lib/iomgr/executor.cc | 13 +++-- src/core/lib/iomgr/is_epollexclusive_available.cc | 3 +- src/core/lib/iomgr/load_file.cc | 4 +- src/core/lib/iomgr/resolve_address_posix.cc | 8 +-- src/core/lib/iomgr/resource_quota.cc | 10 ++-- src/core/lib/iomgr/sockaddr_utils.cc | 48 ++++++++++------ src/core/lib/iomgr/socket_utils_common_posix.cc | 6 +- src/core/lib/iomgr/socket_utils_linux.cc | 3 +- src/core/lib/iomgr/tcp_client_posix.cc | 7 ++- src/core/lib/iomgr/tcp_posix.cc | 29 +++++----- src/core/lib/iomgr/tcp_server_posix.cc | 9 ++- .../lib/iomgr/tcp_server_utils_posix_common.cc | 4 +- .../lib/iomgr/tcp_server_utils_posix_ifaddrs.cc | 7 ++- src/core/lib/iomgr/timer_generic.cc | 11 ++-- src/core/lib/iomgr/timer_heap.cc | 8 +-- src/core/lib/iomgr/timer_manager.cc | 3 +- src/core/lib/iomgr/udp_server.cc | 24 +++++--- src/core/lib/iomgr/unix_sockets_posix.cc | 20 ++++--- src/core/lib/iomgr/wakeup_fd_cv.cc | 4 +- src/core/lib/json/json_reader.cc | 6 +- src/core/lib/json/json_string.cc | 3 +- src/core/lib/json/json_writer.cc | 6 +- src/core/lib/security/context/security_context.cc | 24 ++++---- .../credentials/composite/composite_credentials.cc | 17 +++--- src/core/lib/security/credentials/credentials.cc | 7 ++- .../security/credentials/credentials_metadata.cc | 4 +- .../security/credentials/fake/fake_credentials.cc | 19 +++--- .../google_default/google_default_credentials.cc | 9 ++- .../security/credentials/iam/iam_credentials.cc | 6 +- .../lib/security/credentials/jwt/json_token.cc | 3 +- .../security/credentials/jwt/jwt_credentials.cc | 4 +- .../lib/security/credentials/jwt/jwt_verifier.cc | 22 ++++--- .../credentials/oauth2/oauth2_credentials.cc | 29 ++++++---- .../credentials/plugin/plugin_credentials.cc | 16 ++++-- .../security/credentials/ssl/ssl_credentials.cc | 39 +++++++------ .../lib/security/transport/client_auth_filter.cc | 20 +++---- src/core/lib/security/transport/lb_targets_info.cc | 8 ++- src/core/lib/security/transport/secure_endpoint.cc | 10 ++-- .../lib/security/transport/security_connector.cc | 37 ++++++------ .../lib/security/transport/security_handshaker.cc | 19 +++--- src/core/lib/slice/b64.cc | 9 ++- src/core/lib/slice/slice.cc | 20 ++++--- src/core/lib/slice/slice_buffer.cc | 18 +++--- src/core/lib/slice/slice_hash_table.cc | 3 +- src/core/lib/slice/slice_intern.cc | 21 ++++--- src/core/lib/slice/slice_string_helpers.cc | 9 +-- src/core/lib/surface/call.cc | 34 ++++++----- src/core/lib/surface/channel.cc | 12 ++-- src/core/lib/surface/channel_init.cc | 9 +-- src/core/lib/surface/completion_queue.cc | 67 ++++++++++++---------- src/core/lib/surface/server.cc | 54 +++++++++-------- src/core/lib/transport/bdp_estimator.cc | 7 ++- src/core/lib/transport/byte_stream.cc | 24 +++++--- src/core/lib/transport/connectivity_state.cc | 8 +-- src/core/lib/transport/error_utils.cc | 13 +++-- src/core/lib/transport/metadata.cc | 31 ++++++---- src/core/lib/transport/service_config.cc | 4 +- src/core/lib/transport/timeout_encoding.cc | 3 +- src/core/lib/transport/transport.cc | 3 +- 86 files changed, 687 insertions(+), 489 deletions(-) (limited to 'src/core/lib') diff --git a/src/core/lib/backoff/backoff.cc b/src/core/lib/backoff/backoff.cc index 81ea429a6a..4b74afc244 100644 --- a/src/core/lib/backoff/backoff.cc +++ b/src/core/lib/backoff/backoff.cc @@ -55,13 +55,14 @@ grpc_millis BackOff::NextAttemptTime() { initial_ = false; return current_backoff_ + grpc_core::ExecCtx::Get()->Now(); } - current_backoff_ = - static_cast(std::min(current_backoff_ * options_.multiplier(), - static_cast(options_.max_backoff()))); + current_backoff_ = static_cast( + std::min(current_backoff_ * options_.multiplier(), + static_cast(options_.max_backoff()))); const double jitter = generate_uniform_random_number_between( &rng_state_, -options_.jitter() * current_backoff_, options_.jitter() * current_backoff_); - const grpc_millis next_timeout = static_cast(current_backoff_ + jitter); + const grpc_millis next_timeout = + static_cast(current_backoff_ + jitter); return next_timeout + grpc_core::ExecCtx::Get()->Now(); } diff --git a/src/core/lib/channel/channel_args.cc b/src/core/lib/channel/channel_args.cc index 8f448bfd91..98fdfa6b9a 100644 --- a/src/core/lib/channel/channel_args.cc +++ b/src/core/lib/channel/channel_args.cc @@ -93,7 +93,8 @@ grpc_channel_args* grpc_channel_args_copy_and_add_and_remove( dst->args = nullptr; return dst; } - dst->args = static_cast(gpr_malloc(sizeof(grpc_arg) * dst->num_args)); + dst->args = + static_cast(gpr_malloc(sizeof(grpc_arg) * dst->num_args)); // Copy args from src that are not being removed. size_t dst_idx = 0; if (src != nullptr) { @@ -118,7 +119,8 @@ grpc_channel_args* grpc_channel_args_copy(const grpc_channel_args* src) { grpc_channel_args* grpc_channel_args_union(const grpc_channel_args* a, const grpc_channel_args* b) { const size_t max_out = (a->num_args + b->num_args); - grpc_arg* uniques = static_cast(gpr_malloc(sizeof(*uniques) * max_out)); + grpc_arg* uniques = + static_cast(gpr_malloc(sizeof(*uniques) * max_out)); for (size_t i = 0; i < a->num_args; ++i) uniques[i] = a->args[i]; size_t uniques_idx = a->num_args; @@ -169,7 +171,8 @@ static int cmp_key_stable(const void* ap, const void* bp) { } grpc_channel_args* grpc_channel_args_normalize(const grpc_channel_args* a) { - grpc_arg** args = static_cast(gpr_malloc(sizeof(grpc_arg*) * a->num_args)); + grpc_arg** args = + static_cast(gpr_malloc(sizeof(grpc_arg*) * a->num_args)); for (size_t i = 0; i < a->num_args; i++) { args[i] = &a->args[i]; } diff --git a/src/core/lib/channel/channel_stack.cc b/src/core/lib/channel/channel_stack.cc index c311c73b85..737d828e4b 100644 --- a/src/core/lib/channel/channel_stack.cc +++ b/src/core/lib/channel/channel_stack.cc @@ -104,8 +104,9 @@ grpc_error* grpc_channel_stack_init( GRPC_STREAM_REF_INIT(&stack->refcount, initial_refs, destroy, destroy_arg, name); elems = CHANNEL_ELEMS_FROM_STACK(stack); - user_data = (reinterpret_cast(elems)) + ROUND_UP_TO_ALIGNMENT_SIZE( - filter_count * sizeof(grpc_channel_element)); + user_data = + (reinterpret_cast(elems)) + + ROUND_UP_TO_ALIGNMENT_SIZE(filter_count * sizeof(grpc_channel_element)); /* init per-filter data */ grpc_error* first_error = GRPC_ERROR_NONE; @@ -243,11 +244,13 @@ void grpc_channel_next_op(grpc_channel_element* elem, grpc_transport_op* op) { grpc_channel_stack* grpc_channel_stack_from_top_element( grpc_channel_element* elem) { - return reinterpret_cast(reinterpret_cast(elem)-ROUND_UP_TO_ALIGNMENT_SIZE( - sizeof(grpc_channel_stack))); + return reinterpret_cast( + reinterpret_cast(elem) - + ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_channel_stack))); } grpc_call_stack* grpc_call_stack_from_top_element(grpc_call_element* elem) { - return reinterpret_cast(reinterpret_cast(elem)-ROUND_UP_TO_ALIGNMENT_SIZE( - sizeof(grpc_call_stack))); + return reinterpret_cast( + reinterpret_cast(elem) - + ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call_stack))); } diff --git a/src/core/lib/channel/channel_stack_builder.cc b/src/core/lib/channel/channel_stack_builder.cc index c04f4c603a..cae862ec0e 100644 --- a/src/core/lib/channel/channel_stack_builder.cc +++ b/src/core/lib/channel/channel_stack_builder.cc @@ -78,7 +78,8 @@ const char* grpc_channel_stack_builder_get_target( static grpc_channel_stack_builder_iterator* create_iterator_at_filter_node( grpc_channel_stack_builder* builder, filter_node* node) { grpc_channel_stack_builder_iterator* it = - static_cast(gpr_malloc(sizeof(*it))); + static_cast( + gpr_malloc(sizeof(*it))); it->builder = builder; it->node = node; return it; @@ -213,7 +214,8 @@ bool grpc_channel_stack_builder_prepend_filter( static void add_after(filter_node* before, const grpc_channel_filter* filter, grpc_post_filter_create_init_func post_init_func, void* user_data) { - filter_node* new_node = static_cast(gpr_malloc(sizeof(*new_node))); + filter_node* new_node = + static_cast(gpr_malloc(sizeof(*new_node))); new_node->next = before->next; new_node->prev = before; new_node->next->prev = new_node->prev->next = new_node; @@ -265,7 +267,8 @@ grpc_error* grpc_channel_stack_builder_finish( // create an array of filters const grpc_channel_filter** filters = - static_cast(gpr_malloc(sizeof(*filters) * num_filters)); + static_cast( + gpr_malloc(sizeof(*filters) * num_filters)); size_t i = 0; for (filter_node* p = builder->begin.next; p != &builder->end; p = p->next) { filters[i++] = p->filter; @@ -277,8 +280,8 @@ grpc_error* grpc_channel_stack_builder_finish( // allocate memory, with prefix_bytes followed by channel_stack_size *result = gpr_zalloc(prefix_bytes + channel_stack_size); // fetch a pointer to the channel stack - grpc_channel_stack* channel_stack = - reinterpret_cast(static_cast(*result) + prefix_bytes); + grpc_channel_stack* channel_stack = reinterpret_cast( + static_cast(*result) + prefix_bytes); // and initialize it grpc_error* error = grpc_channel_stack_init( initial_refs, destroy, destroy_arg == nullptr ? *result : destroy_arg, diff --git a/src/core/lib/channel/connected_channel.cc b/src/core/lib/channel/connected_channel.cc index 516d49e4d3..a16e89ce00 100644 --- a/src/core/lib/channel/connected_channel.cc +++ b/src/core/lib/channel/connected_channel.cc @@ -115,7 +115,8 @@ static void con_start_transport_stream_op_batch( // calld->on_complete like we can for the other ops. However, // cancellation isn't in the fast path, so we just allocate a new // closure for each one. - callback_state* state = static_cast(gpr_malloc(sizeof(*state))); + callback_state* state = + static_cast(gpr_malloc(sizeof(*state))); intercept_callback(calld, state, true, "on_complete (cancel_stream)", &batch->on_complete); } else { diff --git a/src/core/lib/channel/handshaker.cc b/src/core/lib/channel/handshaker.cc index daacbdebd3..518e880c15 100644 --- a/src/core/lib/channel/handshaker.cc +++ b/src/core/lib/channel/handshaker.cc @@ -81,8 +81,8 @@ struct grpc_handshake_manager { }; grpc_handshake_manager* grpc_handshake_manager_create() { - grpc_handshake_manager* mgr = - static_cast(gpr_zalloc(sizeof(grpc_handshake_manager))); + grpc_handshake_manager* mgr = static_cast( + gpr_zalloc(sizeof(grpc_handshake_manager))); gpr_mu_init(&mgr->mu); gpr_ref_init(&mgr->refs, 1); return mgr; @@ -233,8 +233,8 @@ void grpc_handshake_manager_do_handshake( mgr->args.endpoint = endpoint; mgr->args.args = grpc_channel_args_copy(channel_args); mgr->args.user_data = user_data; - mgr->args.read_buffer = - static_cast(gpr_malloc(sizeof(*mgr->args.read_buffer))); + mgr->args.read_buffer = static_cast( + gpr_malloc(sizeof(*mgr->args.read_buffer))); grpc_slice_buffer_init(mgr->args.read_buffer); // Initialize state needed for calling handshakers. mgr->acceptor = acceptor; diff --git a/src/core/lib/channel/handshaker_registry.cc b/src/core/lib/channel/handshaker_registry.cc index f23f009275..5464cc42f4 100644 --- a/src/core/lib/channel/handshaker_registry.cc +++ b/src/core/lib/channel/handshaker_registry.cc @@ -35,7 +35,8 @@ static void grpc_handshaker_factory_list_register( grpc_handshaker_factory_list* list, bool at_start, grpc_handshaker_factory* factory) { list->list = static_cast(gpr_realloc( - list->list, (list->num_factories + 1) * sizeof(grpc_handshaker_factory*))); + list->list, + (list->num_factories + 1) * sizeof(grpc_handshaker_factory*))); if (at_start) { memmove(list->list + 1, list->list, sizeof(grpc_handshaker_factory*) * list->num_factories); diff --git a/src/core/lib/compression/compression_internal.cc b/src/core/lib/compression/compression_internal.cc index e49c67f784..36829c8adf 100644 --- a/src/core/lib/compression/compression_internal.cc +++ b/src/core/lib/compression/compression_internal.cc @@ -190,7 +190,8 @@ grpc_message_compression_algorithm grpc_message_compression_algorithm_for_level( GRPC_API_TRACE("grpc_message_compression_algorithm_for_level(level=%d)", 1, ((int)level)); if (level > GRPC_COMPRESS_LEVEL_HIGH) { - gpr_log(GPR_ERROR, "Unknown message compression level %d.", static_cast(level)); + gpr_log(GPR_ERROR, "Unknown message compression level %d.", + static_cast(level)); abort(); } diff --git a/src/core/lib/compression/message_compress.cc b/src/core/lib/compression/message_compress.cc index 238eff780c..2e44551935 100644 --- a/src/core/lib/compression/message_compress.cc +++ b/src/core/lib/compression/message_compress.cc @@ -39,20 +39,20 @@ static int zlib_body(z_stream* zs, grpc_slice_buffer* input, const uInt uint_max = ~static_cast(0); GPR_ASSERT(GRPC_SLICE_LENGTH(outbuf) <= uint_max); - zs->avail_out = static_castGRPC_SLICE_LENGTH(outbuf); + zs->avail_out = static_cast GRPC_SLICE_LENGTH(outbuf); zs->next_out = GRPC_SLICE_START_PTR(outbuf); flush = Z_NO_FLUSH; for (i = 0; i < input->count; i++) { if (i == input->count - 1) flush = Z_FINISH; GPR_ASSERT(GRPC_SLICE_LENGTH(input->slices[i]) <= uint_max); - zs->avail_in = static_castGRPC_SLICE_LENGTH(input->slices[i]); + zs->avail_in = static_cast GRPC_SLICE_LENGTH(input->slices[i]); zs->next_in = GRPC_SLICE_START_PTR(input->slices[i]); do { if (zs->avail_out == 0) { grpc_slice_buffer_add_indexed(output, outbuf); outbuf = GRPC_SLICE_MALLOC(OUTPUT_BLOCK_SIZE); GPR_ASSERT(GRPC_SLICE_LENGTH(outbuf) <= uint_max); - zs->avail_out = static_castGRPC_SLICE_LENGTH(outbuf); + zs->avail_out = static_cast GRPC_SLICE_LENGTH(outbuf); zs->next_out = GRPC_SLICE_START_PTR(outbuf); } r = flate(zs, flush); diff --git a/src/core/lib/compression/stream_compression_gzip.cc b/src/core/lib/compression/stream_compression_gzip.cc index c48fe9305d..48fe99b69f 100644 --- a/src/core/lib/compression/stream_compression_gzip.cc +++ b/src/core/lib/compression/stream_compression_gzip.cc @@ -52,7 +52,7 @@ static bool gzip_flate(grpc_stream_compression_context_gzip* ctx, ctx->zs.next_out = GRPC_SLICE_START_PTR(slice_out); while (ctx->zs.avail_out > 0 && in->length > 0 && !eoc) { grpc_slice slice = grpc_slice_buffer_take_first(in); - ctx->zs.avail_in = static_castGRPC_SLICE_LENGTH(slice); + ctx->zs.avail_in = static_cast GRPC_SLICE_LENGTH(slice); ctx->zs.next_in = GRPC_SLICE_START_PTR(slice); r = ctx->flate(&ctx->zs, Z_NO_FLUSH); if (r < 0 && r != Z_BUF_ERROR) { @@ -184,8 +184,8 @@ grpc_stream_compression_context_create_gzip( GPR_ASSERT(method == GRPC_STREAM_COMPRESSION_GZIP_COMPRESS || method == GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS); grpc_stream_compression_context_gzip* gzip_ctx = - static_cast(gpr_zalloc( - sizeof(grpc_stream_compression_context_gzip))); + static_cast( + gpr_zalloc(sizeof(grpc_stream_compression_context_gzip))); int r; if (gzip_ctx == nullptr) { return nullptr; diff --git a/src/core/lib/debug/stats.cc b/src/core/lib/debug/stats.cc index f4de6a82a9..09a86287e4 100644 --- a/src/core/lib/debug/stats.cc +++ b/src/core/lib/debug/stats.cc @@ -32,8 +32,8 @@ static size_t g_num_cores; void grpc_stats_init(void) { g_num_cores = GPR_MAX(1, gpr_cpu_num_cores()); - grpc_stats_per_cpu_storage = - static_cast(gpr_zalloc(sizeof(grpc_stats_data) * g_num_cores)); + grpc_stats_per_cpu_storage = static_cast( + gpr_zalloc(sizeof(grpc_stats_data) * g_num_cores)); } void grpc_stats_shutdown(void) { gpr_free(grpc_stats_per_cpu_storage); } @@ -83,7 +83,8 @@ size_t grpc_stats_histo_count(const grpc_stats_data* stats, grpc_stats_histograms histogram) { size_t sum = 0; for (int i = 0; i < grpc_stats_histo_buckets[histogram]; i++) { - sum += static_cast(stats->histograms[grpc_stats_histo_start[histogram] + i]); + sum += static_cast( + stats->histograms[grpc_stats_histo_start[histogram] + i]); } return sum; } @@ -133,7 +134,8 @@ double grpc_stats_histo_percentile(const grpc_stats_data* stats, return threshold_for_count_below( stats->histograms + grpc_stats_histo_start[histogram], grpc_stats_histo_bucket_boundaries[histogram], - grpc_stats_histo_buckets[histogram], static_cast(count) * percentile / 100.0); + grpc_stats_histo_buckets[histogram], + static_cast(count) * percentile / 100.0); } char* grpc_stats_data_as_json(const grpc_stats_data* data) { diff --git a/src/core/lib/gpr/arena.cc b/src/core/lib/gpr/arena.cc index a1eefa56bc..5bc575f711 100644 --- a/src/core/lib/gpr/arena.cc +++ b/src/core/lib/gpr/arena.cc @@ -71,18 +71,20 @@ size_t gpr_arena_destroy(gpr_arena* arena) { void* gpr_arena_alloc(gpr_arena* arena, size_t size) { size = ROUND_UP_TO_ALIGNMENT_SIZE(size); - size_t start = - static_cast(gpr_atm_no_barrier_fetch_add(&arena->size_so_far, size)); + size_t start = static_cast( + gpr_atm_no_barrier_fetch_add(&arena->size_so_far, size)); zone* z = &arena->initial_zone; while (start > z->size_end) { zone* next_z = (zone*)gpr_atm_acq_load(&z->next_atm); if (next_z == nullptr) { - size_t next_z_size = static_castgpr_atm_no_barrier_load(&arena->size_so_far); - next_z = static_cast(zalloc_aligned(ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(zone)) + - next_z_size)); + size_t next_z_size = + static_cast gpr_atm_no_barrier_load(&arena->size_so_far); + next_z = static_cast(zalloc_aligned( + ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(zone)) + next_z_size)); next_z->size_begin = z->size_end; next_z->size_end = z->size_end + next_z_size; - if (!gpr_atm_rel_cas(&z->next_atm, static_cast(NULL), (gpr_atm)next_z)) { + if (!gpr_atm_rel_cas(&z->next_atm, static_cast(NULL), + (gpr_atm)next_z)) { gpr_free_aligned(next_z); next_z = (zone*)gpr_atm_acq_load(&z->next_atm); } @@ -95,7 +97,9 @@ void* gpr_arena_alloc(gpr_arena* arena, size_t size) { GPR_ASSERT(start >= z->size_begin); GPR_ASSERT(start + size <= z->size_end); char* ptr = (z == &arena->initial_zone) - ? reinterpret_cast(arena) + ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(gpr_arena)) - : reinterpret_cast(z) + ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(zone)); + ? reinterpret_cast(arena) + + ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(gpr_arena)) + : reinterpret_cast(z) + + ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(zone)); return ptr + start - z->size_begin; } diff --git a/src/core/lib/gpr/log.cc b/src/core/lib/gpr/log.cc index 9211a00a69..410096c0f7 100644 --- a/src/core/lib/gpr/log.cc +++ b/src/core/lib/gpr/log.cc @@ -45,7 +45,8 @@ const char* gpr_log_severity_string(gpr_log_severity severity) { void gpr_log_message(const char* file, int line, gpr_log_severity severity, const char* message) { - if (static_cast(severity) < gpr_atm_no_barrier_load(&g_min_severity_to_print)) { + if (static_cast(severity) < + gpr_atm_no_barrier_load(&g_min_severity_to_print)) { return; } diff --git a/src/core/lib/gpr/string.cc b/src/core/lib/gpr/string.cc index 9c07f43cae..5a16377e49 100644 --- a/src/core/lib/gpr/string.cc +++ b/src/core/lib/gpr/string.cc @@ -243,7 +243,8 @@ void gpr_strvec_destroy(gpr_strvec* sv) { void gpr_strvec_add(gpr_strvec* sv, char* str) { if (sv->count == sv->capacity) { sv->capacity = GPR_MAX(sv->capacity + 8, sv->capacity * 2); - sv->strs = static_cast(gpr_realloc(sv->strs, sizeof(char*) * sv->capacity)); + sv->strs = static_cast( + gpr_realloc(sv->strs, sizeof(char*) * sv->capacity)); } sv->strs[sv->count++] = str; } @@ -265,7 +266,8 @@ int gpr_stricmp(const char* a, const char* b) { static void add_string_to_split(const char* beg, const char* end, char*** strs, size_t* nstrs, size_t* capstrs) { - char* out = static_cast(gpr_malloc(static_cast(end - beg) + 1)); + char* out = + static_cast(gpr_malloc(static_cast(end - beg) + 1)); memcpy(out, beg, static_cast(end - beg)); out[end - beg] = 0; if (*nstrs == *capstrs) { diff --git a/src/core/lib/gpr/thd_posix.cc b/src/core/lib/gpr/thd_posix.cc index e8e61ca396..ce268e1fbc 100644 --- a/src/core/lib/gpr/thd_posix.cc +++ b/src/core/lib/gpr/thd_posix.cc @@ -103,9 +103,13 @@ int gpr_thd_new(gpr_thd_id* t, const char* thd_name, return thread_started; } -gpr_thd_id gpr_thd_currentid(void) { return static_cast(pthread_self()); } +gpr_thd_id gpr_thd_currentid(void) { + return static_cast(pthread_self()); +} -void gpr_thd_join(gpr_thd_id t) { pthread_join(static_cast(t), nullptr); } +void gpr_thd_join(gpr_thd_id t) { + pthread_join(static_cast(t), nullptr); +} /***************************************** * Only used when fork support is enabled diff --git a/src/core/lib/gpr/time.cc b/src/core/lib/gpr/time.cc index 9ebfaa7525..39ebeb4339 100644 --- a/src/core/lib/gpr/time.cc +++ b/src/core/lib/gpr/time.cc @@ -81,8 +81,9 @@ static gpr_timespec to_seconds_from_sub_second_time(int64_t time_in_units, units_per_sec) - 1; } - out.tv_nsec = static_cast((time_in_units - out.tv_sec * units_per_sec) * - GPR_NS_PER_SEC / units_per_sec); + out.tv_nsec = + static_cast((time_in_units - out.tv_sec * units_per_sec) * + GPR_NS_PER_SEC / units_per_sec); out.clock_type = type; } return out; @@ -216,7 +217,8 @@ int32_t gpr_time_to_millis(gpr_timespec t) { care?) */ return -2147483647; } else { - return static_cast(t.tv_sec * GPR_MS_PER_SEC + t.tv_nsec / GPR_NS_PER_MS); + return static_cast(t.tv_sec * GPR_MS_PER_SEC + + t.tv_nsec / GPR_NS_PER_MS); } } diff --git a/src/core/lib/http/format_request.cc b/src/core/lib/http/format_request.cc index ff273ffc1a..6581bef7cd 100644 --- a/src/core/lib/http/format_request.cc +++ b/src/core/lib/http/format_request.cc @@ -89,7 +89,8 @@ grpc_slice grpc_httpcli_format_post_request(const grpc_httpcli_request* request, if (!has_content_type) { gpr_strvec_add(&out, gpr_strdup("Content-Type: text/plain\r\n")); } - gpr_asprintf(&tmp, "Content-Length: %lu\r\n", static_cast(body_size)); + gpr_asprintf(&tmp, "Content-Length: %lu\r\n", + static_cast(body_size)); gpr_strvec_add(&out, tmp); } gpr_strvec_add(&out, gpr_strdup("\r\n")); diff --git a/src/core/lib/http/httpcli_security_connector.cc b/src/core/lib/http/httpcli_security_connector.cc index ab684f6093..d754558060 100644 --- a/src/core/lib/http/httpcli_security_connector.cc +++ b/src/core/lib/http/httpcli_security_connector.cc @@ -111,8 +111,8 @@ static grpc_security_status httpcli_ssl_channel_security_connector_create( return GRPC_SECURITY_ERROR; } - c = static_cast(gpr_zalloc( - sizeof(grpc_httpcli_ssl_channel_security_connector))); + c = static_cast( + gpr_zalloc(sizeof(grpc_httpcli_ssl_channel_security_connector))); gpr_ref_init(&c->base.base.refcount, 1); c->base.base.vtable = &httpcli_ssl_vtable; diff --git a/src/core/lib/http/parser.cc b/src/core/lib/http/parser.cc index 74689a6671..724b6d1885 100644 --- a/src/core/lib/http/parser.cc +++ b/src/core/lib/http/parser.cc @@ -88,7 +88,8 @@ static grpc_error* handle_request_line(grpc_http_parser* parser) { if (cur == end) return GRPC_ERROR_CREATE_FROM_STATIC_STRING( "No method on HTTP request line"); - parser->http.request->method = buf2str(beg, static_cast(cur - beg - 1)); + parser->http.request->method = + buf2str(beg, static_cast(cur - beg - 1)); beg = cur; while (cur != end && *cur++ != ' ') @@ -182,7 +183,8 @@ static grpc_error* add_header(grpc_http_parser* parser) { cur++; } GPR_ASSERT((size_t)(end - cur) >= parser->cur_line_end_length); - hdr.value = buf2str(cur, static_cast(end - cur) - parser->cur_line_end_length); + hdr.value = buf2str( + cur, static_cast(end - cur) - parser->cur_line_end_length); switch (parser->type) { case GRPC_HTTP_RESPONSE: @@ -198,8 +200,8 @@ static grpc_error* add_header(grpc_http_parser* parser) { if (*hdr_count == parser->hdr_capacity) { parser->hdr_capacity = GPR_MAX(parser->hdr_capacity + 1, parser->hdr_capacity * 3 / 2); - *hdrs = static_cast(gpr_realloc( - *hdrs, parser->hdr_capacity * sizeof(**hdrs))); + *hdrs = static_cast( + gpr_realloc(*hdrs, parser->hdr_capacity * sizeof(**hdrs))); } (*hdrs)[(*hdr_count)++] = hdr; @@ -257,7 +259,8 @@ static grpc_error* addbyte_body(grpc_http_parser* parser, uint8_t byte) { if (*body_length == parser->body_capacity) { parser->body_capacity = GPR_MAX(8, parser->body_capacity * 3 / 2); - *body = static_cast(gpr_realloc((void*)*body, parser->body_capacity)); + *body = + static_cast(gpr_realloc((void*)*body, parser->body_capacity)); } (*body)[*body_length] = static_cast(byte); (*body_length)++; diff --git a/src/core/lib/iomgr/call_combiner.cc b/src/core/lib/iomgr/call_combiner.cc index f180594545..3b11e0266d 100644 --- a/src/core/lib/iomgr/call_combiner.cc +++ b/src/core/lib/iomgr/call_combiner.cc @@ -68,8 +68,8 @@ void grpc_call_combiner_start(grpc_call_combiner* call_combiner, call_combiner, closure DEBUG_FMT_ARGS, reason, grpc_error_string(error)); } - size_t prev_size = - static_cast(gpr_atm_full_fetch_add(&call_combiner->size, (gpr_atm)1)); + size_t prev_size = static_cast( + gpr_atm_full_fetch_add(&call_combiner->size, (gpr_atm)1)); if (grpc_call_combiner_trace.enabled()) { gpr_log(GPR_DEBUG, " size: %" PRIdPTR " -> %" PRIdPTR, prev_size, prev_size + 1); @@ -90,7 +90,8 @@ void grpc_call_combiner_start(grpc_call_combiner* call_combiner, } // Queue was not empty, so add closure to queue. closure->error_data.error = error; - gpr_mpscq_push(&call_combiner->queue, reinterpret_cast(closure)); + gpr_mpscq_push(&call_combiner->queue, + reinterpret_cast(closure)); } } @@ -102,8 +103,8 @@ void grpc_call_combiner_stop(grpc_call_combiner* call_combiner DEBUG_ARGS, "==> grpc_call_combiner_stop() [%p] [" DEBUG_FMT_STR "%s]", call_combiner DEBUG_FMT_ARGS, reason); } - size_t prev_size = - static_cast(gpr_atm_full_fetch_add(&call_combiner->size, (gpr_atm)-1)); + size_t prev_size = static_cast( + gpr_atm_full_fetch_add(&call_combiner->size, (gpr_atm)-1)); if (grpc_call_combiner_trace.enabled()) { gpr_log(GPR_DEBUG, " size: %" PRIdPTR " -> %" PRIdPTR, prev_size, prev_size - 1); @@ -115,8 +116,8 @@ void grpc_call_combiner_stop(grpc_call_combiner* call_combiner DEBUG_ARGS, gpr_log(GPR_DEBUG, " checking queue"); } bool empty; - grpc_closure* closure = reinterpret_cast(gpr_mpscq_pop_and_check_end( - &call_combiner->queue, &empty)); + grpc_closure* closure = reinterpret_cast( + gpr_mpscq_pop_and_check_end(&call_combiner->queue, &empty)); if (closure == nullptr) { // This can happen either due to a race condition within the mpscq // code or because of a race with grpc_call_combiner_start(). diff --git a/src/core/lib/iomgr/combiner.cc b/src/core/lib/iomgr/combiner.cc index 6ff6fccf03..a7edf17e9b 100644 --- a/src/core/lib/iomgr/combiner.cc +++ b/src/core/lib/iomgr/combiner.cc @@ -342,7 +342,8 @@ static void combiner_finally_exec(grpc_closure* closure, grpc_error* error) { } static void enqueue_finally(void* closure, grpc_error* error) { - combiner_finally_exec(static_cast(closure), GRPC_ERROR_REF(error)); + combiner_finally_exec(static_cast(closure), + GRPC_ERROR_REF(error)); } grpc_closure_scheduler* grpc_combiner_scheduler(grpc_combiner* combiner) { diff --git a/src/core/lib/iomgr/error.cc b/src/core/lib/iomgr/error.cc index 0ba0617f75..4088cf612e 100644 --- a/src/core/lib/iomgr/error.cc +++ b/src/core/lib/iomgr/error.cc @@ -148,7 +148,8 @@ grpc_error* grpc_error_ref(grpc_error* err) { static void unref_errs(grpc_error* err) { uint8_t slot = err->first_err; while (slot != UINT8_MAX) { - grpc_linked_error* lerr = reinterpret_cast(err->arena + slot); + grpc_linked_error* lerr = + reinterpret_cast(err->arena + slot); GRPC_ERROR_UNREF(lerr->err); GPR_ASSERT(err->last_err == slot ? lerr->next == UINT8_MAX : lerr->next != UINT8_MAX); @@ -200,8 +201,8 @@ static uint8_t get_placement(grpc_error** err, size_t size) { GPR_ASSERT(*err); uint8_t slots = static_cast(size / sizeof(intptr_t)); if ((*err)->arena_size + slots > (*err)->arena_capacity) { - (*err)->arena_capacity = - static_castGPR_MIN(UINT8_MAX - 1, (3 * (*err)->arena_capacity / 2)); + (*err)->arena_capacity = static_cast GPR_MIN( + UINT8_MAX - 1, (3 * (*err)->arena_capacity / 2)); if ((*err)->arena_size + slots > (*err)->arena_capacity) { return UINT8_MAX; } @@ -317,9 +318,10 @@ grpc_error* grpc_error_create(const char* file, int line, grpc_slice desc, GPR_TIMER_SCOPE("grpc_error_create", 0); uint8_t initial_arena_capacity = static_cast( DEFAULT_ERROR_CAPACITY + - static_cast(num_referencing * SLOTS_PER_LINKED_ERROR) + SURPLUS_CAPACITY); - grpc_error* err = static_cast(gpr_malloc( - sizeof(*err) + initial_arena_capacity * sizeof(intptr_t))); + static_cast(num_referencing * SLOTS_PER_LINKED_ERROR) + + SURPLUS_CAPACITY); + grpc_error* err = static_cast( + gpr_malloc(sizeof(*err) + initial_arena_capacity * sizeof(intptr_t))); if (err == nullptr) { // TODO(ctiller): make gpr_malloc return NULL return GRPC_ERROR_OOM; } @@ -362,7 +364,8 @@ static void ref_strs(grpc_error* err) { for (size_t i = 0; i < GRPC_ERROR_STR_MAX; ++i) { uint8_t slot = err->strs[i]; if (slot != UINT8_MAX) { - grpc_slice_ref_internal(*reinterpret_cast(err->arena + slot)); + grpc_slice_ref_internal( + *reinterpret_cast(err->arena + slot)); } } } @@ -370,7 +373,8 @@ static void ref_strs(grpc_error* err) { static void ref_errs(grpc_error* err) { uint8_t slot = err->first_err; while (slot != UINT8_MAX) { - grpc_linked_error* lerr = reinterpret_cast(err->arena + slot); + grpc_linked_error* lerr = + reinterpret_cast(err->arena + slot); GRPC_ERROR_REF(lerr->err); slot = lerr->next; } @@ -399,11 +403,12 @@ static grpc_error* copy_error_and_unref(grpc_error* in) { uint8_t new_arena_capacity = in->arena_capacity; // the returned err will be added to, so we ensure this is room to avoid // unneeded allocations. - if (in->arena_capacity - in->arena_size < static_castSLOTS_PER_STR) { + if (in->arena_capacity - in->arena_size < + static_cast SLOTS_PER_STR) { new_arena_capacity = static_cast(3 * new_arena_capacity / 2); } - out = static_cast(gpr_malloc(sizeof(*in) + - new_arena_capacity * sizeof(intptr_t))); + out = static_cast( + gpr_malloc(sizeof(*in) + new_arena_capacity * sizeof(intptr_t))); #ifndef NDEBUG if (grpc_trace_error_refcount.enabled()) { gpr_log(GPR_DEBUG, "%p create copying %p", out, in); @@ -571,8 +576,8 @@ static void append_esc_str(const uint8_t* str, size_t len, char** s, size_t* sz, static void append_kv(kv_pairs* kvs, char* key, char* value) { if (kvs->num_kvs == kvs->cap_kvs) { kvs->cap_kvs = GPR_MAX(3 * kvs->cap_kvs / 2, 4); - kvs->kvs = - static_cast(gpr_realloc(kvs->kvs, sizeof(*kvs->kvs) * kvs->cap_kvs)); + kvs->kvs = static_cast( + gpr_realloc(kvs->kvs, sizeof(*kvs->kvs) * kvs->cap_kvs)); } kvs->kvs[kvs->num_kvs].key = key; kvs->kvs[kvs->num_kvs].value = value; @@ -662,7 +667,8 @@ static void add_errs(grpc_error* err, char** s, size_t* sz, size_t* cap) { uint8_t slot = err->first_err; bool first = true; while (slot != UINT8_MAX) { - grpc_linked_error* lerr = reinterpret_cast(err->arena + slot); + grpc_linked_error* lerr = + reinterpret_cast(err->arena + slot); if (!first) append_chr(',', s, sz, cap); first = false; const char* e = grpc_error_string(lerr->err); @@ -698,8 +704,8 @@ static char* finish_kvs(kv_pairs* kvs) { append_chr('{', &s, &sz, &cap); for (size_t i = 0; i < kvs->num_kvs; i++) { if (i != 0) append_chr(',', &s, &sz, &cap); - append_esc_str(reinterpret_cast(kvs->kvs[i].key), strlen(kvs->kvs[i].key), &s, - &sz, &cap); + append_esc_str(reinterpret_cast(kvs->kvs[i].key), + strlen(kvs->kvs[i].key), &s, &sz, &cap); gpr_free(kvs->kvs[i].key); append_chr(':', &s, &sz, &cap); append_str(kvs->kvs[i].value, &s, &sz, &cap); diff --git a/src/core/lib/iomgr/ev_epoll1_linux.cc b/src/core/lib/iomgr/ev_epoll1_linux.cc index ad013c01b6..f84f3f8205 100644 --- a/src/core/lib/iomgr/ev_epoll1_linux.cc +++ b/src/core/lib/iomgr/ev_epoll1_linux.cc @@ -458,8 +458,8 @@ static grpc_error* pollset_global_init(void) { return GRPC_OS_ERROR(errno, "epoll_ctl"); } g_num_neighborhoods = GPR_CLAMP(gpr_cpu_num_cores(), 1, MAX_NEIGHBORHOODS); - g_neighborhoods = static_cast(gpr_zalloc(sizeof(*g_neighborhoods) * - g_num_neighborhoods)); + g_neighborhoods = static_cast( + gpr_zalloc(sizeof(*g_neighborhoods) * g_num_neighborhoods)); for (size_t i = 0; i < g_num_neighborhoods; i++) { gpr_mu_init(&g_neighborhoods[i].mu); } diff --git a/src/core/lib/iomgr/ev_epollex_linux.cc b/src/core/lib/iomgr/ev_epollex_linux.cc index e201845cd2..8bce34b2fd 100644 --- a/src/core/lib/iomgr/ev_epollex_linux.cc +++ b/src/core/lib/iomgr/ev_epollex_linux.cc @@ -479,7 +479,7 @@ static pollable* pollable_ref(pollable* p) { #else static pollable* pollable_ref(pollable* p, int line, const char* reason) { if (grpc_trace_pollable_refcount.enabled()) { - int r = static_castgpr_atm_no_barrier_load(&p->refs.count); + int r = static_cast gpr_atm_no_barrier_load(&p->refs.count); gpr_log(__FILE__, line, GPR_LOG_SEVERITY_DEBUG, "POLLABLE:%p ref %d->%d %s", p, r, r + 1, reason); } @@ -494,7 +494,7 @@ static void pollable_unref(pollable* p) { static void pollable_unref(pollable* p, int line, const char* reason) { if (p == nullptr) return; if (grpc_trace_pollable_refcount.enabled()) { - int r = static_castgpr_atm_no_barrier_load(&p->refs.count); + int r = static_cast gpr_atm_no_barrier_load(&p->refs.count); gpr_log(__FILE__, line, GPR_LOG_SEVERITY_DEBUG, "POLLABLE:%p unref %d->%d %s", p, r, r - 1, reason); } @@ -516,7 +516,8 @@ static grpc_error* pollable_add_fd(pollable* p, grpc_fd* fd) { } struct epoll_event ev_fd; - ev_fd.events = static_cast(EPOLLET | EPOLLIN | EPOLLOUT | EPOLLEXCLUSIVE); + ev_fd.events = + static_cast(EPOLLET | EPOLLIN | EPOLLOUT | EPOLLEXCLUSIVE); ev_fd.data.ptr = fd; if (epoll_ctl(epfd, EPOLL_CTL_ADD, fd->fd, &ev_fd) != 0) { switch (errno) { @@ -768,7 +769,8 @@ static grpc_error* pollable_process_events(grpc_pollset* pollset, } append_error(&error, grpc_wakeup_fd_consume_wakeup( - (grpc_wakeup_fd*)((~static_cast(1)) & (intptr_t)data_ptr)), + (grpc_wakeup_fd*)((~static_cast(1)) & + (intptr_t)data_ptr)), err_desc); } else { grpc_fd* fd = static_cast(data_ptr); @@ -1170,7 +1172,8 @@ static grpc_pollset_set* pss_lock_adam(grpc_pollset_set* pss) { } static grpc_pollset_set* pollset_set_create(void) { - grpc_pollset_set* pss = static_cast(gpr_zalloc(sizeof(*pss))); + grpc_pollset_set* pss = + static_cast(gpr_zalloc(sizeof(*pss))); gpr_mu_init(&pss->mu); gpr_ref_init(&pss->refs, 1); return pss; @@ -1210,8 +1213,8 @@ static void pollset_set_add_fd(grpc_pollset_set* pss, grpc_fd* fd) { } if (pss->fd_count == pss->fd_capacity) { pss->fd_capacity = GPR_MAX(pss->fd_capacity * 2, 8); - pss->fds = - static_cast(gpr_realloc(pss->fds, pss->fd_capacity * sizeof(*pss->fds))); + pss->fds = static_cast( + gpr_realloc(pss->fds, pss->fd_capacity * sizeof(*pss->fds))); } REF_BY(fd, 2, "pollset_set"); pss->fds[pss->fd_count++] = fd; @@ -1373,7 +1376,8 @@ static void pollset_set_add_pollset_set(grpc_pollset_set* a, b->parent = a; if (a->fd_capacity < a->fd_count + b->fd_count) { a->fd_capacity = GPR_MAX(2 * a->fd_capacity, a->fd_count + b->fd_count); - a->fds = static_cast(gpr_realloc(a->fds, a->fd_capacity * sizeof(*a->fds))); + a->fds = static_cast( + gpr_realloc(a->fds, a->fd_capacity * sizeof(*a->fds))); } size_t initial_a_fd_count = a->fd_count; a->fd_count = 0; @@ -1390,8 +1394,8 @@ static void pollset_set_add_pollset_set(grpc_pollset_set* a, if (a->pollset_capacity < a->pollset_count + b->pollset_count) { a->pollset_capacity = GPR_MAX(2 * a->pollset_capacity, a->pollset_count + b->pollset_count); - a->pollsets = static_cast(gpr_realloc( - a->pollsets, a->pollset_capacity * sizeof(*a->pollsets))); + a->pollsets = static_cast( + gpr_realloc(a->pollsets, a->pollset_capacity * sizeof(*a->pollsets))); } if (b->pollset_count > 0) { memcpy(a->pollsets + a->pollset_count, b->pollsets, diff --git a/src/core/lib/iomgr/ev_epollsig_linux.cc b/src/core/lib/iomgr/ev_epollsig_linux.cc index 438b4c8c09..5c99c72aa5 100644 --- a/src/core/lib/iomgr/ev_epollsig_linux.cc +++ b/src/core/lib/iomgr/ev_epollsig_linux.cc @@ -368,8 +368,8 @@ static void polling_island_add_fds_locked(polling_island* pi, grpc_fd** fds, if (pi->fd_cnt == pi->fd_capacity) { pi->fd_capacity = GPR_MAX(pi->fd_capacity + 8, pi->fd_cnt * 3 / 2); - pi->fds = - static_cast(gpr_realloc(pi->fds, sizeof(grpc_fd*) * pi->fd_capacity)); + pi->fds = static_cast( + gpr_realloc(pi->fds, sizeof(grpc_fd*) * pi->fd_capacity)); } pi->fds[pi->fd_cnt++] = fds[i]; @@ -976,7 +976,8 @@ static grpc_error* pollset_worker_kick(grpc_pollset_worker* worker) { grpc_error* err = GRPC_ERROR_NONE; /* Kick the worker only if it was not already kicked */ - if (gpr_atm_no_barrier_cas(&worker->is_kicked, static_cast(0), static_cast(1))) { + if (gpr_atm_no_barrier_cas(&worker->is_kicked, static_cast(0), + static_cast(1))) { GRPC_POLLING_TRACE( "pollset_worker_kick: Kicking worker: %p (thread id: %ld)", (void*)worker, (long int)worker->pt_id); @@ -1538,7 +1539,8 @@ static void pollset_add_fd(grpc_pollset* pollset, grpc_fd* fd) { */ static grpc_pollset_set* pollset_set_create(void) { - grpc_pollset_set* pss = static_cast(gpr_malloc(sizeof(*pss))); + grpc_pollset_set* pss = + static_cast(gpr_malloc(sizeof(*pss))); gpr_mu_init(&pss->po.mu); pss->po.pi = nullptr; #ifndef NDEBUG diff --git a/src/core/lib/iomgr/ev_poll_posix.cc b/src/core/lib/iomgr/ev_poll_posix.cc index 769fdbc299..e92163322f 100644 --- a/src/core/lib/iomgr/ev_poll_posix.cc +++ b/src/core/lib/iomgr/ev_poll_posix.cc @@ -835,8 +835,8 @@ static void pollset_add_fd(grpc_pollset* pollset, grpc_fd* fd) { if (pollset->fd_count == pollset->fd_capacity) { pollset->fd_capacity = GPR_MAX(pollset->fd_capacity + 8, pollset->fd_count * 3 / 2); - pollset->fds = static_cast(gpr_realloc( - pollset->fds, sizeof(grpc_fd*) * pollset->fd_capacity)); + pollset->fds = static_cast( + gpr_realloc(pollset->fds, sizeof(grpc_fd*) * pollset->fd_capacity)); } pollset->fds[pollset->fd_count++] = fd; GRPC_FD_REF(fd, "multipoller"); @@ -889,8 +889,8 @@ static grpc_error* pollset_work(grpc_pollset* pollset, worker.wakeup_fd = pollset->local_wakeup_cache; pollset->local_wakeup_cache = worker.wakeup_fd->next; } else { - worker.wakeup_fd = - static_cast(gpr_malloc(sizeof(*worker.wakeup_fd))); + worker.wakeup_fd = static_cast( + gpr_malloc(sizeof(*worker.wakeup_fd))); error = grpc_wakeup_fd_init(&worker.wakeup_fd->fd); if (error != GRPC_ERROR_NONE) { GRPC_LOG_IF_ERROR("pollset_work", GRPC_ERROR_REF(error)); @@ -946,7 +946,8 @@ static grpc_error* pollset_work(grpc_pollset* pollset, const size_t watch_size = sizeof(*watchers) * (pollset->fd_count + 2); void* buf = gpr_malloc(pfd_size + watch_size); pfds = static_cast(buf); - watchers = static_cast((void*)(static_cast(buf) + pfd_size)); + watchers = static_cast( + (void*)(static_cast(buf) + pfd_size)); } fd_count = 0; @@ -972,8 +973,8 @@ static grpc_error* pollset_work(grpc_pollset* pollset, for (i = 1; i < pfd_count; i++) { grpc_fd* fd = watchers[i].fd; - pfds[i].events = static_cast(fd_begin_poll(fd, pollset, &worker, POLLIN, - POLLOUT, &watchers[i])); + pfds[i].events = static_cast( + fd_begin_poll(fd, pollset, &worker, POLLIN, POLLOUT, &watchers[i])); GRPC_FD_UNREF(fd, "multipoller_start"); } @@ -1222,9 +1223,9 @@ static void pollset_set_add_pollset_set(grpc_pollset_set* bag, gpr_mu_lock(&bag->mu); if (bag->pollset_set_count == bag->pollset_set_capacity) { bag->pollset_set_capacity = GPR_MAX(8, 2 * bag->pollset_set_capacity); - bag->pollset_sets = static_cast(gpr_realloc( - bag->pollset_sets, - bag->pollset_set_capacity * sizeof(*bag->pollset_sets))); + bag->pollset_sets = static_cast( + gpr_realloc(bag->pollset_sets, + bag->pollset_set_capacity * sizeof(*bag->pollset_sets))); } bag->pollset_sets[bag->pollset_set_count++] = item; for (i = 0, j = 0; i < bag->fd_count; i++) { @@ -1259,8 +1260,9 @@ static void pollset_set_add_fd(grpc_pollset_set* pollset_set, grpc_fd* fd) { gpr_mu_lock(&pollset_set->mu); if (pollset_set->fd_count == pollset_set->fd_capacity) { pollset_set->fd_capacity = GPR_MAX(8, 2 * pollset_set->fd_capacity); - pollset_set->fds = static_cast(gpr_realloc( - pollset_set->fds, pollset_set->fd_capacity * sizeof(*pollset_set->fds))); + pollset_set->fds = static_cast( + gpr_realloc(pollset_set->fds, + pollset_set->fd_capacity * sizeof(*pollset_set->fds))); } GRPC_FD_REF(fd, "pollset_set"); pollset_set->fds[pollset_set->fd_count++] = fd; @@ -1316,8 +1318,8 @@ static void init_result(poll_args* pargs) { gpr_ref_init(&pargs->result->refcount, 1); pargs->result->watchers = nullptr; pargs->result->watchcount = 0; - pargs->result->fds = - static_cast(gpr_malloc(sizeof(struct pollfd) * pargs->nfds)); + pargs->result->fds = static_cast( + gpr_malloc(sizeof(struct pollfd) * pargs->nfds)); memcpy(pargs->result->fds, pargs->fds, sizeof(struct pollfd) * pargs->nfds); pargs->result->nfds = pargs->nfds; pargs->result->retval = 0; @@ -1356,7 +1358,8 @@ static poll_args* get_poller_locked(struct pollfd* fds, nfds_t count) { return pargs; } - poll_args* pargs = static_cast(gpr_malloc(sizeof(struct poll_args))); + poll_args* pargs = + static_cast(gpr_malloc(sizeof(struct poll_args))); gpr_cv_init(&pargs->trigger); pargs->fds = fds; pargs->nfds = count; @@ -1514,7 +1517,8 @@ static int cvfd_poll(struct pollfd* fds, nfds_t nfds, int timeout) { gpr_cv pollcv_cv; gpr_cv_init(&pollcv_cv); pollcv->cv = &pollcv_cv; - grpc_cv_node* fd_cvs = static_cast(gpr_malloc(nfds * sizeof(grpc_cv_node))); + grpc_cv_node* fd_cvs = + static_cast(gpr_malloc(nfds * sizeof(grpc_cv_node))); for (i = 0; i < nfds; i++) { fds[i].revents = 0; @@ -1546,8 +1550,8 @@ static int cvfd_poll(struct pollfd* fds, nfds_t nfds, int timeout) { res = 0; if (!skip_poll && nsockfds > 0) { - struct pollfd* pollfds = - static_cast(gpr_malloc(sizeof(struct pollfd) * nsockfds)); + struct pollfd* pollfds = static_cast( + gpr_malloc(sizeof(struct pollfd) * nsockfds)); idx = 0; for (i = 0; i < nfds; i++) { if (fds[i].fd >= 0) { @@ -1610,8 +1614,8 @@ static void global_cv_fd_table_init() { gpr_cv_init(&g_cvfds.shutdown_cv); gpr_ref_init(&g_cvfds.pollcount, 1); g_cvfds.size = CV_DEFAULT_TABLE_SIZE; - g_cvfds.cvfds = - static_cast(gpr_malloc(sizeof(grpc_fd_node) * CV_DEFAULT_TABLE_SIZE)); + g_cvfds.cvfds = static_cast( + gpr_malloc(sizeof(grpc_fd_node) * CV_DEFAULT_TABLE_SIZE)); g_cvfds.free_fds = nullptr; thread_grace = gpr_time_from_millis(POLLCV_THREAD_GRACE_MS, GPR_TIMESPAN); for (int i = 0; i < CV_DEFAULT_TABLE_SIZE; i++) { @@ -1628,7 +1632,8 @@ static void global_cv_fd_table_init() { poll_cache.size = 32; poll_cache.count = 0; poll_cache.free_pollers = nullptr; - poll_cache.active_pollers = static_cast(gpr_malloc(sizeof(void*) * 32)); + poll_cache.active_pollers = + static_cast(gpr_malloc(sizeof(void*) * 32)); for (unsigned int i = 0; i < poll_cache.size; i++) { poll_cache.active_pollers[i] = nullptr; } diff --git a/src/core/lib/iomgr/exec_ctx.cc b/src/core/lib/iomgr/exec_ctx.cc index 89c6a873e6..5401a94dd3 100644 --- a/src/core/lib/iomgr/exec_ctx.cc +++ b/src/core/lib/iomgr/exec_ctx.cc @@ -53,8 +53,8 @@ static gpr_timespec g_start_time; static gpr_atm timespec_to_atm_round_down(gpr_timespec ts) { ts = gpr_time_sub(ts, g_start_time); - double x = - GPR_MS_PER_SEC * static_cast(ts.tv_sec) + static_cast(ts.tv_nsec) / GPR_NS_PER_MS; + double x = GPR_MS_PER_SEC * static_cast(ts.tv_sec) + + static_cast(ts.tv_nsec) / GPR_NS_PER_MS; if (x < 0) return 0; if (x > GPR_ATM_MAX) return GPR_ATM_MAX; return static_cast(x); @@ -64,7 +64,8 @@ static gpr_atm timespec_to_atm_round_up(gpr_timespec ts) { ts = gpr_time_sub(ts, g_start_time); double x = GPR_MS_PER_SEC * static_cast(ts.tv_sec) + static_cast(ts.tv_nsec) / GPR_NS_PER_MS + - static_cast(GPR_NS_PER_SEC - 1) / static_cast(GPR_NS_PER_SEC); + static_cast(GPR_NS_PER_SEC - 1) / + static_cast(GPR_NS_PER_SEC); if (x < 0) return 0; if (x > GPR_ATM_MAX) return GPR_ATM_MAX; return static_cast(x); diff --git a/src/core/lib/iomgr/executor.cc b/src/core/lib/iomgr/executor.cc index 901bbdd4df..16782dacc5 100644 --- a/src/core/lib/iomgr/executor.cc +++ b/src/core/lib/iomgr/executor.cc @@ -94,8 +94,8 @@ void grpc_executor_set_threading(bool threading) { g_max_threads = GPR_MAX(1, 2 * gpr_cpu_num_cores()); gpr_atm_no_barrier_store(&g_cur_threads, 1); gpr_tls_init(&g_this_thread_state); - g_thread_state = - static_cast(gpr_zalloc(sizeof(thread_state) * g_max_threads)); + g_thread_state = static_cast( + gpr_zalloc(sizeof(thread_state) * g_max_threads)); for (size_t i = 0; i < g_max_threads; i++) { gpr_mu_init(&g_thread_state[i].mu); gpr_cv_init(&g_thread_state[i].cv); @@ -170,7 +170,8 @@ static void executor_thread(void* arg) { ts->elems = GRPC_CLOSURE_LIST_INIT; gpr_mu_unlock(&ts->mu); if (executor_trace.enabled()) { - gpr_log(GPR_DEBUG, "EXECUTOR[%d]: execute", static_cast(ts - g_thread_state)); + gpr_log(GPR_DEBUG, "EXECUTOR[%d]: execute", + static_cast(ts - g_thread_state)); } grpc_core::ExecCtx::Get()->InvalidateNow(); @@ -188,7 +189,8 @@ static void executor_push(grpc_closure* closure, grpc_error* error, } do { retry_push = false; - size_t cur_thread_count = static_castgpr_atm_no_barrier_load(&g_cur_threads); + size_t cur_thread_count = + static_cast gpr_atm_no_barrier_load(&g_cur_threads); if (cur_thread_count == 0) { if (executor_trace.enabled()) { #ifndef NDEBUG @@ -255,7 +257,8 @@ static void executor_push(grpc_closure* closure, grpc_error* error, break; } if (try_new_thread && gpr_spinlock_trylock(&g_adding_thread_lock)) { - cur_thread_count = static_castgpr_atm_no_barrier_load(&g_cur_threads); + cur_thread_count = + static_cast gpr_atm_no_barrier_load(&g_cur_threads); if (cur_thread_count < g_max_threads) { gpr_atm_no_barrier_store(&g_cur_threads, cur_thread_count + 1); diff --git a/src/core/lib/iomgr/is_epollexclusive_available.cc b/src/core/lib/iomgr/is_epollexclusive_available.cc index a58a5775d3..542cc41e8f 100644 --- a/src/core/lib/iomgr/is_epollexclusive_available.cc +++ b/src/core/lib/iomgr/is_epollexclusive_available.cc @@ -61,7 +61,8 @@ bool grpc_is_epollexclusive_available(void) { /* choose events that should cause an error on EPOLLEXCLUSIVE enabled kernels - specifically the combination of EPOLLONESHOT and EPOLLEXCLUSIVE */ - ev.events = static_cast(EPOLLET | EPOLLIN | EPOLLEXCLUSIVE | EPOLLONESHOT); + ev.events = + static_cast(EPOLLET | EPOLLIN | EPOLLEXCLUSIVE | EPOLLONESHOT); ev.data.ptr = nullptr; if (epoll_ctl(fd, EPOLL_CTL_ADD, evfd, &ev) != 0) { if (errno != EINVAL) { diff --git a/src/core/lib/iomgr/load_file.cc b/src/core/lib/iomgr/load_file.cc index 5e637ff8b5..7f5f642c98 100644 --- a/src/core/lib/iomgr/load_file.cc +++ b/src/core/lib/iomgr/load_file.cc @@ -47,8 +47,8 @@ grpc_error* grpc_load_file(const char* filename, int add_null_terminator, /* Converting to size_t on the assumption that it will not fail */ contents_size = static_cast(ftell(file)); fseek(file, 0, SEEK_SET); - contents = - static_cast(gpr_malloc(contents_size + (add_null_terminator ? 1 : 0))); + contents = static_cast( + gpr_malloc(contents_size + (add_null_terminator ? 1 : 0))); bytes_read = fread(contents, 1, contents_size, file); if (bytes_read < contents_size) { error = GRPC_OS_ERROR(errno, "fread"); diff --git a/src/core/lib/iomgr/resolve_address_posix.cc b/src/core/lib/iomgr/resolve_address_posix.cc index b49b080c12..dd5363dc0a 100644 --- a/src/core/lib/iomgr/resolve_address_posix.cc +++ b/src/core/lib/iomgr/resolve_address_posix.cc @@ -114,14 +114,14 @@ static grpc_error* blocking_resolve_address_impl( } /* Success path: set addrs non-NULL, fill it in */ - *addresses = - static_cast(gpr_malloc(sizeof(grpc_resolved_addresses))); + *addresses = static_cast( + gpr_malloc(sizeof(grpc_resolved_addresses))); (*addresses)->naddrs = 0; for (resp = result; resp != nullptr; resp = resp->ai_next) { (*addresses)->naddrs++; } - (*addresses)->addrs = static_cast(gpr_malloc( - sizeof(grpc_resolved_address) * (*addresses)->naddrs)); + (*addresses)->addrs = static_cast( + gpr_malloc(sizeof(grpc_resolved_address) * (*addresses)->naddrs)); i = 0; for (resp = result; resp != nullptr; resp = resp->ai_next) { memcpy(&(*addresses)->addrs[i].addr, resp->ai_addr, resp->ai_addrlen); diff --git a/src/core/lib/iomgr/resource_quota.cc b/src/core/lib/iomgr/resource_quota.cc index 40dd29b6a4..da310694ef 100644 --- a/src/core/lib/iomgr/resource_quota.cc +++ b/src/core/lib/iomgr/resource_quota.cc @@ -419,8 +419,8 @@ static const grpc_slice_refcount_vtable ru_slice_vtable = { static grpc_slice ru_slice_create(grpc_resource_user* resource_user, size_t size) { - ru_slice_refcount* rc = - static_cast(gpr_malloc(sizeof(ru_slice_refcount) + size)); + ru_slice_refcount* rc = static_cast( + gpr_malloc(sizeof(ru_slice_refcount) + size)); rc->base.vtable = &ru_slice_vtable; rc->base.sub_refcount = &rc->base; gpr_ref_init(&rc->refs, 1); @@ -659,7 +659,8 @@ void grpc_resource_quota_resize(grpc_resource_quota* resource_quota, } size_t grpc_resource_quota_peek_size(grpc_resource_quota* resource_quota) { - return static_castgpr_atm_no_barrier_load(&resource_quota->last_size); + return static_cast gpr_atm_no_barrier_load( + &resource_quota->last_size); } /******************************************************************************* @@ -672,7 +673,8 @@ grpc_resource_quota* grpc_resource_quota_from_channel_args( if (0 == strcmp(channel_args->args[i].key, GRPC_ARG_RESOURCE_QUOTA)) { if (channel_args->args[i].type == GRPC_ARG_POINTER) { return grpc_resource_quota_ref_internal( - static_cast(channel_args->args[i].value.pointer.p)); + static_cast( + channel_args->args[i].value.pointer.p)); } else { gpr_log(GPR_DEBUG, GRPC_ARG_RESOURCE_QUOTA " should be a pointer"); } diff --git a/src/core/lib/iomgr/sockaddr_utils.cc b/src/core/lib/iomgr/sockaddr_utils.cc index 06f080376a..69be87168e 100644 --- a/src/core/lib/iomgr/sockaddr_utils.cc +++ b/src/core/lib/iomgr/sockaddr_utils.cc @@ -39,13 +39,15 @@ static const uint8_t kV4MappedPrefix[] = {0, 0, 0, 0, 0, 0, int grpc_sockaddr_is_v4mapped(const grpc_resolved_address* resolved_addr, grpc_resolved_address* resolved_addr4_out) { GPR_ASSERT(resolved_addr != resolved_addr4_out); - const struct sockaddr* addr = reinterpret_cast(resolved_addr->addr); + const struct sockaddr* addr = + reinterpret_cast(resolved_addr->addr); struct sockaddr_in* addr4_out = resolved_addr4_out == nullptr ? nullptr : reinterpret_cast(resolved_addr4_out->addr); if (addr->sa_family == AF_INET6) { - const struct sockaddr_in6* addr6 = reinterpret_cast(addr); + const struct sockaddr_in6* addr6 = + reinterpret_cast(addr); if (memcmp(addr6->sin6_addr.s6_addr, kV4MappedPrefix, sizeof(kV4MappedPrefix)) == 0) { if (resolved_addr4_out != nullptr) { @@ -66,11 +68,13 @@ int grpc_sockaddr_is_v4mapped(const grpc_resolved_address* resolved_addr, int grpc_sockaddr_to_v4mapped(const grpc_resolved_address* resolved_addr, grpc_resolved_address* resolved_addr6_out) { GPR_ASSERT(resolved_addr != resolved_addr6_out); - const struct sockaddr* addr = reinterpret_cast(resolved_addr->addr); + const struct sockaddr* addr = + reinterpret_cast(resolved_addr->addr); struct sockaddr_in6* addr6_out = reinterpret_cast(resolved_addr6_out->addr); if (addr->sa_family == AF_INET) { - const struct sockaddr_in* addr4 = reinterpret_cast(addr); + const struct sockaddr_in* addr4 = + reinterpret_cast(addr); memset(resolved_addr6_out, 0, sizeof(*resolved_addr6_out)); addr6_out->sin6_family = AF_INET6; memcpy(&addr6_out->sin6_addr.s6_addr[0], kV4MappedPrefix, 12); @@ -92,7 +96,8 @@ int grpc_sockaddr_is_wildcard(const grpc_resolved_address* resolved_addr, addr = reinterpret_cast(resolved_addr->addr); if (addr->sa_family == AF_INET) { /* Check for 0.0.0.0 */ - const struct sockaddr_in* addr4 = reinterpret_cast(addr); + const struct sockaddr_in* addr4 = + reinterpret_cast(addr); if (addr4->sin_addr.s_addr != 0) { return 0; } @@ -100,7 +105,8 @@ int grpc_sockaddr_is_wildcard(const grpc_resolved_address* resolved_addr, return 1; } else if (addr->sa_family == AF_INET6) { /* Check for :: */ - const struct sockaddr_in6* addr6 = reinterpret_cast(addr); + const struct sockaddr_in6* addr6 = + reinterpret_cast(addr); int i; for (i = 0; i < 16; i++) { if (addr6->sin6_addr.s6_addr[i] != 0) { @@ -122,7 +128,8 @@ void grpc_sockaddr_make_wildcards(int port, grpc_resolved_address* wild4_out, void grpc_sockaddr_make_wildcard4(int port, grpc_resolved_address* resolved_wild_out) { - struct sockaddr_in* wild_out = reinterpret_cast(resolved_wild_out->addr); + struct sockaddr_in* wild_out = + reinterpret_cast(resolved_wild_out->addr); GPR_ASSERT(port >= 0 && port < 65536); memset(resolved_wild_out, 0, sizeof(*resolved_wild_out)); wild_out->sin_family = AF_INET; @@ -132,7 +139,8 @@ void grpc_sockaddr_make_wildcard4(int port, void grpc_sockaddr_make_wildcard6(int port, grpc_resolved_address* resolved_wild_out) { - struct sockaddr_in6* wild_out = reinterpret_cast(resolved_wild_out->addr); + struct sockaddr_in6* wild_out = + reinterpret_cast(resolved_wild_out->addr); GPR_ASSERT(port >= 0 && port < 65536); memset(resolved_wild_out, 0, sizeof(*resolved_wild_out)); wild_out->sin6_family = AF_INET6; @@ -158,11 +166,13 @@ int grpc_sockaddr_to_string(char** out, } addr = reinterpret_cast(resolved_addr->addr); if (addr->sa_family == AF_INET) { - const struct sockaddr_in* addr4 = reinterpret_cast(addr); + const struct sockaddr_in* addr4 = + reinterpret_cast(addr); ip = &addr4->sin_addr; port = ntohs(addr4->sin_port); } else if (addr->sa_family == AF_INET6) { - const struct sockaddr_in6* addr6 = reinterpret_cast(addr); + const struct sockaddr_in6* addr6 = + reinterpret_cast(addr); ip = &addr6->sin6_addr; port = ntohs(addr6->sin6_port); sin6_scope_id = addr6->sin6_scope_id; @@ -208,7 +218,8 @@ char* grpc_sockaddr_to_uri(const grpc_resolved_address* resolved_addr) { const char* grpc_sockaddr_get_uri_scheme( const grpc_resolved_address* resolved_addr) { - const struct sockaddr* addr = reinterpret_cast(resolved_addr->addr); + const struct sockaddr* addr = + reinterpret_cast(resolved_addr->addr); switch (addr->sa_family) { case AF_INET: return "ipv4"; @@ -221,12 +232,14 @@ const char* grpc_sockaddr_get_uri_scheme( } int grpc_sockaddr_get_family(const grpc_resolved_address* resolved_addr) { - const struct sockaddr* addr = reinterpret_cast(resolved_addr->addr); + const struct sockaddr* addr = + reinterpret_cast(resolved_addr->addr); return addr->sa_family; } int grpc_sockaddr_get_port(const grpc_resolved_address* resolved_addr) { - const struct sockaddr* addr = reinterpret_cast(resolved_addr->addr); + const struct sockaddr* addr = + reinterpret_cast(resolved_addr->addr); switch (addr->sa_family) { case AF_INET: return ntohs(((struct sockaddr_in*)addr)->sin_port); @@ -244,15 +257,18 @@ int grpc_sockaddr_get_port(const grpc_resolved_address* resolved_addr) { int grpc_sockaddr_set_port(const grpc_resolved_address* resolved_addr, int port) { - const struct sockaddr* addr = reinterpret_cast(resolved_addr->addr); + const struct sockaddr* addr = + reinterpret_cast(resolved_addr->addr); switch (addr->sa_family) { case AF_INET: GPR_ASSERT(port >= 0 && port < 65536); - ((struct sockaddr_in*)addr)->sin_port = htons(static_cast(port)); + ((struct sockaddr_in*)addr)->sin_port = + htons(static_cast(port)); return 1; case AF_INET6: GPR_ASSERT(port >= 0 && port < 65536); - ((struct sockaddr_in6*)addr)->sin6_port = htons(static_cast(port)); + ((struct sockaddr_in6*)addr)->sin6_port = + htons(static_cast(port)); return 1; default: gpr_log(GPR_ERROR, "Unknown socket family %d in grpc_sockaddr_set_port", diff --git a/src/core/lib/iomgr/socket_utils_common_posix.cc b/src/core/lib/iomgr/socket_utils_common_posix.cc index 2668aa6d10..a0cca6195b 100644 --- a/src/core/lib/iomgr/socket_utils_common_posix.cc +++ b/src/core/lib/iomgr/socket_utils_common_posix.cc @@ -218,7 +218,8 @@ static void probe_ipv6_once(void) { memset(&addr, 0, sizeof(addr)); addr.sin6_family = AF_INET6; addr.sin6_addr.s6_addr[15] = 1; /* [::1]:0 */ - if (bind(fd, reinterpret_cast(&addr), sizeof(addr)) == 0) { + if (bind(fd, reinterpret_cast(&addr), sizeof(addr)) == + 0) { g_ipv6_loopback_available = 1; } else { gpr_log(GPR_INFO, @@ -278,7 +279,8 @@ static int create_socket(grpc_socket_factory* factory, int domain, int type, grpc_error* grpc_create_dualstack_socket_using_factory( grpc_socket_factory* factory, const grpc_resolved_address* resolved_addr, int type, int protocol, grpc_dualstack_mode* dsmode, int* newfd) { - const struct sockaddr* addr = reinterpret_cast(resolved_addr->addr); + const struct sockaddr* addr = + reinterpret_cast(resolved_addr->addr); int family = addr->sa_family; if (family == AF_INET6) { if (grpc_ipv6_loopback_available()) { diff --git a/src/core/lib/iomgr/socket_utils_linux.cc b/src/core/lib/iomgr/socket_utils_linux.cc index edb5274e0e..e8bf05c3a8 100644 --- a/src/core/lib/iomgr/socket_utils_linux.cc +++ b/src/core/lib/iomgr/socket_utils_linux.cc @@ -35,7 +35,8 @@ int grpc_accept4(int sockfd, grpc_resolved_address* resolved_addr, int nonblock, GPR_ASSERT(resolved_addr->len <= (socklen_t)-1); flags |= nonblock ? SOCK_NONBLOCK : 0; flags |= cloexec ? SOCK_CLOEXEC : 0; - return accept4(sockfd, reinterpret_cast(resolved_addr->addr), + return accept4(sockfd, + reinterpret_cast(resolved_addr->addr), reinterpret_cast(&resolved_addr->len), flags); } diff --git a/src/core/lib/iomgr/tcp_client_posix.cc b/src/core/lib/iomgr/tcp_client_posix.cc index 8d08127915..33a0b0404d 100644 --- a/src/core/lib/iomgr/tcp_client_posix.cc +++ b/src/core/lib/iomgr/tcp_client_posix.cc @@ -79,8 +79,8 @@ static grpc_error* prepare_socket(const grpc_resolved_address* addr, int fd, for (size_t i = 0; i < channel_args->num_args; i++) { if (0 == strcmp(channel_args->args[i].key, GRPC_ARG_SOCKET_MUTATOR)) { GPR_ASSERT(channel_args->args[i].type == GRPC_ARG_POINTER); - grpc_socket_mutator* mutator = - static_cast(channel_args->args[i].value.pointer.p); + grpc_socket_mutator* mutator = static_cast( + channel_args->args[i].value.pointer.p); err = grpc_set_socket_with_mutator(fd, mutator); if (err != GRPC_ERROR_NONE) goto error; } @@ -291,7 +291,8 @@ void grpc_tcp_client_create_from_prepared_fd( async_connect* ac; do { GPR_ASSERT(addr->len < ~(socklen_t)0); - err = connect(fd, reinterpret_cast(addr->addr), static_cast(addr->len)); + err = connect(fd, reinterpret_cast(addr->addr), + static_cast(addr->len)); } while (err < 0 && errno == EINTR); if (err >= 0) { char* addr_str = grpc_sockaddr_to_uri(addr); diff --git a/src/core/lib/iomgr/tcp_posix.cc b/src/core/lib/iomgr/tcp_posix.cc index 71819adaba..50efd04382 100644 --- a/src/core/lib/iomgr/tcp_posix.cc +++ b/src/core/lib/iomgr/tcp_posix.cc @@ -165,8 +165,8 @@ static void drop_uncovered(grpc_tcp* tcp) { gpr_atm old_count = gpr_atm_no_barrier_fetch_add(&g_uncovered_notifications_pending, -1); if (grpc_tcp_trace.enabled()) { - gpr_log(GPR_DEBUG, "BACKUP_POLLER:%p uncover cnt %d->%d", p, static_cast(old_count), - static_cast(old_count) - 1); + gpr_log(GPR_DEBUG, "BACKUP_POLLER:%p uncover cnt %d->%d", p, + static_cast(old_count), static_cast(old_count) - 1); } GPR_ASSERT(old_count != 1); } @@ -176,12 +176,13 @@ static void cover_self(grpc_tcp* tcp) { gpr_atm old_count = gpr_atm_no_barrier_fetch_add(&g_uncovered_notifications_pending, 2); if (grpc_tcp_trace.enabled()) { - gpr_log(GPR_DEBUG, "BACKUP_POLLER: cover cnt %d->%d", static_cast(old_count), - 2 + static_cast(old_count)); + gpr_log(GPR_DEBUG, "BACKUP_POLLER: cover cnt %d->%d", + static_cast(old_count), 2 + static_cast(old_count)); } if (old_count == 0) { GRPC_STATS_INC_TCP_BACKUP_POLLERS_CREATED(); - p = static_cast(gpr_zalloc(sizeof(*p) + grpc_pollset_size())); + p = static_cast( + gpr_zalloc(sizeof(*p) + grpc_pollset_size())); if (grpc_tcp_trace.enabled()) { gpr_log(GPR_DEBUG, "BACKUP_POLLER:%p create", p); } @@ -257,8 +258,8 @@ static size_t get_target_read_size(grpc_tcp* tcp) { double pressure = grpc_resource_quota_get_memory_pressure(rq); double target = tcp->target_length * (pressure > 0.8 ? (1.0 - pressure) / 0.2 : 1.0); - size_t sz = ((static_castGPR_CLAMP(target, tcp->min_read_chunk_size, - tcp->max_read_chunk_size)) + + size_t sz = ((static_cast GPR_CLAMP(target, tcp->min_read_chunk_size, + tcp->max_read_chunk_size)) + 255) & ~static_cast(255); /* don't use more than 1/16th of the overall resource quota for a single read @@ -733,27 +734,25 @@ grpc_endpoint* grpc_tcp_create(grpc_fd* em_fd, for (size_t i = 0; i < channel_args->num_args; i++) { if (0 == strcmp(channel_args->args[i].key, GRPC_ARG_TCP_READ_CHUNK_SIZE)) { - grpc_integer_options options = {tcp_read_chunk_size, 1, - MAX_CHUNK_SIZE}; + grpc_integer_options options = {tcp_read_chunk_size, 1, MAX_CHUNK_SIZE}; tcp_read_chunk_size = grpc_channel_arg_get_integer(&channel_args->args[i], options); } else if (0 == strcmp(channel_args->args[i].key, GRPC_ARG_TCP_MIN_READ_CHUNK_SIZE)) { - grpc_integer_options options = {tcp_read_chunk_size, 1, - MAX_CHUNK_SIZE}; + grpc_integer_options options = {tcp_read_chunk_size, 1, MAX_CHUNK_SIZE}; tcp_min_read_chunk_size = grpc_channel_arg_get_integer(&channel_args->args[i], options); } else if (0 == strcmp(channel_args->args[i].key, GRPC_ARG_TCP_MAX_READ_CHUNK_SIZE)) { - grpc_integer_options options = {tcp_read_chunk_size, 1, - MAX_CHUNK_SIZE}; + grpc_integer_options options = {tcp_read_chunk_size, 1, MAX_CHUNK_SIZE}; tcp_max_read_chunk_size = grpc_channel_arg_get_integer(&channel_args->args[i], options); } else if (0 == strcmp(channel_args->args[i].key, GRPC_ARG_RESOURCE_QUOTA)) { grpc_resource_quota_unref_internal(resource_quota); - resource_quota = grpc_resource_quota_ref_internal( - static_cast(channel_args->args[i].value.pointer.p)); + resource_quota = + grpc_resource_quota_ref_internal(static_cast( + channel_args->args[i].value.pointer.p)); } } } diff --git a/src/core/lib/iomgr/tcp_server_posix.cc b/src/core/lib/iomgr/tcp_server_posix.cc index f8f94e3fbb..fe6108e4ac 100644 --- a/src/core/lib/iomgr/tcp_server_posix.cc +++ b/src/core/lib/iomgr/tcp_server_posix.cc @@ -72,7 +72,8 @@ grpc_error* grpc_tcp_server_create(grpc_closure* shutdown_complete, grpc_tcp_server** server) { gpr_once_init(&check_init, init); - grpc_tcp_server* s = static_cast(gpr_zalloc(sizeof(grpc_tcp_server))); + grpc_tcp_server* s = + static_cast(gpr_zalloc(sizeof(grpc_tcp_server))); s->so_reuseport = has_so_reuseport; s->expand_wildcard_addrs = false; for (size_t i = 0; i < (args == nullptr ? 0 : args->num_args); i++) { @@ -410,8 +411,10 @@ grpc_error* grpc_tcp_server_add_port(grpc_tcp_server* s, if (requested_port == 0) { for (sp = s->head; sp; sp = sp->next) { sockname_temp.len = sizeof(struct sockaddr_storage); - if (0 == getsockname(sp->fd, reinterpret_cast(&sockname_temp.addr), - reinterpret_cast(&sockname_temp.len))) { + if (0 == + getsockname(sp->fd, + reinterpret_cast(&sockname_temp.addr), + reinterpret_cast(&sockname_temp.len))) { int used_port = grpc_sockaddr_get_port(&sockname_temp); if (used_port > 0) { memcpy(&sockname_temp, addr, sizeof(grpc_resolved_address)); diff --git a/src/core/lib/iomgr/tcp_server_utils_posix_common.cc b/src/core/lib/iomgr/tcp_server_utils_posix_common.cc index e98ebb7813..be2a00a9dc 100644 --- a/src/core/lib/iomgr/tcp_server_utils_posix_common.cc +++ b/src/core/lib/iomgr/tcp_server_utils_posix_common.cc @@ -169,7 +169,9 @@ grpc_error* grpc_tcp_server_prepare_socket(int fd, if (err != GRPC_ERROR_NONE) goto error; GPR_ASSERT(addr->len < ~(socklen_t)0); - if (bind(fd, reinterpret_cast(const_cast(addr->addr)), static_cast(addr->len)) < 0) { + if (bind(fd, + reinterpret_cast(const_cast(addr->addr)), + static_cast(addr->len)) < 0) { err = GRPC_OS_ERROR(errno, "bind"); goto error; } diff --git a/src/core/lib/iomgr/tcp_server_utils_posix_ifaddrs.cc b/src/core/lib/iomgr/tcp_server_utils_posix_ifaddrs.cc index 5470dbcff7..612c2584bc 100644 --- a/src/core/lib/iomgr/tcp_server_utils_posix_ifaddrs.cc +++ b/src/core/lib/iomgr/tcp_server_utils_posix_ifaddrs.cc @@ -66,13 +66,14 @@ static grpc_error* get_unused_port(int* port) { if (dsmode == GRPC_DSMODE_IPV4) { grpc_sockaddr_make_wildcard4(0, &wild); } - if (bind(fd, reinterpret_cast(wild.addr), static_cast(wild.len)) != 0) { + if (bind(fd, reinterpret_cast(wild.addr), + static_cast(wild.len)) != 0) { err = GRPC_OS_ERROR(errno, "bind"); close(fd); return err; } - if (getsockname(fd, reinterpret_cast(wild.addr), reinterpret_cast(&wild.len)) != - 0) { + if (getsockname(fd, reinterpret_cast(wild.addr), + reinterpret_cast(&wild.len)) != 0) { err = GRPC_OS_ERROR(errno, "getsockname"); close(fd); return err; diff --git a/src/core/lib/iomgr/timer_generic.cc b/src/core/lib/iomgr/timer_generic.cc index b47c12b689..697162f7a8 100644 --- a/src/core/lib/iomgr/timer_generic.cc +++ b/src/core/lib/iomgr/timer_generic.cc @@ -240,9 +240,10 @@ void grpc_timer_list_init() { uint32_t i; g_num_shards = GPR_MIN(1, 2 * gpr_cpu_num_cores()); - g_shards = static_cast(gpr_zalloc(g_num_shards * sizeof(*g_shards))); - g_shard_queue = - static_cast(gpr_zalloc(g_num_shards * sizeof(*g_shard_queue))); + g_shards = + static_cast(gpr_zalloc(g_num_shards * sizeof(*g_shards))); + g_shard_queue = static_cast( + gpr_zalloc(g_num_shards * sizeof(*g_shard_queue))); g_shared_mutables.initialized = true; g_shared_mutables.checker_mu = GPR_SPINLOCK_INITIALIZER; @@ -359,8 +360,8 @@ void grpc_timer_init(grpc_timer* timer, grpc_millis deadline, return; } - grpc_time_averaged_stats_add_sample(&shard->stats, - static_cast(deadline - now) / 1000.0); + grpc_time_averaged_stats_add_sample( + &shard->stats, static_cast(deadline - now) / 1000.0); ADD_TO_HASH_TABLE(timer); diff --git a/src/core/lib/iomgr/timer_heap.cc b/src/core/lib/iomgr/timer_heap.cc index 9aedfd3755..c26896ee4a 100644 --- a/src/core/lib/iomgr/timer_heap.cc +++ b/src/core/lib/iomgr/timer_heap.cc @@ -74,8 +74,8 @@ static void maybe_shrink(grpc_timer_heap* heap) { if (heap->timer_count >= 8 && heap->timer_count <= heap->timer_capacity / SHRINK_FULLNESS_FACTOR / 2) { heap->timer_capacity = heap->timer_count * SHRINK_FULLNESS_FACTOR; - heap->timers = static_cast(gpr_realloc( - heap->timers, heap->timer_capacity * sizeof(grpc_timer*))); + heap->timers = static_cast( + gpr_realloc(heap->timers, heap->timer_capacity * sizeof(grpc_timer*))); } } @@ -99,8 +99,8 @@ int grpc_timer_heap_add(grpc_timer_heap* heap, grpc_timer* timer) { if (heap->timer_count == heap->timer_capacity) { heap->timer_capacity = GPR_MAX(heap->timer_capacity + 1, heap->timer_capacity * 3 / 2); - heap->timers = static_cast(gpr_realloc( - heap->timers, heap->timer_capacity * sizeof(grpc_timer*))); + heap->timers = static_cast( + gpr_realloc(heap->timers, heap->timer_capacity * sizeof(grpc_timer*))); } timer->heap_index = heap->timer_count; adjust_upwards(heap->timers, heap->timer_count, timer); diff --git a/src/core/lib/iomgr/timer_manager.cc b/src/core/lib/iomgr/timer_manager.cc index 4cefb7fc9f..a528c22264 100644 --- a/src/core/lib/iomgr/timer_manager.cc +++ b/src/core/lib/iomgr/timer_manager.cc @@ -86,7 +86,8 @@ static void start_timer_thread_and_unlock(void) { } gpr_thd_options opt = gpr_thd_options_default(); gpr_thd_options_set_joinable(&opt); - completed_thread* ct = static_cast(gpr_malloc(sizeof(*ct))); + completed_thread* ct = + static_cast(gpr_malloc(sizeof(*ct))); // The call to gpr_thd_new() has to be under the same lock used by // gc_completed_threads(), particularly due to ct->t, which is written here // (internally by gpr_thd_new) and read there. Otherwise it's possible for ct diff --git a/src/core/lib/iomgr/udp_server.cc b/src/core/lib/iomgr/udp_server.cc index 9fabb898de..eecb3b09d9 100644 --- a/src/core/lib/iomgr/udp_server.cc +++ b/src/core/lib/iomgr/udp_server.cc @@ -139,7 +139,8 @@ static grpc_socket_factory* get_socket_factory(const grpc_channel_args* args) { } grpc_udp_server* grpc_udp_server_create(const grpc_channel_args* args) { - grpc_udp_server* s = static_cast(gpr_malloc(sizeof(grpc_udp_server))); + grpc_udp_server* s = + static_cast(gpr_malloc(sizeof(grpc_udp_server))); gpr_mu_init(&s->mu); s->socket_factory = get_socket_factory(args); if (s->socket_factory) { @@ -156,7 +157,8 @@ grpc_udp_server* grpc_udp_server_create(const grpc_channel_args* args) { } static void shutdown_fd(void* args, grpc_error* error) { - struct shutdown_fd_args* shutdown_args = static_cast(args); + struct shutdown_fd_args* shutdown_args = + static_cast(args); grpc_udp_listener* sp = shutdown_args->sp; gpr_log(GPR_DEBUG, "shutdown fd %d", sp->fd); gpr_mu_lock(shutdown_args->server_mu); @@ -279,7 +281,10 @@ static int bind_socket(grpc_socket_factory* socket_factory, int sockfd, const grpc_resolved_address* addr) { return (socket_factory != nullptr) ? grpc_socket_factory_bind(socket_factory, sockfd, addr) - : bind(sockfd, reinterpret_cast(const_cast(addr->addr)), static_cast(addr->len)); + : bind(sockfd, + reinterpret_cast( + const_cast(addr->addr)), + static_cast(addr->len)); } /* Prepare a recently-created socket for listening. */ @@ -287,7 +292,8 @@ static int prepare_socket(grpc_socket_factory* socket_factory, int fd, const grpc_resolved_address* addr, int rcv_buf_size, int snd_buf_size) { grpc_resolved_address sockname_temp; - struct sockaddr* addr_ptr = reinterpret_cast(const_cast(addr->addr)); + struct sockaddr* addr_ptr = + reinterpret_cast(const_cast(addr->addr)); if (fd < 0) { goto error; @@ -530,12 +536,14 @@ int grpc_udp_server_add_port(grpc_udp_server* s, if (grpc_sockaddr_get_port(addr) == 0) { for (sp = s->head; sp; sp = sp->next) { sockname_temp.len = sizeof(struct sockaddr_storage); - if (0 == getsockname(sp->fd, reinterpret_cast(sockname_temp.addr), - reinterpret_cast(&sockname_temp.len))) { + if (0 == + getsockname(sp->fd, + reinterpret_cast(sockname_temp.addr), + reinterpret_cast(&sockname_temp.len))) { port = grpc_sockaddr_get_port(&sockname_temp); if (port > 0) { - allocated_addr = - static_cast(gpr_malloc(sizeof(grpc_resolved_address))); + allocated_addr = static_cast( + gpr_malloc(sizeof(grpc_resolved_address))); memcpy(allocated_addr, addr, sizeof(grpc_resolved_address)); grpc_sockaddr_set_port(allocated_addr, port); addr = allocated_addr; diff --git a/src/core/lib/iomgr/unix_sockets_posix.cc b/src/core/lib/iomgr/unix_sockets_posix.cc index 90ed06b7d5..b603916c47 100644 --- a/src/core/lib/iomgr/unix_sockets_posix.cc +++ b/src/core/lib/iomgr/unix_sockets_posix.cc @@ -51,11 +51,11 @@ grpc_error* grpc_resolve_unix_domain_address(const char* name, gpr_free(err_msg); return err; } - *addrs = - static_cast(gpr_malloc(sizeof(grpc_resolved_addresses))); + *addrs = static_cast( + gpr_malloc(sizeof(grpc_resolved_addresses))); (*addrs)->naddrs = 1; - (*addrs)->addrs = - static_cast(gpr_malloc(sizeof(grpc_resolved_address))); + (*addrs)->addrs = static_cast( + gpr_malloc(sizeof(grpc_resolved_address))); un = reinterpret_cast((*addrs)->addrs->addr); un->sun_family = AF_UNIX; strncpy(un->sun_path, name, sizeof(un->sun_path)); @@ -64,17 +64,20 @@ grpc_error* grpc_resolve_unix_domain_address(const char* name, } int grpc_is_unix_socket(const grpc_resolved_address* resolved_addr) { - const struct sockaddr* addr = reinterpret_cast(resolved_addr->addr); + const struct sockaddr* addr = + reinterpret_cast(resolved_addr->addr); return addr->sa_family == AF_UNIX; } void grpc_unlink_if_unix_domain_socket( const grpc_resolved_address* resolved_addr) { - const struct sockaddr* addr = reinterpret_cast(resolved_addr->addr); + const struct sockaddr* addr = + reinterpret_cast(resolved_addr->addr); if (addr->sa_family != AF_UNIX) { return; } - struct sockaddr_un* un = reinterpret_cast(const_cast(resolved_addr->addr)); + struct sockaddr_un* un = reinterpret_cast( + const_cast(resolved_addr->addr)); struct stat st; if (stat(un->sun_path, &st) == 0 && (st.st_mode & S_IFMT) == S_IFSOCK) { @@ -84,7 +87,8 @@ void grpc_unlink_if_unix_domain_socket( char* grpc_sockaddr_to_uri_unix_if_possible( const grpc_resolved_address* resolved_addr) { - const struct sockaddr* addr = reinterpret_cast(resolved_addr->addr); + const struct sockaddr* addr = + reinterpret_cast(resolved_addr->addr); if (addr->sa_family != AF_UNIX) { return nullptr; } diff --git a/src/core/lib/iomgr/wakeup_fd_cv.cc b/src/core/lib/iomgr/wakeup_fd_cv.cc index 80f07ccf23..59718243e0 100644 --- a/src/core/lib/iomgr/wakeup_fd_cv.cc +++ b/src/core/lib/iomgr/wakeup_fd_cv.cc @@ -43,8 +43,8 @@ static grpc_error* cv_fd_init(grpc_wakeup_fd* fd_info) { gpr_mu_lock(&g_cvfds.mu); if (!g_cvfds.free_fds) { newsize = GPR_MIN(g_cvfds.size * 2, g_cvfds.size + MAX_TABLE_RESIZE); - g_cvfds.cvfds = static_cast(gpr_realloc(g_cvfds.cvfds, - sizeof(grpc_fd_node) * newsize)); + g_cvfds.cvfds = static_cast( + gpr_realloc(g_cvfds.cvfds, sizeof(grpc_fd_node) * newsize)); for (i = g_cvfds.size; i < newsize; i++) { g_cvfds.cvfds[i].is_set = 0; g_cvfds.cvfds[i].cvs = nullptr; diff --git a/src/core/lib/json/json_reader.cc b/src/core/lib/json/json_reader.cc index 019214a167..6dadea5006 100644 --- a/src/core/lib/json/json_reader.cc +++ b/src/core/lib/json/json_reader.cc @@ -417,8 +417,10 @@ grpc_json_reader_status grpc_json_reader_run(grpc_json_reader* reader) { } else { return GRPC_JSON_PARSE_ERROR; } - reader->unicode_char = static_cast(reader->unicode_char << 4); - reader->unicode_char = static_cast(reader->unicode_char | c); + reader->unicode_char = + static_cast(reader->unicode_char << 4); + reader->unicode_char = + static_cast(reader->unicode_char | c); switch (reader->state) { case GRPC_JSON_STATE_STRING_ESCAPE_U1: diff --git a/src/core/lib/json/json_string.cc b/src/core/lib/json/json_string.cc index dcaf11d0c9..8200900956 100644 --- a/src/core/lib/json/json_string.cc +++ b/src/core/lib/json/json_string.cc @@ -68,7 +68,8 @@ static void json_writer_output_check(void* userdata, size_t needed) { needed -= state->free_space; /* Round up by 256 bytes. */ needed = (needed + 0xff) & ~0xffU; - state->output = static_cast(gpr_realloc(state->output, state->allocated + needed)); + state->output = + static_cast(gpr_realloc(state->output, state->allocated + needed)); state->free_space += needed; state->allocated += needed; } diff --git a/src/core/lib/json/json_writer.cc b/src/core/lib/json/json_writer.cc index df49cbe4dc..6d442b8716 100644 --- a/src/core/lib/json/json_writer.cc +++ b/src/core/lib/json/json_writer.cc @@ -179,8 +179,10 @@ static void json_writer_escape_string(grpc_json_writer* writer, * That range is exactly 20 bits. */ utf32 -= 0x10000; - json_writer_escape_utf16(writer, static_cast(0xd800 | (utf32 >> 10))); - json_writer_escape_utf16(writer, static_cast(0xdc00 | (utf32 & 0x3ff))); + json_writer_escape_utf16(writer, + static_cast(0xd800 | (utf32 >> 10))); + json_writer_escape_utf16( + writer, static_cast(0xdc00 | (utf32 & 0x3ff))); } else { json_writer_escape_utf16(writer, static_cast(utf32)); } diff --git a/src/core/lib/security/context/security_context.cc b/src/core/lib/security/context/security_context.cc index cd8fabea28..c7e212bb21 100644 --- a/src/core/lib/security/context/security_context.cc +++ b/src/core/lib/security/context/security_context.cc @@ -44,8 +44,8 @@ grpc_call_error grpc_call_set_credentials(grpc_call* call, gpr_log(GPR_ERROR, "Method is client-side only."); return GRPC_CALL_ERROR_NOT_ON_SERVER; } - ctx = static_cast(grpc_call_context_get( - call, GRPC_CONTEXT_SECURITY)); + ctx = static_cast( + grpc_call_context_get(call, GRPC_CONTEXT_SECURITY)); if (ctx == nullptr) { ctx = grpc_client_security_context_create(); ctx->creds = grpc_call_credentials_ref(creds); @@ -80,13 +80,14 @@ void grpc_auth_context_release(grpc_auth_context* context) { /* --- grpc_client_security_context --- */ grpc_client_security_context* grpc_client_security_context_create(void) { - return static_cast(gpr_zalloc( - sizeof(grpc_client_security_context))); + return static_cast( + gpr_zalloc(sizeof(grpc_client_security_context))); } void grpc_client_security_context_destroy(void* ctx) { grpc_core::ExecCtx exec_ctx; - grpc_client_security_context* c = static_cast(ctx); + grpc_client_security_context* c = + static_cast(ctx); grpc_call_credentials_unref(c->creds); GRPC_AUTH_CONTEXT_UNREF(c->auth_context, "client_security_context"); if (c->extension.instance != nullptr && c->extension.destroy != nullptr) { @@ -98,12 +99,13 @@ void grpc_client_security_context_destroy(void* ctx) { /* --- grpc_server_security_context --- */ grpc_server_security_context* grpc_server_security_context_create(void) { - return static_cast(gpr_zalloc( - sizeof(grpc_server_security_context))); + return static_cast( + gpr_zalloc(sizeof(grpc_server_security_context))); } void grpc_server_security_context_destroy(void* ctx) { - grpc_server_security_context* c = static_cast(ctx); + grpc_server_security_context* c = + static_cast(ctx); GRPC_AUTH_CONTEXT_UNREF(c->auth_context, "server_security_context"); if (c->extension.instance != nullptr && c->extension.destroy != nullptr) { c->extension.destroy(c->extension.instance); @@ -258,9 +260,9 @@ static void ensure_auth_context_capacity(grpc_auth_context* ctx) { if (ctx->properties.count == ctx->properties.capacity) { ctx->properties.capacity = GPR_MAX(ctx->properties.capacity + 8, ctx->properties.capacity * 2); - ctx->properties.array = static_cast(gpr_realloc( - ctx->properties.array, - ctx->properties.capacity * sizeof(grpc_auth_property))); + ctx->properties.array = static_cast( + gpr_realloc(ctx->properties.array, + ctx->properties.capacity * sizeof(grpc_auth_property))); } } diff --git a/src/core/lib/security/credentials/composite/composite_credentials.cc b/src/core/lib/security/credentials/composite/composite_credentials.cc index 248177a178..ea2c4e208f 100644 --- a/src/core/lib/security/credentials/composite/composite_credentials.cc +++ b/src/core/lib/security/credentials/composite/composite_credentials.cc @@ -40,7 +40,8 @@ typedef struct { } grpc_composite_call_credentials_metadata_context; static void composite_call_destruct(grpc_call_credentials* creds) { - grpc_composite_call_credentials* c = reinterpret_cast(creds); + grpc_composite_call_credentials* c = + reinterpret_cast(creds); for (size_t i = 0; i < c->inner.num_creds; i++) { grpc_call_credentials_unref(c->inner.creds_array[i]); } @@ -75,10 +76,11 @@ static bool composite_call_get_request_metadata( grpc_auth_metadata_context auth_md_context, grpc_credentials_mdelem_array* md_array, grpc_closure* on_request_metadata, grpc_error** error) { - grpc_composite_call_credentials* c = reinterpret_cast(creds); + grpc_composite_call_credentials* c = + reinterpret_cast(creds); grpc_composite_call_credentials_metadata_context* ctx; - ctx = static_cast(gpr_zalloc( - sizeof(grpc_composite_call_credentials_metadata_context))); + ctx = static_cast( + gpr_zalloc(sizeof(grpc_composite_call_credentials_metadata_context))); ctx->composite_creds = c; ctx->pollent = pollent; ctx->auth_md_context = auth_md_context; @@ -106,7 +108,8 @@ static bool composite_call_get_request_metadata( static void composite_call_cancel_get_request_metadata( grpc_call_credentials* creds, grpc_credentials_mdelem_array* md_array, grpc_error* error) { - grpc_composite_call_credentials* c = reinterpret_cast(creds); + grpc_composite_call_credentials* c = + reinterpret_cast(creds); for (size_t i = 0; i < c->inner.num_creds; ++i) { grpc_call_credentials_cancel_get_request_metadata( c->inner.creds_array[i], md_array, GRPC_ERROR_REF(error)); @@ -145,8 +148,8 @@ grpc_call_credentials* grpc_composite_call_credentials_create( GPR_ASSERT(reserved == nullptr); GPR_ASSERT(creds1 != nullptr); GPR_ASSERT(creds2 != nullptr); - c = static_cast(gpr_zalloc( - sizeof(grpc_composite_call_credentials))); + c = static_cast( + gpr_zalloc(sizeof(grpc_composite_call_credentials))); c->base.type = GRPC_CALL_CREDENTIALS_TYPE_COMPOSITE; c->base.vtable = &composite_call_credentials_vtable; gpr_ref_init(&c->base.refcount, 1); diff --git a/src/core/lib/security/credentials/credentials.cc b/src/core/lib/security/credentials/credentials.cc index c1ca881292..17f7de58be 100644 --- a/src/core/lib/security/credentials/credentials.cc +++ b/src/core/lib/security/credentials/credentials.cc @@ -40,8 +40,8 @@ grpc_credentials_metadata_request* grpc_credentials_metadata_request_create( grpc_call_credentials* creds) { grpc_credentials_metadata_request* r = - static_cast(gpr_zalloc( - sizeof(grpc_credentials_metadata_request))); + static_cast( + gpr_zalloc(sizeof(grpc_credentials_metadata_request))); r->creds = grpc_call_credentials_ref(creds); return r; } @@ -149,7 +149,8 @@ static void credentials_pointer_arg_destroy(void* p) { } static void* credentials_pointer_arg_copy(void* p) { - return grpc_channel_credentials_ref(static_cast(p)); + return grpc_channel_credentials_ref( + static_cast(p)); } static int credentials_pointer_cmp(void* a, void* b) { return GPR_ICMP(a, b); } diff --git a/src/core/lib/security/credentials/credentials_metadata.cc b/src/core/lib/security/credentials/credentials_metadata.cc index 76e856f48e..250e384155 100644 --- a/src/core/lib/security/credentials/credentials_metadata.cc +++ b/src/core/lib/security/credentials/credentials_metadata.cc @@ -33,8 +33,8 @@ static void mdelem_list_ensure_capacity(grpc_credentials_mdelem_array* list, while (new_size < target_size) { new_size *= 2; } - list->md = - static_cast(gpr_realloc(list->md, sizeof(grpc_mdelem) * new_size)); + list->md = static_cast( + gpr_realloc(list->md, sizeof(grpc_mdelem) * new_size)); } void grpc_credentials_mdelem_array_add(grpc_credentials_mdelem_array* list, diff --git a/src/core/lib/security/credentials/fake/fake_credentials.cc b/src/core/lib/security/credentials/fake/fake_credentials.cc index b4f0dfdbdc..3b29db2efa 100644 --- a/src/core/lib/security/credentials/fake/fake_credentials.cc +++ b/src/core/lib/security/credentials/fake/fake_credentials.cc @@ -59,8 +59,8 @@ static grpc_server_credentials_vtable grpc_channel_credentials* grpc_fake_transport_security_credentials_create( void) { - grpc_channel_credentials* c = - static_cast(gpr_zalloc(sizeof(grpc_channel_credentials))); + grpc_channel_credentials* c = static_cast( + gpr_zalloc(sizeof(grpc_channel_credentials))); c->type = GRPC_CHANNEL_CREDENTIALS_TYPE_FAKE_TRANSPORT_SECURITY; c->vtable = &fake_transport_security_credentials_vtable; gpr_ref_init(&c->refcount, 1); @@ -69,8 +69,8 @@ grpc_channel_credentials* grpc_fake_transport_security_credentials_create( grpc_server_credentials* grpc_fake_transport_security_server_credentials_create( void) { - grpc_server_credentials* c = - static_cast(gpr_malloc(sizeof(grpc_server_credentials))); + grpc_server_credentials* c = static_cast( + gpr_malloc(sizeof(grpc_server_credentials))); memset(c, 0, sizeof(grpc_server_credentials)); c->type = GRPC_CHANNEL_CREDENTIALS_TYPE_FAKE_TRANSPORT_SECURITY; gpr_ref_init(&c->refcount, 1); @@ -97,7 +97,8 @@ const char* grpc_fake_transport_get_expected_targets( /* -- Metadata-only test credentials. -- */ static void md_only_test_destruct(grpc_call_credentials* creds) { - grpc_md_only_test_credentials* c = reinterpret_cast(creds); + grpc_md_only_test_credentials* c = + reinterpret_cast(creds); GRPC_MDELEM_UNREF(c->md); } @@ -105,7 +106,8 @@ static bool md_only_test_get_request_metadata( grpc_call_credentials* creds, grpc_polling_entity* pollent, grpc_auth_metadata_context context, grpc_credentials_mdelem_array* md_array, grpc_closure* on_request_metadata, grpc_error** error) { - grpc_md_only_test_credentials* c = reinterpret_cast(creds); + grpc_md_only_test_credentials* c = + reinterpret_cast(creds); grpc_credentials_mdelem_array_add(md_array, c->md); if (c->is_async) { GRPC_CLOSURE_SCHED(on_request_metadata, GRPC_ERROR_NONE); @@ -126,8 +128,9 @@ static grpc_call_credentials_vtable md_only_test_vtable = { grpc_call_credentials* grpc_md_only_test_credentials_create( const char* md_key, const char* md_value, bool is_async) { - grpc_md_only_test_credentials* c = static_cast(gpr_zalloc( - sizeof(grpc_md_only_test_credentials))); + grpc_md_only_test_credentials* c = + static_cast( + gpr_zalloc(sizeof(grpc_md_only_test_credentials))); c->base.type = GRPC_CALL_CREDENTIALS_TYPE_OAUTH2; c->base.vtable = &md_only_test_vtable; gpr_ref_init(&c->base.refcount, 1); diff --git a/src/core/lib/security/credentials/google_default/google_default_credentials.cc b/src/core/lib/security/credentials/google_default/google_default_credentials.cc index dd7d52d750..65455f94b3 100644 --- a/src/core/lib/security/credentials/google_default/google_default_credentials.cc +++ b/src/core/lib/security/credentials/google_default/google_default_credentials.cc @@ -60,7 +60,8 @@ typedef struct { static void on_compute_engine_detection_http_response(void* user_data, grpc_error* error) { - compute_engine_detector* detector = static_cast(user_data); + compute_engine_detector* detector = + static_cast(user_data); if (error == GRPC_ERROR_NONE && detector->response.status == 200 && detector->response.hdr_count > 0) { /* Internet providers can return a generic response to all requests, so @@ -98,7 +99,8 @@ static int is_stack_running_on_compute_engine() { on compute engine. */ grpc_millis max_detection_delay = GPR_MS_PER_SEC; - grpc_pollset* pollset = static_cast(gpr_zalloc(grpc_pollset_size())); + grpc_pollset* pollset = + static_cast(gpr_zalloc(grpc_pollset_size())); grpc_pollset_init(pollset, &g_polling_mu); detector.pollent = grpc_polling_entity_create_from_pollset(pollset); detector.is_done = 0; @@ -171,7 +173,8 @@ static grpc_error* create_default_creds_from_path( goto end; } json = grpc_json_parse_string_with_len( - reinterpret_castGRPC_SLICE_START_PTR(creds_data), GRPC_SLICE_LENGTH(creds_data)); + reinterpret_cast GRPC_SLICE_START_PTR(creds_data), + GRPC_SLICE_LENGTH(creds_data)); if (json == nullptr) { error = grpc_error_set_str( GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed to parse JSON"), diff --git a/src/core/lib/security/credentials/iam/iam_credentials.cc b/src/core/lib/security/credentials/iam/iam_credentials.cc index 20f4ff95f5..7f19fbc785 100644 --- a/src/core/lib/security/credentials/iam/iam_credentials.cc +++ b/src/core/lib/security/credentials/iam/iam_credentials.cc @@ -28,7 +28,8 @@ #include static void iam_destruct(grpc_call_credentials* creds) { - grpc_google_iam_credentials* c = reinterpret_cast(creds); + grpc_google_iam_credentials* c = + reinterpret_cast(creds); grpc_credentials_mdelem_array_destroy(&c->md_array); } @@ -38,7 +39,8 @@ static bool iam_get_request_metadata(grpc_call_credentials* creds, grpc_credentials_mdelem_array* md_array, grpc_closure* on_request_metadata, grpc_error** error) { - grpc_google_iam_credentials* c = reinterpret_cast(creds); + grpc_google_iam_credentials* c = + reinterpret_cast(creds); grpc_credentials_mdelem_array_append(md_array, &c->md_array); return true; } diff --git a/src/core/lib/security/credentials/jwt/json_token.cc b/src/core/lib/security/credentials/jwt/json_token.cc index eae1be17fd..f7c9f57808 100644 --- a/src/core/lib/security/credentials/jwt/json_token.cc +++ b/src/core/lib/security/credentials/jwt/json_token.cc @@ -219,7 +219,8 @@ static char* dot_concat_and_free_strings(char* str1, char* str2) { size_t str1_len = strlen(str1); size_t str2_len = strlen(str2); size_t result_len = str1_len + 1 /* dot */ + str2_len; - char* result = static_cast(gpr_malloc(result_len + 1 /* NULL terminated */)); + char* result = + static_cast(gpr_malloc(result_len + 1 /* NULL terminated */)); char* current = result; memcpy(current, str1, str1_len); current += str1_len; diff --git a/src/core/lib/security/credentials/jwt/jwt_credentials.cc b/src/core/lib/security/credentials/jwt/jwt_credentials.cc index 44101acd78..05c08a68b0 100644 --- a/src/core/lib/security/credentials/jwt/jwt_credentials.cc +++ b/src/core/lib/security/credentials/jwt/jwt_credentials.cc @@ -123,8 +123,8 @@ grpc_service_account_jwt_access_credentials_create_from_auth_json_key( gpr_log(GPR_ERROR, "Invalid input for jwt credentials creation"); return nullptr; } - c = static_cast(gpr_zalloc( - sizeof(grpc_service_account_jwt_access_credentials))); + c = static_cast( + gpr_zalloc(sizeof(grpc_service_account_jwt_access_credentials))); c->base.type = GRPC_CALL_CREDENTIALS_TYPE_JWT; gpr_ref_init(&c->base.refcount, 1); c->base.vtable = &jwt_vtable; diff --git a/src/core/lib/security/credentials/jwt/jwt_verifier.cc b/src/core/lib/security/credentials/jwt/jwt_verifier.cc index 3d7541f4c9..f5c1ada6ca 100644 --- a/src/core/lib/security/credentials/jwt/jwt_verifier.cc +++ b/src/core/lib/security/credentials/jwt/jwt_verifier.cc @@ -82,8 +82,9 @@ static grpc_json* parse_json_part_from_jwt(const char* str, size_t len, gpr_log(GPR_ERROR, "Invalid base64."); return nullptr; } - json = grpc_json_parse_string_with_len(reinterpret_castGRPC_SLICE_START_PTR(*buffer), - GRPC_SLICE_LENGTH(*buffer)); + json = grpc_json_parse_string_with_len( + reinterpret_cast GRPC_SLICE_START_PTR(*buffer), + GRPC_SLICE_LENGTH(*buffer)); if (json == nullptr) { grpc_slice_unref_internal(*buffer); gpr_log(GPR_ERROR, "JSON parsing error."); @@ -347,7 +348,8 @@ static verifier_cb_ctx* verifier_cb_ctx_create( const char* signed_jwt, size_t signed_jwt_len, void* user_data, grpc_jwt_verification_done_cb cb) { grpc_core::ExecCtx exec_ctx; - verifier_cb_ctx* ctx = static_cast(gpr_zalloc(sizeof(verifier_cb_ctx))); + verifier_cb_ctx* ctx = + static_cast(gpr_zalloc(sizeof(verifier_cb_ctx))); ctx->verifier = verifier; ctx->pollent = grpc_polling_entity_create_from_pollset(pollset); ctx->header = header; @@ -754,8 +756,8 @@ const char* grpc_jwt_issuer_email_domain(const char* issuer) { if (dot == nullptr || dot == email_domain) return email_domain; GPR_ASSERT(dot > email_domain); /* There may be a subdomain, we just want the domain. */ - dot = static_cast(gpr_memrchr((void*)email_domain, '.', - static_cast(dot - email_domain))); + dot = static_cast(gpr_memrchr( + (void*)email_domain, '.', static_cast(dot - email_domain))); if (dot == nullptr) return email_domain; return dot + 1; } @@ -861,7 +863,8 @@ void grpc_jwt_verifier_verify(grpc_jwt_verifier* verifier, cb != nullptr); dot = strchr(cur, '.'); if (dot == nullptr) goto error; - json = parse_json_part_from_jwt(cur, static_cast(dot - cur), &header_buffer); + json = parse_json_part_from_jwt(cur, static_cast(dot - cur), + &header_buffer); if (json == nullptr) goto error; header = jose_header_from_json(json, header_buffer); if (header == nullptr) goto error; @@ -869,7 +872,8 @@ void grpc_jwt_verifier_verify(grpc_jwt_verifier* verifier, cur = dot + 1; dot = strchr(cur, '.'); if (dot == nullptr) goto error; - json = parse_json_part_from_jwt(cur, static_cast(dot - cur), &claims_buffer); + json = parse_json_part_from_jwt(cur, static_cast(dot - cur), + &claims_buffer); if (json == nullptr) goto error; claims = grpc_jwt_claims_from_json(json, claims_buffer); if (claims == nullptr) goto error; @@ -898,8 +902,8 @@ grpc_jwt_verifier* grpc_jwt_verifier_create( /* We know at least of one mapping. */ v->allocated_mappings = 1 + num_mappings; - v->mappings = static_cast(gpr_malloc(v->allocated_mappings * - sizeof(email_key_mapping))); + v->mappings = static_cast( + gpr_malloc(v->allocated_mappings * sizeof(email_key_mapping))); verifier_put_mapping(v, GRPC_GOOGLE_SERVICE_ACCOUNTS_EMAIL_DOMAIN, GRPC_GOOGLE_SERVICE_ACCOUNTS_KEY_URL_PREFIX); /* User-Provided mappings. */ diff --git a/src/core/lib/security/credentials/oauth2/oauth2_credentials.cc b/src/core/lib/security/credentials/oauth2/oauth2_credentials.cc index b4fb9a43e7..afae7d8f2f 100644 --- a/src/core/lib/security/credentials/oauth2/oauth2_credentials.cc +++ b/src/core/lib/security/credentials/oauth2/oauth2_credentials.cc @@ -128,7 +128,8 @@ grpc_oauth2_token_fetcher_credentials_parse_server_response( } if (response->body_length > 0) { - null_terminated_body = static_cast(gpr_malloc(response->body_length + 1)); + null_terminated_body = + static_cast(gpr_malloc(response->body_length + 1)); null_terminated_body[response->body_length] = '\0'; memcpy(null_terminated_body, response->body, response->body_length); } @@ -269,8 +270,8 @@ static bool oauth2_token_fetcher_get_request_metadata( // Couldn't get the token from the cache. // Add request to c->pending_requests and start a new fetch if needed. grpc_oauth2_pending_get_request_metadata* pending_request = - static_cast(gpr_malloc( - sizeof(*pending_request))); + static_cast( + gpr_malloc(sizeof(*pending_request))); pending_request->md_array = md_array; pending_request->on_request_metadata = on_request_metadata; pending_request->pollent = pollent; @@ -371,8 +372,8 @@ static void compute_engine_fetch_oauth2( grpc_call_credentials* grpc_google_compute_engine_credentials_create( void* reserved) { grpc_oauth2_token_fetcher_credentials* c = - static_cast(gpr_malloc( - sizeof(grpc_oauth2_token_fetcher_credentials))); + static_cast( + gpr_malloc(sizeof(grpc_oauth2_token_fetcher_credentials))); GRPC_API_TRACE("grpc_compute_engine_credentials_create(reserved=%p)", 1, (reserved)); GPR_ASSERT(reserved == nullptr); @@ -401,7 +402,8 @@ static void refresh_token_fetch_oauth2( grpc_httpcli_context* httpcli_context, grpc_polling_entity* pollent, grpc_iomgr_cb_func response_cb, grpc_millis deadline) { grpc_google_refresh_token_credentials* c = - reinterpret_cast(metadata_req->creds); + reinterpret_cast( + metadata_req->creds); grpc_http_header header = {(char*)"Content-Type", (char*)"application/x-www-form-urlencoded"}; grpc_httpcli_request request; @@ -437,8 +439,8 @@ grpc_refresh_token_credentials_create_from_auth_refresh_token( gpr_log(GPR_ERROR, "Invalid input for refresh token credentials creation"); return nullptr; } - c = static_cast(gpr_zalloc( - sizeof(grpc_google_refresh_token_credentials))); + c = static_cast( + gpr_zalloc(sizeof(grpc_google_refresh_token_credentials))); init_oauth2_token_fetcher(&c->base, refresh_token_fetch_oauth2); c->base.base.vtable = &refresh_token_vtable; c->refresh_token = refresh_token; @@ -478,7 +480,8 @@ grpc_call_credentials* grpc_google_refresh_token_credentials_create( // static void access_token_destruct(grpc_call_credentials* creds) { - grpc_access_token_credentials* c = reinterpret_cast(creds); + grpc_access_token_credentials* c = + reinterpret_cast(creds); GRPC_MDELEM_UNREF(c->access_token_md); } @@ -486,7 +489,8 @@ static bool access_token_get_request_metadata( 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 = reinterpret_cast(creds); + grpc_access_token_credentials* c = + reinterpret_cast(creds); grpc_credentials_mdelem_array_add(md_array, c->access_token_md); return true; } @@ -503,8 +507,9 @@ static grpc_call_credentials_vtable access_token_vtable = { grpc_call_credentials* grpc_access_token_credentials_create( const char* access_token, void* reserved) { - grpc_access_token_credentials* c = static_cast(gpr_zalloc( - sizeof(grpc_access_token_credentials))); + grpc_access_token_credentials* c = + static_cast( + gpr_zalloc(sizeof(grpc_access_token_credentials))); GRPC_API_TRACE( "grpc_access_token_credentials_create(access_token=, " "reserved=%p)", diff --git a/src/core/lib/security/credentials/plugin/plugin_credentials.cc b/src/core/lib/security/credentials/plugin/plugin_credentials.cc index 89f94f9e6d..ddb86e153b 100644 --- a/src/core/lib/security/credentials/plugin/plugin_credentials.cc +++ b/src/core/lib/security/credentials/plugin/plugin_credentials.cc @@ -34,7 +34,8 @@ grpc_core::TraceFlag grpc_plugin_credentials_trace(false, "plugin_credentials"); static void plugin_destruct(grpc_call_credentials* creds) { - grpc_plugin_credentials* c = reinterpret_cast(creds); + grpc_plugin_credentials* c = + reinterpret_cast(creds); gpr_mu_destroy(&c->mu); if (c->plugin.state != nullptr && c->plugin.destroy != nullptr) { c->plugin.destroy(c->plugin.state); @@ -147,13 +148,14 @@ static bool plugin_get_request_metadata(grpc_call_credentials* creds, grpc_credentials_mdelem_array* md_array, grpc_closure* on_request_metadata, grpc_error** error) { - grpc_plugin_credentials* c = reinterpret_cast(creds); + grpc_plugin_credentials* c = + reinterpret_cast(creds); bool retval = true; // Synchronous return. if (c->plugin.get_metadata != nullptr) { // Create pending_request object. grpc_plugin_credentials_pending_request* pending_request = - static_cast(gpr_zalloc( - sizeof(*pending_request))); + static_cast( + gpr_zalloc(sizeof(*pending_request))); pending_request->creds = c; pending_request->md_array = md_array; pending_request->on_request_metadata = on_request_metadata; @@ -225,7 +227,8 @@ static bool plugin_get_request_metadata(grpc_call_credentials* creds, static void plugin_cancel_get_request_metadata( grpc_call_credentials* creds, grpc_credentials_mdelem_array* md_array, grpc_error* error) { - grpc_plugin_credentials* c = reinterpret_cast(creds); + grpc_plugin_credentials* c = + reinterpret_cast(creds); gpr_mu_lock(&c->mu); for (grpc_plugin_credentials_pending_request* pending_request = c->pending_requests; @@ -252,7 +255,8 @@ static grpc_call_credentials_vtable plugin_vtable = { grpc_call_credentials* grpc_metadata_credentials_create_from_plugin( grpc_metadata_credentials_plugin plugin, void* reserved) { - grpc_plugin_credentials* c = static_cast(gpr_zalloc(sizeof(*c))); + grpc_plugin_credentials* c = + static_cast(gpr_zalloc(sizeof(*c))); GRPC_API_TRACE("grpc_metadata_credentials_create_from_plugin(reserved=%p)", 1, (reserved)); GPR_ASSERT(reserved == nullptr); diff --git a/src/core/lib/security/credentials/ssl/ssl_credentials.cc b/src/core/lib/security/credentials/ssl/ssl_credentials.cc index 4237039274..a4fce25f3a 100644 --- a/src/core/lib/security/credentials/ssl/ssl_credentials.cc +++ b/src/core/lib/security/credentials/ssl/ssl_credentials.cc @@ -85,8 +85,8 @@ static void ssl_build_config(const char* pem_root_certs, if (pem_key_cert_pair != nullptr) { GPR_ASSERT(pem_key_cert_pair->private_key != nullptr); GPR_ASSERT(pem_key_cert_pair->cert_chain != nullptr); - config->pem_key_cert_pair = static_cast(gpr_zalloc( - sizeof(tsi_ssl_pem_key_cert_pair))); + config->pem_key_cert_pair = static_cast( + gpr_zalloc(sizeof(tsi_ssl_pem_key_cert_pair))); config->pem_key_cert_pair->cert_chain = gpr_strdup(pem_key_cert_pair->cert_chain); config->pem_key_cert_pair->private_key = @@ -97,8 +97,8 @@ static void ssl_build_config(const char* pem_root_certs, grpc_channel_credentials* grpc_ssl_credentials_create( const char* pem_root_certs, grpc_ssl_pem_key_cert_pair* pem_key_cert_pair, void* reserved) { - grpc_ssl_credentials* c = - static_cast(gpr_zalloc(sizeof(grpc_ssl_credentials))); + grpc_ssl_credentials* c = static_cast( + gpr_zalloc(sizeof(grpc_ssl_credentials))); GRPC_API_TRACE( "grpc_ssl_credentials_create(pem_root_certs=%s, " "pem_key_cert_pair=%p, " @@ -123,7 +123,8 @@ struct grpc_ssl_server_credentials_options { }; static void ssl_server_destruct(grpc_server_credentials* creds) { - grpc_ssl_server_credentials* c = reinterpret_cast(creds); + grpc_ssl_server_credentials* c = + reinterpret_cast(creds); grpc_tsi_ssl_pem_key_cert_pairs_destroy(c->config.pem_key_cert_pairs, c->config.num_key_cert_pairs); gpr_free(c->config.pem_root_certs); @@ -143,8 +144,8 @@ tsi_ssl_pem_key_cert_pair* grpc_convert_grpc_to_tsi_cert_pairs( tsi_ssl_pem_key_cert_pair* tsi_pairs = nullptr; if (num_key_cert_pairs > 0) { GPR_ASSERT(pem_key_cert_pairs != nullptr); - tsi_pairs = static_cast(gpr_zalloc( - num_key_cert_pairs * sizeof(tsi_ssl_pem_key_cert_pair))); + tsi_pairs = static_cast( + gpr_zalloc(num_key_cert_pairs * sizeof(tsi_ssl_pem_key_cert_pair))); } for (size_t i = 0; i < num_key_cert_pairs; i++) { GPR_ASSERT(pem_key_cert_pairs[i].private_key != nullptr); @@ -174,15 +175,15 @@ grpc_ssl_server_certificate_config* grpc_ssl_server_certificate_config_create( const grpc_ssl_pem_key_cert_pair* pem_key_cert_pairs, size_t num_key_cert_pairs) { grpc_ssl_server_certificate_config* config = - static_cast(gpr_zalloc( - sizeof(grpc_ssl_server_certificate_config))); + static_cast( + gpr_zalloc(sizeof(grpc_ssl_server_certificate_config))); if (pem_root_certs != nullptr) { config->pem_root_certs = gpr_strdup(pem_root_certs); } if (num_key_cert_pairs > 0) { GPR_ASSERT(pem_key_cert_pairs != nullptr); - config->pem_key_cert_pairs = static_cast(gpr_zalloc( - num_key_cert_pairs * sizeof(grpc_ssl_pem_key_cert_pair))); + config->pem_key_cert_pairs = static_cast( + gpr_zalloc(num_key_cert_pairs * sizeof(grpc_ssl_pem_key_cert_pair))); } config->num_key_cert_pairs = num_key_cert_pairs; for (size_t i = 0; i < num_key_cert_pairs; i++) { @@ -217,8 +218,8 @@ grpc_ssl_server_credentials_create_options_using_config( gpr_log(GPR_ERROR, "Certificate config must not be NULL."); goto done; } - options = static_cast(gpr_zalloc( - sizeof(grpc_ssl_server_credentials_options))); + options = static_cast( + gpr_zalloc(sizeof(grpc_ssl_server_credentials_options))); options->client_certificate_request = client_certificate_request; options->certificate_config = config; done: @@ -235,14 +236,14 @@ grpc_ssl_server_credentials_create_options_using_config_fetcher( } grpc_ssl_server_certificate_config_fetcher* fetcher = - static_cast(gpr_zalloc( - sizeof(grpc_ssl_server_certificate_config_fetcher))); + static_cast( + gpr_zalloc(sizeof(grpc_ssl_server_certificate_config_fetcher))); fetcher->cb = cb; fetcher->user_data = user_data; grpc_ssl_server_credentials_options* options = - static_cast(gpr_zalloc( - sizeof(grpc_ssl_server_credentials_options))); + static_cast( + gpr_zalloc(sizeof(grpc_ssl_server_credentials_options))); options->client_certificate_request = client_certificate_request; options->certificate_config_fetcher = fetcher; @@ -307,8 +308,8 @@ grpc_server_credentials* grpc_ssl_server_credentials_create_with_options( goto done; } - c = static_cast(gpr_zalloc( - sizeof(grpc_ssl_server_credentials))); + c = static_cast( + gpr_zalloc(sizeof(grpc_ssl_server_credentials))); c->base.type = GRPC_CHANNEL_CREDENTIALS_TYPE_SSL; gpr_ref_init(&c->base.refcount, 1); c->base.vtable = &ssl_server_vtable; diff --git a/src/core/lib/security/transport/client_auth_filter.cc b/src/core/lib/security/transport/client_auth_filter.cc index b5171acc87..d2313807ff 100644 --- a/src/core/lib/security/transport/client_auth_filter.cc +++ b/src/core/lib/security/transport/client_auth_filter.cc @@ -93,7 +93,8 @@ static void add_error(grpc_error** combined, grpc_error* error) { } static void on_credentials_metadata(void* arg, grpc_error* input_error) { - grpc_transport_stream_op_batch* batch = static_cast(arg); + grpc_transport_stream_op_batch* batch = + static_cast(arg); grpc_call_element* elem = static_cast(batch->handler_private.extra_arg); call_data* calld = static_cast(elem->call_data); @@ -173,9 +174,8 @@ static void send_security_metadata(grpc_call_element* elem, call_data* calld = static_cast(elem->call_data); channel_data* chand = static_cast(elem->channel_data); grpc_client_security_context* ctx = - static_cast(batch->payload - ->context[GRPC_CONTEXT_SECURITY] - .value); + static_cast( + batch->payload->context[GRPC_CONTEXT_SECURITY].value); grpc_call_credentials* channel_call_creds = chand->security_connector->request_metadata_creds; int call_creds_has_md = (ctx != nullptr) && (ctx->creds != nullptr); @@ -231,7 +231,8 @@ static void send_security_metadata(grpc_call_element* elem, } static void on_host_checked(void* arg, grpc_error* error) { - grpc_transport_stream_op_batch* batch = static_cast(arg); + grpc_transport_stream_op_batch* batch = + static_cast(arg); grpc_call_element* elem = static_cast(batch->handler_private.extra_arg); call_data* calld = static_cast(elem->call_data); @@ -283,9 +284,8 @@ static void auth_start_transport_stream_op_batch( grpc_client_security_context_destroy; } grpc_client_security_context* sec_ctx = - static_cast(batch->payload - ->context[GRPC_CONTEXT_SECURITY] - .value); + static_cast( + batch->payload->context[GRPC_CONTEXT_SECURITY].value); GRPC_AUTH_CONTEXT_UNREF(sec_ctx->auth_context, "client auth filter"); sec_ctx->auth_context = GRPC_AUTH_CONTEXT_REF(chand->auth_context, "client_auth_filter"); @@ -400,8 +400,8 @@ static grpc_error* init_channel_elem(grpc_channel_element* elem, /* initialize members */ chand->security_connector = - reinterpret_cast(GRPC_SECURITY_CONNECTOR_REF( - sc, "client_auth_filter")); + reinterpret_cast( + GRPC_SECURITY_CONNECTOR_REF(sc, "client_auth_filter")); chand->auth_context = GRPC_AUTH_CONTEXT_REF(auth_context, "client_auth_filter"); return GRPC_ERROR_NONE; diff --git a/src/core/lib/security/transport/lb_targets_info.cc b/src/core/lib/security/transport/lb_targets_info.cc index 84a72731c9..67a3c7449d 100644 --- a/src/core/lib/security/transport/lb_targets_info.cc +++ b/src/core/lib/security/transport/lb_targets_info.cc @@ -32,8 +32,9 @@ static void targets_info_destroy(void* p) { grpc_slice_hash_table_unref(static_cast(p)); } static int targets_info_cmp(void* a, void* b) { - return grpc_slice_hash_table_cmp(static_cast(a), - static_cast(b)); + return grpc_slice_hash_table_cmp( + static_cast(a), + static_cast(b)); } static const grpc_arg_pointer_vtable server_to_balancer_names_vtable = { targets_info_copy, targets_info_destroy, targets_info_cmp}; @@ -51,7 +52,8 @@ grpc_slice_hash_table* grpc_lb_targets_info_find_in_args( grpc_channel_args_find(args, GRPC_ARG_LB_SECURE_NAMING_MAP); if (targets_info_arg != nullptr) { GPR_ASSERT(targets_info_arg->type == GRPC_ARG_POINTER); - return static_cast(targets_info_arg->value.pointer.p); + return static_cast( + targets_info_arg->value.pointer.p); } return nullptr; } diff --git a/src/core/lib/security/transport/secure_endpoint.cc b/src/core/lib/security/transport/secure_endpoint.cc index a63dbc07c8..f72f8b6121 100644 --- a/src/core/lib/security/transport/secure_endpoint.cc +++ b/src/core/lib/security/transport/secure_endpoint.cc @@ -205,7 +205,8 @@ static void on_read(void* user_data, grpc_error* error) { ep->read_buffer, grpc_slice_split_head( &ep->read_staging_buffer, - static_cast(cur - GRPC_SLICE_START_PTR(ep->read_staging_buffer)))); + static_cast( + cur - GRPC_SLICE_START_PTR(ep->read_staging_buffer)))); } } @@ -324,8 +325,8 @@ static void endpoint_write(grpc_endpoint* secure_ep, grpc_slice_buffer* slices, &ep->output_buffer, grpc_slice_split_head( &ep->write_staging_buffer, - static_cast(cur - - GRPC_SLICE_START_PTR(ep->write_staging_buffer)))); + static_cast( + cur - GRPC_SLICE_START_PTR(ep->write_staging_buffer)))); } } } @@ -403,7 +404,8 @@ grpc_endpoint* grpc_secure_endpoint_create( grpc_endpoint* transport, grpc_slice* leftover_slices, size_t leftover_nslices) { size_t i; - secure_endpoint* ep = static_cast(gpr_malloc(sizeof(secure_endpoint))); + secure_endpoint* ep = + static_cast(gpr_malloc(sizeof(secure_endpoint))); ep->base.vtable = &vtable; ep->wrapped_ep = transport; ep->protector = protector; diff --git a/src/core/lib/security/transport/security_connector.cc b/src/core/lib/security/transport/security_connector.cc index e9a2d23535..bd5da1bbd2 100644 --- a/src/core/lib/security/transport/security_connector.cc +++ b/src/core/lib/security/transport/security_connector.cc @@ -498,7 +498,8 @@ grpc_channel_security_connector* grpc_fake_channel_security_connector_create( grpc_call_credentials* request_metadata_creds, const char* target, const grpc_channel_args* args) { grpc_fake_channel_security_connector* c = - static_cast(gpr_zalloc(sizeof(*c))); + static_cast( + gpr_zalloc(sizeof(*c))); gpr_ref_init(&c->base.base.refcount, 1); c->base.base.url_scheme = GRPC_FAKE_SECURITY_URL_SCHEME; c->base.base.vtable = &fake_channel_vtable; @@ -518,8 +519,8 @@ grpc_channel_security_connector* grpc_fake_channel_security_connector_create( grpc_server_security_connector* grpc_fake_server_security_connector_create( grpc_server_credentials* server_creds) { grpc_server_security_connector* c = - static_cast(gpr_zalloc( - sizeof(grpc_server_security_connector))); + static_cast( + gpr_zalloc(sizeof(grpc_server_security_connector))); gpr_ref_init(&c->base.refcount, 1); c->base.vtable = &fake_server_vtable; c->base.url_scheme = GRPC_FAKE_SECURITY_URL_SCHEME; @@ -597,8 +598,8 @@ static void ssl_channel_add_handshakers(grpc_channel_security_connector* sc, static const char** fill_alpn_protocol_strings(size_t* num_alpn_protocols) { GPR_ASSERT(num_alpn_protocols != nullptr); *num_alpn_protocols = grpc_chttp2_num_alpn_versions(); - const char** alpn_protocol_strings = - static_cast(gpr_malloc(sizeof(const char*) * (*num_alpn_protocols))); + const char** alpn_protocol_strings = static_cast( + gpr_malloc(sizeof(const char*) * (*num_alpn_protocols))); for (size_t i = 0; i < *num_alpn_protocols; i++) { alpn_protocol_strings[i] = grpc_chttp2_get_alpn_version_index(i); } @@ -632,8 +633,8 @@ static bool try_replace_server_handshaker_factory( cert_pairs, config->num_key_cert_pairs, config->pem_root_certs, get_tsi_client_certificate_request_type( server_creds->config.client_certificate_request), - ssl_cipher_suites(), alpn_protocol_strings, static_cast(num_alpn_protocols), - &new_handshaker_factory); + ssl_cipher_suites(), alpn_protocol_strings, + static_cast(num_alpn_protocols), &new_handshaker_factory); gpr_free(cert_pairs); gpr_free((void*)alpn_protocol_strings); @@ -850,8 +851,8 @@ tsi_peer tsi_shallow_peer_from_ssl_auth_context( while (grpc_auth_property_iterator_next(&it) != nullptr) max_num_props++; if (max_num_props > 0) { - peer.properties = static_cast(gpr_malloc(max_num_props * - sizeof(tsi_peer_property))); + peer.properties = static_cast( + gpr_malloc(max_num_props * sizeof(tsi_peer_property))); it = grpc_auth_context_property_iterator(auth_context); while ((prop = grpc_auth_property_iterator_next(&it)) != nullptr) { if (strcmp(prop->name, GRPC_X509_SAN_PROPERTY_NAME) == 0) { @@ -963,7 +964,8 @@ const char* grpc_get_default_ssl_roots(void) { gpr_once_init(&once, init_default_pem_root_certs); return GRPC_SLICE_IS_EMPTY(default_pem_root_certs) ? nullptr - : reinterpret_castGRPC_SLICE_START_PTR(default_pem_root_certs); + : reinterpret_cast + GRPC_SLICE_START_PTR(default_pem_root_certs); } grpc_security_status grpc_ssl_channel_security_connector_create( @@ -994,8 +996,8 @@ grpc_security_status grpc_ssl_channel_security_connector_create( pem_root_certs = config->pem_root_certs; } - c = static_cast(gpr_zalloc( - sizeof(grpc_ssl_channel_security_connector))); + c = static_cast( + gpr_zalloc(sizeof(grpc_ssl_channel_security_connector))); gpr_ref_init(&c->base.base.refcount, 1); c->base.base.vtable = &ssl_channel_vtable; @@ -1017,8 +1019,8 @@ grpc_security_status grpc_ssl_channel_security_connector_create( config->pem_key_cert_pair->cert_chain != nullptr; result = tsi_create_ssl_client_handshaker_factory( has_key_cert_pair ? config->pem_key_cert_pair : nullptr, pem_root_certs, - ssl_cipher_suites(), alpn_protocol_strings, static_cast(num_alpn_protocols), - &c->client_handshaker_factory); + ssl_cipher_suites(), alpn_protocol_strings, + static_cast(num_alpn_protocols), &c->client_handshaker_factory); if (result != TSI_OK) { gpr_log(GPR_ERROR, "Handshaker factory creation failed with %s.", tsi_result_to_string(result)); @@ -1039,8 +1041,8 @@ static grpc_ssl_server_security_connector* grpc_ssl_server_security_connector_initialize( grpc_server_credentials* server_creds) { grpc_ssl_server_security_connector* c = - static_cast(gpr_zalloc( - sizeof(grpc_ssl_server_security_connector))); + static_cast( + gpr_zalloc(sizeof(grpc_ssl_server_security_connector))); gpr_ref_init(&c->base.base.refcount, 1); c->base.base.url_scheme = GRPC_SSL_URL_SCHEME; c->base.base.vtable = &ssl_server_vtable; @@ -1078,7 +1080,8 @@ grpc_security_status grpc_ssl_server_security_connector_create( get_tsi_client_certificate_request_type( server_credentials->config.client_certificate_request), ssl_cipher_suites(), alpn_protocol_strings, - static_cast(num_alpn_protocols), &c->server_handshaker_factory); + static_cast(num_alpn_protocols), + &c->server_handshaker_factory); gpr_free((void*)alpn_protocol_strings); if (result != TSI_OK) { gpr_log(GPR_ERROR, "Handshaker factory creation failed with %s.", diff --git a/src/core/lib/security/transport/security_handshaker.cc b/src/core/lib/security/transport/security_handshaker.cc index 2e7c3570b6..b37392ab81 100644 --- a/src/core/lib/security/transport/security_handshaker.cc +++ b/src/core/lib/security/transport/security_handshaker.cc @@ -68,8 +68,8 @@ typedef struct { static size_t move_read_buffer_into_handshake_buffer(security_handshaker* h) { size_t bytes_in_read_buffer = h->args->read_buffer->length; if (h->handshake_buffer_size < bytes_in_read_buffer) { - h->handshake_buffer = - static_cast(gpr_realloc(h->handshake_buffer, bytes_in_read_buffer)); + h->handshake_buffer = static_cast( + gpr_realloc(h->handshake_buffer, bytes_in_read_buffer)); h->handshake_buffer_size = bytes_in_read_buffer; } size_t offset = 0; @@ -408,15 +408,16 @@ static const grpc_handshaker_vtable security_handshaker_vtable = { static grpc_handshaker* security_handshaker_create( tsi_handshaker* handshaker, grpc_security_connector* connector) { - security_handshaker* h = - static_cast(gpr_zalloc(sizeof(security_handshaker))); + security_handshaker* h = static_cast( + gpr_zalloc(sizeof(security_handshaker))); grpc_handshaker_init(&security_handshaker_vtable, &h->base); h->handshaker = handshaker; h->connector = GRPC_SECURITY_CONNECTOR_REF(connector, "handshake"); gpr_mu_init(&h->mu); gpr_ref_init(&h->refs, 1); h->handshake_buffer_size = GRPC_INITIAL_HANDSHAKE_BUFFER_SIZE; - h->handshake_buffer = static_cast(gpr_malloc(h->handshake_buffer_size)); + h->handshake_buffer = + static_cast(gpr_malloc(h->handshake_buffer_size)); GRPC_CLOSURE_INIT(&h->on_handshake_data_sent_to_peer, on_handshake_data_sent_to_peer, h, grpc_schedule_on_exec_ctx); @@ -469,8 +470,8 @@ static void client_handshaker_factory_add_handshakers( grpc_handshaker_factory* handshaker_factory, const grpc_channel_args* args, grpc_handshake_manager* handshake_mgr) { grpc_channel_security_connector* security_connector = - reinterpret_cast(grpc_security_connector_find_in_args( - args)); + reinterpret_cast( + grpc_security_connector_find_in_args(args)); grpc_channel_security_connector_add_handshakers(security_connector, handshake_mgr); } @@ -479,8 +480,8 @@ static void server_handshaker_factory_add_handshakers( grpc_handshaker_factory* hf, const grpc_channel_args* args, grpc_handshake_manager* handshake_mgr) { grpc_server_security_connector* security_connector = - reinterpret_cast(grpc_security_connector_find_in_args( - args)); + reinterpret_cast( + grpc_security_connector_find_in_args(args)); grpc_server_security_connector_add_handshakers(security_connector, handshake_mgr); } diff --git a/src/core/lib/slice/b64.cc b/src/core/lib/slice/b64.cc index 1d938be11c..3e19b7197f 100644 --- a/src/core/lib/slice/b64.cc +++ b/src/core/lib/slice/b64.cc @@ -128,13 +128,15 @@ grpc_slice grpc_base64_decode(const char* b64, int url_safe) { static void decode_one_char(const unsigned char* codes, unsigned char* result, size_t* result_offset) { - uint32_t packed = (static_cast(codes[0]) << 2) | (static_cast(codes[1]) >> 4); + uint32_t packed = (static_cast(codes[0]) << 2) | + (static_cast(codes[1]) >> 4); result[(*result_offset)++] = static_cast(packed); } static void decode_two_chars(const unsigned char* codes, unsigned char* result, size_t* result_offset) { - uint32_t packed = (static_cast(codes[0]) << 10) | (static_cast(codes[1]) << 4) | + uint32_t packed = (static_cast(codes[0]) << 10) | + (static_cast(codes[1]) << 4) | (static_cast(codes[2]) >> 2); result[(*result_offset)++] = static_cast(packed >> 8); result[(*result_offset)++] = static_cast(packed); @@ -175,7 +177,8 @@ static int decode_group(const unsigned char* codes, size_t num_codes, decode_two_chars(codes, result, result_offset); } else { /* No padding. */ - uint32_t packed = (static_cast(codes[0]) << 18) | (static_cast(codes[1]) << 12) | + uint32_t packed = (static_cast(codes[0]) << 18) | + (static_cast(codes[1]) << 12) | (static_cast(codes[2]) << 6) | codes[3]; result[(*result_offset)++] = static_cast(packed >> 16); result[(*result_offset)++] = static_cast(packed >> 8); diff --git a/src/core/lib/slice/slice.cc b/src/core/lib/slice/slice.cc index 136cce1d1e..476d941fbb 100644 --- a/src/core/lib/slice/slice.cc +++ b/src/core/lib/slice/slice.cc @@ -173,8 +173,8 @@ static const grpc_slice_refcount_vtable new_with_len_vtable = { grpc_slice grpc_slice_new_with_len(void* p, size_t len, void (*destroy)(void*, size_t)) { grpc_slice slice; - new_with_len_slice_refcount* rc = static_cast(gpr_malloc( - sizeof(new_with_len_slice_refcount))); + new_with_len_slice_refcount* rc = static_cast( + gpr_malloc(sizeof(new_with_len_slice_refcount))); gpr_ref_init(&rc->refs, 1); rc->rc.vtable = &new_with_len_vtable; rc->rc.sub_refcount = &rc->rc; @@ -232,8 +232,8 @@ grpc_slice grpc_slice_malloc_large(size_t length) { refcount is a malloc_refcount bytes is an array of bytes of the requested length Both parts are placed in the same allocation returned from gpr_malloc */ - malloc_refcount* rc = - static_cast(gpr_malloc(sizeof(malloc_refcount) + length)); + malloc_refcount* rc = static_cast( + gpr_malloc(sizeof(malloc_refcount) + length)); /* Initial refcount on rc is 1 - and it's up to the caller to release this reference. */ @@ -314,7 +314,8 @@ grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* source, size_t split, /* inlined data, copy it out */ GPR_ASSERT(source->data.inlined.length >= split); tail.refcount = nullptr; - tail.data.inlined.length = static_cast(source->data.inlined.length - split); + tail.data.inlined.length = + static_cast(source->data.inlined.length - split); memcpy(tail.data.inlined.bytes, source->data.inlined.bytes + split, tail.data.inlined.length); source->data.inlined.length = static_cast(split); @@ -443,15 +444,15 @@ int grpc_slice_buf_start_eq(grpc_slice a, const void* b, size_t len) { } int grpc_slice_rchr(grpc_slice s, char c) { - const char* b = reinterpret_castGRPC_SLICE_START_PTR(s); + const char* b = reinterpret_cast GRPC_SLICE_START_PTR(s); int i; - for (i = static_castGRPC_SLICE_LENGTH(s) - 1; i != -1 && b[i] != c; i--) + for (i = static_cast GRPC_SLICE_LENGTH(s) - 1; i != -1 && b[i] != c; i--) ; return i; } int grpc_slice_chr(grpc_slice s, char c) { - const char* b = reinterpret_castGRPC_SLICE_START_PTR(s); + const char* b = reinterpret_cast GRPC_SLICE_START_PTR(s); const char* p = static_cast(memchr(b, c, GRPC_SLICE_LENGTH(s))); return p == nullptr ? -1 : static_cast(p - b); } @@ -466,7 +467,8 @@ int grpc_slice_slice(grpc_slice haystack, grpc_slice needle) { if (haystack_len < needle_len) return -1; if (haystack_len == needle_len) return grpc_slice_eq(haystack, needle) ? 0 : -1; - if (needle_len == 1) return grpc_slice_chr(haystack, static_cast(*needle_bytes)); + if (needle_len == 1) + return grpc_slice_chr(haystack, static_cast(*needle_bytes)); const uint8_t* last = haystack_bytes + haystack_len - needle_len; for (const uint8_t* cur = haystack_bytes; cur != last; ++cur) { diff --git a/src/core/lib/slice/slice_buffer.cc b/src/core/lib/slice/slice_buffer.cc index 84a2b5f6d9..0416c9d371 100644 --- a/src/core/lib/slice/slice_buffer.cc +++ b/src/core/lib/slice/slice_buffer.cc @@ -45,12 +45,12 @@ static void maybe_embiggen(grpc_slice_buffer* sb) { sb->capacity = GROW(sb->capacity); GPR_ASSERT(sb->capacity > slice_count); if (sb->base_slices == sb->inlined) { - sb->base_slices = - static_cast(gpr_malloc(sb->capacity * sizeof(grpc_slice))); + sb->base_slices = static_cast( + gpr_malloc(sb->capacity * sizeof(grpc_slice))); memcpy(sb->base_slices, sb->inlined, slice_count * sizeof(grpc_slice)); } else { - sb->base_slices = static_cast(gpr_realloc( - sb->base_slices, sb->capacity * sizeof(grpc_slice))); + sb->base_slices = static_cast( + gpr_realloc(sb->base_slices, sb->capacity * sizeof(grpc_slice))); } sb->slices = sb->base_slices + slice_offset; @@ -89,7 +89,8 @@ uint8_t* grpc_slice_buffer_tiny_add(grpc_slice_buffer* sb, size_t n) { if ((back->data.inlined.length + n) > sizeof(back->data.inlined.bytes)) goto add_new; out = back->data.inlined.bytes + back->data.inlined.length; - back->data.inlined.length = static_cast(back->data.inlined.length + n); + back->data.inlined.length = + static_cast(back->data.inlined.length + n); return out; add_new: @@ -125,8 +126,8 @@ void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice s) { GRPC_SLICE_INLINED_SIZE) { memcpy(back->data.inlined.bytes + back->data.inlined.length, s.data.inlined.bytes, s.data.inlined.length); - back->data.inlined.length = - static_cast(back->data.inlined.length + s.data.inlined.length); + back->data.inlined.length = static_cast( + back->data.inlined.length + s.data.inlined.length); } else { size_t cp1 = GRPC_SLICE_INLINED_SIZE - back->data.inlined.length; memcpy(back->data.inlined.bytes + back->data.inlined.length, @@ -136,7 +137,8 @@ void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice s) { back = &sb->slices[n]; sb->count = n + 1; back->refcount = nullptr; - back->data.inlined.length = static_cast(s.data.inlined.length - cp1); + back->data.inlined.length = + static_cast(s.data.inlined.length - cp1); memcpy(back->data.inlined.bytes, s.data.inlined.bytes + cp1, s.data.inlined.length - cp1); } diff --git a/src/core/lib/slice/slice_hash_table.cc b/src/core/lib/slice/slice_hash_table.cc index 1818b126ca..2342e90485 100644 --- a/src/core/lib/slice/slice_hash_table.cc +++ b/src/core/lib/slice/slice_hash_table.cc @@ -67,7 +67,8 @@ grpc_slice_hash_table* grpc_slice_hash_table_create( // Keep load factor low to improve performance of lookups. table->size = num_entries * 2; const size_t entry_size = sizeof(grpc_slice_hash_table_entry) * table->size; - table->entries = static_cast(gpr_zalloc(entry_size)); + table->entries = + static_cast(gpr_zalloc(entry_size)); for (size_t i = 0; i < num_entries; ++i) { grpc_slice_hash_table_entry* entry = &entries[i]; grpc_slice_hash_table_add(table, entry->key, entry->value); diff --git a/src/core/lib/slice/slice_intern.cc b/src/core/lib/slice/slice_intern.cc index f4aad73e0f..2d633c4903 100644 --- a/src/core/lib/slice/slice_intern.cc +++ b/src/core/lib/slice/slice_intern.cc @@ -98,15 +98,18 @@ static void interned_slice_unref(void* p) { } static void interned_slice_sub_ref(void* p) { - interned_slice_ref((static_cast(p)) - offsetof(interned_slice_refcount, sub)); + interned_slice_ref((static_cast(p)) - + offsetof(interned_slice_refcount, sub)); } static void interned_slice_sub_unref(void* p) { - interned_slice_unref((static_cast(p)) - offsetof(interned_slice_refcount, sub)); + interned_slice_unref((static_cast(p)) - + offsetof(interned_slice_refcount, sub)); } static uint32_t interned_slice_hash(grpc_slice slice) { - interned_slice_refcount* s = reinterpret_cast(slice.refcount); + interned_slice_refcount* s = + reinterpret_cast(slice.refcount); return s->hash; } @@ -129,8 +132,8 @@ static void grow_shard(slice_shard* shard) { interned_slice_refcount** strtab; interned_slice_refcount *s, *next; - strtab = static_cast(gpr_zalloc( - sizeof(interned_slice_refcount*) * capacity)); + strtab = static_cast( + gpr_zalloc(sizeof(interned_slice_refcount*) * capacity)); for (i = 0; i < shard->capacity; i++) { for (s = shard->strs[i]; s; s = next) { @@ -237,8 +240,8 @@ grpc_slice grpc_slice_intern(grpc_slice slice) { /* not found: create a new string */ /* string data goes after the internal_string header */ - s = static_cast(gpr_malloc(sizeof(*s) + - GRPC_SLICE_LENGTH(slice))); + s = static_cast( + gpr_malloc(sizeof(*s) + GRPC_SLICE_LENGTH(slice))); gpr_atm_rel_store(&s->refcnt, 1); s->length = GRPC_SLICE_LENGTH(slice); s->hash = hash; @@ -275,8 +278,8 @@ void grpc_slice_intern_init(void) { gpr_mu_init(&shard->mu); shard->count = 0; shard->capacity = INITIAL_SHARD_CAPACITY; - shard->strs = static_cast(gpr_zalloc(sizeof(*shard->strs) * - shard->capacity)); + shard->strs = static_cast( + gpr_zalloc(sizeof(*shard->strs) * shard->capacity)); } for (size_t i = 0; i < GPR_ARRAY_SIZE(static_metadata_hash); i++) { static_metadata_hash[i].hash = 0; diff --git a/src/core/lib/slice/slice_string_helpers.cc b/src/core/lib/slice/slice_string_helpers.cc index 2015040c12..f91ece3b98 100644 --- a/src/core/lib/slice/slice_string_helpers.cc +++ b/src/core/lib/slice/slice_string_helpers.cc @@ -26,8 +26,8 @@ #include "src/core/lib/slice/slice_internal.h" char* grpc_dump_slice(grpc_slice s, uint32_t flags) { - return gpr_dump(reinterpret_castGRPC_SLICE_START_PTR(s), GRPC_SLICE_LENGTH(s), - flags); + return gpr_dump(reinterpret_cast GRPC_SLICE_START_PTR(s), + GRPC_SLICE_LENGTH(s), flags); } /** Finds the initial (\a begin) and final (\a end) offsets of the next @@ -110,6 +110,7 @@ void grpc_slice_split_without_space(grpc_slice str, const char* sep, } bool grpc_parse_slice_to_uint32(grpc_slice str, uint32_t* result) { - return gpr_parse_bytes_to_uint32(reinterpret_castGRPC_SLICE_START_PTR(str), - GRPC_SLICE_LENGTH(str), result) != 0; + return gpr_parse_bytes_to_uint32( + reinterpret_cast GRPC_SLICE_START_PTR(str), + GRPC_SLICE_LENGTH(str), result) != 0; } diff --git a/src/core/lib/surface/call.cc b/src/core/lib/surface/call.cc index d6949103c7..db7c01cc33 100644 --- a/src/core/lib/surface/call.cc +++ b/src/core/lib/surface/call.cc @@ -360,7 +360,8 @@ grpc_error* grpc_call_create(const grpc_call_create_args* args, GRPC_MDVALUE(args->add_initial_metadata[i])); } } - call->send_extra_metadata_count = static_cast(args->add_initial_metadata_count); + call->send_extra_metadata_count = + static_cast(args->add_initial_metadata_count); } else { GPR_ASSERT(args->add_initial_metadata_count == 0); call->send_extra_metadata_count = 0; @@ -608,7 +609,8 @@ grpc_call_error grpc_call_cancel(grpc_call* call, void* reserved) { // the filter stack. static void execute_batch_in_call_combiner(void* arg, grpc_error* ignored) { GPR_TIMER_SCOPE("execute_batch", 0); - grpc_transport_stream_op_batch* batch = static_cast(arg); + grpc_transport_stream_op_batch* batch = + static_cast(arg); grpc_call* call = static_cast(batch->handler_private.extra_arg); grpc_call_element* elem = CALL_ELEM_FROM_CALL(call, 0); GRPC_CALL_LOG_OP(GPR_INFO, elem, batch); @@ -991,8 +993,9 @@ static uint32_t decode_status(grpc_mdelem md) { if (!grpc_parse_slice_to_uint32(GRPC_MDVALUE(md), &status)) { status = GRPC_STATUS_UNKNOWN; /* could not parse status code */ } - grpc_mdelem_set_user_data(md, destroy_status, - (void*)static_cast(status + STATUS_OFFSET)); + grpc_mdelem_set_user_data( + md, destroy_status, + (void*)static_cast(status + STATUS_OFFSET)); } return status; } @@ -1040,8 +1043,8 @@ static void publish_app_metadata(grpc_call* call, grpc_metadata_batch* b, if (dest->count + b->list.count > dest->capacity) { dest->capacity = GPR_MAX(dest->capacity + b->list.count, dest->capacity * 3 / 2); - dest->metadata = static_cast(gpr_realloc( - dest->metadata, sizeof(grpc_metadata) * dest->capacity)); + dest->metadata = static_cast( + gpr_realloc(dest->metadata, sizeof(grpc_metadata) * dest->capacity)); } for (grpc_linked_mdelem* l = b->list.head; l != nullptr; l = l->next) { mdusr = &dest->metadata[dest->count++]; @@ -1170,8 +1173,8 @@ static batch_control* allocate_batch_control(grpc_call* call, int slot = batch_slot_for_op(ops[0].op); batch_control** pslot = &call->active_batches[slot]; if (*pslot == nullptr) { - *pslot = - static_cast(gpr_arena_alloc(call->arena, sizeof(batch_control))); + *pslot = static_cast( + gpr_arena_alloc(call->arena, sizeof(batch_control))); } batch_control* bctl = *pslot; if (bctl->call != nullptr) { @@ -1192,7 +1195,7 @@ static void finish_batch_completion(void* user_data, } static grpc_error* consolidate_batch_errors(batch_control* bctl) { - size_t n = static_castgpr_atm_acq_load(&bctl->num_errors); + size_t n = static_cast gpr_atm_acq_load(&bctl->num_errors); if (n == 0) { return GRPC_ERROR_NONE; } else if (n == 1) { @@ -1584,9 +1587,10 @@ static grpc_call_error call_start_batch(grpc_call* call, const grpc_op* ops, if (nops == 0) { if (!is_notify_tag_closure) { GPR_ASSERT(grpc_cq_begin_op(call->cq, notify_tag)); - grpc_cq_end_op( - call->cq, notify_tag, GRPC_ERROR_NONE, free_no_op_completion, nullptr, - static_cast(gpr_malloc(sizeof(grpc_cq_completion)))); + grpc_cq_end_op(call->cq, notify_tag, GRPC_ERROR_NONE, + free_no_op_completion, nullptr, + static_cast( + gpr_malloc(sizeof(grpc_cq_completion)))); } else { GRPC_CLOSURE_SCHED((grpc_closure*)notify_tag, GRPC_ERROR_NONE); } @@ -1662,7 +1666,8 @@ static grpc_call_error call_start_batch(grpc_call* call, const grpc_op* ops, if (!prepare_application_metadata( call, static_cast(op->data.send_initial_metadata.count), op->data.send_initial_metadata.metadata, 0, call->is_client, - &call->compression_md, static_cast(additional_metadata_count))) { + &call->compression_md, + static_cast(additional_metadata_count))) { error = GRPC_CALL_ERROR_INVALID_METADATA; goto done_with_error; } @@ -1779,7 +1784,8 @@ static grpc_call_error call_start_batch(grpc_call* call, const grpc_op* ops, } if (!prepare_application_metadata( call, - static_cast(op->data.send_status_from_server.trailing_metadata_count), + static_cast( + op->data.send_status_from_server.trailing_metadata_count), op->data.send_status_from_server.trailing_metadata, 1, 1, nullptr, 0)) { for (int n = 0; n < call->send_extra_metadata_count; n++) { diff --git a/src/core/lib/surface/channel.cc b/src/core/lib/surface/channel.cc index 06dbfdcb49..6c73c2cd76 100644 --- a/src/core/lib/surface/channel.cc +++ b/src/core/lib/surface/channel.cc @@ -190,17 +190,20 @@ size_t grpc_channel_get_call_size_estimate(grpc_channel* channel) { (which is common) - which tends to help most allocators reuse memory 2. a small amount of allowed growth over the estimate without hitting the arena size doubling case, reducing overall memory usage */ - return (static_castgpr_atm_no_barrier_load(&channel->call_size_estimate) + + return (static_cast gpr_atm_no_barrier_load( + &channel->call_size_estimate) + 2 * ROUND_UP_SIZE) & ~static_cast(ROUND_UP_SIZE - 1); } void grpc_channel_update_call_size_estimate(grpc_channel* channel, size_t size) { - size_t cur = static_castgpr_atm_no_barrier_load(&channel->call_size_estimate); + size_t cur = + static_cast gpr_atm_no_barrier_load(&channel->call_size_estimate); if (cur < size) { /* size grew: update estimate */ - gpr_atm_no_barrier_cas(&channel->call_size_estimate, static_cast(cur), + gpr_atm_no_barrier_cas(&channel->call_size_estimate, + static_cast(cur), static_cast(size)); /* if we lose: never mind, something else will likely update soon enough */ } else if (cur == size) { @@ -297,7 +300,8 @@ grpc_call* grpc_channel_create_pollset_set_call( void* grpc_channel_register_call(grpc_channel* channel, const char* method, const char* host, void* reserved) { - registered_call* rc = static_cast(gpr_malloc(sizeof(registered_call))); + registered_call* rc = + static_cast(gpr_malloc(sizeof(registered_call))); GRPC_API_TRACE( "grpc_channel_register_call(channel=%p, method=%s, host=%s, reserved=%p)", 4, (channel, method, host, reserved)); diff --git a/src/core/lib/surface/channel_init.cc b/src/core/lib/surface/channel_init.cc index 6b63195272..b1e1dceed3 100644 --- a/src/core/lib/surface/channel_init.cc +++ b/src/core/lib/surface/channel_init.cc @@ -52,9 +52,9 @@ void grpc_channel_init_register_stage(grpc_channel_stack_type type, GPR_ASSERT(!g_finalized); if (g_slots[type].cap_slots == g_slots[type].num_slots) { g_slots[type].cap_slots = GPR_MAX(8, 3 * g_slots[type].cap_slots / 2); - g_slots[type].slots = static_cast(gpr_realloc( - g_slots[type].slots, - g_slots[type].cap_slots * sizeof(*g_slots[type].slots))); + g_slots[type].slots = static_cast( + gpr_realloc(g_slots[type].slots, + g_slots[type].cap_slots * sizeof(*g_slots[type].slots))); } stage_slot* s = &g_slots[type].slots[g_slots[type].num_slots++]; s->insertion_order = g_slots[type].num_slots; @@ -84,7 +84,8 @@ void grpc_channel_init_finalize(void) { void grpc_channel_init_shutdown(void) { for (int i = 0; i < GRPC_NUM_CHANNEL_STACK_TYPES; i++) { gpr_free(g_slots[i].slots); - g_slots[i].slots = static_cast((void*)static_cast(0xdeadbeef)); + g_slots[i].slots = + static_cast((void*)static_cast(0xdeadbeef)); } } diff --git a/src/core/lib/surface/completion_queue.cc b/src/core/lib/surface/completion_queue.cc index 2f4bcc357c..d1f3276257 100644 --- a/src/core/lib/surface/completion_queue.cc +++ b/src/core/lib/surface/completion_queue.cc @@ -142,7 +142,8 @@ static grpc_error* non_polling_poller_kick( if (specific_worker == nullptr) specific_worker = reinterpret_cast(p->root); if (specific_worker != nullptr) { - non_polling_worker* w = reinterpret_cast(specific_worker); + non_polling_worker* w = + reinterpret_cast(specific_worker); if (!w->kicked) { w->kicked = true; gpr_cv_signal(&w->cv); @@ -357,7 +358,7 @@ int grpc_completion_queue_thread_local_cache_flush(grpc_completion_queue* cq, *ok = (storage->next & static_cast(1)) == 1; storage->done(storage->done_arg, storage); ret = 1; - cq_next_data* cqd = static_castDATA_FROM_CQ(cq); + cq_next_data* cqd = static_cast DATA_FROM_CQ(cq); if (gpr_atm_full_fetch_add(&cqd->pending_events, -1) == 1) { GRPC_CQ_INTERNAL_REF(cq, "shutting_down"); gpr_mu_lock(cq->mu); @@ -395,7 +396,8 @@ static grpc_cq_completion* cq_event_queue_pop(grpc_cq_event_queue* q) { GRPC_STATS_INC_CQ_EV_QUEUE_TRYLOCK_SUCCESSES(); bool is_empty = false; - c = reinterpret_cast(gpr_mpscq_pop_and_check_end(&q->queue, &is_empty)); + c = reinterpret_cast( + gpr_mpscq_pop_and_check_end(&q->queue, &is_empty)); gpr_spinlock_unlock(&q->queue_lock); if (c == nullptr && !is_empty) { @@ -415,7 +417,7 @@ static grpc_cq_completion* cq_event_queue_pop(grpc_cq_event_queue* q) { /* Note: The counter is not incremented/decremented atomically with push/pop. * The count is only eventually consistent */ static long cq_event_queue_num_items(grpc_cq_event_queue* q) { - return static_castgpr_atm_no_barrier_load(&q->num_queue_items); + return static_cast gpr_atm_no_barrier_load(&q->num_queue_items); } grpc_completion_queue* grpc_completion_queue_create_internal( @@ -437,9 +439,9 @@ grpc_completion_queue* grpc_completion_queue_create_internal( grpc_core::ExecCtx exec_ctx; GRPC_STATS_INC_CQS_CREATED(); - cq = static_cast(gpr_zalloc(sizeof(grpc_completion_queue) + - vtable->data_size + - poller_vtable->size())); + cq = static_cast( + gpr_zalloc(sizeof(grpc_completion_queue) + vtable->data_size + + poller_vtable->size())); cq->vtable = vtable; cq->poller_vtable = poller_vtable; @@ -587,12 +589,12 @@ static bool atm_inc_if_nonzero(gpr_atm* counter) { } static bool cq_begin_op_for_next(grpc_completion_queue* cq, void* tag) { - cq_next_data* cqd = static_castDATA_FROM_CQ(cq); + cq_next_data* cqd = static_cast DATA_FROM_CQ(cq); return atm_inc_if_nonzero(&cqd->pending_events); } static bool cq_begin_op_for_pluck(grpc_completion_queue* cq, void* tag) { - cq_pluck_data* cqd = static_castDATA_FROM_CQ(cq); + cq_pluck_data* cqd = static_cast DATA_FROM_CQ(cq); return atm_inc_if_nonzero(&cqd->pending_events); } @@ -632,7 +634,7 @@ static void cq_end_op_for_next(grpc_completion_queue* cq, void* tag, gpr_log(GPR_ERROR, "Operation failed: tag=%p, error=%s", tag, errmsg); } } - cq_next_data* cqd = static_castDATA_FROM_CQ(cq); + cq_next_data* cqd = static_cast DATA_FROM_CQ(cq); int is_success = (error == GRPC_ERROR_NONE); storage->tag = tag; @@ -701,7 +703,7 @@ static void cq_end_op_for_pluck(grpc_completion_queue* cq, void* tag, void* done_arg, grpc_cq_completion* storage) { GPR_TIMER_SCOPE("cq_end_op_for_pluck", 0); - cq_pluck_data* cqd = static_castDATA_FROM_CQ(cq); + cq_pluck_data* cqd = static_cast DATA_FROM_CQ(cq); int is_success = (error == GRPC_ERROR_NONE); if (grpc_api_trace.enabled() || @@ -719,7 +721,8 @@ static void cq_end_op_for_pluck(grpc_completion_queue* cq, void* tag, storage->tag = tag; storage->done = done; storage->done_arg = done_arg; - storage->next = ((uintptr_t)&cqd->completed_head) | (static_cast(is_success)); + storage->next = + ((uintptr_t)&cqd->completed_head) | (static_cast(is_success)); gpr_mu_lock(cq->mu); cq_check_tag(cq, tag, false); /* Used in debug builds only */ @@ -778,9 +781,10 @@ class ExecCtxNext : public grpc_core::ExecCtx { ExecCtxNext(void* arg) : ExecCtx(0), check_ready_to_finish_arg_(arg) {} bool CheckReadyToFinish() override { - cq_is_finished_arg* a = static_cast(check_ready_to_finish_arg_); + cq_is_finished_arg* a = + static_cast(check_ready_to_finish_arg_); grpc_completion_queue* cq = a->cq; - cq_next_data* cqd = static_castDATA_FROM_CQ(cq); + cq_next_data* cqd = static_cast DATA_FROM_CQ(cq); GPR_ASSERT(a->stolen_completion == nullptr); gpr_atm current_last_seen_things_queued_ever = @@ -836,7 +840,7 @@ static grpc_event cq_next(grpc_completion_queue* cq, gpr_timespec deadline, GPR_TIMER_SCOPE("grpc_completion_queue_next", 0); grpc_event ret; - cq_next_data* cqd = static_castDATA_FROM_CQ(cq); + cq_next_data* cqd = static_cast DATA_FROM_CQ(cq); GRPC_API_TRACE( "grpc_completion_queue_next(" @@ -961,7 +965,7 @@ static grpc_event cq_next(grpc_completion_queue* cq, gpr_timespec deadline, - grpc_completion_queue_shutdown() MUST have been called before calling this function */ static void cq_finish_shutdown_next(grpc_completion_queue* cq) { - cq_next_data* cqd = static_castDATA_FROM_CQ(cq); + cq_next_data* cqd = static_cast DATA_FROM_CQ(cq); GPR_ASSERT(cqd->shutdown_called); GPR_ASSERT(gpr_atm_no_barrier_load(&cqd->pending_events) == 0); @@ -970,7 +974,7 @@ static void cq_finish_shutdown_next(grpc_completion_queue* cq) { } static void cq_shutdown_next(grpc_completion_queue* cq) { - cq_next_data* cqd = static_castDATA_FROM_CQ(cq); + cq_next_data* cqd = static_cast DATA_FROM_CQ(cq); /* Need an extra ref for cq here because: * We call cq_finish_shutdown_next() below, that would call pollset shutdown. @@ -1003,7 +1007,7 @@ grpc_event grpc_completion_queue_next(grpc_completion_queue* cq, static int add_plucker(grpc_completion_queue* cq, void* tag, grpc_pollset_worker** worker) { - cq_pluck_data* cqd = static_castDATA_FROM_CQ(cq); + cq_pluck_data* cqd = static_cast DATA_FROM_CQ(cq); if (cqd->num_pluckers == GRPC_MAX_COMPLETION_QUEUE_PLUCKERS) { return 0; } @@ -1015,7 +1019,7 @@ static int add_plucker(grpc_completion_queue* cq, void* tag, static void del_plucker(grpc_completion_queue* cq, void* tag, grpc_pollset_worker** worker) { - cq_pluck_data* cqd = static_castDATA_FROM_CQ(cq); + cq_pluck_data* cqd = static_cast DATA_FROM_CQ(cq); for (int i = 0; i < cqd->num_pluckers; i++) { if (cqd->pluckers[i].tag == tag && cqd->pluckers[i].worker == worker) { cqd->num_pluckers--; @@ -1031,9 +1035,10 @@ class ExecCtxPluck : public grpc_core::ExecCtx { ExecCtxPluck(void* arg) : ExecCtx(0), check_ready_to_finish_arg_(arg) {} bool CheckReadyToFinish() override { - cq_is_finished_arg* a = static_cast(check_ready_to_finish_arg_); + cq_is_finished_arg* a = + static_cast(check_ready_to_finish_arg_); grpc_completion_queue* cq = a->cq; - cq_pluck_data* cqd = static_castDATA_FROM_CQ(cq); + cq_pluck_data* cqd = static_cast DATA_FROM_CQ(cq); GPR_ASSERT(a->stolen_completion == nullptr); gpr_atm current_last_seen_things_queued_ever = @@ -1045,10 +1050,12 @@ class ExecCtxPluck : public grpc_core::ExecCtx { gpr_atm_no_barrier_load(&cqd->things_queued_ever); grpc_cq_completion* c; grpc_cq_completion* prev = &cqd->completed_head; - while ((c = (grpc_cq_completion*)(prev->next & ~static_cast(1))) != + while ((c = (grpc_cq_completion*)(prev->next & + ~static_cast(1))) != &cqd->completed_head) { if (c->tag == a->tag) { - prev->next = (prev->next & static_cast(1)) | (c->next & ~static_cast(1)); + prev->next = (prev->next & static_cast(1)) | + (c->next & ~static_cast(1)); if (c == cqd->completed_tail) { cqd->completed_tail = prev; } @@ -1075,7 +1082,7 @@ static grpc_event cq_pluck(grpc_completion_queue* cq, void* tag, grpc_cq_completion* c; grpc_cq_completion* prev; grpc_pollset_worker* worker = nullptr; - cq_pluck_data* cqd = static_castDATA_FROM_CQ(cq); + cq_pluck_data* cqd = static_cast DATA_FROM_CQ(cq); if (grpc_cq_pluck_trace.enabled()) { GRPC_API_TRACE( @@ -1115,10 +1122,12 @@ static grpc_event cq_pluck(grpc_completion_queue* cq, void* tag, break; } prev = &cqd->completed_head; - while ((c = (grpc_cq_completion*)(prev->next & ~static_cast(1))) != - &cqd->completed_head) { + while ( + (c = (grpc_cq_completion*)(prev->next & ~static_cast(1))) != + &cqd->completed_head) { if (c->tag == tag) { - prev->next = (prev->next & static_cast(1)) | (c->next & ~static_cast(1)); + prev->next = (prev->next & static_cast(1)) | + (c->next & ~static_cast(1)); if (c == cqd->completed_tail) { cqd->completed_tail = prev; } @@ -1191,7 +1200,7 @@ grpc_event grpc_completion_queue_pluck(grpc_completion_queue* cq, void* tag, } static void cq_finish_shutdown_pluck(grpc_completion_queue* cq) { - cq_pluck_data* cqd = static_castDATA_FROM_CQ(cq); + cq_pluck_data* cqd = static_cast DATA_FROM_CQ(cq); GPR_ASSERT(cqd->shutdown_called); GPR_ASSERT(!gpr_atm_no_barrier_load(&cqd->shutdown)); @@ -1203,7 +1212,7 @@ static void cq_finish_shutdown_pluck(grpc_completion_queue* cq) { /* NOTE: This function is almost exactly identical to cq_shutdown_next() but * merging them is a bit tricky and probably not worth it */ static void cq_shutdown_pluck(grpc_completion_queue* cq) { - cq_pluck_data* cqd = static_castDATA_FROM_CQ(cq); + cq_pluck_data* cqd = static_cast DATA_FROM_CQ(cq); /* Need an extra ref for cq here because: * We call cq_finish_shutdown_pluck() below, that would call pollset shutdown. diff --git a/src/core/lib/surface/server.cc b/src/core/lib/surface/server.cc index ad3ee62ad8..d71a23a5d7 100644 --- a/src/core/lib/surface/server.cc +++ b/src/core/lib/surface/server.cc @@ -241,8 +241,8 @@ static void channel_broadcaster_init(grpc_server* s, channel_broadcaster* cb) { count++; } cb->num_channels = count; - cb->channels = - static_cast(gpr_malloc(sizeof(*cb->channels) * cb->num_channels)); + cb->channels = static_cast( + gpr_malloc(sizeof(*cb->channels) * cb->num_channels)); count = 0; for (c = s->root_channel_data.next; c != &s->root_channel_data; c = c->next) { cb->channels[count++] = c->channel; @@ -256,7 +256,8 @@ struct shutdown_cleanup_args { }; static void shutdown_cleanup(void* arg, grpc_error* error) { - struct shutdown_cleanup_args* a = static_cast(arg); + struct shutdown_cleanup_args* a = + static_cast(arg); grpc_slice_unref_internal(a->slice); gpr_free(a); } @@ -304,8 +305,8 @@ static void channel_broadcaster_shutdown(channel_broadcaster* cb, static void request_matcher_init(request_matcher* rm, grpc_server* server) { memset(rm, 0, sizeof(*rm)); rm->server = server; - rm->requests_per_cq = static_cast(gpr_malloc( - sizeof(*rm->requests_per_cq) * server->cq_count)); + rm->requests_per_cq = static_cast( + gpr_malloc(sizeof(*rm->requests_per_cq) * server->cq_count)); for (size_t i = 0; i < server->cq_count; i++) { gpr_locked_mpscq_init(&rm->requests_per_cq[i]); } @@ -320,7 +321,8 @@ static void request_matcher_destroy(request_matcher* rm) { } static void kill_zombie(void* elem, grpc_error* error) { - grpc_call_unref(grpc_call_from_top_element(static_cast(elem))); + grpc_call_unref( + grpc_call_from_top_element(static_cast(elem))); } static void request_matcher_zombify_all_pending_calls(request_matcher* rm) { @@ -341,8 +343,8 @@ static void request_matcher_kill_requests(grpc_server* server, grpc_error* error) { requested_call* rc; for (size_t i = 0; i < server->cq_count; i++) { - while ((rc = reinterpret_cast(gpr_locked_mpscq_pop( - &rm->requests_per_cq[i]))) != nullptr) { + while ((rc = reinterpret_cast( + gpr_locked_mpscq_pop(&rm->requests_per_cq[i]))) != nullptr) { fail_call(server, i, rc, GRPC_ERROR_REF(error)); } } @@ -487,8 +489,8 @@ static void publish_new_rpc(void* arg, grpc_error* error) { for (size_t i = 0; i < server->cq_count; i++) { size_t cq_idx = (chand->cq_idx + i) % server->cq_count; - requested_call* rc = - reinterpret_cast(gpr_locked_mpscq_try_pop(&rm->requests_per_cq[cq_idx])); + requested_call* rc = reinterpret_cast( + gpr_locked_mpscq_try_pop(&rm->requests_per_cq[cq_idx])); if (rc == nullptr) { continue; } else { @@ -509,8 +511,8 @@ static void publish_new_rpc(void* arg, grpc_error* error) { // added to the pending list. for (size_t i = 0; i < server->cq_count; i++) { size_t cq_idx = (chand->cq_idx + i) % server->cq_count; - requested_call* rc = - reinterpret_cast(gpr_locked_mpscq_pop(&rm->requests_per_cq[cq_idx])); + requested_call* rc = reinterpret_cast( + gpr_locked_mpscq_pop(&rm->requests_per_cq[cq_idx])); if (rc == nullptr) { continue; } else { @@ -939,7 +941,8 @@ void grpc_server_register_completion_queue(grpc_server* server, grpc_server* grpc_server_create(const grpc_channel_args* args, void* reserved) { GRPC_API_TRACE("grpc_server_create(%p, %p)", 2, (args, reserved)); - grpc_server* server = static_cast(gpr_zalloc(sizeof(grpc_server))); + grpc_server* server = + static_cast(gpr_zalloc(sizeof(grpc_server))); gpr_mu_init(&server->mu_global); gpr_mu_init(&server->mu_call); @@ -1020,8 +1023,8 @@ void grpc_server_start(grpc_server* server) { server->started = true; server->pollset_count = 0; - server->pollsets = - static_cast(gpr_malloc(sizeof(grpc_pollset*) * server->cq_count)); + server->pollsets = static_cast( + gpr_malloc(sizeof(grpc_pollset*) * server->cq_count)); for (i = 0; i < server->cq_count; i++) { if (grpc_cq_can_listen(server->cqs[i])) { server->pollsets[server->pollset_count++] = @@ -1063,9 +1066,9 @@ void grpc_server_setup_transport(grpc_server* s, grpc_transport* transport, grpc_transport_op* op = nullptr; channel = grpc_channel_create(nullptr, args, GRPC_SERVER_CHANNEL, transport); - chand = static_cast(grpc_channel_stack_element( - grpc_channel_get_channel_stack(channel), 0) - ->channel_data); + chand = static_cast( + grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0) + ->channel_data); chand->server = s; server_ref(s); chand->channel = channel; @@ -1089,7 +1092,8 @@ void grpc_server_setup_transport(grpc_server* s, grpc_transport* transport, if (num_registered_methods > 0) { slots = 2 * num_registered_methods; alloc = sizeof(channel_registered_method) * slots; - chand->registered_methods = static_cast(gpr_zalloc(alloc)); + chand->registered_methods = + static_cast(gpr_zalloc(alloc)); for (rm = s->registered_methods; rm; rm = rm->next) { grpc_slice host; bool has_host; @@ -1176,13 +1180,14 @@ void grpc_server_shutdown_and_notify(grpc_server* server, GPR_ASSERT(grpc_cq_begin_op(cq, tag)); if (server->shutdown_published) { grpc_cq_end_op(cq, tag, GRPC_ERROR_NONE, done_published_shutdown, nullptr, - static_cast(gpr_malloc(sizeof(grpc_cq_completion)))); + static_cast( + gpr_malloc(sizeof(grpc_cq_completion)))); gpr_mu_unlock(&server->mu_global); return; } - server->shutdown_tags = static_cast(gpr_realloc( - server->shutdown_tags, - sizeof(shutdown_tag) * (server->num_shutdown_tags + 1))); + server->shutdown_tags = static_cast( + gpr_realloc(server->shutdown_tags, + sizeof(shutdown_tag) * (server->num_shutdown_tags + 1))); sdt = &server->shutdown_tags[server->num_shutdown_tags++]; sdt->tag = tag; sdt->cq = cq; @@ -1289,7 +1294,8 @@ static grpc_call_error queue_call_request(grpc_server* server, size_t cq_idx, matching calls */ gpr_mu_lock(&server->mu_call); while ((calld = rm->pending_head) != nullptr) { - rc = reinterpret_cast(gpr_locked_mpscq_pop(&rm->requests_per_cq[cq_idx])); + rc = reinterpret_cast( + gpr_locked_mpscq_pop(&rm->requests_per_cq[cq_idx])); if (rc == nullptr) break; rm->pending_head = calld->pending_next; gpr_mu_unlock(&server->mu_call); diff --git a/src/core/lib/transport/bdp_estimator.cc b/src/core/lib/transport/bdp_estimator.cc index 044183e8fd..70b308230b 100644 --- a/src/core/lib/transport/bdp_estimator.cc +++ b/src/core/lib/transport/bdp_estimator.cc @@ -40,7 +40,8 @@ BdpEstimator::BdpEstimator(const char* name) grpc_millis BdpEstimator::CompletePing() { gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC); gpr_timespec dt_ts = gpr_time_sub(now, ping_start_time_); - double dt = static_cast(dt_ts.tv_sec) + 1e-9 * static_cast(dt_ts.tv_nsec); + double dt = static_cast(dt_ts.tv_sec) + + 1e-9 * static_cast(dt_ts.tv_nsec); double bw = dt > 0 ? (static_cast(accumulator_) / dt) : 0; int start_inter_ping_delay = inter_ping_delay_; if (grpc_bdp_estimator_trace.enabled()) { @@ -64,8 +65,8 @@ grpc_millis BdpEstimator::CompletePing() { stable_estimate_count_++; if (stable_estimate_count_ >= 2) { inter_ping_delay_ += - 100 + - static_cast(rand() * 100.0 / RAND_MAX); // if the ping estimate is steady, + 100 + static_cast(rand() * 100.0 / + RAND_MAX); // if the ping estimate is steady, // slowly ramp down the probe time } } diff --git a/src/core/lib/transport/byte_stream.cc b/src/core/lib/transport/byte_stream.cc index 2ae0b8298a..afb55b2f20 100644 --- a/src/core/lib/transport/byte_stream.cc +++ b/src/core/lib/transport/byte_stream.cc @@ -49,14 +49,16 @@ void grpc_byte_stream_destroy(grpc_byte_stream* byte_stream) { static bool slice_buffer_stream_next(grpc_byte_stream* byte_stream, size_t max_size_hint, grpc_closure* on_complete) { - grpc_slice_buffer_stream* stream = reinterpret_cast(byte_stream); + grpc_slice_buffer_stream* stream = + reinterpret_cast(byte_stream); GPR_ASSERT(stream->cursor < stream->backing_buffer->count); return true; } static grpc_error* slice_buffer_stream_pull(grpc_byte_stream* byte_stream, grpc_slice* slice) { - grpc_slice_buffer_stream* stream = reinterpret_cast(byte_stream); + grpc_slice_buffer_stream* stream = + reinterpret_cast(byte_stream); if (stream->shutdown_error != GRPC_ERROR_NONE) { return GRPC_ERROR_REF(stream->shutdown_error); } @@ -69,13 +71,15 @@ static grpc_error* slice_buffer_stream_pull(grpc_byte_stream* byte_stream, static void slice_buffer_stream_shutdown(grpc_byte_stream* byte_stream, grpc_error* error) { - grpc_slice_buffer_stream* stream = reinterpret_cast(byte_stream); + grpc_slice_buffer_stream* stream = + reinterpret_cast(byte_stream); GRPC_ERROR_UNREF(stream->shutdown_error); stream->shutdown_error = error; } static void slice_buffer_stream_destroy(grpc_byte_stream* byte_stream) { - grpc_slice_buffer_stream* stream = reinterpret_cast(byte_stream); + grpc_slice_buffer_stream* stream = + reinterpret_cast(byte_stream); grpc_slice_buffer_reset_and_unref_internal(stream->backing_buffer); GRPC_ERROR_UNREF(stream->shutdown_error); } @@ -112,7 +116,8 @@ void grpc_byte_stream_cache_destroy(grpc_byte_stream_cache* cache) { static bool caching_byte_stream_next(grpc_byte_stream* byte_stream, size_t max_size_hint, grpc_closure* on_complete) { - grpc_caching_byte_stream* stream = reinterpret_cast(byte_stream); + grpc_caching_byte_stream* stream = + reinterpret_cast(byte_stream); if (stream->shutdown_error != GRPC_ERROR_NONE) return true; if (stream->cursor < stream->cache->cache_buffer.count) return true; return grpc_byte_stream_next(stream->cache->underlying_stream, max_size_hint, @@ -121,7 +126,8 @@ static bool caching_byte_stream_next(grpc_byte_stream* byte_stream, static grpc_error* caching_byte_stream_pull(grpc_byte_stream* byte_stream, grpc_slice* slice) { - grpc_caching_byte_stream* stream = reinterpret_cast(byte_stream); + grpc_caching_byte_stream* stream = + reinterpret_cast(byte_stream); if (stream->shutdown_error != GRPC_ERROR_NONE) { return GRPC_ERROR_REF(stream->shutdown_error); } @@ -143,14 +149,16 @@ static grpc_error* caching_byte_stream_pull(grpc_byte_stream* byte_stream, static void caching_byte_stream_shutdown(grpc_byte_stream* byte_stream, grpc_error* error) { - grpc_caching_byte_stream* stream = reinterpret_cast(byte_stream); + grpc_caching_byte_stream* stream = + reinterpret_cast(byte_stream); GRPC_ERROR_UNREF(stream->shutdown_error); stream->shutdown_error = GRPC_ERROR_REF(error); grpc_byte_stream_shutdown(stream->cache->underlying_stream, error); } static void caching_byte_stream_destroy(grpc_byte_stream* byte_stream) { - grpc_caching_byte_stream* stream = reinterpret_cast(byte_stream); + grpc_caching_byte_stream* stream = + reinterpret_cast(byte_stream); GRPC_ERROR_UNREF(stream->shutdown_error); } diff --git a/src/core/lib/transport/connectivity_state.cc b/src/core/lib/transport/connectivity_state.cc index 183d5987ee..a5b7bb508f 100644 --- a/src/core/lib/transport/connectivity_state.cc +++ b/src/core/lib/transport/connectivity_state.cc @@ -74,7 +74,7 @@ void grpc_connectivity_state_destroy(grpc_connectivity_state_tracker* tracker) { grpc_connectivity_state grpc_connectivity_state_check( grpc_connectivity_state_tracker* tracker) { grpc_connectivity_state cur = - static_castgpr_atm_no_barrier_load( + static_cast gpr_atm_no_barrier_load( &tracker->current_state_atm); if (grpc_connectivity_state_trace.enabled()) { gpr_log(GPR_DEBUG, "CONWATCH: %p %s: get %s", tracker, tracker->name, @@ -86,7 +86,7 @@ grpc_connectivity_state grpc_connectivity_state_check( grpc_connectivity_state grpc_connectivity_state_get( grpc_connectivity_state_tracker* tracker, grpc_error** error) { grpc_connectivity_state cur = - static_castgpr_atm_no_barrier_load( + static_cast gpr_atm_no_barrier_load( &tracker->current_state_atm); if (grpc_connectivity_state_trace.enabled()) { gpr_log(GPR_DEBUG, "CONWATCH: %p %s: get %s", tracker, tracker->name, @@ -107,7 +107,7 @@ bool grpc_connectivity_state_notify_on_state_change( grpc_connectivity_state_tracker* tracker, grpc_connectivity_state* current, grpc_closure* notify) { grpc_connectivity_state cur = - static_castgpr_atm_no_barrier_load( + static_cast gpr_atm_no_barrier_load( &tracker->current_state_atm); if (grpc_connectivity_state_trace.enabled()) { if (current == nullptr) { @@ -158,7 +158,7 @@ void grpc_connectivity_state_set(grpc_connectivity_state_tracker* tracker, grpc_connectivity_state state, grpc_error* error, const char* reason) { grpc_connectivity_state cur = - static_castgpr_atm_no_barrier_load( + static_cast gpr_atm_no_barrier_load( &tracker->current_state_atm); grpc_connectivity_state_watcher* w; if (grpc_connectivity_state_trace.enabled()) { diff --git a/src/core/lib/transport/error_utils.cc b/src/core/lib/transport/error_utils.cc index b968383eda..79d904315e 100644 --- a/src/core/lib/transport/error_utils.cc +++ b/src/core/lib/transport/error_utils.cc @@ -32,7 +32,8 @@ static grpc_error* recursively_find_error_with_field(grpc_error* error, // Otherwise, search through its children. uint8_t slot = error->first_err; while (slot != UINT8_MAX) { - grpc_linked_error* lerr = reinterpret_cast(error->arena + slot); + grpc_linked_error* lerr = + reinterpret_cast(error->arena + slot); grpc_error* result = recursively_find_error_with_field(lerr->err, which); if (result) return result; slot = lerr->next; @@ -65,8 +66,8 @@ void grpc_error_get_status(grpc_error* error, grpc_millis deadline, status = static_cast(integer); } else if (grpc_error_get_int(found_error, GRPC_ERROR_INT_HTTP2_ERROR, &integer)) { - status = grpc_http2_error_to_grpc_status(static_cast(integer), - deadline); + status = grpc_http2_error_to_grpc_status( + static_cast(integer), deadline); } if (code != nullptr) *code = status; @@ -79,7 +80,8 @@ void grpc_error_get_status(grpc_error* error, grpc_millis deadline, *http_error = static_cast(integer); } else if (grpc_error_get_int(found_error, GRPC_ERROR_INT_GRPC_STATUS, &integer)) { - *http_error = grpc_status_to_http2_error(static_cast(integer)); + *http_error = + grpc_status_to_http2_error(static_cast(integer)); } else { *http_error = found_error == GRPC_ERROR_NONE ? GRPC_HTTP2_NO_ERROR : GRPC_HTTP2_INTERNAL_ERROR; @@ -103,7 +105,8 @@ bool grpc_error_has_clear_grpc_status(grpc_error* error) { } uint8_t slot = error->first_err; while (slot != UINT8_MAX) { - grpc_linked_error* lerr = reinterpret_cast(error->arena + slot); + grpc_linked_error* lerr = + reinterpret_cast(error->arena + slot); if (grpc_error_has_clear_grpc_status(lerr->err)) { return true; } diff --git a/src/core/lib/transport/metadata.cc b/src/core/lib/transport/metadata.cc index 418224bc97..e06e0b5313 100644 --- a/src/core/lib/transport/metadata.cc +++ b/src/core/lib/transport/metadata.cc @@ -118,8 +118,8 @@ void grpc_mdctx_global_init(void) { shard->count = 0; gpr_atm_no_barrier_store(&shard->free_estimate, 0); shard->capacity = INITIAL_SHARD_CAPACITY; - shard->elems = static_cast(gpr_zalloc(sizeof(*shard->elems) * - shard->capacity)); + shard->elems = static_cast( + gpr_zalloc(sizeof(*shard->elems) * shard->capacity)); } } @@ -206,8 +206,8 @@ static void grow_mdtab(mdtab_shard* shard) { interned_metadata *md, *next; uint32_t hash; - mdtab = - static_cast(gpr_zalloc(sizeof(interned_metadata*) * capacity)); + mdtab = static_cast( + gpr_zalloc(sizeof(interned_metadata*) * capacity)); for (i = 0; i < shard->capacity; i++) { for (md = shard->elems[i]; md; md = next) { @@ -335,8 +335,9 @@ grpc_mdelem grpc_mdelem_from_grpc_metadata(grpc_metadata* metadata) { grpc_slice_maybe_static_intern(metadata->key, &changed); grpc_slice value_slice = grpc_slice_maybe_static_intern(metadata->value, &changed); - return grpc_mdelem_create(key_slice, value_slice, - changed ? nullptr : reinterpret_cast(metadata)); + return grpc_mdelem_create( + key_slice, value_slice, + changed ? nullptr : reinterpret_cast(metadata)); } static size_t get_base64_encoded_size(size_t raw_length) { @@ -363,7 +364,8 @@ grpc_mdelem grpc_mdelem_ref(grpc_mdelem gmd DEBUG_ARGS) { case GRPC_MDELEM_STORAGE_STATIC: break; case GRPC_MDELEM_STORAGE_INTERNED: { - interned_metadata* md = reinterpret_castGRPC_MDELEM_DATA(gmd); + interned_metadata* md = + reinterpret_cast GRPC_MDELEM_DATA(gmd); #ifndef NDEBUG if (grpc_trace_metadata.enabled()) { char* key_str = grpc_slice_to_c_string(md->key); @@ -385,7 +387,8 @@ grpc_mdelem grpc_mdelem_ref(grpc_mdelem gmd DEBUG_ARGS) { break; } case GRPC_MDELEM_STORAGE_ALLOCATED: { - allocated_metadata* md = reinterpret_castGRPC_MDELEM_DATA(gmd); + allocated_metadata* md = + reinterpret_cast GRPC_MDELEM_DATA(gmd); #ifndef NDEBUG if (grpc_trace_metadata.enabled()) { char* key_str = grpc_slice_to_c_string(md->key); @@ -415,7 +418,8 @@ void grpc_mdelem_unref(grpc_mdelem gmd DEBUG_ARGS) { case GRPC_MDELEM_STORAGE_STATIC: break; case GRPC_MDELEM_STORAGE_INTERNED: { - interned_metadata* md = reinterpret_castGRPC_MDELEM_DATA(gmd); + interned_metadata* md = + reinterpret_cast GRPC_MDELEM_DATA(gmd); #ifndef NDEBUG if (grpc_trace_metadata.enabled()) { char* key_str = grpc_slice_to_c_string(md->key); @@ -441,7 +445,8 @@ void grpc_mdelem_unref(grpc_mdelem gmd DEBUG_ARGS) { break; } case GRPC_MDELEM_STORAGE_ALLOCATED: { - allocated_metadata* md = reinterpret_castGRPC_MDELEM_DATA(gmd); + allocated_metadata* md = + reinterpret_cast GRPC_MDELEM_DATA(gmd); #ifndef NDEBUG if (grpc_trace_metadata.enabled()) { char* key_str = grpc_slice_to_c_string(md->key); @@ -475,7 +480,8 @@ void* grpc_mdelem_get_user_data(grpc_mdelem md, void (*destroy_func)(void*)) { return (void*)grpc_static_mdelem_user_data[GRPC_MDELEM_DATA(md) - grpc_static_mdelem_table]; case GRPC_MDELEM_STORAGE_INTERNED: { - interned_metadata* im = reinterpret_castGRPC_MDELEM_DATA(md); + interned_metadata* im = + reinterpret_cast GRPC_MDELEM_DATA(md); void* result; if (gpr_atm_acq_load(&im->destroy_user_data) == (gpr_atm)destroy_func) { return (void*)gpr_atm_no_barrier_load(&im->user_data); @@ -500,7 +506,8 @@ void* grpc_mdelem_set_user_data(grpc_mdelem md, void (*destroy_func)(void*), return (void*)grpc_static_mdelem_user_data[GRPC_MDELEM_DATA(md) - grpc_static_mdelem_table]; case GRPC_MDELEM_STORAGE_INTERNED: { - interned_metadata* im = reinterpret_castGRPC_MDELEM_DATA(md); + interned_metadata* im = + reinterpret_cast GRPC_MDELEM_DATA(md); GPR_ASSERT(!is_mdelem_static(md)); GPR_ASSERT((user_data == nullptr) == (destroy_func == nullptr)); gpr_mu_lock(&im->mu_user_data); diff --git a/src/core/lib/transport/service_config.cc b/src/core/lib/transport/service_config.cc index f5805b2fa4..75196c5f88 100644 --- a/src/core/lib/transport/service_config.cc +++ b/src/core/lib/transport/service_config.cc @@ -209,8 +209,8 @@ grpc_slice_hash_table* grpc_service_config_create_method_config_table( num_entries += count; } // Populate method config table entries. - entries = static_cast(gpr_malloc( - num_entries * sizeof(grpc_slice_hash_table_entry))); + entries = static_cast( + gpr_malloc(num_entries * sizeof(grpc_slice_hash_table_entry))); size_t idx = 0; for (grpc_json* method = field->child; method != nullptr; method = method->next) { diff --git a/src/core/lib/transport/timeout_encoding.cc b/src/core/lib/transport/timeout_encoding.cc index f47f3fa44b..6800255be2 100644 --- a/src/core/lib/transport/timeout_encoding.cc +++ b/src/core/lib/transport/timeout_encoding.cc @@ -138,5 +138,6 @@ int grpc_http2_decode_timeout(grpc_slice text, grpc_millis* timeout) { return 0; } p++; - return is_all_whitespace(reinterpret_cast(p), reinterpret_cast(end)); + return is_all_whitespace(reinterpret_cast(p), + reinterpret_cast(end)); } diff --git a/src/core/lib/transport/transport.cc b/src/core/lib/transport/transport.cc index 56fc1ce13e..d71d4fdd76 100644 --- a/src/core/lib/transport/transport.cc +++ b/src/core/lib/transport/transport.cc @@ -239,7 +239,8 @@ static void destroy_made_transport_op(void* arg, grpc_error* error) { } grpc_transport_op* grpc_make_transport_op(grpc_closure* on_complete) { - made_transport_op* op = static_cast(gpr_malloc(sizeof(*op))); + made_transport_op* op = + static_cast(gpr_malloc(sizeof(*op))); GRPC_CLOSURE_INIT(&op->outer_on_complete, destroy_made_transport_op, op, grpc_schedule_on_exec_ctx); op->inner_on_complete = on_complete; -- cgit v1.2.3