grpc 1.41.1 → 1.44.0.pre2

data/src/core/ext/upb-generated/udpa/type/v1/typed_struct.upb.h

@@ -1,83 +0,0 @@
-/* This file was generated by upbc (the upb compiler) from the input
- * file:
- *
- *     udpa/type/v1/typed_struct.proto
- *
- * Do not edit -- your changes will be discarded when the file is
- * regenerated. */
-
-#ifndef UDPA_TYPE_V1_TYPED_STRUCT_PROTO_UPB_H_
-#define UDPA_TYPE_V1_TYPED_STRUCT_PROTO_UPB_H_
-
-#include "upb/msg_internal.h"
-#include "upb/decode.h"
-#include "upb/decode_fast.h"
-#include "upb/encode.h"
-
-#include "upb/port_def.inc"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct udpa_type_v1_TypedStruct;
-typedef struct udpa_type_v1_TypedStruct udpa_type_v1_TypedStruct;
-extern const upb_msglayout udpa_type_v1_TypedStruct_msginit;
-struct google_protobuf_Struct;
-extern const upb_msglayout google_protobuf_Struct_msginit;
-
-
-/* udpa.type.v1.TypedStruct */
-
-UPB_INLINE udpa_type_v1_TypedStruct *udpa_type_v1_TypedStruct_new(upb_arena *arena) {
-  return (udpa_type_v1_TypedStruct *)_upb_msg_new(&udpa_type_v1_TypedStruct_msginit, arena);
-}
-UPB_INLINE udpa_type_v1_TypedStruct *udpa_type_v1_TypedStruct_parse(const char *buf, size_t size,
-                        upb_arena *arena) {
-  udpa_type_v1_TypedStruct *ret = udpa_type_v1_TypedStruct_new(arena);
-  if (!ret) return NULL;
-  if (!upb_decode(buf, size, ret, &udpa_type_v1_TypedStruct_msginit, arena)) return NULL;
-  return ret;
-}
-UPB_INLINE udpa_type_v1_TypedStruct *udpa_type_v1_TypedStruct_parse_ex(const char *buf, size_t size,
-                           const upb_extreg *extreg, int options,
-                           upb_arena *arena) {
-  udpa_type_v1_TypedStruct *ret = udpa_type_v1_TypedStruct_new(arena);
-  if (!ret) return NULL;
-  if (!_upb_decode(buf, size, ret, &udpa_type_v1_TypedStruct_msginit, extreg, options, arena)) {
-    return NULL;
-  }
-  return ret;
-}
-UPB_INLINE char *udpa_type_v1_TypedStruct_serialize(const udpa_type_v1_TypedStruct *msg, upb_arena *arena, size_t *len) {
-  return upb_encode(msg, &udpa_type_v1_TypedStruct_msginit, arena, len);
-}
-
-UPB_INLINE upb_strview udpa_type_v1_TypedStruct_type_url(const udpa_type_v1_TypedStruct *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview); }
-UPB_INLINE bool udpa_type_v1_TypedStruct_has_value(const udpa_type_v1_TypedStruct *msg) { return _upb_hasbit(msg, 1); }
-UPB_INLINE const struct google_protobuf_Struct* udpa_type_v1_TypedStruct_value(const udpa_type_v1_TypedStruct *msg) { return *UPB_PTR_AT(msg, UPB_SIZE(12, 24), const struct google_protobuf_Struct*); }
-
-UPB_INLINE void udpa_type_v1_TypedStruct_set_type_url(udpa_type_v1_TypedStruct *msg, upb_strview value) {
-  *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_strview) = value;
-}
-UPB_INLINE void udpa_type_v1_TypedStruct_set_value(udpa_type_v1_TypedStruct *msg, struct google_protobuf_Struct* value) {
-  _upb_sethas(msg, 1);
-  *UPB_PTR_AT(msg, UPB_SIZE(12, 24), struct google_protobuf_Struct*) = value;
-}
-UPB_INLINE struct google_protobuf_Struct* udpa_type_v1_TypedStruct_mutable_value(udpa_type_v1_TypedStruct *msg, upb_arena *arena) {
-  struct google_protobuf_Struct* sub = (struct google_protobuf_Struct*)udpa_type_v1_TypedStruct_value(msg);
-  if (sub == NULL) {
-    sub = (struct google_protobuf_Struct*)_upb_msg_new(&google_protobuf_Struct_msginit, arena);
-    if (!sub) return NULL;
-    udpa_type_v1_TypedStruct_set_value(msg, sub);
-  }
-  return sub;
-}
-
-#ifdef __cplusplus
-}  /* extern "C" */
-#endif
-
-#include "upb/port_undef.inc"
-
-#endif  /* UDPA_TYPE_V1_TYPED_STRUCT_PROTO_UPB_H_ */

