grpc 1.41.1 → 1.44.0.pre2

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

@@ -1,56 +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_COMPRESSION_ARGS_H
-#define GRPC_CORE_LIB_COMPRESSION_COMPRESSION_ARGS_H
-
-#include <grpc/support/port_platform.h>
-
-#include <grpc/compression.h>
-#include <grpc/impl/codegen/grpc_types.h>
-
-/** Returns the compression algorithm set in \a a. */
-grpc_compression_algorithm
-grpc_channel_args_get_channel_default_compression_algorithm(
-    const grpc_channel_args* a);
-
-/** Returns a channel arg instance with compression enabled. If \a a is
- * non-NULL, its args are copied. N.B. GRPC_COMPRESS_NONE disables compression
- * for the channel. */
-grpc_channel_args* grpc_channel_args_set_channel_default_compression_algorithm(
-    grpc_channel_args* a, grpc_compression_algorithm algorithm);
-
-/** Sets the support for the given compression algorithm. By default, all
- * compression algorithms are enabled. It's an error to disable an algorithm set
- * by grpc_channel_args_set_compression_algorithm.
- *
- * Returns an instance with the updated algorithm states. The \a a pointer is
- * modified to point to the returned instance (which may be different from the
- * input value of \a a). */
-grpc_channel_args* grpc_channel_args_compression_algorithm_set_state(
-    grpc_channel_args** a, grpc_compression_algorithm algorithm, int state);
-
-/** Returns the bitset representing the support state (true for enabled, false
- * for disabled) for compression algorithms.
- *
- * The i-th bit of the returned bitset corresponds to the i-th entry in the
- * grpc_compression_algorithm enum. */
-uint32_t grpc_channel_args_compression_algorithm_get_states(
-    const grpc_channel_args* a);
-
-#endif /* GRPC_CORE_LIB_COMPRESSION_COMPRESSION_ARGS_H */

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

