grpc 1.34.0 → 1.37.0

data/src/core/lib/iomgr/tcp_uv.cc

@@ -252,8 +252,8 @@ static void accept_new_connection(grpc_custom_socket* socket) {
   uv_socket->accept_error = GRPC_ERROR_NONE;
   uv_socket->pending_connections -= 1;
   if (uv_socket->accept_error != GRPC_ERROR_NONE) {
-    uv_stream_t dummy_handle;
-    uv_accept((uv_stream_t*)uv_socket->handle, &dummy_handle);
+    uv_stream_t phony_handle;
+    uv_accept((uv_stream_t*)uv_socket->handle, &phony_handle);
     uv_socket->accept_cb(socket, new_socket, error);
   } else {
     uv_socket_t* uv_new_socket = (uv_socket_t*)gpr_malloc(sizeof(uv_socket_t));

data/src/core/lib/iomgr/timer_custom.cc

@@ -57,16 +57,16 @@ static void timer_init(grpc_timer* timer, grpc_millis deadline,
   timer->pending = true;
   timer->closure = closure;
   grpc_custom_timer* timer_wrapper =
-      (grpc_custom_timer*)gpr_malloc(sizeof(grpc_custom_timer));
+      static_cast<grpc_custom_timer*>(gpr_malloc(sizeof(grpc_custom_timer)));
   timer_wrapper->timeout_ms = timeout;
-  timer->custom_timer = (void*)timer_wrapper;
+  timer->custom_timer = timer_wrapper;
   timer_wrapper->original = timer;
   custom_timer_impl->start(timer_wrapper);
 }
 
 static void timer_cancel(grpc_timer* timer) {
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
-  grpc_custom_timer* tw = (grpc_custom_timer*)timer->custom_timer;
+  grpc_custom_timer* tw = static_cast<grpc_custom_timer*>(timer->custom_timer);
   if (timer->pending) {
     timer->pending = false;
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, timer->closure,

data/src/core/lib/iomgr/timer_generic.cc

@@ -409,7 +409,7 @@ static void timer_init(grpc_timer* timer, grpc_millis deadline,
   }
   gpr_mu_unlock(&shard->mu);
 
-  /* Deadline may have decreased, we need to adjust the master queue.  Note
+  /* Deadline may have decreased, we need to adjust the main queue.  Note
      that there is a potential racy unlocked region here.  There could be a
      reordering of multiple grpc_timer_init calls, at this point, but the < test
      below should ensure that we err on the side of caution.  There could
@@ -432,7 +432,7 @@ static void timer_init(grpc_timer* timer, grpc_millis deadline,
       note_deadline_change(shard);
       if (shard->shard_queue_index == 0 && deadline < old_min_deadline) {
 #if GPR_ARCH_64
-        // TODO: sreek - Using c-style cast here. static_cast<> gives an error
+        // TODO(sreek): Using c-style cast here. static_cast<> gives an error
         // (on mac platforms complaining that gpr_atm* is (long *) while
         // (&g_shared_mutables.min_timer) is a (long long *). The cast should be
         // safe since we know that both are pointer types and 64-bit wide.
@@ -586,7 +586,7 @@ static grpc_timer_check_result run_some_expired_timers(grpc_millis now,
   grpc_timer_check_result result = GRPC_TIMERS_NOT_CHECKED;
 
 #if GPR_ARCH_64
-  // TODO: sreek - Using c-style cast here. static_cast<> gives an error (on
+  // TODO(sreek): Using c-style cast here. static_cast<> gives an error (on
   // mac platforms complaining that gpr_atm* is (long *) while
   // (&g_shared_mutables.min_timer) is a (long long *). The cast should be
   // safe since we know that both are pointer types and 64-bit wide
@@ -639,7 +639,7 @@ static grpc_timer_check_result run_some_expired_timers(grpc_millis now,
 
       /* An grpc_timer_init() on the shard could intervene here, adding a new
          timer that is earlier than new_min_deadline.  However,
-         grpc_timer_init() will block on the master_lock before it can call
+         grpc_timer_init() will block on the mutex before it can call
          set_min_deadline, so this one will complete first and then the Addtimer
          will reduce the min_deadline (perhaps unnecessarily). */
       g_shard_queue[0]->min_deadline = new_min_deadline;
@@ -651,7 +651,7 @@ static grpc_timer_check_result run_some_expired_timers(grpc_millis now,
     }
 
 #if GPR_ARCH_64
-    // TODO: sreek - Using c-style cast here. static_cast<> gives an error (on
+    // TODO(sreek): Using c-style cast here. static_cast<> gives an error (on
     // mac platforms complaining that gpr_atm* is (long *) while
     // (&g_shared_mutables.min_timer) is a (long long *). The cast should be
     // safe since we know that both are pointer types and 64-bit wide

data/src/core/lib/iomgr/timer_manager.cc

@@ -133,7 +133,7 @@ static void run_some_timers() {
   }
   grpc_core::ExecCtx::Get()->Flush();
   gpr_mu_lock(&g_mu);
-  // garbage collect any threads hanging out that are dead
+  // garbage collect any threads that are dead
   gc_completed_threads();
   // get ready to wait again
   ++g_waiter_count;
@@ -342,8 +342,8 @@ void grpc_timer_manager_shutdown(void) {
   gpr_cv_destroy(&g_cv_shutdown);
 }
 
-void grpc_timer_manager_set_threading(bool threaded) {
-  if (threaded) {
+void grpc_timer_manager_set_threading(bool enabled) {
+  if (enabled) {
     start_threads();
   } else {
     stop_threads();

data/src/core/lib/iomgr/udp_server.cc

@@ -570,8 +570,7 @@ static int add_socket_to_server(grpc_udp_server* s, int fd,
   return port;
 }
 
-int grpc_udp_server_add_port(grpc_udp_server* s,
-                             const grpc_resolved_address* addr,
+int grpc_udp_server_add_port(grpc_udp_server* s, grpc_resolved_address* addr,
                              int rcv_buf_size, int snd_buf_size,
                              GrpcUdpHandlerFactory* handler_factory,
                              size_t num_listeners) {

data/src/core/lib/iomgr/udp_server.h

@@ -93,8 +93,7 @@ int grpc_udp_server_get_fd(grpc_udp_server* s, unsigned port_index);
 
 /* TODO(ctiller): deprecate this, and make grpc_udp_server_add_ports to handle
                   all of the multiple socket port matching logic in one place */
-int grpc_udp_server_add_port(grpc_udp_server* s,
-                             const grpc_resolved_address* addr,
+int grpc_udp_server_add_port(grpc_udp_server* s, grpc_resolved_address* addr,
                              int rcv_buf_size, int snd_buf_size,
                              GrpcUdpHandlerFactory* handler_factory,
                              size_t num_listeners);

data/src/core/lib/iomgr/unix_sockets_posix.cc

@@ -42,24 +42,24 @@ void grpc_create_socketpair_if_unix(int sv[2]) {
   GPR_ASSERT(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0);
 }
 
-grpc_error* grpc_resolve_unix_domain_address(const char* name,
-                                             grpc_resolved_addresses** addrs) {
-  *addrs = static_cast<grpc_resolved_addresses*>(
+grpc_error* grpc_resolve_unix_domain_address(
+    const char* name, grpc_resolved_addresses** addresses) {
+  *addresses = static_cast<grpc_resolved_addresses*>(
       gpr_malloc(sizeof(grpc_resolved_addresses)));
-  (*addrs)->naddrs = 1;
-  (*addrs)->addrs = static_cast<grpc_resolved_address*>(
+  (*addresses)->naddrs = 1;
+  (*addresses)->addrs = static_cast<grpc_resolved_address*>(
       gpr_malloc(sizeof(grpc_resolved_address)));
-  return grpc_core::UnixSockaddrPopulate(name, (*addrs)->addrs);
+  return grpc_core::UnixSockaddrPopulate(name, (*addresses)->addrs);
 }
 
 grpc_error* grpc_resolve_unix_abstract_domain_address(
-    const absl::string_view name, grpc_resolved_addresses** addrs) {
-  *addrs = static_cast<grpc_resolved_addresses*>(
+    const absl::string_view name, grpc_resolved_addresses** addresses) {
+  *addresses = static_cast<grpc_resolved_addresses*>(
       gpr_malloc(sizeof(grpc_resolved_addresses)));
-  (*addrs)->naddrs = 1;
-  (*addrs)->addrs = static_cast<grpc_resolved_address*>(
+  (*addresses)->naddrs = 1;
+  (*addresses)->addrs = static_cast<grpc_resolved_address*>(
       gpr_malloc(sizeof(grpc_resolved_address)));
-  return grpc_core::UnixAbstractSockaddrPopulate(name, (*addrs)->addrs);
+  return grpc_core::UnixAbstractSockaddrPopulate(name, (*addresses)->addrs);
 }
 
 int grpc_is_unix_socket(const grpc_resolved_address* resolved_addr) {
@@ -96,16 +96,15 @@ std::string grpc_sockaddr_to_uri_unix_if_possible(
   if (addr->sa_family != AF_UNIX) {
     return "";
   }
-  if (((struct sockaddr_un*)addr)->sun_path[0] == '\0' &&
-      ((struct sockaddr_un*)addr)->sun_path[1] != '\0') {
-    const struct sockaddr_un* un =
-        reinterpret_cast<const struct sockaddr_un*>(resolved_addr->addr);
+  const auto* unix_addr = reinterpret_cast<const struct sockaddr_un*>(addr);
+  if (unix_addr->sun_path[0] == '\0' && unix_addr->sun_path[1] != '\0') {
     return absl::StrCat(
         "unix-abstract:",
-        absl::string_view(un->sun_path + 1,
-                          resolved_addr->len - sizeof(un->sun_family) - 1));
+        absl::string_view(
+            unix_addr->sun_path + 1,
+            resolved_addr->len - sizeof(unix_addr->sun_family) - 1));
   }
-  return absl::StrCat("unix:", ((struct sockaddr_un*)addr)->sun_path);
+  return absl::StrCat("unix:", unix_addr->sun_path);
 }
 
 #endif

data/src/core/lib/iomgr/wakeup_fd_nospecial.cc

@@ -17,7 +17,7 @@
  */
 
 /*
- * This is a dummy file to provide an invalid specialized_wakeup_fd_vtable on
+ * This is a phony file to provide an invalid specialized_wakeup_fd_vtable on
  * systems without anything better than pipe.
  */
 

data/src/core/lib/json/json.h

@@ -76,6 +76,7 @@ class Json {
 
   // Construct from copying a string.
   // If is_number is true, the type will be NUMBER instead of STRING.
+  // NOLINTNEXTLINE(google-explicit-constructor)
   Json(const std::string& string, bool is_number = false)
       : type_(is_number ? Type::NUMBER : Type::STRING), string_value_(string) {}
   Json& operator=(const std::string& string) {
@@ -85,12 +86,14 @@ class Json {
   }
 
   // Same thing for C-style strings, both const and mutable.
+  // NOLINTNEXTLINE(google-explicit-constructor)
   Json(const char* string, bool is_number = false)
       : Json(std::string(string), is_number) {}
   Json& operator=(const char* string) {
     *this = std::string(string);
     return *this;
   }
+  // NOLINTNEXTLINE(google-explicit-constructor)
   Json(char* string, bool is_number = false)
       : Json(std::string(string), is_number) {}
   Json& operator=(char* string) {
@@ -99,6 +102,7 @@ class Json {
   }
 
   // Construct by moving a string.
+  // NOLINTNEXTLINE(google-explicit-constructor)
   Json(std::string&& string)
       : type_(Type::STRING), string_value_(std::move(string)) {}
   Json& operator=(std::string&& string) {
@@ -108,6 +112,7 @@ class Json {
   }
 
   // Construct from bool.
+  // NOLINTNEXTLINE(google-explicit-constructor)
   Json(bool b) : type_(b ? Type::JSON_TRUE : Type::JSON_FALSE) {}
   Json& operator=(bool b) {
     type_ = b ? Type::JSON_TRUE : Type::JSON_FALSE;
@@ -116,6 +121,7 @@ class Json {
 
   // Construct from any numeric type.
   template <typename NumericType>
+  // NOLINTNEXTLINE(google-explicit-constructor)
   Json(NumericType number)
       : type_(Type::NUMBER), string_value_(std::to_string(number)) {}
   template <typename NumericType>
@@ -126,6 +132,7 @@ class Json {
   }
 
   // Construct by copying object.
+  // NOLINTNEXTLINE(google-explicit-constructor)
   Json(const Object& object) : type_(Type::OBJECT), object_value_(object) {}
   Json& operator=(const Object& object) {
     type_ = Type::OBJECT;
@@ -134,6 +141,7 @@ class Json {
   }
 
   // Construct by moving object.
+  // NOLINTNEXTLINE(google-explicit-constructor)
   Json(Object&& object)
       : type_(Type::OBJECT), object_value_(std::move(object)) {}
   Json& operator=(Object&& object) {
@@ -143,6 +151,7 @@ class Json {
   }
 
   // Construct by copying array.
+  // NOLINTNEXTLINE(google-explicit-constructor)
   Json(const Array& array) : type_(Type::ARRAY), array_value_(array) {}
   Json& operator=(const Array& array) {
     type_ = Type::ARRAY;
@@ -151,6 +160,7 @@ class Json {
   }
 
   // Construct by moving array.
+  // NOLINTNEXTLINE(google-explicit-constructor)
   Json(Array&& array) : type_(Type::ARRAY), array_value_(std::move(array)) {}
   Json& operator=(Array&& array) {
     type_ = Type::ARRAY;

data/src/core/lib/matchers/matchers.cc

@@ -0,0 +1,339 @@
+// 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.
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/matchers/matchers.h"
+
+#include "absl/memory/memory.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/str_split.h"
+
+namespace grpc_core {
+
+//
+// StringMatcher
+//
+
+absl::StatusOr<StringMatcher> StringMatcher::Create(Type type,
+                                                    absl::string_view matcher,
+                                                    bool case_sensitive) {
+  if (type == Type::SAFE_REGEX) {
+    RE2::Options options;
+    options.set_case_sensitive(case_sensitive);
+    auto regex_matcher = absl::make_unique<RE2>(std::string(matcher), options);
+    if (!regex_matcher->ok()) {
+      return absl::InvalidArgumentError(
+          "Invalid regex string specified in matcher.");
+    }
+    return StringMatcher(std::move(regex_matcher), case_sensitive);
+  } else {
+    return StringMatcher(type, matcher, case_sensitive);
+  }
+}
+
+StringMatcher::StringMatcher(Type type, absl::string_view matcher,
+                             bool case_sensitive)
+    : type_(type), string_matcher_(matcher), case_sensitive_(case_sensitive) {}
+
+StringMatcher::StringMatcher(std::unique_ptr<RE2> regex_matcher,
+                             bool case_sensitive)
+    : type_(Type::SAFE_REGEX),
+      regex_matcher_(std::move(regex_matcher)),
+      case_sensitive_(case_sensitive) {}
+
+StringMatcher::StringMatcher(const StringMatcher& other)
+    : type_(other.type_), case_sensitive_(other.case_sensitive_) {
+  if (type_ == Type::SAFE_REGEX) {
+    RE2::Options options;
+    options.set_case_sensitive(other.case_sensitive_);
+    regex_matcher_ =
+        absl::make_unique<RE2>(other.regex_matcher_->pattern(), options);
+  } else {
+    string_matcher_ = other.string_matcher_;
+  }
+}
+
+StringMatcher& StringMatcher::operator=(const StringMatcher& other) {
+  type_ = other.type_;
+  if (type_ == Type::SAFE_REGEX) {
+    RE2::Options options;
+    options.set_case_sensitive(other.case_sensitive_);
+    regex_matcher_ =
+        absl::make_unique<RE2>(other.regex_matcher_->pattern(), options);
+  } else {
+    string_matcher_ = other.string_matcher_;
+  }
+  case_sensitive_ = other.case_sensitive_;
+  return *this;
+}
+
+StringMatcher::StringMatcher(StringMatcher&& other) noexcept
+    : type_(other.type_), case_sensitive_(other.case_sensitive_) {
+  if (type_ == Type::SAFE_REGEX) {
+    regex_matcher_ = std::move(other.regex_matcher_);
+  } else {
+    string_matcher_ = std::move(other.string_matcher_);
+  }
+}
+
+StringMatcher& StringMatcher::operator=(StringMatcher&& other) noexcept {
+  type_ = other.type_;
+  if (type_ == Type::SAFE_REGEX) {
+    regex_matcher_ = std::move(other.regex_matcher_);
+  } else {
+    string_matcher_ = std::move(other.string_matcher_);
+  }
+  case_sensitive_ = other.case_sensitive_;
+  return *this;
+}
+
+bool StringMatcher::operator==(const StringMatcher& other) const {
+  if (type_ != other.type_ || case_sensitive_ != other.case_sensitive_) {
+    return false;
+  }
+  if (type_ == Type::SAFE_REGEX) {
+    return regex_matcher_->pattern() == other.regex_matcher_->pattern();
+  } else {
+    return string_matcher_ == other.string_matcher_;
+  }
+}
+
+bool StringMatcher::Match(absl::string_view value) const {
+  switch (type_) {
+    case Type::EXACT:
+      return case_sensitive_ ? value == string_matcher_
+                             : absl::EqualsIgnoreCase(value, string_matcher_);
+    case StringMatcher::Type::PREFIX:
+      return case_sensitive_
+                 ? absl::StartsWith(value, string_matcher_)
+                 : absl::StartsWithIgnoreCase(value, string_matcher_);
+    case StringMatcher::Type::SUFFIX:
+      return case_sensitive_ ? absl::EndsWith(value, string_matcher_)
+                             : absl::EndsWithIgnoreCase(value, string_matcher_);
+    case StringMatcher::Type::CONTAINS:
+      return case_sensitive_
+                 ? absl::StrContains(value, string_matcher_)
+                 : absl::StrContains(absl::AsciiStrToLower(value),
+                                     absl::AsciiStrToLower(string_matcher_));
+    case StringMatcher::Type::SAFE_REGEX:
+      return RE2::FullMatch(std::string(value), *regex_matcher_);
+    default:
+      return false;
+  }
+}
+
+std::string StringMatcher::ToString() const {
+  switch (type_) {
+    case Type::EXACT:
+      return absl::StrFormat("StringMatcher{exact=%s%s}", string_matcher_,
+                             case_sensitive_ ? "" : ", case_sensitive=false");
+    case Type::PREFIX:
+      return absl::StrFormat("StringMatcher{prefix=%s%s}", string_matcher_,
+                             case_sensitive_ ? "" : ", case_sensitive=false");
+    case Type::SUFFIX:
+      return absl::StrFormat("StringMatcher{suffix=%s%s}", string_matcher_,
+                             case_sensitive_ ? "" : ", case_sensitive=false");
+    case Type::CONTAINS:
+      return absl::StrFormat("StringMatcher{contains=%s%s}", string_matcher_,
+                             case_sensitive_ ? "" : ", case_sensitive=false");
+    case Type::SAFE_REGEX:
+      return absl::StrFormat("StringMatcher{safe_regex=%s%s}",
+                             regex_matcher_->pattern(),
+                             case_sensitive_ ? "" : ", case_sensitive=false");
+    default:
+      return "";
+  }
+}
+
+//
+// HeaderMatcher
+//
+
+absl::StatusOr<HeaderMatcher> HeaderMatcher::Create(
+    absl::string_view name, Type type, absl::string_view matcher,
+    int64_t range_start, int64_t range_end, bool present_match,
+    bool invert_match) {
+  if (static_cast<int>(type) < 5) {
+    // Only for EXACT, PREFIX, SUFFIX, SAFE_REGEX and CONTAINS.
+    absl::StatusOr<StringMatcher> string_matcher =
+        StringMatcher::Create(static_cast<StringMatcher::Type>(type), matcher,
+                              /*case_sensitive=*/true);
+    if (!string_matcher.ok()) {
+      return string_matcher.status();
+    }
+    return HeaderMatcher(name, type, std::move(string_matcher.value()),
+                         invert_match);
+  } else if (type == Type::RANGE) {
+    if (range_start > range_end) {
+      return absl::InvalidArgumentError(
+          "Invalid range specifier specified: end cannot be smaller than "
+          "start.");
+    }
+    return HeaderMatcher(name, range_start, range_end, invert_match);
+  } else {
+    return HeaderMatcher(name, present_match, invert_match);
+  }
+}
+
+HeaderMatcher::HeaderMatcher(absl::string_view name, Type type,
+                             StringMatcher string_matcher, bool invert_match)
+    : name_(name),
+      type_(type),
+      matcher_(std::move(string_matcher)),
+      invert_match_(invert_match) {}
+
+HeaderMatcher::HeaderMatcher(absl::string_view name, int64_t range_start,
+                             int64_t range_end, bool invert_match)
+    : name_(name),
+      type_(Type::RANGE),
+      range_start_(range_start),
+      range_end_(range_end),
+      invert_match_(invert_match) {}
+
+HeaderMatcher::HeaderMatcher(absl::string_view name, bool present_match,
+                             bool invert_match)
+    : name_(name),
+      type_(Type::PRESENT),
+      present_match_(present_match),
+      invert_match_(invert_match) {}
+
+HeaderMatcher::HeaderMatcher(const HeaderMatcher& other)
+    : name_(other.name_),
+      type_(other.type_),
+      invert_match_(other.invert_match_) {
+  switch (type_) {
+    case Type::RANGE:
+      range_start_ = other.range_start_;
+      range_end_ = other.range_end_;
+      break;
+    case Type::PRESENT:
+      present_match_ = other.present_match_;
+      break;
+    default:
+      matcher_ = other.matcher_;
+  }
+}
+
+HeaderMatcher& HeaderMatcher::operator=(const HeaderMatcher& other) {
+  name_ = other.name_;
+  type_ = other.type_;
+  invert_match_ = other.invert_match_;
+  switch (type_) {
+    case Type::RANGE:
+      range_start_ = other.range_start_;
+      range_end_ = other.range_end_;
+      break;
+    case Type::PRESENT:
+      present_match_ = other.present_match_;
+      break;
+    default:
+      matcher_ = other.matcher_;
+  }
+  return *this;
+}
+
+HeaderMatcher::HeaderMatcher(HeaderMatcher&& other) noexcept
+    : name_(std::move(other.name_)),
+      type_(other.type_),
+      invert_match_(other.invert_match_) {
+  switch (type_) {
+    case Type::RANGE:
+      range_start_ = other.range_start_;
+      range_end_ = other.range_end_;
+      break;
+    case Type::PRESENT:
+      present_match_ = other.present_match_;
+      break;
+    default:
+      matcher_ = std::move(other.matcher_);
+  }
+}
+
+HeaderMatcher& HeaderMatcher::operator=(HeaderMatcher&& other) noexcept {
+  name_ = std::move(other.name_);
+  type_ = other.type_;
+  invert_match_ = other.invert_match_;
+  switch (type_) {
+    case Type::RANGE:
+      range_start_ = other.range_start_;
+      range_end_ = other.range_end_;
+      break;
+    case Type::PRESENT:
+      present_match_ = other.present_match_;
+      break;
+    default:
+      matcher_ = std::move(other.matcher_);
+  }
+  return *this;
+}
+
+bool HeaderMatcher::operator==(const HeaderMatcher& other) const {
+  if (name_ != other.name_) return false;
+  if (type_ != other.type_) return false;
+  if (invert_match_ != other.invert_match_) return false;
+  switch (type_) {
+    case Type::RANGE:
+      return range_start_ == other.range_start_ &&
+             range_end_ == other.range_end_;
+    case Type::PRESENT:
+      return present_match_ == other.present_match_;
+    default:
+      return matcher_ == other.matcher_;
+  }
+}
+
+bool HeaderMatcher::Match(
+    const absl::optional<absl::string_view>& value) const {
+  bool match;
+  if (type_ == Type::PRESENT) {
+    match = value.has_value() == present_match_;
+  } else if (!value.has_value()) {
+    // All other types fail to match if field is not present.
+    match = false;
+  } else if (type_ == Type::RANGE) {
+    int64_t int_value;
+    match = absl::SimpleAtoi(value.value(), &int_value) &&
+            int_value >= range_start_ && int_value < range_end_;
+  } else {
+    match = matcher_.Match(value.value());
+  }
+  return match != invert_match_;
+}
+
+std::string HeaderMatcher::ToString() const {
+  switch (type_) {
+    case Type::RANGE:
+      return absl::StrFormat("HeaderMatcher{%s %srange=[%d, %d]}", name_,
+                             invert_match_ ? "not " : "", range_start_,
+                             range_end_);
+    case Type::PRESENT:
+      return absl::StrFormat("HeaderMatcher{%s %spresent=%s}", name_,
+                             invert_match_ ? "not " : "",
+                             present_match_ ? "true" : "false");
+    case Type::EXACT:
+    case Type::PREFIX:
+    case Type::SUFFIX:
+    case Type::SAFE_REGEX:
+    case Type::CONTAINS:
+      return absl::StrFormat("HeaderMatcher{%s %s%s}", name_,
+                             invert_match_ ? "not " : "", matcher_.ToString());
+    default:
+      return "";
+  }
+}
+
+}  // namespace grpc_core