data/src/core/ext/upbdefs-generated/udpa/type/v1/typed_struct.upbdefs.c

@@ -1,44 +0,0 @@
-/* This file was generated by upbc (the upb compiler) from the input
- * file:
- *
- *     udpa/type/v1/typed_struct.proto
- *
- * Do not edit -- your changes will be discarded when the file is
- * regenerated. */
-
-#include "upb/def.h"
-#include "udpa/type/v1/typed_struct.upbdefs.h"
-
-extern upb_def_init validate_validate_proto_upbdefinit;
-extern upb_def_init google_protobuf_struct_proto_upbdefinit;
-extern const upb_msglayout udpa_type_v1_TypedStruct_msginit;
-
-static const upb_msglayout *layouts[1] = {
-  &udpa_type_v1_TypedStruct_msginit,
-};
-
-static const char descriptor[251] = {'\n', '\037', 'u', 'd', 'p', 'a', '/', 't', 'y', 'p', 'e', '/', 'v', '1', '/', 't', 'y', 'p', 'e', 'd', '_', 's', 't', 'r', 'u', 
-'c', 't', '.', 'p', 'r', 'o', 't', 'o', '\022', '\014', 'u', 'd', 'p', 'a', '.', 't', 'y', 'p', 'e', '.', 'v', '1', '\032', '\027', 'v', 
-'a', 'l', 'i', 'd', 'a', 't', 'e', '/', 'v', 'a', 'l', 'i', 'd', 'a', 't', 'e', '.', 'p', 'r', 'o', 't', 'o', '\032', '\034', 'g', 
-'o', 'o', 'g', 'l', 'e', '/', 'p', 'r', 'o', 't', 'o', 'b', 'u', 'f', '/', 's', 't', 'r', 'u', 'c', 't', '.', 'p', 'r', 'o', 
-'t', 'o', '\"', 'W', '\n', '\013', 'T', 'y', 'p', 'e', 'd', 'S', 't', 'r', 'u', 'c', 't', '\022', '\031', '\n', '\010', 't', 'y', 'p', 'e', 
-'_', 'u', 'r', 'l', '\030', '\001', ' ', '\001', '(', '\t', 'R', '\007', 't', 'y', 'p', 'e', 'U', 'r', 'l', '\022', '-', '\n', '\005', 'v', 'a', 
-'l', 'u', 'e', '\030', '\002', ' ', '\001', '(', '\013', '2', '\027', '.', 'g', 'o', 'o', 'g', 'l', 'e', '.', 'p', 'r', 'o', 't', 'o', 'b', 
-'u', 'f', '.', 'S', 't', 'r', 'u', 'c', 't', 'R', '\005', 'v', 'a', 'l', 'u', 'e', 'B', '2', '\n', '\034', 'c', 'o', 'm', '.', 'g', 
-'i', 't', 'h', 'u', 'b', '.', 'u', 'd', 'p', 'a', '.', 'u', 'd', 'p', 'a', '.', 't', 'y', 'p', 'e', '.', 'v', '1', 'B', '\020', 
-'T', 'y', 'p', 'e', 'd', 'S', 't', 'r', 'u', 'c', 't', 'P', 'r', 'o', 't', 'o', 'P', '\001', 'b', '\006', 'p', 'r', 'o', 't', 'o', 
-'3', 
-};
-
-static upb_def_init *deps[3] = {
-  &validate_validate_proto_upbdefinit,
-  &google_protobuf_struct_proto_upbdefinit,
-  NULL
-};
-
-upb_def_init udpa_type_v1_typed_struct_proto_upbdefinit = {
-  deps,
-  layouts,
-  "udpa/type/v1/typed_struct.proto",
-  UPB_STRVIEW_INIT(descriptor, 251)
-};