@@ -1,81 +0,0 @@
-/*
- *
- * Copyright 2017 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/stream_compression.h"
-
-#include <grpc/support/log.h>
-
-#include "src/core/lib/compression/stream_compression_gzip.h"
-#include "src/core/lib/slice/slice_utils.h"
-
-extern const grpc_stream_compression_vtable
-    grpc_stream_compression_identity_vtable;
-
-bool grpc_stream_compress(grpc_stream_compression_context* ctx,
-                          grpc_slice_buffer* in, grpc_slice_buffer* out,
-                          size_t* output_size, size_t max_output_size,
-                          grpc_stream_compression_flush flush) {
-  return ctx->vtable->compress(ctx, in, out, output_size, max_output_size,
-                               flush);
-}
-
-bool grpc_stream_decompress(grpc_stream_compression_context* ctx,
-                            grpc_slice_buffer* in, grpc_slice_buffer* out,
-                            size_t* output_size, size_t max_output_size,
-                            bool* end_of_context) {
-  return ctx->vtable->decompress(ctx, in, out, output_size, max_output_size,
-                                 end_of_context);
-}
-
-grpc_stream_compression_context* grpc_stream_compression_context_create(
-    grpc_stream_compression_method method) {
-  switch (method) {
-    case GRPC_STREAM_COMPRESSION_IDENTITY_COMPRESS:
-    case GRPC_STREAM_COMPRESSION_IDENTITY_DECOMPRESS:
-      return grpc_stream_compression_identity_vtable.context_create(method);
-    case GRPC_STREAM_COMPRESSION_GZIP_COMPRESS:
-    case GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS:
-      return grpc_stream_compression_gzip_vtable.context_create(method);
-    default:
-      gpr_log(GPR_ERROR, "Unknown stream compression method: %d", method);
-      return nullptr;
-  }
-}
-
-void grpc_stream_compression_context_destroy(
-    grpc_stream_compression_context* ctx) {
-  ctx->vtable->context_destroy(ctx);
-}
-
-int grpc_stream_compression_method_parse(
-    grpc_slice value, bool is_compress,
-    grpc_stream_compression_method* method) {
-  if (grpc_slice_eq_static_interned(value, GRPC_MDSTR_IDENTITY)) {
-    *method = is_compress ? GRPC_STREAM_COMPRESSION_IDENTITY_COMPRESS
-                          : GRPC_STREAM_COMPRESSION_IDENTITY_DECOMPRESS;
-    return 1;
-  } else if (grpc_slice_eq_static_interned(value, GRPC_MDSTR_GZIP)) {
-    *method = is_compress ? GRPC_STREAM_COMPRESSION_GZIP_COMPRESS
-                          : GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS;
-    return 1;
-  } else {
-    return 0;
-  }
-}

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

@@ -1,117 +0,0 @@
-/*
- *
- * Copyright 2017 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_STREAM_COMPRESSION_H
-#define GRPC_CORE_LIB_COMPRESSION_STREAM_COMPRESSION_H
-
-#include <grpc/support/port_platform.h>
-
-#include <stdbool.h>
-
-#include <zlib.h>
-
-#include <grpc/slice_buffer.h>
-
-#include "src/core/lib/transport/static_metadata.h"
-
-typedef struct grpc_stream_compression_vtable grpc_stream_compression_vtable;
-
-/* Stream compression/decompression context */
-typedef struct grpc_stream_compression_context {
-  const grpc_stream_compression_vtable* vtable;
-} grpc_stream_compression_context;
-
-typedef enum grpc_stream_compression_method {
-  GRPC_STREAM_COMPRESSION_IDENTITY_COMPRESS = 0,
-  GRPC_STREAM_COMPRESSION_IDENTITY_DECOMPRESS,
-  GRPC_STREAM_COMPRESSION_GZIP_COMPRESS,
-  GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS,
-  GRPC_STREAM_COMPRESSION_METHOD_COUNT
-} grpc_stream_compression_method;
-
-typedef enum grpc_stream_compression_flush {
-  GRPC_STREAM_COMPRESSION_FLUSH_NONE = 0,
-  GRPC_STREAM_COMPRESSION_FLUSH_SYNC,
-  GRPC_STREAM_COMPRESSION_FLUSH_FINISH,
-  GRPC_STREAM_COMPRESSION_FLUSH_COUNT
-} grpc_stream_compression_flush;
-
-struct grpc_stream_compression_vtable {
-  bool (*compress)(grpc_stream_compression_context* ctx, grpc_slice_buffer* in,
-                   grpc_slice_buffer* out, size_t* output_size,
-                   size_t max_output_size, grpc_stream_compression_flush flush);
-  bool (*decompress)(grpc_stream_compression_context* ctx,
-                     grpc_slice_buffer* in, grpc_slice_buffer* out,
-                     size_t* output_size, size_t max_output_size,
-                     bool* end_of_context);
-  grpc_stream_compression_context* (*context_create)(
-      grpc_stream_compression_method method);
-  void (*context_destroy)(grpc_stream_compression_context* ctx);
-};
-
-/**
- * Compress bytes provided in \a in with a given context, with an optional flush
- * at the end of compression. Emits at most \a max_output_size compressed bytes
- * into \a out. If all the bytes in input buffer \a in are depleted and \a flush
- * is not GRPC_STREAM_COMPRESSION_FLUSH_NONE, the corresponding flush method is
- * executed. The total number of bytes emitted is outputted in \a output_size.
- *
- * A SYNC flush indicates that the entire messages in \a in can be decompressed
- * from \a out. A FINISH flush implies a SYNC flush, and that any further
- * compression will not be dependent on the state of the current context and any
- * previous compressed bytes. It allows corresponding decompression context to
- * be dropped when reaching this boundary.
- */
-bool grpc_stream_compress(grpc_stream_compression_context* ctx,
-                          grpc_slice_buffer* in, grpc_slice_buffer* out,
-                          size_t* output_size, size_t max_output_size,
-                          grpc_stream_compression_flush flush);
-
-/**
- * Decompress bytes provided in \a in with a given context. Emits at most \a
- * max_output_size decompressed bytes into \a out. If decompression process
- * reached the end of a gzip stream, \a end_of_context is set to true; otherwise
- * it is set to false. The total number of bytes emitted is outputted in \a
- * output_size.
- */
-bool grpc_stream_decompress(grpc_stream_compression_context* ctx,
-                            grpc_slice_buffer* in, grpc_slice_buffer* out,
-                            size_t* output_size, size_t max_output_size,
-                            bool* end_of_context);
-
-/**
- * Creates a stream compression context. \a pending_bytes_buffer is the input
- * buffer for compression/decompression operations. \a method specifies whether
- * the context is for compression or decompression.
- */
-grpc_stream_compression_context* grpc_stream_compression_context_create(
-    grpc_stream_compression_method method);
-
-/**
- * Destroys a stream compression context.
- */
-void grpc_stream_compression_context_destroy(
-    grpc_stream_compression_context* ctx);
-
-/**
- * Parse stream compression method based on algorithm name
- */
-int grpc_stream_compression_method_parse(
-    grpc_slice value, bool is_compress, grpc_stream_compression_method* method);
-
-#endif  // GRPC_CORE_LIB_COMPRESSION_STREAM_COMPRESSION_H

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

