Chiebot-Mirror
/
grpc
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Revert "Stream compression configuration"

Browse Source 
This reverts commit a4dc077d3c.
pull/11782/head
Muxi Yan 8 years ago
parent 6a9833b377
commit c97fc14a0e
12 changed files with 559 additions and 774 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 10
      include/grpc/compression.h
  2. 21
      include/grpc/impl/codegen/compression_types.h
  3. 43
      src/core/ext/filters/http/message_compress/message_compress_filter.c
  4. 6
      src/core/ext/transport/chttp2/transport/chttp2_transport.c
  5. 5
      src/core/lib/compression/algorithm_metadata.h
  6. 121
      src/core/lib/compression/compression.c
  7. 5
      src/core/lib/compression/message_compress.c
  8. 95
      src/core/lib/surface/call.c
  9. 798
      src/core/lib/transport/static_metadata.c
  10. 204
      src/core/lib/transport/static_metadata.h
  11. 22
      test/core/compression/algorithm_test.c
  12. 3
      test/core/compression/message_compress_test.c

10
include/grpc/compression.h
Unescape View File

@ -30,16 +30,12 @@
extern "C" {
#endif
/** Parses \a value as a grpc_compression_algorithm instance, updating \a
* algorithm. Returns 1 upon success, 0 otherwise. */
/** Parses the first \a name_length bytes of \a name as a
* grpc_compression_algorithm instance, updating \a algorithm. Returns 1 upon
* success, 0 otherwise. */
GRPCAPI int grpc_compression_algorithm_parse(
grpc_slice value, grpc_compression_algorithm *algorithm);
/** Parses \a value as a grpc_compression_algorithm instance for stream
* compression, updating \a algorithm. Returns 1 upon success, 0 otherwise. */
GRPCAPI int grpc_stream_compression_algorithm_parse(
grpc_slice value, grpc_compression_algorithm *algorithm);
/** Updates \a name with the encoding name corresponding to a valid \a
* algorithm. Note that \a name is statically allocated and must *not* be freed.
* Returns 1 upon success, 0 otherwise. */

21
include/grpc/impl/codegen/compression_types.h
Unescape View File

@ -58,21 +58,9 @@ typedef enum {
GRPC_COMPRESS_DEFLATE,
GRPC_COMPRESS_GZIP,
/* TODO(ctiller): snappy */
GRPC_STREAM_COMPRESS_GZIP,
GRPC_COMPRESS_ALGORITHMS_COUNT
} grpc_compression_algorithm;
#define GRPC_IS_STREAM_COMPRESSION_ALGORITHM(x) \
((x) >= GRPC_STREAM_COMPRESS_GZIP && (x) < GRPC_COMPRESS_ALGORITHMS_COUNT)
#define GRPC_IS_MESSAGE_COMPRESSION_ALGORITHM(x) \
((x) >= GRPC_COMPRESS_DEFLATE && (x) <= GRPC_COMPRESS_GZIP)
#define GRPC_STREAM_COMPRESS_FLAG_OFFSET \
(GRPC_STREAM_COMPRESS_GZIP - GRPC_COMPRESS_DEFLATE)
#define GRPC_MESSAGE_COMPRESSION_ALGORITHM_MASK \
((1u << GRPC_COMPRESS_DEFLATE) | (1u << GRPC_COMPRESS_GZIP))
#define GRPC_STREAM_COMPRESSION_ALGORITHM_MASK \
((1u << GRPC_STREAM_COMPRESS_GZIP))
/** Compression levels allow a party with knowledge of its peer's accepted
* encodings to request compression in an abstract way. The level-algorithm
* mapping is performed internally and depends on the peer's supported
@ -82,18 +70,9 @@ typedef enum {
GRPC_COMPRESS_LEVEL_LOW,
GRPC_COMPRESS_LEVEL_MED,
GRPC_COMPRESS_LEVEL_HIGH,
GRPC_STREAM_COMPRESS_LEVEL_LOW,
GRPC_STREAM_COMPRESS_LEVEL_MED,
GRPC_STREAM_COMPRESS_LEVEL_HIGH,
GRPC_COMPRESS_LEVEL_COUNT
} grpc_compression_level;
#define GRPC_IS_STREAM_COMPRESSION_LEVEL(x) \
(((x) >= GRPC_STREAM_COMPRESS_LEVEL_LOW) && \
((x) <= GRPC_STREAM_COMPRESS_LEVEL_HIGH))
#define GRPC_IS_MESSAGE_COMPRESSION_LEVEL(x) \
(((x) >= GRPC_COMPRESS_LEVEL_LOW) && ((x) <= GRPC_COMPRESS_LEVEL_HIGH))
typedef struct grpc_compression_options {
/** All algs are enabled by default. This option corresponds to the channel
* argument key behind \a GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET

43
src/core/ext/filters/http/message_compress/message_compress_filter.c
Unescape View File

@ -45,7 +45,6 @@ typedef struct call_data {
grpc_slice_buffer slices; /**< Buffers up input slices to be compressed */
grpc_linked_mdelem compression_algorithm_storage;
grpc_linked_mdelem accept_encoding_storage;
grpc_linked_mdelem accept_stream_encoding_storage;
uint32_t remaining_slice_bytes;
/** Compression algorithm we'll try to use. It may be given by incoming
* metadata, or by the channel's default compression settings. */
@ -90,8 +89,7 @@ static bool skip_compression(grpc_call_element *elem, uint32_t flags,
return 1;
}
if (has_compression_algorithm) {
if (calld->compression_algorithm == GRPC_COMPRESS_NONE ||
GRPC_IS_STREAM_COMPRESSION_ALGORITHM(calld->compression_algorithm)) {
if (calld->compression_algorithm == GRPC_COMPRESS_NONE) {
return 1;
}
return 0; /* we have an actual call-specific algorithm */
@ -113,22 +111,11 @@ static grpc_error *process_send_initial_metadata(
*has_compression_algorithm = false;
/* Parse incoming request for compression. If any, it'll be available
* at calld->compression_algorithm */
if (initial_metadata->idx.named.grpc_internal_encoding_request != NULL ||
initial_metadata->idx.named.grpc_internal_stream_encoding_request !=
NULL) {
int result;
grpc_mdelem md;
if (initial_metadata->idx.named.grpc_internal_encoding_request != NULL) {
md = initial_metadata->idx.named.grpc_internal_encoding_request->md;
result = grpc_compression_algorithm_parse(GRPC_MDVALUE(md),
&calld->compression_algorithm);
} else {
md =
initial_metadata->idx.named.grpc_internal_stream_encoding_request->md;
result = grpc_stream_compression_algorithm_parse(
GRPC_MDVALUE(md), &calld->compression_algorithm);
}
if (!result) {
if (initial_metadata->idx.named.grpc_internal_encoding_request != NULL) {
grpc_mdelem md =
initial_metadata->idx.named.grpc_internal_encoding_request->md;
if (!grpc_compression_algorithm_parse(GRPC_MDVALUE(md),
&calld->compression_algorithm)) {
char *val = grpc_slice_to_c_string(GRPC_MDVALUE(md));
gpr_log(GPR_ERROR,
"Invalid compression algorithm: '%s' (unknown). Ignoring.", val);
@ -146,12 +133,10 @@ static grpc_error *process_send_initial_metadata(
calld->compression_algorithm = GRPC_COMPRESS_NONE;
}
*has_compression_algorithm = true;
grpc_metadata_batch_remove(
exec_ctx, initial_metadata,
initial_metadata->idx.named.grpc_internal_encoding_request != NULL
? initial_metadata->idx.named.grpc_internal_encoding_request
: initial_metadata->idx.named
.grpc_internal_stream_encoding_request);
initial_metadata->idx.named.grpc_internal_encoding_request);
} else {
/* If no algorithm was found in the metadata and we aren't
* exceptionally skipping compression, fall back to the channel
@ -174,17 +159,7 @@ static grpc_error *process_send_initial_metadata(
error = grpc_metadata_batch_add_tail(
exec_ctx, initial_metadata, &calld->accept_encoding_storage,
GRPC_MDELEM_ACCEPT_ENCODING_FOR_ALGORITHMS(
channeld->supported_compression_algorithms &
GRPC_MESSAGE_COMPRESSION_ALGORITHM_MASK));
if (error != GRPC_ERROR_NONE) return error;
error = grpc_metadata_batch_add_tail(
exec_ctx, initial_metadata, &calld->accept_stream_encoding_storage,
GRPC_MDELEM_ACCEPT_STREAM_ENCODING_FOR_ALGORITHMS(
(channeld->supported_compression_algorithms &
GRPC_STREAM_COMPRESSION_ALGORITHM_MASK) >>
GRPC_STREAM_COMPRESS_FLAG_OFFSET));
channeld->supported_compression_algorithms));
return error;
}

6
src/core/ext/transport/chttp2/transport/chttp2_transport.c
Unescape View File

@ -1274,12 +1274,6 @@ static void perform_stream_op_locked(grpc_exec_ctx *exec_ctx, void *stream_op,
if (op->send_initial_metadata) {
GPR_ASSERT(s->send_initial_metadata_finished == NULL);
on_complete->next_data.scratch |= CLOSURE_BARRIER_MAY_COVER_WRITE;
/* Identify stream compression */
s->stream_compression_send_enabled =
(op_payload->send_initial_metadata.send_initial_metadata->idx.named
.content_encoding != NULL);
s->send_initial_metadata_finished = add_closure_barrier(on_complete);
s->send_initial_metadata =
op_payload->send_initial_metadata.send_initial_metadata;

5
src/core/lib/compression/algorithm_metadata.h
Unescape View File

@ -35,9 +35,4 @@ grpc_mdelem grpc_compression_encoding_mdelem(
grpc_compression_algorithm grpc_compression_algorithm_from_slice(
grpc_slice str);
/** Find stream compression algorithm based on passed in mdstr - returns
* GRPC_COMPRESS_ALGORITHM_COUNT on failure */
grpc_compression_algorithm grpc_stream_compression_algorithm_from_slice(
grpc_slice str);
#endif /* GRPC_CORE_LIB_COMPRESSION_ALGORITHM_METADATA_H */

121
src/core/lib/compression/compression.c
Unescape View File

@ -46,19 +46,6 @@ int grpc_compression_algorithm_parse(grpc_slice name,
}
}
int grpc_stream_compression_algorithm_parse(
grpc_slice name, grpc_compression_algorithm *algorithm) {
if (grpc_slice_eq(name, GRPC_MDSTR_IDENTITY)) {
*algorithm = GRPC_COMPRESS_NONE;
return 1;
} else if (grpc_slice_eq(name, GRPC_MDSTR_GZIP)) {
*algorithm = GRPC_STREAM_COMPRESS_GZIP;
return 1;
} else {
return 0;
}
}
int grpc_compression_algorithm_name(grpc_compression_algorithm algorithm,
char **name) {
GRPC_API_TRACE("grpc_compression_algorithm_parse(algorithm=%d, name=%p)", 2,
@ -71,7 +58,6 @@ int grpc_compression_algorithm_name(grpc_compression_algorithm algorithm,
*name = "deflate";
return 1;
case GRPC_COMPRESS_GZIP:
case GRPC_STREAM_COMPRESS_GZIP:
*name = "gzip";
return 1;
case GRPC_COMPRESS_ALGORITHMS_COUNT:
@ -88,13 +74,6 @@ grpc_compression_algorithm grpc_compression_algorithm_from_slice(
return GRPC_COMPRESS_ALGORITHMS_COUNT;
}
grpc_compression_algorithm grpc_stream_compression_algorithm_from_slice(
grpc_slice str) {
if (grpc_slice_eq(str, GRPC_MDSTR_IDENTITY)) return GRPC_COMPRESS_NONE;
if (grpc_slice_eq(str, GRPC_MDSTR_GZIP)) return GRPC_STREAM_COMPRESS_GZIP;
return GRPC_COMPRESS_ALGORITHMS_COUNT;
}
grpc_slice grpc_compression_algorithm_slice(
grpc_compression_algorithm algorithm) {
switch (algorithm) {
@ -103,7 +82,6 @@ grpc_slice grpc_compression_algorithm_slice(
case GRPC_COMPRESS_DEFLATE:
return GRPC_MDSTR_DEFLATE;
case GRPC_COMPRESS_GZIP:
case GRPC_STREAM_COMPRESS_GZIP:
return GRPC_MDSTR_GZIP;
case GRPC_COMPRESS_ALGORITHMS_COUNT:
return grpc_empty_slice();
@ -120,8 +98,6 @@ grpc_mdelem grpc_compression_encoding_mdelem(
return GRPC_MDELEM_GRPC_ENCODING_DEFLATE;
case GRPC_COMPRESS_GZIP:
return GRPC_MDELEM_GRPC_ENCODING_GZIP;
case GRPC_STREAM_COMPRESS_GZIP:
return GRPC_MDELEM_CONTENT_ENCODING_GZIP;
default:
break;
}
@ -156,61 +132,52 @@ grpc_compression_algorithm grpc_compression_algorithm_for_level(
grpc_compression_level level, uint32_t accepted_encodings) {
GRPC_API_TRACE("grpc_compression_algorithm_for_level(level=%d)", 1,
((int)level));
if (level == GRPC_COMPRESS_LEVEL_NONE ||
GRPC_IS_MESSAGE_COMPRESSION_LEVEL(level)) {
/* Message-wise compression */
const size_t num_supported = GPR_BITCOUNT(
accepted_encodings &
GRPC_MESSAGE_COMPRESSION_ALGORITHM_MASK); /* discard NONE */
if (level == GRPC_COMPRESS_LEVEL_NONE || num_supported == 0) {
return GRPC_COMPRESS_NONE;
}
if (level > GRPC_COMPRESS_LEVEL_HIGH) {
gpr_log(GPR_ERROR, "Unknown compression level %d.", (int)level);
abort();
}
const size_t num_supported =
GPR_BITCOUNT(accepted_encodings) - 1; /* discard NONE */
if (level == GRPC_COMPRESS_LEVEL_NONE || num_supported == 0) {
return GRPC_COMPRESS_NONE;
}
GPR_ASSERT(level > 0);
/* Establish a "ranking" or compression algorithms in increasing order of
* compression.
* This is simplistic and we will probably want to introduce other
* dimensions
* in the future (cpu/memory cost, etc). */
const grpc_compression_algorithm algos_ranking[] = {GRPC_COMPRESS_GZIP,
GRPC_COMPRESS_DEFLATE};
/* intersect algos_ranking with the supported ones keeping the ranked order
*/
grpc_compression_algorithm
sorted_supported_algos[GRPC_COMPRESS_ALGORITHMS_COUNT];
size_t algos_supported_idx = 0;
for (size_t i = 0; i < GPR_ARRAY_SIZE(algos_ranking); i++) {
const grpc_compression_algorithm alg = algos_ranking[i];
for (size_t j = 0; j < num_supported; j++) {
if (GPR_BITGET(accepted_encodings, alg) == 1) {
/* if \a alg in supported */
sorted_supported_algos[algos_supported_idx++] = alg;
break;
}
GPR_ASSERT(level > 0);
/* Establish a "ranking" or compression algorithms in increasing order of
* compression.
* This is simplistic and we will probably want to introduce other dimensions
* in the future (cpu/memory cost, etc). */
const grpc_compression_algorithm algos_ranking[] = {GRPC_COMPRESS_GZIP,
GRPC_COMPRESS_DEFLATE};
/* intersect algos_ranking with the supported ones keeping the ranked order */
grpc_compression_algorithm
sorted_supported_algos[GRPC_COMPRESS_ALGORITHMS_COUNT];
size_t algos_supported_idx = 0;
for (size_t i = 0; i < GPR_ARRAY_SIZE(algos_ranking); i++) {
const grpc_compression_algorithm alg = algos_ranking[i];
for (size_t j = 0; j < num_supported; j++) {
if (GPR_BITGET(accepted_encodings, alg) == 1) {
/* if \a alg in supported */
sorted_supported_algos[algos_supported_idx++] = alg;
break;
}
if (algos_supported_idx == num_supported) break;
}
switch (level) {
case GRPC_COMPRESS_LEVEL_NONE:
abort(); /* should have been handled already */
case GRPC_COMPRESS_LEVEL_LOW:
return sorted_supported_algos[0];
case GRPC_COMPRESS_LEVEL_MED:
return sorted_supported_algos[num_supported / 2];
case GRPC_COMPRESS_LEVEL_HIGH:
return sorted_supported_algos[num_supported - 1];
default:
abort();
};
} else if (GRPC_IS_STREAM_COMPRESSION_LEVEL(level)) {
/* Stream compression */
/* Only supports gzip at this time. */
return GRPC_STREAM_COMPRESS_GZIP;
} else {
gpr_log(GPR_ERROR, "Unknown compression level %d.", (int)level);
abort();
if (algos_supported_idx == num_supported) break;
}
switch (level) {
case GRPC_COMPRESS_LEVEL_NONE:
abort(); /* should have been handled already */
case GRPC_COMPRESS_LEVEL_LOW:
return sorted_supported_algos[0];
case GRPC_COMPRESS_LEVEL_MED:
return sorted_supported_algos[num_supported / 2];
case GRPC_COMPRESS_LEVEL_HIGH:
return sorted_supported_algos[num_supported - 1];
default:
abort();
};
}

5
src/core/lib/compression/message_compress.c
Unescape View File

@ -155,9 +155,6 @@ static int compress_inner(grpc_exec_ctx* exec_ctx,
case GRPC_COMPRESS_GZIP:
return zlib_compress(exec_ctx, input, output, 1);
case GRPC_COMPRESS_ALGORITHMS_COUNT:
/* Stream compression is taken care of in transport layer */
return 0;
default:
break;
}
gpr_log(GPR_ERROR, "invalid compression algorithm %d", algorithm);
@ -186,8 +183,6 @@ int grpc_msg_decompress(grpc_exec_ctx* exec_ctx,
return zlib_decompress(exec_ctx, input, output, 1);
case GRPC_COMPRESS_ALGORITHMS_COUNT:
break;
default:
break;
}
gpr_log(GPR_ERROR, "invalid compression algorithm %d", algorithm);
return 0;

95
src/core/lib/surface/call.c
Unescape View File

@ -769,9 +769,8 @@ uint32_t grpc_call_test_only_get_message_flags(grpc_call *call) {
static void destroy_encodings_accepted_by_peer(void *p) { return; }
static void parse_encodings_accepted_by_peer(
grpc_exec_ctx *exec_ctx, grpc_mdelem mdel,
uint32_t *encodings_accepted_by_peer, bool stream_compression) {
static void set_encodings_accepted_by_peer(grpc_exec_ctx *exec_ctx,
grpc_call *call, grpc_mdelem mdel) {
size_t i;
grpc_compression_algorithm algorithm;
grpc_slice_buffer accept_encoding_parts;
@ -781,46 +780,24 @@ static void parse_encodings_accepted_by_peer(
accepted_user_data =
grpc_mdelem_get_user_data(mdel, destroy_encodings_accepted_by_peer);
if (accepted_user_data != NULL) {
uint32_t flag = (uint32_t)(((uintptr_t)accepted_user_data) - 1);
if (stream_compression) {
*encodings_accepted_by_peer |= flag & 1u;
*encodings_accepted_by_peer |= (flag & ~(uint32_t)1)
<< GRPC_STREAM_COMPRESS_FLAG_OFFSET;
} else {
*encodings_accepted_by_peer |= flag;
}
call->encodings_accepted_by_peer =
(uint32_t)(((uintptr_t)accepted_user_data) - 1);
return;
}
uint32_t user_data = 0;
accept_encoding_slice = GRPC_MDVALUE(mdel);
grpc_slice_buffer_init(&accept_encoding_parts);
grpc_slice_split(accept_encoding_slice, ",", &accept_encoding_parts);
/* No need to zero call->encodings_accepted_by_peer: grpc_call_create already
* zeroes the whole grpc_call */
/* Always support no compression */
GPR_BITSET(encodings_accepted_by_peer, GRPC_COMPRESS_NONE);
GPR_BITSET(&call->encodings_accepted_by_peer, GRPC_COMPRESS_NONE);
for (i = 0; i < accept_encoding_parts.count; i++) {
grpc_slice accept_encoding_entry_slice = accept_encoding_parts.slices[i];
int result;
if (stream_compression) {
result = grpc_stream_compression_algorithm_parse(
accept_encoding_entry_slice, &algorithm);
if (result) {
user_data |=
(1u << (algorithm == GRPC_COMPRESS_NONE
? 0
: algorithm - (GRPC_STREAM_COMPRESS_FLAG_OFFSET)));
}
} else {
result = grpc_compression_algorithm_parse(accept_encoding_entry_slice,
&algorithm);
if (result) {
user_data |= (1u << algorithm);
}
}
if (result) {
GPR_BITSET(encodings_accepted_by_peer, algorithm);
if (grpc_compression_algorithm_parse(accept_encoding_entry_slice,
&algorithm)) {
GPR_BITSET(&call->encodings_accepted_by_peer, algorithm);
} else {
char *accept_encoding_entry_str =
grpc_slice_to_c_string(accept_encoding_entry_slice);
@ -835,7 +812,7 @@ static void parse_encodings_accepted_by_peer(
grpc_mdelem_set_user_data(
mdel, destroy_encodings_accepted_by_peer,
(void *)(((uintptr_t)encodings_accepted_by_peer) + 1));
(void *)(((uintptr_t)call->encodings_accepted_by_peer) + 1));
}
uint32_t grpc_call_test_only_get_encodings_accepted_by_peer(grpc_call *call) {
@ -937,14 +914,9 @@ static uint32_t decode_status(grpc_mdelem md) {
return status;
}
static grpc_compression_algorithm decode_compression(grpc_mdelem md,
bool stream_compression) {
grpc_compression_algorithm algorithm;
if (stream_compression) {
algorithm = grpc_stream_compression_algorithm_from_slice(GRPC_MDVALUE(md));
} else {
algorithm = grpc_compression_algorithm_from_slice(GRPC_MDVALUE(md));
}
static grpc_compression_algorithm decode_compression(grpc_mdelem md) {
grpc_compression_algorithm algorithm =
grpc_compression_algorithm_from_slice(GRPC_MDVALUE(md));
if (algorithm == GRPC_COMPRESS_ALGORITHMS_COUNT) {
char *md_c_str = grpc_slice_to_c_string(GRPC_MDVALUE(md));
gpr_log(GPR_ERROR,
@ -981,43 +953,20 @@ static void publish_app_metadata(grpc_call *call, grpc_metadata_batch *b,
static void recv_initial_filter(grpc_exec_ctx *exec_ctx, grpc_call *call,
grpc_metadata_batch *b) {
if (b->idx.named.content_encoding != NULL) {
GPR_TIMER_BEGIN("incoming_compression_algorithm", 0);
set_incoming_compression_algorithm(
call, decode_compression(b->idx.named.content_encoding->md, true));
GPR_TIMER_END("incoming_compression_algorithm", 0);
grpc_metadata_batch_remove(exec_ctx, b, b->idx.named.content_encoding);
/* Stream compression overrides message compression */
if (b->idx.named.grpc_encoding != NULL) {
grpc_metadata_batch_remove(exec_ctx, b, b->idx.named.grpc_encoding);
}
} else if (b->idx.named.grpc_encoding != NULL) {
if (b->idx.named.grpc_encoding != NULL) {
GPR_TIMER_BEGIN("incoming_compression_algorithm", 0);
set_incoming_compression_algorithm(
call, decode_compression(b->idx.named.grpc_encoding->md, false));
call, decode_compression(b->idx.named.grpc_encoding->md));
GPR_TIMER_END("incoming_compression_algorithm", 0);
grpc_metadata_batch_remove(exec_ctx, b, b->idx.named.grpc_encoding);
}
uint32_t encodings_accepted_by_peer = 0;
GPR_BITSET(&encodings_accepted_by_peer, GRPC_COMPRESS_NONE);
if (b->idx.named.grpc_accept_encoding != NULL) {
GPR_TIMER_BEGIN("encodings_accepted_by_peer", 0);
parse_encodings_accepted_by_peer(exec_ctx,
b->idx.named.grpc_accept_encoding->md,
&encodings_accepted_by_peer, false);
set_encodings_accepted_by_peer(exec_ctx, call,
b->idx.named.grpc_accept_encoding->md);
grpc_metadata_batch_remove(exec_ctx, b, b->idx.named.grpc_accept_encoding);
GPR_TIMER_END("encodings_accepted_by_peer", 0);
}
if (b->idx.named.accept_encoding != NULL) {
GPR_TIMER_BEGIN("encodings_accepted_by_peer", 0);
parse_encodings_accepted_by_peer(exec_ctx, b->idx.named.accept_encoding->md,
&encodings_accepted_by_peer, true);
grpc_metadata_batch_remove(exec_ctx, b, b->idx.named.accept_encoding);
GPR_TIMER_END("encodings_accepted_by_peer", 0);
}
call->encodings_accepted_by_peer = encodings_accepted_by_peer;
publish_app_metadata(call, b, false);
}
@ -1309,8 +1258,7 @@ static void process_data_after_md(grpc_exec_ctx *exec_ctx,
} else {
call->test_only_last_message_flags = call->receiving_stream->flags;
if ((call->receiving_stream->flags & GRPC_WRITE_INTERNAL_COMPRESS) &&
(GRPC_IS_MESSAGE_COMPRESSION_ALGORITHM(
call->incoming_compression_algorithm))) {
(call->incoming_compression_algorithm > GRPC_COMPRESS_NONE)) {
*call->receiving_buffer = grpc_raw_compressed_byte_buffer_create(
NULL, 0, call->incoming_compression_algorithm);
} else {
@ -1536,10 +1484,7 @@ static grpc_call_error call_start_batch(grpc_exec_ctx *exec_ctx,
call, effective_compression_level);
// the following will be picked up by the compress filter and used as
// the call's compression algorithm.
compression_md.key =
GRPC_IS_STREAM_COMPRESSION_ALGORITHM(calgo)
? GRPC_MDSTR_GRPC_INTERNAL_STREAM_ENCODING_REQUEST
: GRPC_MDSTR_GRPC_INTERNAL_ENCODING_REQUEST;
compression_md.key = GRPC_MDSTR_GRPC_INTERNAL_ENCODING_REQUEST;
compression_md.value = grpc_compression_algorithm_slice(calgo);
additional_metadata_count++;
}

798
src/core/lib/transport/static_metadata.c
View File

File diff suppressed because it is too large Load Diff

204
src/core/lib/transport/static_metadata.h
Unescape View File

@ -29,7 +29,7 @@
#include "src/core/lib/transport/metadata.h"
#define GRPC_STATIC_MDSTR_COUNT 100
#define GRPC_STATIC_MDSTR_COUNT 99
extern const grpc_slice grpc_static_slice_table[GRPC_STATIC_MDSTR_COUNT];
/* ":path" */
#define GRPC_MDSTR_PATH (grpc_static_slice_table[0])
@ -61,181 +61,178 @@ extern const grpc_slice grpc_static_slice_table[GRPC_STATIC_MDSTR_COUNT];
#define GRPC_MDSTR_GRPC_TRACE_BIN (grpc_static_slice_table[13])
/* "content-type" */
#define GRPC_MDSTR_CONTENT_TYPE (grpc_static_slice_table[14])
/* "content-encoding" */
#define GRPC_MDSTR_CONTENT_ENCODING (grpc_static_slice_table[15])
/* "accept-encoding" */
#define GRPC_MDSTR_ACCEPT_ENCODING (grpc_static_slice_table[16])
/* "grpc-internal-encoding-request" */
#define GRPC_MDSTR_GRPC_INTERNAL_ENCODING_REQUEST (grpc_static_slice_table[17])
/* "grpc-internal-stream-encoding-request" */
#define GRPC_MDSTR_GRPC_INTERNAL_STREAM_ENCODING_REQUEST \
(grpc_static_slice_table[18])
#define GRPC_MDSTR_GRPC_INTERNAL_ENCODING_REQUEST (grpc_static_slice_table[15])
/* "user-agent" */
#define GRPC_MDSTR_USER_AGENT (grpc_static_slice_table[19])
#define GRPC_MDSTR_USER_AGENT (grpc_static_slice_table[16])
/* "host" */
#define GRPC_MDSTR_HOST (grpc_static_slice_table[20])
#define GRPC_MDSTR_HOST (grpc_static_slice_table[17])
/* "lb-token" */
#define GRPC_MDSTR_LB_TOKEN (grpc_static_slice_table[21])
#define GRPC_MDSTR_LB_TOKEN (grpc_static_slice_table[18])
/* "grpc-timeout" */
#define GRPC_MDSTR_GRPC_TIMEOUT (grpc_static_slice_table[22])
#define GRPC_MDSTR_GRPC_TIMEOUT (grpc_static_slice_table[19])
/* "" */
#define GRPC_MDSTR_EMPTY (grpc_static_slice_table[23])
#define GRPC_MDSTR_EMPTY (grpc_static_slice_table[20])
/* "grpc.wait_for_ready" */
#define GRPC_MDSTR_GRPC_DOT_WAIT_FOR_READY (grpc_static_slice_table[24])
#define GRPC_MDSTR_GRPC_DOT_WAIT_FOR_READY (grpc_static_slice_table[21])
/* "grpc.timeout" */
#define GRPC_MDSTR_GRPC_DOT_TIMEOUT (grpc_static_slice_table[25])
#define GRPC_MDSTR_GRPC_DOT_TIMEOUT (grpc_static_slice_table[22])
/* "grpc.max_request_message_bytes" */
#define GRPC_MDSTR_GRPC_DOT_MAX_REQUEST_MESSAGE_BYTES \
(grpc_static_slice_table[26])
(grpc_static_slice_table[23])
/* "grpc.max_response_message_bytes" */
#define GRPC_MDSTR_GRPC_DOT_MAX_RESPONSE_MESSAGE_BYTES \
(grpc_static_slice_table[27])
(grpc_static_slice_table[24])
/* "/grpc.lb.v1.LoadBalancer/BalanceLoad" */
#define GRPC_MDSTR_SLASH_GRPC_DOT_LB_DOT_V1_DOT_LOADBALANCER_SLASH_BALANCELOAD \
(grpc_static_slice_table[28])
(grpc_static_slice_table[25])
/* "0" */
#define GRPC_MDSTR_0 (grpc_static_slice_table[29])
#define GRPC_MDSTR_0 (grpc_static_slice_table[26])
/* "1" */
#define GRPC_MDSTR_1 (grpc_static_slice_table[30])
#define GRPC_MDSTR_1 (grpc_static_slice_table[27])
/* "2" */
#define GRPC_MDSTR_2 (grpc_static_slice_table[31])
#define GRPC_MDSTR_2 (grpc_static_slice_table[28])
/* "identity" */
#define GRPC_MDSTR_IDENTITY (grpc_static_slice_table[32])
#define GRPC_MDSTR_IDENTITY (grpc_static_slice_table[29])
/* "gzip" */
#define GRPC_MDSTR_GZIP (grpc_static_slice_table[33])
#define GRPC_MDSTR_GZIP (grpc_static_slice_table[30])
/* "deflate" */
#define GRPC_MDSTR_DEFLATE (grpc_static_slice_table[34])
#define GRPC_MDSTR_DEFLATE (grpc_static_slice_table[31])
/* "trailers" */
#define GRPC_MDSTR_TRAILERS (grpc_static_slice_table[35])
#define GRPC_MDSTR_TRAILERS (grpc_static_slice_table[32])
/* "application/grpc" */
#define GRPC_MDSTR_APPLICATION_SLASH_GRPC (grpc_static_slice_table[36])
#define GRPC_MDSTR_APPLICATION_SLASH_GRPC (grpc_static_slice_table[33])
/* "POST" */
#define GRPC_MDSTR_POST (grpc_static_slice_table[37])
#define GRPC_MDSTR_POST (grpc_static_slice_table[34])
/* "200" */
#define GRPC_MDSTR_200 (grpc_static_slice_table[38])
#define GRPC_MDSTR_200 (grpc_static_slice_table[35])
/* "404" */
#define GRPC_MDSTR_404 (grpc_static_slice_table[39])
#define GRPC_MDSTR_404 (grpc_static_slice_table[36])
/* "http" */
#define GRPC_MDSTR_HTTP (grpc_static_slice_table[40])
#define GRPC_MDSTR_HTTP (grpc_static_slice_table[37])
/* "https" */
#define GRPC_MDSTR_HTTPS (grpc_static_slice_table[41])
#define GRPC_MDSTR_HTTPS (grpc_static_slice_table[38])
/* "grpc" */
#define GRPC_MDSTR_GRPC (grpc_static_slice_table[42])
#define GRPC_MDSTR_GRPC (grpc_static_slice_table[39])
/* "GET" */
#define GRPC_MDSTR_GET (grpc_static_slice_table[43])
#define GRPC_MDSTR_GET (grpc_static_slice_table[40])
/* "PUT" */
#define GRPC_MDSTR_PUT (grpc_static_slice_table[44])
#define GRPC_MDSTR_PUT (grpc_static_slice_table[41])
/* "/" */
#define GRPC_MDSTR_SLASH (grpc_static_slice_table[45])
#define GRPC_MDSTR_SLASH (grpc_static_slice_table[42])
/* "/index.html" */
#define GRPC_MDSTR_SLASH_INDEX_DOT_HTML (grpc_static_slice_table[46])
#define GRPC_MDSTR_SLASH_INDEX_DOT_HTML (grpc_static_slice_table[43])
/* "204" */
#define GRPC_MDSTR_204 (grpc_static_slice_table[47])
#define GRPC_MDSTR_204 (grpc_static_slice_table[44])
/* "206" */
#define GRPC_MDSTR_206 (grpc_static_slice_table[48])
#define GRPC_MDSTR_206 (grpc_static_slice_table[45])
/* "304" */
#define GRPC_MDSTR_304 (grpc_static_slice_table[49])
#define GRPC_MDSTR_304 (grpc_static_slice_table[46])
/* "400" */
#define GRPC_MDSTR_400 (grpc_static_slice_table[50])
#define GRPC_MDSTR_400 (grpc_static_slice_table[47])
/* "500" */
#define GRPC_MDSTR_500 (grpc_static_slice_table[51])
#define GRPC_MDSTR_500 (grpc_static_slice_table[48])
/* "accept-charset" */
#define GRPC_MDSTR_ACCEPT_CHARSET (grpc_static_slice_table[52])
#define GRPC_MDSTR_ACCEPT_CHARSET (grpc_static_slice_table[49])
/* "accept-encoding" */
#define GRPC_MDSTR_ACCEPT_ENCODING (grpc_static_slice_table[50])
/* "gzip, deflate" */
#define GRPC_MDSTR_GZIP_COMMA_DEFLATE (grpc_static_slice_table[53])
#define GRPC_MDSTR_GZIP_COMMA_DEFLATE (grpc_static_slice_table[51])
/* "accept-language" */
#define GRPC_MDSTR_ACCEPT_LANGUAGE (grpc_static_slice_table[54])
#define GRPC_MDSTR_ACCEPT_LANGUAGE (grpc_static_slice_table[52])
/* "accept-ranges" */
#define GRPC_MDSTR_ACCEPT_RANGES (grpc_static_slice_table[55])
#define GRPC_MDSTR_ACCEPT_RANGES (grpc_static_slice_table[53])
/* "accept" */
#define GRPC_MDSTR_ACCEPT (grpc_static_slice_table[56])
#define GRPC_MDSTR_ACCEPT (grpc_static_slice_table[54])
/* "access-control-allow-origin" */
#define GRPC_MDSTR_ACCESS_CONTROL_ALLOW_ORIGIN (grpc_static_slice_table[57])
#define GRPC_MDSTR_ACCESS_CONTROL_ALLOW_ORIGIN (grpc_static_slice_table[55])
/* "age" */
#define GRPC_MDSTR_AGE (grpc_static_slice_table[58])
#define GRPC_MDSTR_AGE (grpc_static_slice_table[56])
/* "allow" */
#define GRPC_MDSTR_ALLOW (grpc_static_slice_table[59])
#define GRPC_MDSTR_ALLOW (grpc_static_slice_table[57])
/* "authorization" */
#define GRPC_MDSTR_AUTHORIZATION (grpc_static_slice_table[60])
#define GRPC_MDSTR_AUTHORIZATION (grpc_static_slice_table[58])
/* "cache-control" */
#define GRPC_MDSTR_CACHE_CONTROL (grpc_static_slice_table[61])
#define GRPC_MDSTR_CACHE_CONTROL (grpc_static_slice_table[59])
/* "content-disposition" */
#define GRPC_MDSTR_CONTENT_DISPOSITION (grpc_static_slice_table[62])
#define GRPC_MDSTR_CONTENT_DISPOSITION (grpc_static_slice_table[60])
/* "content-encoding" */
#define GRPC_MDSTR_CONTENT_ENCODING (grpc_static_slice_table[61])
/* "content-language" */
#define GRPC_MDSTR_CONTENT_LANGUAGE (grpc_static_slice_table[63])
#define GRPC_MDSTR_CONTENT_LANGUAGE (grpc_static_slice_table[62])
/* "content-length" */
#define GRPC_MDSTR_CONTENT_LENGTH (grpc_static_slice_table[64])
#define GRPC_MDSTR_CONTENT_LENGTH (grpc_static_slice_table[63])
/* "content-location" */
#define GRPC_MDSTR_CONTENT_LOCATION (grpc_static_slice_table[65])
#define GRPC_MDSTR_CONTENT_LOCATION (grpc_static_slice_table[64])
/* "content-range" */
#define GRPC_MDSTR_CONTENT_RANGE (grpc_static_slice_table[66])
#define GRPC_MDSTR_CONTENT_RANGE (grpc_static_slice_table[65])
/* "cookie" */
#define GRPC_MDSTR_COOKIE (grpc_static_slice_table[67])
#define GRPC_MDSTR_COOKIE (grpc_static_slice_table[66])
/* "date" */
#define GRPC_MDSTR_DATE (grpc_static_slice_table[68])
#define GRPC_MDSTR_DATE (grpc_static_slice_table[67])
/* "etag" */
#define GRPC_MDSTR_ETAG (grpc_static_slice_table[69])
#define GRPC_MDSTR_ETAG (grpc_static_slice_table[68])
/* "expect" */
#define GRPC_MDSTR_EXPECT (grpc_static_slice_table[70])
#define GRPC_MDSTR_EXPECT (grpc_static_slice_table[69])
/* "expires" */
#define GRPC_MDSTR_EXPIRES (grpc_static_slice_table[71])
#define GRPC_MDSTR_EXPIRES (grpc_static_slice_table[70])
/* "from" */
#define GRPC_MDSTR_FROM (grpc_static_slice_table[72])
#define GRPC_MDSTR_FROM (grpc_static_slice_table[71])
/* "if-match" */
#define GRPC_MDSTR_IF_MATCH (grpc_static_slice_table[73])
#define GRPC_MDSTR_IF_MATCH (grpc_static_slice_table[72])
/* "if-modified-since" */
#define GRPC_MDSTR_IF_MODIFIED_SINCE (grpc_static_slice_table[74])
#define GRPC_MDSTR_IF_MODIFIED_SINCE (grpc_static_slice_table[73])
/* "if-none-match" */
#define GRPC_MDSTR_IF_NONE_MATCH (grpc_static_slice_table[75])
#define GRPC_MDSTR_IF_NONE_MATCH (grpc_static_slice_table[74])
/* "if-range" */
#define GRPC_MDSTR_IF_RANGE (grpc_static_slice_table[76])
#define GRPC_MDSTR_IF_RANGE (grpc_static_slice_table[75])
/* "if-unmodified-since" */
#define GRPC_MDSTR_IF_UNMODIFIED_SINCE (grpc_static_slice_table[77])
#define GRPC_MDSTR_IF_UNMODIFIED_SINCE (grpc_static_slice_table[76])
/* "last-modified" */
#define GRPC_MDSTR_LAST_MODIFIED (grpc_static_slice_table[78])
#define GRPC_MDSTR_LAST_MODIFIED (grpc_static_slice_table[77])
/* "lb-cost-bin" */
#define GRPC_MDSTR_LB_COST_BIN (grpc_static_slice_table[79])
#define GRPC_MDSTR_LB_COST_BIN (grpc_static_slice_table[78])
/* "link" */
#define GRPC_MDSTR_LINK (grpc_static_slice_table[80])
#define GRPC_MDSTR_LINK (grpc_static_slice_table[79])
/* "location" */
#define GRPC_MDSTR_LOCATION (grpc_static_slice_table[81])
#define GRPC_MDSTR_LOCATION (grpc_static_slice_table[80])
/* "max-forwards" */
#define GRPC_MDSTR_MAX_FORWARDS (grpc_static_slice_table[82])
#define GRPC_MDSTR_MAX_FORWARDS (grpc_static_slice_table[81])
/* "proxy-authenticate" */
#define GRPC_MDSTR_PROXY_AUTHENTICATE (grpc_static_slice_table[83])
#define GRPC_MDSTR_PROXY_AUTHENTICATE (grpc_static_slice_table[82])
/* "proxy-authorization" */
#define GRPC_MDSTR_PROXY_AUTHORIZATION (grpc_static_slice_table[84])
#define GRPC_MDSTR_PROXY_AUTHORIZATION (grpc_static_slice_table[83])
/* "range" */
#define GRPC_MDSTR_RANGE (grpc_static_slice_table[85])
#define GRPC_MDSTR_RANGE (grpc_static_slice_table[84])
/* "referer" */
#define GRPC_MDSTR_REFERER (grpc_static_slice_table[86])
#define GRPC_MDSTR_REFERER (grpc_static_slice_table[85])
/* "refresh" */
#define GRPC_MDSTR_REFRESH (grpc_static_slice_table[87])
#define GRPC_MDSTR_REFRESH (grpc_static_slice_table[86])
/* "retry-after" */
#define GRPC_MDSTR_RETRY_AFTER (grpc_static_slice_table[88])
#define GRPC_MDSTR_RETRY_AFTER (grpc_static_slice_table[87])
/* "server" */
#define GRPC_MDSTR_SERVER (grpc_static_slice_table[89])
#define GRPC_MDSTR_SERVER (grpc_static_slice_table[88])
/* "set-cookie" */
#define GRPC_MDSTR_SET_COOKIE (grpc_static_slice_table[90])
#define GRPC_MDSTR_SET_COOKIE (grpc_static_slice_table[89])
/* "strict-transport-security" */
#define GRPC_MDSTR_STRICT_TRANSPORT_SECURITY (grpc_static_slice_table[91])
#define GRPC_MDSTR_STRICT_TRANSPORT_SECURITY (grpc_static_slice_table[90])
/* "transfer-encoding" */
#define GRPC_MDSTR_TRANSFER_ENCODING (grpc_static_slice_table[92])
#define GRPC_MDSTR_TRANSFER_ENCODING (grpc_static_slice_table[91])
/* "vary" */
#define GRPC_MDSTR_VARY (grpc_static_slice_table[93])
#define GRPC_MDSTR_VARY (grpc_static_slice_table[92])
/* "via" */
#define GRPC_MDSTR_VIA (grpc_static_slice_table[94])
#define GRPC_MDSTR_VIA (grpc_static_slice_table[93])
/* "www-authenticate" */
#define GRPC_MDSTR_WWW_AUTHENTICATE (grpc_static_slice_table[95])
#define GRPC_MDSTR_WWW_AUTHENTICATE (grpc_static_slice_table[94])
/* "identity,deflate" */
#define GRPC_MDSTR_IDENTITY_COMMA_DEFLATE (grpc_static_slice_table[96])
#define GRPC_MDSTR_IDENTITY_COMMA_DEFLATE (grpc_static_slice_table[95])
/* "identity,gzip" */
#define GRPC_MDSTR_IDENTITY_COMMA_GZIP (grpc_static_slice_table[97])
#define GRPC_MDSTR_IDENTITY_COMMA_GZIP (grpc_static_slice_table[96])
/* "deflate,gzip" */
#define GRPC_MDSTR_DEFLATE_COMMA_GZIP (grpc_static_slice_table[98])
#define GRPC_MDSTR_DEFLATE_COMMA_GZIP (grpc_static_slice_table[97])
/* "identity,deflate,gzip" */
#define GRPC_MDSTR_IDENTITY_COMMA_DEFLATE_COMMA_GZIP \
(grpc_static_slice_table[99])
(grpc_static_slice_table[98])
extern const grpc_slice_refcount_vtable grpc_static_metadata_vtable;
extern grpc_slice_refcount
@ -247,7 +244,7 @@ extern grpc_slice_refcount
#define GRPC_STATIC_METADATA_INDEX(static_slice) \
((int)((static_slice).refcount - grpc_static_metadata_refcounts))
#define GRPC_STATIC_MDELEM_COUNT 84
#define GRPC_STATIC_MDELEM_COUNT 81
extern grpc_mdelem_data grpc_static_mdelem_table[GRPC_STATIC_MDELEM_COUNT];
extern uintptr_t grpc_static_mdelem_user_data[GRPC_STATIC_MDELEM_COUNT];
/* "grpc-status": "0" */
@ -358,8 +355,8 @@ extern uintptr_t grpc_static_mdelem_user_data[GRPC_STATIC_MDELEM_COUNT];
/* "content-disposition": "" */
#define GRPC_MDELEM_CONTENT_DISPOSITION_EMPTY \
(GRPC_MAKE_MDELEM(&grpc_static_mdelem_table[35], GRPC_MDELEM_STORAGE_STATIC))
/* "content-encoding": "gzip" */
#define GRPC_MDELEM_CONTENT_ENCODING_GZIP \
/* "content-encoding": "" */
#define GRPC_MDELEM_CONTENT_ENCODING_EMPTY \
(GRPC_MAKE_MDELEM(&grpc_static_mdelem_table[36], GRPC_MDELEM_STORAGE_STATIC))
/* "content-language": "" */
#define GRPC_MDELEM_CONTENT_LANGUAGE_EMPTY \
@ -493,15 +490,6 @@ extern uintptr_t grpc_static_mdelem_user_data[GRPC_STATIC_MDELEM_COUNT];
/* "grpc-accept-encoding": "identity,deflate,gzip" */
#define GRPC_MDELEM_GRPC_ACCEPT_ENCODING_IDENTITY_COMMA_DEFLATE_COMMA_GZIP \
(GRPC_MAKE_MDELEM(&grpc_static_mdelem_table[80], GRPC_MDELEM_STORAGE_STATIC))
/* "accept-encoding": "identity" */
#define GRPC_MDELEM_ACCEPT_ENCODING_IDENTITY \
(GRPC_MAKE_MDELEM(&grpc_static_mdelem_table[81], GRPC_MDELEM_STORAGE_STATIC))
/* "accept-encoding": "gzip" */
#define GRPC_MDELEM_ACCEPT_ENCODING_GZIP \
(GRPC_MAKE_MDELEM(&grpc_static_mdelem_table[82], GRPC_MDELEM_STORAGE_STATIC))
/* "accept-encoding": "identity,gzip" */
#define GRPC_MDELEM_ACCEPT_ENCODING_IDENTITY_COMMA_GZIP \
(GRPC_MAKE_MDELEM(&grpc_static_mdelem_table[83], GRPC_MDELEM_STORAGE_STATIC))
grpc_mdelem grpc_static_mdelem_for_static_strings(int a, int b);
typedef enum {
@ -520,10 +508,7 @@ typedef enum {
GRPC_BATCH_GRPC_TAGS_BIN,
GRPC_BATCH_GRPC_TRACE_BIN,
GRPC_BATCH_CONTENT_TYPE,
GRPC_BATCH_CONTENT_ENCODING,
GRPC_BATCH_ACCEPT_ENCODING,
GRPC_BATCH_GRPC_INTERNAL_ENCODING_REQUEST,
GRPC_BATCH_GRPC_INTERNAL_STREAM_ENCODING_REQUEST,
GRPC_BATCH_USER_AGENT,
GRPC_BATCH_HOST,
GRPC_BATCH_LB_TOKEN,
@ -548,10 +533,7 @@ typedef union {
struct grpc_linked_mdelem *grpc_tags_bin;
struct grpc_linked_mdelem *grpc_trace_bin;
struct grpc_linked_mdelem *content_type;
struct grpc_linked_mdelem *content_encoding;
struct grpc_linked_mdelem *accept_encoding;
struct grpc_linked_mdelem *grpc_internal_encoding_request;
struct grpc_linked_mdelem *grpc_internal_stream_encoding_request;
struct grpc_linked_mdelem *user_agent;
struct grpc_linked_mdelem *host;
struct grpc_linked_mdelem *lb_token;
@ -570,10 +552,4 @@ extern const uint8_t grpc_static_accept_encoding_metadata[8];
(GRPC_MAKE_MDELEM( \
&grpc_static_mdelem_table[grpc_static_accept_encoding_metadata[(algs)]], \
GRPC_MDELEM_STORAGE_STATIC))
extern const uint8_t grpc_static_accept_stream_encoding_metadata[4];
#define GRPC_MDELEM_ACCEPT_STREAM_ENCODING_FOR_ALGORITHMS(algs) \
(GRPC_MAKE_MDELEM(&grpc_static_mdelem_table \
[grpc_static_accept_stream_encoding_metadata[(algs)]], \
GRPC_MDELEM_STORAGE_STATIC))
#endif /* GRPC_CORE_LIB_TRANSPORT_STATIC_METADATA_H */

22
test/core/compression/algorithm_test.c
Unescape View File

@ -42,29 +42,15 @@ static void test_algorithm_mesh(void) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
GPR_ASSERT(
grpc_compression_algorithm_name((grpc_compression_algorithm)i, &name));
if (GRPC_IS_MESSAGE_COMPRESSION_ALGORITHM(i) || i == GRPC_COMPRESS_NONE) {
GPR_ASSERT(grpc_compression_algorithm_parse(
grpc_slice_from_static_string(name), &parsed));
} else {
GPR_ASSERT(grpc_stream_compression_algorithm_parse(
grpc_slice_from_static_string(name), &parsed));
}
GPR_ASSERT(grpc_compression_algorithm_parse(
grpc_slice_from_static_string(name), &parsed));
GPR_ASSERT((int)parsed == i);
mdstr = grpc_slice_from_copied_string(name);
GPR_ASSERT(grpc_slice_eq(mdstr, grpc_compression_algorithm_slice(parsed)));
if (GRPC_IS_MESSAGE_COMPRESSION_ALGORITHM(i) || i == GRPC_COMPRESS_NONE) {
GPR_ASSERT(parsed == grpc_compression_algorithm_from_slice(mdstr));
} else {
GPR_ASSERT(parsed == grpc_stream_compression_algorithm_from_slice(mdstr));
}
GPR_ASSERT(parsed == grpc_compression_algorithm_from_slice(mdstr));
mdelem = grpc_compression_encoding_mdelem(parsed);
GPR_ASSERT(grpc_slice_eq(GRPC_MDVALUE(mdelem), mdstr));
if (GRPC_IS_MESSAGE_COMPRESSION_ALGORITHM(i) || i == GRPC_COMPRESS_NONE) {
GPR_ASSERT(grpc_slice_eq(GRPC_MDKEY(mdelem), GRPC_MDSTR_GRPC_ENCODING));
} else {
GPR_ASSERT(
grpc_slice_eq(GRPC_MDKEY(mdelem), GRPC_MDSTR_CONTENT_ENCODING));
}
GPR_ASSERT(grpc_slice_eq(GRPC_MDKEY(mdelem), GRPC_MDSTR_GRPC_ENCODING));
grpc_slice_unref_internal(&exec_ctx, mdstr);
GRPC_MDELEM_UNREF(&exec_ctx, mdelem);
grpc_exec_ctx_finish(&exec_ctx);

3
test/core/compression/message_compress_test.c
Unescape View File

@ -297,9 +297,6 @@ int main(int argc, char **argv) {
grpc_init();
for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {
if (i != GRPC_COMPRESS_NONE && !GRPC_IS_MESSAGE_COMPRESSION_ALGORITHM(i)) {
continue;
}
for (j = 0; j < GPR_ARRAY_SIZE(uncompressed_split_modes); j++) {
for (k = 0; k < GPR_ARRAY_SIZE(compressed_split_modes); k++) {
for (m = 0; m < TEST_VALUE_COUNT; m++) {

Write Preview
Loading…
Cancel
Save