data/src/core/ext/upbdefs-generated/udpa/type/v1/typed_struct.upbdefs.h

@@ -1,35 +0,0 @@
-/* This file was generated by upbc (the upb compiler) from the input
- * file:
- *
- *     udpa/type/v1/typed_struct.proto
- *
- * Do not edit -- your changes will be discarded when the file is
- * regenerated. */
-
-#ifndef UDPA_TYPE_V1_TYPED_STRUCT_PROTO_UPBDEFS_H_
-#define UDPA_TYPE_V1_TYPED_STRUCT_PROTO_UPBDEFS_H_
-
-#include "upb/def.h"
-#include "upb/port_def.inc"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "upb/def.h"
-
-#include "upb/port_def.inc"
-
-extern upb_def_init udpa_type_v1_typed_struct_proto_upbdefinit;
-
-UPB_INLINE const upb_msgdef *udpa_type_v1_TypedStruct_getmsgdef(upb_symtab *s) {
-  _upb_symtab_loaddefinit(s, &udpa_type_v1_typed_struct_proto_upbdefinit);
-  return upb_symtab_lookupmsg(s, "udpa.type.v1.TypedStruct");
-}
-
-#ifdef __cplusplus
-}  /* extern "C" */
-#endif
-
-#include "upb/port_undef.inc"
-
-#endif  /* UDPA_TYPE_V1_TYPED_STRUCT_PROTO_UPBDEFS_H_ */

data/src/core/lib/avl/avl.cc