@@ -1,231 +0,0 @@
-/*
- *
- * Copyright 2017 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/stream_compression_gzip.h"
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-
-#include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/slice/slice_internal.h"
-
-#define OUTPUT_BLOCK_SIZE (1024)
-
-typedef struct grpc_stream_compression_context_gzip {
-  grpc_stream_compression_context base;
-
-  z_stream zs;
-  int (*flate)(z_stream* zs, int flush);
-} grpc_stream_compression_context_gzip;
-
-static bool gzip_flate(grpc_stream_compression_context_gzip* ctx,
-                       grpc_slice_buffer* in, grpc_slice_buffer* out,
-                       size_t* output_size, size_t max_output_size, int flush,
-                       bool* end_of_context) {
-  GPR_ASSERT(flush == 0 || flush == Z_SYNC_FLUSH || flush == Z_FINISH);
-  /* Full flush is not allowed when inflating. */
-  GPR_ASSERT(!(ctx->flate == inflate && (flush == Z_FINISH)));
-
-  grpc_core::ExecCtx exec_ctx;
-  int r;
-  bool eoc = false;
-  size_t original_max_output_size = max_output_size;
-  while (max_output_size > 0 && (in->length > 0 || flush) && !eoc) {
-    size_t slice_size = max_output_size < OUTPUT_BLOCK_SIZE ? max_output_size
-                                                            : OUTPUT_BLOCK_SIZE;
-    grpc_slice slice_out = GRPC_SLICE_MALLOC(slice_size);
-    ctx->zs.avail_out = static_cast<uInt>(slice_size);
-    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_peek_first(in);
-      ctx->zs.avail_in = static_cast<uInt> 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) {
-        gpr_log(GPR_ERROR, "zlib error (%d)", r);
-        grpc_slice_unref_internal(slice_out);
-        grpc_slice_buffer_remove_first(in);
-        return false;
-      } else if (r == Z_STREAM_END && ctx->flate == inflate) {
-        eoc = true;
-      }
-      if (ctx->zs.avail_in > 0) {
-        grpc_slice_buffer_sub_first(
-            in, GRPC_SLICE_LENGTH(*slice) - ctx->zs.avail_in,
-            GRPC_SLICE_LENGTH(*slice));
-      } else {
-        grpc_slice_buffer_remove_first(in);
-      }
-    }
-    if (flush != 0 && ctx->zs.avail_out > 0 && !eoc) {
-      GPR_ASSERT(in->length == 0);
-      r = ctx->flate(&ctx->zs, flush);
-      if (flush == Z_SYNC_FLUSH) {
-        switch (r) {
-          case Z_OK:
-            /* Maybe flush is not complete; just made some partial progress. */
-            if (ctx->zs.avail_out > 0) {
-              flush = 0;
-            }
-            break;
-          case Z_BUF_ERROR:
-          case Z_STREAM_END:
-            flush = 0;
-            break;
-          default:
-            gpr_log(GPR_ERROR, "zlib error (%d)", r);
-            grpc_slice_unref_internal(slice_out);
-
-            return false;
-        }
-      } else if (flush == Z_FINISH) {
-        switch (r) {
-          case Z_OK:
-          case Z_BUF_ERROR:
-            /* Wait for the next loop to assign additional output space. */
-            GPR_ASSERT(ctx->zs.avail_out == 0);
-            break;
-          case Z_STREAM_END:
-            flush = 0;
-            break;
-          default:
-            gpr_log(GPR_ERROR, "zlib error (%d)", r);
-            grpc_slice_unref_internal(slice_out);
-
-            return false;
-        }
-      }
-    }
-
-    if (ctx->zs.avail_out == 0) {
-      grpc_slice_buffer_add(out, slice_out);
-    } else if (ctx->zs.avail_out < slice_size) {
-      size_t len = GRPC_SLICE_LENGTH(slice_out);
-      GRPC_SLICE_SET_LENGTH(slice_out, len - ctx->zs.avail_out);
-      grpc_slice_buffer_add(out, slice_out);
-    } else {
-      grpc_slice_unref_internal(slice_out);
-    }
-    max_output_size -= (slice_size - ctx->zs.avail_out);
-  }
-
-  if (end_of_context) {
-    *end_of_context = eoc;
-  }
-  if (output_size) {
-    *output_size = original_max_output_size - max_output_size;
-  }
-  return true;
-}
-
-static bool grpc_stream_compress_gzip(grpc_stream_compression_context* ctx,
-                                      grpc_slice_buffer* in,
-                                      grpc_slice_buffer* out,
-                                      size_t* output_size,
-                                      size_t max_output_size,
-                                      grpc_stream_compression_flush flush) {
-  if (ctx == nullptr) {
-    return false;
-  }
-  grpc_stream_compression_context_gzip* gzip_ctx =
-      reinterpret_cast<grpc_stream_compression_context_gzip*>(ctx);
-  GPR_ASSERT(gzip_ctx->flate == deflate);
-  int gzip_flush;
-  switch (flush) {
-    case GRPC_STREAM_COMPRESSION_FLUSH_NONE:
-      gzip_flush = 0;
-      break;
-    case GRPC_STREAM_COMPRESSION_FLUSH_SYNC:
-      gzip_flush = Z_SYNC_FLUSH;
-      break;
-    case GRPC_STREAM_COMPRESSION_FLUSH_FINISH:
-      gzip_flush = Z_FINISH;
-      break;
-    default:
-      gzip_flush = 0;
-  }
-  return gzip_flate(gzip_ctx, in, out, output_size, max_output_size, gzip_flush,
-                    nullptr);
-}
-
-static bool grpc_stream_decompress_gzip(grpc_stream_compression_context* ctx,
-                                        grpc_slice_buffer* in,
-                                        grpc_slice_buffer* out,
-                                        size_t* output_size,
-                                        size_t max_output_size,
-                                        bool* end_of_context) {
-  if (ctx == nullptr) {
-    return false;
-  }
-  grpc_stream_compression_context_gzip* gzip_ctx =
-      reinterpret_cast<grpc_stream_compression_context_gzip*>(ctx);
-  GPR_ASSERT(gzip_ctx->flate == inflate);
-  return gzip_flate(gzip_ctx, in, out, output_size, max_output_size,
-                    Z_SYNC_FLUSH, end_of_context);
-}
-
-static grpc_stream_compression_context*
-grpc_stream_compression_context_create_gzip(
-    grpc_stream_compression_method method) {
-  GPR_ASSERT(method == GRPC_STREAM_COMPRESSION_GZIP_COMPRESS ||
-             method == GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS);
-  grpc_stream_compression_context_gzip* gzip_ctx =
-      static_cast<grpc_stream_compression_context_gzip*>(
-          gpr_zalloc(sizeof(grpc_stream_compression_context_gzip)));
-  int r;
-  if (gzip_ctx == nullptr) {
-    return nullptr;
-  }
-  if (method == GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS) {
-    r = inflateInit2(&gzip_ctx->zs, 0x1F);
-    gzip_ctx->flate = inflate;
-  } else {
-    r = deflateInit2(&gzip_ctx->zs, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 0x1F, 8,
-                     Z_DEFAULT_STRATEGY);
-    gzip_ctx->flate = deflate;
-  }
-  if (r != Z_OK) {
-    gpr_free(gzip_ctx);
-    return nullptr;
-  }
-
-  gzip_ctx->base.vtable = &grpc_stream_compression_gzip_vtable;
-  return reinterpret_cast<grpc_stream_compression_context*>(gzip_ctx);
-}
-
-static void grpc_stream_compression_context_destroy_gzip(
-    grpc_stream_compression_context* ctx) {
-  if (ctx == nullptr) {
-    return;
-  }
-  grpc_stream_compression_context_gzip* gzip_ctx =
-      reinterpret_cast<grpc_stream_compression_context_gzip*>(ctx);
-  if (gzip_ctx->flate == inflate) {
-    inflateEnd(&gzip_ctx->zs);
-  } else {
-    deflateEnd(&gzip_ctx->zs);
-  }
-  gpr_free(ctx);
-}
-
-const grpc_stream_compression_vtable grpc_stream_compression_gzip_vtable = {
-    grpc_stream_compress_gzip, grpc_stream_decompress_gzip,
-    grpc_stream_compression_context_create_gzip,
-    grpc_stream_compression_context_destroy_gzip};

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

