grpc 1.18.0 → 1.22.0

data/src/core/lib/channel/handshaker.h

@@ -21,12 +21,21 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <grpc/support/string_util.h>
+
 #include <grpc/impl/codegen/grpc_types.h>
 
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gprpp/inlined_vector.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/tcp_server.h"
+#include "src/core/lib/iomgr/timer.h"
+
+namespace grpc_core {
 
 /// Handshakers are used to perform initial handshakes on a connection
 /// before the client sends the initial request.  Some examples of what
@@ -35,12 +44,6 @@
 ///
 /// In general, handshakers should be used via a handshake manager.
 
-///
-/// grpc_handshaker
-///
-
-typedef struct grpc_handshaker grpc_handshaker;
-
 /// Arguments passed through handshakers and to the on_handshake_done callback.
 ///
 /// For handshakers, all members are input/output parameters; for
@@ -55,115 +58,121 @@ typedef struct grpc_handshaker grpc_handshaker;
 ///
 /// For the on_handshake_done callback, all members are input arguments,
 /// which the callback takes ownership of.
-typedef struct {
-  grpc_endpoint* endpoint;
-  grpc_channel_args* args;
-  grpc_slice_buffer* read_buffer;
+struct HandshakerArgs {
+  grpc_endpoint* endpoint = nullptr;
+  grpc_channel_args* args = nullptr;
+  grpc_slice_buffer* read_buffer = nullptr;
   // A handshaker may set this to true before invoking on_handshake_done
   // to indicate that subsequent handshakers should be skipped.
-  bool exit_early;
+  bool exit_early = false;
   // User data passed through the handshake manager.  Not used by
   // individual handshakers.
-  void* user_data;
-} grpc_handshaker_args;
+  void* user_data = nullptr;
+};
 
-typedef struct {
-  /// Destroys the handshaker.
-  void (*destroy)(grpc_handshaker* handshaker);
+///
+/// Handshaker
+///
 
-  /// Shuts down the handshaker (e.g., to clean up when the operation is
-  /// aborted in the middle).
-  void (*shutdown)(grpc_handshaker* handshaker, grpc_error* why);
-
-  /// Performs handshaking, modifying \a args as needed (e.g., to
-  /// replace \a endpoint with a wrapped endpoint).
-  /// When finished, invokes \a on_handshake_done.
-  /// \a acceptor will be NULL for client-side handshakers.
-  void (*do_handshake)(grpc_handshaker* handshaker,
-                       grpc_tcp_server_acceptor* acceptor,
-                       grpc_closure* on_handshake_done,
-                       grpc_handshaker_args* args);
-
-  /// The name of the handshaker, for debugging purposes.
-  const char* name;
-} grpc_handshaker_vtable;
-
-/// Base struct.  To subclass, make this the first member of the
-/// implementation struct.
-struct grpc_handshaker {
-  const grpc_handshaker_vtable* vtable;
+class Handshaker : public RefCounted<Handshaker> {
+ public:
+  virtual ~Handshaker() = default;
+  virtual void Shutdown(grpc_error* why) GRPC_ABSTRACT;
+  virtual void DoHandshake(grpc_tcp_server_acceptor* acceptor,
+                           grpc_closure* on_handshake_done,
+                           HandshakerArgs* args) GRPC_ABSTRACT;
+  virtual const char* name() const GRPC_ABSTRACT;
+  GRPC_ABSTRACT_BASE_CLASS
 };
 
-/// Called by concrete implementations to initialize the base struct.
-void grpc_handshaker_init(const grpc_handshaker_vtable* vtable,
-                          grpc_handshaker* handshaker);
+//
+// HandshakeManager
+//
 
-void grpc_handshaker_destroy(grpc_handshaker* handshaker);
-void grpc_handshaker_shutdown(grpc_handshaker* handshaker, grpc_error* why);
-void grpc_handshaker_do_handshake(grpc_handshaker* handshaker,
-                                  grpc_tcp_server_acceptor* acceptor,
-                                  grpc_closure* on_handshake_done,
-                                  grpc_handshaker_args* args);
-const char* grpc_handshaker_name(grpc_handshaker* handshaker);
+class HandshakeManager : public RefCounted<HandshakeManager> {
+ public:
+  HandshakeManager();
+  ~HandshakeManager();
 
-///
-/// grpc_handshake_manager
-///
+  /// Add \a mgr to the server side list of all pending handshake managers, the
+  /// list starts with \a *head.
+  // Not thread-safe. Caller needs to synchronize.
+  void AddToPendingMgrList(HandshakeManager** head);
+
+  /// Remove \a mgr from the server side list of all pending handshake managers.
+  // Not thread-safe. Caller needs to synchronize.
+  void RemoveFromPendingMgrList(HandshakeManager** head);
 
-typedef struct grpc_handshake_manager grpc_handshake_manager;
+  /// Shutdown all pending handshake managers starting at head on the server
+  /// side. Not thread-safe. Caller needs to synchronize.
+  void ShutdownAllPending(grpc_error* why);
 
-/// Creates a new handshake manager.  Caller takes ownership.
-grpc_handshake_manager* grpc_handshake_manager_create();
+  /// Adds a handshaker to the handshake manager.
+  /// Takes ownership of \a handshaker.
+  void Add(RefCountedPtr<Handshaker> handshaker);
 
-/// Adds a handshaker to the handshake manager.
-/// Takes ownership of \a handshaker.
+  /// Shuts down the handshake manager (e.g., to clean up when the operation is
+  /// aborted in the middle).
+  void Shutdown(grpc_error* why);
+
+  /// Invokes handshakers in the order they were added.
+  /// Takes ownership of \a endpoint, and then passes that ownership to
+  /// the \a on_handshake_done callback.
+  /// Does NOT take ownership of \a channel_args.  Instead, makes a copy before
+  /// invoking the first handshaker.
+  /// \a acceptor will be nullptr for client-side handshakers.
+  ///
+  /// When done, invokes \a on_handshake_done with a HandshakerArgs
+  /// object as its argument.  If the callback is invoked with error !=
+  /// GRPC_ERROR_NONE, then handshaking failed and the handshaker has done
+  /// the necessary clean-up.  Otherwise, the callback takes ownership of
+  /// the arguments.
+  void DoHandshake(grpc_endpoint* endpoint,
+                   const grpc_channel_args* channel_args, grpc_millis deadline,
+                   grpc_tcp_server_acceptor* acceptor,
+                   grpc_iomgr_cb_func on_handshake_done, void* user_data);
+
+ private:
+  bool CallNextHandshakerLocked(grpc_error* error);
+
+  // A function used as the handshaker-done callback when chaining
+  // handshakers together.
+  static void CallNextHandshakerFn(void* arg, grpc_error* error);
+
+  // Callback invoked when deadline is exceeded.
+  static void OnTimeoutFn(void* arg, grpc_error* error);
+
+  static const size_t HANDSHAKERS_INIT_SIZE = 2;
+
+  gpr_mu mu_;
+  bool is_shutdown_ = false;
+  // An array of handshakers added via grpc_handshake_manager_add().
+  InlinedVector<RefCountedPtr<Handshaker>, HANDSHAKERS_INIT_SIZE> handshakers_;
+  // The index of the handshaker to invoke next and closure to invoke it.
+  size_t index_ = 0;
+  grpc_closure call_next_handshaker_;
+  // The acceptor to call the handshakers with.
+  grpc_tcp_server_acceptor* acceptor_;
+  // Deadline timer across all handshakers.
+  grpc_timer deadline_timer_;
+  grpc_closure on_timeout_;
+  // The final callback and user_data to invoke after the last handshaker.
+  grpc_closure on_handshake_done_;
+  // Handshaker args.
+  HandshakerArgs args_;
+  // Links to the previous and next managers in a list of all pending handshakes
+  // Used at server side only.
+  HandshakeManager* prev_ = nullptr;
+  HandshakeManager* next_ = nullptr;
+};
+
+}  // namespace grpc_core
+
+// TODO(arjunroy): These are transitional to account for the new handshaker API
+// and will eventually be removed entirely.
+typedef grpc_core::HandshakeManager grpc_handshake_manager;
+typedef grpc_core::Handshaker grpc_handshaker;
 void grpc_handshake_manager_add(grpc_handshake_manager* mgr,
                                 grpc_handshaker* handshaker);
 
-/// Destroys the handshake manager.
-void grpc_handshake_manager_destroy(grpc_handshake_manager* mgr);
-
-/// Shuts down the handshake manager (e.g., to clean up when the operation is
-/// aborted in the middle).
-/// The caller must still call grpc_handshake_manager_destroy() after
-/// calling this function.
-void grpc_handshake_manager_shutdown(grpc_handshake_manager* mgr,
-                                     grpc_error* why);
-
-/// Invokes handshakers in the order they were added.
-/// Takes ownership of \a endpoint, and then passes that ownership to
-/// the \a on_handshake_done callback.
-/// Does NOT take ownership of \a channel_args.  Instead, makes a copy before
-/// invoking the first handshaker.
-/// \a acceptor will be nullptr for client-side handshakers.
-///
-/// When done, invokes \a on_handshake_done with a grpc_handshaker_args
-/// object as its argument.  If the callback is invoked with error !=
-/// GRPC_ERROR_NONE, then handshaking failed and the handshaker has done
-/// the necessary clean-up.  Otherwise, the callback takes ownership of
-/// the arguments.
-void grpc_handshake_manager_do_handshake(grpc_handshake_manager* mgr,
-                                         grpc_endpoint* endpoint,
-                                         const grpc_channel_args* channel_args,
-                                         grpc_millis deadline,
-                                         grpc_tcp_server_acceptor* acceptor,
-                                         grpc_iomgr_cb_func on_handshake_done,
-                                         void* user_data);
-
-/// Add \a mgr to the server side list of all pending handshake managers, the
-/// list starts with \a *head.
-// Not thread-safe. Caller needs to synchronize.
-void grpc_handshake_manager_pending_list_add(grpc_handshake_manager** head,
-                                             grpc_handshake_manager* mgr);
-
-/// Remove \a mgr from the server side list of all pending handshake managers.
-// Not thread-safe. Caller needs to synchronize.
-void grpc_handshake_manager_pending_list_remove(grpc_handshake_manager** head,
-                                                grpc_handshake_manager* mgr);
-
-/// Shutdown all pending handshake managers on the server side.
-// Not thread-safe. Caller needs to synchronize.
-void grpc_handshake_manager_pending_list_shutdown_all(
-    grpc_handshake_manager* head, grpc_error* why);
-
 #endif /* GRPC_CORE_LIB_CHANNEL_HANDSHAKER_H */

data/src/core/lib/channel/handshaker_factory.h

@@ -27,26 +27,18 @@
 
 // A handshaker factory is used to create handshakers.
 
-typedef struct grpc_handshaker_factory grpc_handshaker_factory;
-
-typedef struct {
-  void (*add_handshakers)(grpc_handshaker_factory* handshaker_factory,
-                          const grpc_channel_args* args,
-                          grpc_pollset_set* interested_parties,
-                          grpc_handshake_manager* handshake_mgr);
-  void (*destroy)(grpc_handshaker_factory* handshaker_factory);
-} grpc_handshaker_factory_vtable;
-
-struct grpc_handshaker_factory {
-  const grpc_handshaker_factory_vtable* vtable;
-};
+namespace grpc_core {
+
+class HandshakerFactory {
+ public:
+  virtual void AddHandshakers(const grpc_channel_args* args,
+                              grpc_pollset_set* interested_parties,
+                              HandshakeManager* handshake_mgr) GRPC_ABSTRACT;
+  virtual ~HandshakerFactory() = default;
 
-void grpc_handshaker_factory_add_handshakers(
-    grpc_handshaker_factory* handshaker_factory, const grpc_channel_args* args,
-    grpc_pollset_set* interested_parties,
-    grpc_handshake_manager* handshake_mgr);
+  GRPC_ABSTRACT_BASE_CLASS
+};
 
-void grpc_handshaker_factory_destroy(
-    grpc_handshaker_factory* handshaker_factory);
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_CHANNEL_HANDSHAKER_FACTORY_H */

data/src/core/lib/channel/handshaker_registry.cc

@@ -19,8 +19,12 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/handshaker_registry.h"
+#include "src/core/lib/gpr/alloc.h"
+#include "src/core/lib/gprpp/inlined_vector.h"
+#include "src/core/lib/gprpp/memory.h"
 
 #include <string.h>
+#include <algorithm>
 
 #include <grpc/support/alloc.h>
 
@@ -28,74 +32,86 @@
 // grpc_handshaker_factory_list
 //
 
-typedef struct {
-  grpc_handshaker_factory** list;
-  size_t num_factories;
-} grpc_handshaker_factory_list;
-
-static void grpc_handshaker_factory_list_register(
-    grpc_handshaker_factory_list* list, bool at_start,
-    grpc_handshaker_factory* factory) {
-  list->list = static_cast<grpc_handshaker_factory**>(gpr_realloc(
-      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);
-    list->list[0] = factory;
-  } else {
-    list->list[list->num_factories] = factory;
-  }
-  ++list->num_factories;
-}
+namespace grpc_core {
+
+namespace {
+
+class HandshakerFactoryList {
+ public:
+  void Register(bool at_start, UniquePtr<HandshakerFactory> factory);
+  void AddHandshakers(const grpc_channel_args* args,
+                      grpc_pollset_set* interested_parties,
+                      HandshakeManager* handshake_mgr);
+
+ private:
+  InlinedVector<UniquePtr<HandshakerFactory>, 2> factories_;
+};
 
-static void grpc_handshaker_factory_list_add_handshakers(
-    grpc_handshaker_factory_list* list, const grpc_channel_args* args,
-    grpc_pollset_set* interested_parties,
-    grpc_handshake_manager* handshake_mgr) {
-  for (size_t i = 0; i < list->num_factories; ++i) {
-    grpc_handshaker_factory_add_handshakers(list->list[i], args,
-                                            interested_parties, handshake_mgr);
+HandshakerFactoryList* g_handshaker_factory_lists = nullptr;
+
+}  // namespace
+
+void HandshakerFactoryList::Register(bool at_start,
+                                     UniquePtr<HandshakerFactory> factory) {
+  factories_.push_back(std::move(factory));
+  if (at_start) {
+    auto* end = &factories_[factories_.size() - 1];
+    std::rotate(&factories_[0], end, end + 1);
   }
 }
 
-static void grpc_handshaker_factory_list_destroy(
-    grpc_handshaker_factory_list* list) {
-  for (size_t i = 0; i < list->num_factories; ++i) {
-    grpc_handshaker_factory_destroy(list->list[i]);
+void HandshakerFactoryList::AddHandshakers(const grpc_channel_args* args,
+                                           grpc_pollset_set* interested_parties,
+                                           HandshakeManager* handshake_mgr) {
+  for (size_t idx = 0; idx < factories_.size(); ++idx) {
+    auto& handshaker_factory = factories_[idx];
+    handshaker_factory->AddHandshakers(args, interested_parties, handshake_mgr);
   }
-  gpr_free(list->list);
 }
 
 //
 // plugin
 //
 
-static grpc_handshaker_factory_list
-    g_handshaker_factory_lists[NUM_HANDSHAKER_TYPES];
+void HandshakerRegistry::Init() {
+  GPR_ASSERT(g_handshaker_factory_lists == nullptr);
+  g_handshaker_factory_lists =
+      static_cast<HandshakerFactoryList*>(gpr_malloc_aligned(
+          sizeof(*g_handshaker_factory_lists) * NUM_HANDSHAKER_TYPES,
+          GPR_MAX_ALIGNMENT));
 
-void grpc_handshaker_factory_registry_init() {
-  memset(g_handshaker_factory_lists, 0, sizeof(g_handshaker_factory_lists));
+  GPR_ASSERT(g_handshaker_factory_lists != nullptr);
+  for (auto idx = 0; idx < NUM_HANDSHAKER_TYPES; ++idx) {
+    auto factory_list = g_handshaker_factory_lists + idx;
+    new (factory_list) HandshakerFactoryList();
+  }
 }
 
-void grpc_handshaker_factory_registry_shutdown() {
-  for (size_t i = 0; i < NUM_HANDSHAKER_TYPES; ++i) {
-    grpc_handshaker_factory_list_destroy(&g_handshaker_factory_lists[i]);
+void HandshakerRegistry::Shutdown() {
+  GPR_ASSERT(g_handshaker_factory_lists != nullptr);
+  for (auto idx = 0; idx < NUM_HANDSHAKER_TYPES; ++idx) {
+    auto factory_list = g_handshaker_factory_lists + idx;
+    factory_list->~HandshakerFactoryList();
   }
+  gpr_free_aligned(g_handshaker_factory_lists);
+  g_handshaker_factory_lists = nullptr;
 }
 
-void grpc_handshaker_factory_register(bool at_start,
-                                      grpc_handshaker_type handshaker_type,
-                                      grpc_handshaker_factory* factory) {
-  grpc_handshaker_factory_list_register(
-      &g_handshaker_factory_lists[handshaker_type], at_start, factory);
+void HandshakerRegistry::RegisterHandshakerFactory(
+    bool at_start, HandshakerType handshaker_type,
+    UniquePtr<HandshakerFactory> factory) {
+  GPR_ASSERT(g_handshaker_factory_lists != nullptr);
+  auto& factory_list = g_handshaker_factory_lists[handshaker_type];
+  factory_list.Register(at_start, std::move(factory));
 }
 
-void grpc_handshakers_add(grpc_handshaker_type handshaker_type,
-                          const grpc_channel_args* args,
-                          grpc_pollset_set* interested_parties,
-                          grpc_handshake_manager* handshake_mgr) {
-  grpc_handshaker_factory_list_add_handshakers(
-      &g_handshaker_factory_lists[handshaker_type], args, interested_parties,
-      handshake_mgr);
+void HandshakerRegistry::AddHandshakers(HandshakerType handshaker_type,
+                                        const grpc_channel_args* args,
+                                        grpc_pollset_set* interested_parties,
+                                        HandshakeManager* handshake_mgr) {
+  GPR_ASSERT(g_handshaker_factory_lists != nullptr);
+  auto& factory_list = g_handshaker_factory_lists[handshaker_type];
+  factory_list.AddHandshakers(args, interested_parties, handshake_mgr);
 }
+
+}  // namespace grpc_core

data/src/core/lib/channel/handshaker_registry.h

@@ -25,25 +25,30 @@
 
 #include "src/core/lib/channel/handshaker_factory.h"
 
+namespace grpc_core {
+
 typedef enum {
   HANDSHAKER_CLIENT = 0,
   HANDSHAKER_SERVER,
   NUM_HANDSHAKER_TYPES,  // Must be last.
-} grpc_handshaker_type;
-
-void grpc_handshaker_factory_registry_init();
-void grpc_handshaker_factory_registry_shutdown();
-
-/// Registers a new handshaker factory.  Takes ownership.
-/// If \a at_start is true, the new handshaker will be at the beginning of
-/// the list.  Otherwise, it will be added to the end.
-void grpc_handshaker_factory_register(bool at_start,
-                                      grpc_handshaker_type handshaker_type,
-                                      grpc_handshaker_factory* factory);
-
-void grpc_handshakers_add(grpc_handshaker_type handshaker_type,
-                          const grpc_channel_args* args,
-                          grpc_pollset_set* interested_parties,
-                          grpc_handshake_manager* handshake_mgr);
+} HandshakerType;
+
+class HandshakerRegistry {
+ public:
+  /// Registers a new handshaker factory.  Takes ownership.
+  /// If \a at_start is true, the new handshaker will be at the beginning of
+  /// the list.  Otherwise, it will be added to the end.
+  static void RegisterHandshakerFactory(bool at_start,
+                                        HandshakerType handshaker_type,
+                                        UniquePtr<HandshakerFactory> factory);
+  static void AddHandshakers(HandshakerType handshaker_type,
+                             const grpc_channel_args* args,
+                             grpc_pollset_set* interested_parties,
+                             HandshakeManager* handshake_mgr);
+  static void Init();
+  static void Shutdown();
+};
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_CHANNEL_HANDSHAKER_REGISTRY_H */

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

@@ -32,7 +32,7 @@ grpc_slice grpc_compression_algorithm_slice(
 /** Find compression algorithm based on passed in mdstr - returns
  *  GRPC_COMPRESS_ALGORITHM_COUNT on failure */
 grpc_compression_algorithm grpc_compression_algorithm_from_slice(
-    grpc_slice str);
+    const grpc_slice& str);
 
 /** Return compression algorithm based metadata element */
 grpc_mdelem grpc_compression_encoding_mdelem(
@@ -51,11 +51,11 @@ grpc_mdelem grpc_stream_compression_encoding_mdelem(
 /** 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(grpc_slice str);
+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(
-    grpc_slice str);
+    const grpc_slice& str);
 
 #endif /* GRPC_CORE_LIB_COMPRESSION_ALGORITHM_METADATA_H */

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

@@ -26,6 +26,7 @@
 #include "src/core/lib/compression/algorithm_metadata.h"
 #include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/slice/slice_utils.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/transport/static_metadata.h"
 
@@ -42,16 +43,17 @@ int grpc_compression_algorithm_is_stream(grpc_compression_algorithm algorithm) {
 
 int grpc_compression_algorithm_parse(grpc_slice name,
                                      grpc_compression_algorithm* algorithm) {
-  if (grpc_slice_eq(name, GRPC_MDSTR_IDENTITY)) {
+  if (grpc_slice_eq_static_interned(name, GRPC_MDSTR_IDENTITY)) {
     *algorithm = GRPC_COMPRESS_NONE;
     return 1;
-  } else if (grpc_slice_eq(name, GRPC_MDSTR_DEFLATE)) {
+  } else if (grpc_slice_eq_static_interned(name, GRPC_MDSTR_DEFLATE)) {
     *algorithm = GRPC_COMPRESS_DEFLATE;
     return 1;
-  } else if (grpc_slice_eq(name, GRPC_MDSTR_GZIP)) {
+  } else if (grpc_slice_eq_static_interned(name, GRPC_MDSTR_GZIP)) {
     *algorithm = GRPC_COMPRESS_GZIP;
     return 1;
-  } else if (grpc_slice_eq(name, GRPC_MDSTR_STREAM_SLASH_GZIP)) {
+  } else if (grpc_slice_eq_static_interned(name,
+                                           GRPC_MDSTR_STREAM_SLASH_GZIP)) {
     *algorithm = GRPC_COMPRESS_STREAM_GZIP;
     return 1;
   } else {
@@ -147,11 +149,14 @@ grpc_slice grpc_compression_algorithm_slice(
 }
 
 grpc_compression_algorithm grpc_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_DEFLATE)) return GRPC_COMPRESS_DEFLATE;
-  if (grpc_slice_eq(str, GRPC_MDSTR_GZIP)) return GRPC_COMPRESS_GZIP;
-  if (grpc_slice_eq(str, GRPC_MDSTR_STREAM_SLASH_GZIP))
+    const grpc_slice& str) {
+  if (grpc_slice_eq_static_interned(str, GRPC_MDSTR_IDENTITY))
+    return GRPC_COMPRESS_NONE;
+  if (grpc_slice_eq_static_interned(str, GRPC_MDSTR_DEFLATE))
+    return GRPC_COMPRESS_DEFLATE;
+  if (grpc_slice_eq_static_interned(str, GRPC_MDSTR_GZIP))
+    return GRPC_COMPRESS_GZIP;
+  if (grpc_slice_eq_static_interned(str, GRPC_MDSTR_STREAM_SLASH_GZIP))
     return GRPC_COMPRESS_STREAM_GZIP;
   return GRPC_COMPRESS_ALGORITHMS_COUNT;
 }