@@ -1,306 +0,0 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/avl/avl.h"
-
-#include <assert.h>
-#include <stdlib.h>
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
-
-#include "src/core/lib/gpr/useful.h"
-
-grpc_avl grpc_avl_create(const grpc_avl_vtable* vtable) {
-  grpc_avl out;
-  out.vtable = vtable;
-  out.root = nullptr;
-  return out;
-}
-
-static grpc_avl_node* ref_node(grpc_avl_node* node) {
-  if (node) {
-    gpr_ref(&node->refs);
-  }
-  return node;
-}
-
-static void unref_node(const grpc_avl_vtable* vtable, grpc_avl_node* node,
-                       void* user_data) {
-  if (node == nullptr) {
-    return;
-  }
-  if (gpr_unref(&node->refs)) {
-    vtable->destroy_key(node->key, user_data);
-    vtable->destroy_value(node->value, user_data);
-    unref_node(vtable, node->left, user_data);
-    unref_node(vtable, node->right, user_data);
-    gpr_free(node);
-  }
-}
-
-static long node_height(grpc_avl_node* node) {
-  return node == nullptr ? 0 : node->height;
-}
-
-#ifndef NDEBUG
-static long calculate_height(grpc_avl_node* node) {
-  return node == nullptr ? 0
-                         : 1 + GPR_MAX(calculate_height(node->left),
-                                       calculate_height(node->right));
-}
-
-static grpc_avl_node* assert_invariants(grpc_avl_node* n) {
-  if (n == nullptr) return nullptr;
-  assert_invariants(n->left);
-  assert_invariants(n->right);
-  assert(calculate_height(n) == n->height);
-  assert(labs(node_height(n->left) - node_height(n->right)) <= 1);
-  return n;
-}
-#else
-static grpc_avl_node* assert_invariants(grpc_avl_node* n) { return n; }
-#endif
-
-grpc_avl_node* new_node(void* key, void* value, grpc_avl_node* left,
-                        grpc_avl_node* right) {
-  grpc_avl_node* node = static_cast<grpc_avl_node*>(gpr_malloc(sizeof(*node)));
-  gpr_ref_init(&node->refs, 1);
-  node->key = key;
-  node->value = value;
-  node->left = assert_invariants(left);
-  node->right = assert_invariants(right);
-  node->height = 1 + GPR_MAX(node_height(left), node_height(right));
-  return node;
-}
-
-static grpc_avl_node* get(const grpc_avl_vtable* vtable, grpc_avl_node* node,
-                          void* key, void* user_data) {
-  long cmp;
-
-  if (node == nullptr) {
-    return nullptr;
-  }
-
-  cmp = vtable->compare_keys(node->key, key, user_data);
-  if (cmp == 0) {
-    return node;
-  } else if (cmp > 0) {
-    return get(vtable, node->left, key, user_data);
-  } else {
-    return get(vtable, node->right, key, user_data);
-  }
-}
-
-void* grpc_avl_get(grpc_avl avl, void* key, void* user_data) {
-  grpc_avl_node* node = get(avl.vtable, avl.root, key, user_data);
-  return node ? node->value : nullptr;
-}
-
-int grpc_avl_maybe_get(grpc_avl avl, void* key, void** value, void* user_data) {
-  grpc_avl_node* node = get(avl.vtable, avl.root, key, user_data);
-  if (node != nullptr) {
-    *value = node->value;
-    return 1;
-  }
-  return 0;
-}
-
-static grpc_avl_node* rotate_left(const grpc_avl_vtable* vtable, void* key,
-                                  void* value, grpc_avl_node* left,
-                                  grpc_avl_node* right, void* user_data) {
-  grpc_avl_node* n = new_node(vtable->copy_key(right->key, user_data),
-                              vtable->copy_value(right->value, user_data),
-                              new_node(key, value, left, ref_node(right->left)),
-                              ref_node(right->right));
-  unref_node(vtable, right, user_data);
-  return n;
-}
-
-static grpc_avl_node* rotate_right(const grpc_avl_vtable* vtable, void* key,
-                                   void* value, grpc_avl_node* left,
-                                   grpc_avl_node* right, void* user_data) {
-  grpc_avl_node* n =
-      new_node(vtable->copy_key(left->key, user_data),
-               vtable->copy_value(left->value, user_data), ref_node(left->left),
-               new_node(key, value, ref_node(left->right), right));
-  unref_node(vtable, left, user_data);
-  return n;
-}
-
-static grpc_avl_node* rotate_left_right(const grpc_avl_vtable* vtable,
-                                        void* key, void* value,
-                                        grpc_avl_node* left,
-                                        grpc_avl_node* right, void* user_data) {
-  /* rotate_right(..., rotate_left(left), right) */
-  grpc_avl_node* n =
-      new_node(vtable->copy_key(left->right->key, user_data),
-               vtable->copy_value(left->right->value, user_data),
-               new_node(vtable->copy_key(left->key, user_data),
-                        vtable->copy_value(left->value, user_data),
-                        ref_node(left->left), ref_node(left->right->left)),
-               new_node(key, value, ref_node(left->right->right), right));
-  unref_node(vtable, left, user_data);
-  return n;
-}
-
-static grpc_avl_node* rotate_right_left(const grpc_avl_vtable* vtable,
-                                        void* key, void* value,
-                                        grpc_avl_node* left,
-                                        grpc_avl_node* right, void* user_data) {
-  /* rotate_left(..., left, rotate_right(right)) */
-  grpc_avl_node* n =
-      new_node(vtable->copy_key(right->left->key, user_data),
-               vtable->copy_value(right->left->value, user_data),
-               new_node(key, value, left, ref_node(right->left->left)),
-               new_node(vtable->copy_key(right->key, user_data),
-                        vtable->copy_value(right->value, user_data),
-                        ref_node(right->left->right), ref_node(right->right)));
-  unref_node(vtable, right, user_data);
-  return n;
-}
-
-static grpc_avl_node* rebalance(const grpc_avl_vtable* vtable, void* key,
-                                void* value, grpc_avl_node* left,
-                                grpc_avl_node* right, void* user_data) {
-  switch (node_height(left) - node_height(right)) {
-    case 2:
-      if (node_height(left->left) - node_height(left->right) == -1) {
-        return assert_invariants(
-            rotate_left_right(vtable, key, value, left, right, user_data));
-      } else {
-        return assert_invariants(
-            rotate_right(vtable, key, value, left, right, user_data));
-      }
-    case -2:
-      if (node_height(right->left) - node_height(right->right) == 1) {
-        return assert_invariants(
-            rotate_right_left(vtable, key, value, left, right, user_data));
-      } else {
-        return assert_invariants(
-            rotate_left(vtable, key, value, left, right, user_data));
-      }
-    default:
-      return assert_invariants(new_node(key, value, left, right));
-  }
-}
-
-static grpc_avl_node* add_key(const grpc_avl_vtable* vtable,
-                              grpc_avl_node* node, void* key, void* value,
-                              void* user_data) {
-  long cmp;
-  if (node == nullptr) {
-    return new_node(key, value, nullptr, nullptr);
-  }
-  cmp = vtable->compare_keys(node->key, key, user_data);
-  if (cmp == 0) {
-    return new_node(key, value, ref_node(node->left), ref_node(node->right));
-  } else if (cmp > 0) {
-    return rebalance(vtable, vtable->copy_key(node->key, user_data),
-                     vtable->copy_value(node->value, user_data),
-                     add_key(vtable, node->left, key, value, user_data),
-                     ref_node(node->right), user_data);
-  } else {
-    return rebalance(
-        vtable, vtable->copy_key(node->key, user_data),
-        vtable->copy_value(node->value, user_data), ref_node(node->left),
-        add_key(vtable, node->right, key, value, user_data), user_data);
-  }
-}
-
-grpc_avl grpc_avl_add(grpc_avl avl, void* key, void* value, void* user_data) {
-  grpc_avl_node* old_root = avl.root;
-  avl.root = add_key(avl.vtable, avl.root, key, value, user_data);
-  assert_invariants(avl.root);
-  unref_node(avl.vtable, old_root, user_data);
-  return avl;
-}
-
-static grpc_avl_node* in_order_head(grpc_avl_node* node) {
-  while (node->left != nullptr) {
-    node = node->left;
-  }
-  return node;
-}
-
-static grpc_avl_node* in_order_tail(grpc_avl_node* node) {
-  while (node->right != nullptr) {
-    node = node->right;
-  }
-  return node;
-}
-
-static grpc_avl_node* remove_key(const grpc_avl_vtable* vtable,
-                                 grpc_avl_node* node, void* key,
-                                 void* user_data) {
-  long cmp;
-  if (node == nullptr) {
-    return nullptr;
-  }
-  cmp = vtable->compare_keys(node->key, key, user_data);
-  if (cmp == 0) {
-    if (node->left == nullptr) {
-      return ref_node(node->right);
-    } else if (node->right == nullptr) {
-      return ref_node(node->left);
-    } else if (node->left->height < node->right->height) {
-      grpc_avl_node* h = in_order_head(node->right);
-      return rebalance(
-          vtable, vtable->copy_key(h->key, user_data),
-          vtable->copy_value(h->value, user_data), ref_node(node->left),
-          remove_key(vtable, node->right, h->key, user_data), user_data);
-    } else {
-      grpc_avl_node* h = in_order_tail(node->left);
-      return rebalance(vtable, vtable->copy_key(h->key, user_data),
-                       vtable->copy_value(h->value, user_data),
-                       remove_key(vtable, node->left, h->key, user_data),
-                       ref_node(node->right), user_data);
-    }
-  } else if (cmp > 0) {
-    return rebalance(vtable, vtable->copy_key(node->key, user_data),
-                     vtable->copy_value(node->value, user_data),
-                     remove_key(vtable, node->left, key, user_data),
-                     ref_node(node->right), user_data);
-  } else {
-    return rebalance(
-        vtable, vtable->copy_key(node->key, user_data),
-        vtable->copy_value(node->value, user_data), ref_node(node->left),
-        remove_key(vtable, node->right, key, user_data), user_data);
-  }
-}
-
-grpc_avl grpc_avl_remove(grpc_avl avl, void* key, void* user_data) {
-  grpc_avl_node* old_root = avl.root;
-  avl.root = remove_key(avl.vtable, avl.root, key, user_data);
-  assert_invariants(avl.root);
-  unref_node(avl.vtable, old_root, user_data);
-  return avl;
-}
-
-grpc_avl grpc_avl_ref(grpc_avl avl, void* /*user_data*/) {
-  ref_node(avl.root);
-  return avl;
-}
-
-void grpc_avl_unref(grpc_avl avl, void* user_data) {
-  unref_node(avl.vtable, avl.root, user_data);
-}
-
-int grpc_avl_is_empty(grpc_avl avl) { return avl.root == nullptr; }