@@ -1,91 +0,0 @@
-/*
- *
- * Copyright 2017 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/stream_compression_identity.h"
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-
-#include "src/core/lib/slice/slice_internal.h"
-
-#define OUTPUT_BLOCK_SIZE (1024)
-
-/* Singleton context used for all identity streams. */
-static grpc_stream_compression_context identity_ctx = {
-    &grpc_stream_compression_identity_vtable};
-
-static void grpc_stream_compression_pass_through(grpc_slice_buffer* in,
-                                                 grpc_slice_buffer* out,
-                                                 size_t* output_size,
-                                                 size_t max_output_size) {
-  if (max_output_size >= in->length) {
-    if (output_size) {
-      *output_size = in->length;
-    }
-    grpc_slice_buffer_move_into(in, out);
-  } else {
-    if (output_size) {
-      *output_size = max_output_size;
-    }
-    grpc_slice_buffer_move_first(in, max_output_size, out);
-  }
-}
-
-static bool grpc_stream_compress_identity(
-    grpc_stream_compression_context* ctx, grpc_slice_buffer* in,
-    grpc_slice_buffer* out, size_t* output_size, size_t max_output_size,
-    grpc_stream_compression_flush /*flush*/) {
-  if (ctx == nullptr) {
-    return false;
-  }
-  grpc_stream_compression_pass_through(in, out, output_size, max_output_size);
-  return true;
-}
-
-static bool grpc_stream_decompress_identity(
-    grpc_stream_compression_context* ctx, grpc_slice_buffer* in,
-    grpc_slice_buffer* out, size_t* output_size, size_t max_output_size,
-    bool* end_of_context) {
-  if (ctx == nullptr) {
-    return false;
-  }
-  grpc_stream_compression_pass_through(in, out, output_size, max_output_size);
-  if (end_of_context) {
-    *end_of_context = false;
-  }
-  return true;
-}
-
-static grpc_stream_compression_context*
-grpc_stream_compression_context_create_identity(
-    grpc_stream_compression_method method) {
-  GPR_ASSERT(method == GRPC_STREAM_COMPRESSION_IDENTITY_COMPRESS ||
-             method == GRPC_STREAM_COMPRESSION_IDENTITY_DECOMPRESS);
-  /* No context needed in this case. Use fake context instead. */
-  return &identity_ctx;
-}
-
-static void grpc_stream_compression_context_destroy_identity(
-    grpc_stream_compression_context* /*ctx*/) {}
-
-const grpc_stream_compression_vtable grpc_stream_compression_identity_vtable = {
-    grpc_stream_compress_identity, grpc_stream_decompress_identity,
-    grpc_stream_compression_context_create_identity,
-    grpc_stream_compression_context_destroy_identity};

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