data/src/core/lib/compression/algorithm_metadata.h

@@ -1,62 +0,0 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef GRPC_CORE_LIB_COMPRESSION_ALGORITHM_METADATA_H
-#define GRPC_CORE_LIB_COMPRESSION_ALGORITHM_METADATA_H
-
-#include <grpc/support/port_platform.h>
-
-#include <grpc/compression.h>
-
-#include "src/core/lib/compression/compression_internal.h"
-#include "src/core/lib/transport/metadata.h"
-
-/** Return compression algorithm based metadata value */
-grpc_slice grpc_compression_algorithm_slice(
-    grpc_compression_algorithm algorithm);
-
-/** Find compression algorithm based on passed in mdstr - returns
- *  GRPC_COMPRESS_ALGORITHM_COUNT on failure */
-grpc_compression_algorithm grpc_compression_algorithm_from_slice(
-    const grpc_slice& str);
-
-/** Return compression algorithm based metadata element */
-grpc_mdelem grpc_compression_encoding_mdelem(
-    grpc_compression_algorithm algorithm);
-
-/** Return message compression algorithm based metadata element (grpc-encoding:
- * xxx) */
-grpc_mdelem grpc_message_compression_encoding_mdelem(
-    grpc_message_compression_algorithm algorithm);
-
-/** Return stream compression algorithm based metadata element
- * (content-encoding: xxx) */
-grpc_mdelem grpc_stream_compression_encoding_mdelem(
-    grpc_stream_compression_algorithm algorithm);
-
-/** Find compression algorithm based on passed in mdstr - returns
- * GRPC_COMPRESS_ALGORITHM_COUNT on failure */
-grpc_message_compression_algorithm
-grpc_message_compression_algorithm_from_slice(const grpc_slice& str);
-
-/** Find stream compression algorithm based on passed in mdstr - returns
- * GRPC_STREAM_COMPRESS_ALGORITHM_COUNT on failure */
-grpc_stream_compression_algorithm grpc_stream_compression_algorithm_from_slice(
-    const grpc_slice& str);
-
-#endif /* GRPC_CORE_LIB_COMPRESSION_ALGORITHM_METADATA_H */

data/src/core/lib/compression/compression_args.cc

@@ -1,136 +0,0 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/compression/compression_args.h"
-
-#include <limits.h>
-#include <string.h>
-
-#include <grpc/compression.h>
-#include <grpc/grpc.h>
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-
-#include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gpr/useful.h"
-
-grpc_compression_algorithm
-grpc_channel_args_get_channel_default_compression_algorithm(
-    const grpc_channel_args* a) {
-  size_t i;
-  if (a == nullptr) return GRPC_COMPRESS_NONE;
-  for (i = 0; i < a->num_args; ++i) {
-    if (a->args[i].type == GRPC_ARG_INTEGER &&
-        !strcmp(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM, a->args[i].key)) {
-      grpc_compression_algorithm default_algorithm =
-          static_cast<grpc_compression_algorithm>(a->args[i].value.integer);
-      return default_algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT
-                 ? default_algorithm
-                 : GRPC_COMPRESS_NONE;
-    }
-  }
-  return GRPC_COMPRESS_NONE;
-}
-
-grpc_channel_args* grpc_channel_args_set_channel_default_compression_algorithm(
-    grpc_channel_args* a, grpc_compression_algorithm algorithm) {
-  GPR_ASSERT(algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT);
-  grpc_arg tmp;
-  tmp.type = GRPC_ARG_INTEGER;
-  tmp.key = const_cast<char*>(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM);
-  tmp.value.integer = algorithm;
-  return grpc_channel_args_copy_and_add(a, &tmp, 1);
-}
-
-/** Returns 1 if the argument for compression algorithm's enabled states bitset
- * was found in \a a, returning the arg's value in \a states. Otherwise, returns
- * 0. */
-static int find_compression_algorithm_states_bitset(const grpc_channel_args* a,
-                                                    int** states_arg) {
-  if (a != nullptr) {
-    size_t i;
-    for (i = 0; i < a->num_args; ++i) {
-      if (a->args[i].type == GRPC_ARG_INTEGER &&
-          !strcmp(GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET,
-                  a->args[i].key)) {
-        *states_arg = &a->args[i].value.integer;
-        **states_arg =
-            (**states_arg & ((1 << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1)) |
-            0x1; /* forcefully enable support for no compression */
-        return 1;
-      }
-    }
-  }
-  return 0; /* GPR_FALSE */
-}
-
-grpc_channel_args* grpc_channel_args_compression_algorithm_set_state(
-    grpc_channel_args** a, grpc_compression_algorithm algorithm, int state) {
-  int* states_arg = nullptr;
-  grpc_channel_args* result = *a;
-  const int states_arg_found =
-      find_compression_algorithm_states_bitset(*a, &states_arg);
-
-  if (grpc_channel_args_get_channel_default_compression_algorithm(*a) ==
-          algorithm &&
-      state == 0) {
-    const char* algo_name = nullptr;
-    GPR_ASSERT(grpc_compression_algorithm_name(algorithm, &algo_name) != 0);
-    gpr_log(GPR_ERROR,
-            "Tried to disable default compression algorithm '%s'. The "
-            "operation has been ignored.",
-            algo_name);
-  } else if (states_arg_found) {
-    if (state != 0) {
-      GPR_BITSET((unsigned*)states_arg, algorithm);
-    } else if (algorithm != GRPC_COMPRESS_NONE) {
-      GPR_BITCLEAR((unsigned*)states_arg, algorithm);
-    }
-  } else {
-    /* create a new arg */
-    grpc_arg tmp;
-    tmp.type = GRPC_ARG_INTEGER;
-    tmp.key =
-        const_cast<char*>(GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET);
-    /* all enabled by default */
-    tmp.value.integer = (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1;
-    if (state != 0) {
-      GPR_BITSET((unsigned*)&tmp.value.integer, algorithm);
-    } else if (algorithm != GRPC_COMPRESS_NONE) {
-      GPR_BITCLEAR((unsigned*)&tmp.value.integer, algorithm);
-    }
-    result = grpc_channel_args_copy_and_add(*a, &tmp, 1);
-    grpc_channel_args_destroy(*a);
-    *a = result;
-  }
-  return result;
-}
-
-uint32_t grpc_channel_args_compression_algorithm_get_states(
-    const grpc_channel_args* a) {
-  int* states_arg;
-  if (find_compression_algorithm_states_bitset(a, &states_arg)) {
-    return static_cast<uint32_t>(*states_arg);
-  } else {
-    return (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1; /* All algs. enabled */
-  }
-}