@@ -1,29 +0,0 @@
-/*
- *
- * Copyright 2017 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_STREAM_COMPRESSION_IDENTITY_H
-#define GRPC_CORE_LIB_COMPRESSION_STREAM_COMPRESSION_IDENTITY_H
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/compression/stream_compression.h"
-
-extern const grpc_stream_compression_vtable
-    grpc_stream_compression_identity_vtable;
-
-#endif  // GRPC_CORE_LIB_COMPRESSION_STREAM_COMPRESSION_IDENTITY_H

data/src/core/lib/gprpp/match.h

@@ -1,73 +0,0 @@
-// Copyright 2021 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_GPRPP_MATCH_H
-#define GRPC_CORE_LIB_GPRPP_MATCH_H
-
-#include <grpc/impl/codegen/port_platform.h>
-
-#include "absl/types/variant.h"
-
-#include "src/core/lib/gprpp/overload.h"
-
-namespace grpc_core {
-
-namespace detail {
-
-template <typename... Cases>
-struct MatchPointerExtractor {
-  OverloadType<Cases...> cases;
-  template <typename T>
-  auto operator()(T& value) -> decltype(cases(&value)) {
-    return cases(&value);
-  }
-};
-
-}  // namespace detail
-
-/// Match on a variant.
-/// Given variant \a value, and a set of callables \a fs, call the appropriate
-/// callable based on the type contained in \a value.
-///
-/// Example (prints "hoorah"):
-///   variant<int, string> v = 42;
-///   Match(v,
-///         [](int i) { puts("hoorah"); },
-///         [](string s) { puts("boo"); });
-template <typename... Fs, typename T0, typename... Ts>
-auto Match(const absl::variant<T0, Ts...>& value, Fs... fs)
-    -> decltype(std::declval<OverloadType<Fs...>>()(std::declval<T0>())) {
-  return absl::visit(Overload(std::move(fs)...), value);
-}
-
-/// A version of Match that takes a mutable pointer to a variant and calls its
-/// overload callables with a mutable pointer to the current variant value.
-///
-/// Example:
-///   variant<int, string> v = 42;
-///   MatchMutable(&v,
-///                [](int* i) { *i = 1; },
-///                [](string* s) { *s = "foo"; });
-///   // v now contains 1.
-template <typename... Fs, typename T0, typename... Ts>
-auto MatchMutable(absl::variant<T0, Ts...>* value, Fs... fs)
-    -> decltype(std::declval<OverloadType<Fs...>>()(std::declval<T0*>())) {
-  return absl::visit(detail::MatchPointerExtractor<Fs...>{OverloadType<Fs...>(
-                         std::move(fs)...)},
-                     *value);
-}
-
-}  // namespace grpc_core
-
-#endif  // GRPC_CORE_LIB_GPRPP_MATCH_H