grpc 1.35.0 → 1.38.0

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;

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

@@ -56,6 +56,8 @@
 #include <grpc/support/string_util.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
+
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/memory.h"
@@ -64,7 +66,6 @@
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/sockaddr.h"
-#include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/iomgr/socket_factory_posix.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
@@ -83,11 +84,11 @@ class GrpcUdpListener {
 
   /* Called when data is available to read from the socket.
    * Return true if there is more data to read from fd. */
-  void OnRead(grpc_error* error, void* do_read_arg);
+  void OnRead(grpc_error_handle error, void* do_read_arg);
 
   /* Called when the socket is writeable. The given closure should be scheduled
    * when the socket becomes blocked next time. */
-  void OnCanWrite(grpc_error* error, void* do_write_arg);
+  void OnCanWrite(grpc_error_handle error, void* do_write_arg);
 
   /* Called when the grpc_fd is about to be orphaned (and the FD closed). */
   void OnFdAboutToOrphan();
@@ -107,16 +108,16 @@ class GrpcUdpListener {
 
  private:
   /* event manager callback when reads are ready */
-  static void on_read(void* arg, grpc_error* error);
-  static void on_write(void* arg, grpc_error* error);
+  static void on_read(void* arg, grpc_error_handle error);
+  static void on_write(void* arg, grpc_error_handle error);
 
-  static void do_read(void* arg, grpc_error* error);
-  static void do_write(void* arg, grpc_error* error);
+  static void do_read(void* arg, grpc_error_handle error);
+  static void do_write(void* arg, grpc_error_handle error);
   // Wrapper of grpc_fd_notify_on_write() with a grpc_closure callback
   // interface.
-  static void fd_notify_on_write_wrapper(void* arg, grpc_error* error);
+  static void fd_notify_on_write_wrapper(void* arg, grpc_error_handle error);
 
-  static void shutdown_fd(void* args, grpc_error* error);
+  static void shutdown_fd(void* args, grpc_error_handle error);
 
   int fd_;
   grpc_fd* emfd_;
@@ -222,7 +223,7 @@ grpc_udp_server* grpc_udp_server_create(const grpc_channel_args* args) {
 }
 
 // static
-void GrpcUdpListener::shutdown_fd(void* args, grpc_error* error) {
+void GrpcUdpListener::shutdown_fd(void* args, grpc_error_handle error) {
   if (args == nullptr) {
     // No-op if shutdown args are null.
     return;
@@ -261,7 +262,7 @@ static void finish_shutdown(grpc_udp_server* s) {
   delete s;
 }
 
-static void destroyed_port(void* server, grpc_error* /*error*/) {
+static void destroyed_port(void* server, grpc_error_handle /*error*/) {
   grpc_udp_server* s = static_cast<grpc_udp_server*>(server);
   gpr_mu_lock(&s->mu);
   s->destroyed_ports++;
@@ -436,7 +437,7 @@ error:
 }
 
 // static
-void GrpcUdpListener::do_read(void* arg, grpc_error* error) {
+void GrpcUdpListener::do_read(void* arg, grpc_error_handle error) {
   GrpcUdpListener* sp = static_cast<GrpcUdpListener*>(arg);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   /* TODO: the reason we hold server->mu here is merely to prevent fd
@@ -460,12 +461,12 @@ void GrpcUdpListener::do_read(void* arg, grpc_error* error) {
 }
 
 // static
-void GrpcUdpListener::on_read(void* arg, grpc_error* error) {
+void GrpcUdpListener::on_read(void* arg, grpc_error_handle error) {
   GrpcUdpListener* sp = static_cast<GrpcUdpListener*>(arg);
   sp->OnRead(error, arg);
 }
 
-void GrpcUdpListener::OnRead(grpc_error* error, void* do_read_arg) {
+void GrpcUdpListener::OnRead(grpc_error_handle error, void* do_read_arg) {
   if (error != GRPC_ERROR_NONE) {
     gpr_mu_lock(&server_->mu);
     if (0 == --server_->active_ports && server_->shutdown) {
@@ -497,7 +498,7 @@ void GrpcUdpListener::OnRead(grpc_error* error, void* do_read_arg) {
 // static
 // Wrapper of grpc_fd_notify_on_write() with a grpc_closure callback interface.
 void GrpcUdpListener::fd_notify_on_write_wrapper(void* arg,
-                                                 grpc_error* /*error*/) {
+                                                 grpc_error_handle /*error*/) {
   GrpcUdpListener* sp = static_cast<GrpcUdpListener*>(arg);
   gpr_mu_lock(sp->mutex());
   if (!sp->notify_on_write_armed_) {
@@ -508,7 +509,7 @@ void GrpcUdpListener::fd_notify_on_write_wrapper(void* arg,
 }
 
 // static
-void GrpcUdpListener::do_write(void* arg, grpc_error* error) {
+void GrpcUdpListener::do_write(void* arg, grpc_error_handle error) {
   GrpcUdpListener* sp = static_cast<GrpcUdpListener*>(arg);
   gpr_mu_lock(sp->mutex());
   if (sp->already_shutdown_) {
@@ -527,12 +528,12 @@ void GrpcUdpListener::do_write(void* arg, grpc_error* error) {
 }
 
 // static
-void GrpcUdpListener::on_write(void* arg, grpc_error* error) {
+void GrpcUdpListener::on_write(void* arg, grpc_error_handle error) {
   GrpcUdpListener* sp = static_cast<GrpcUdpListener*>(arg);
   sp->OnCanWrite(error, arg);
 }
 
-void GrpcUdpListener::OnCanWrite(grpc_error* error, void* do_write_arg) {
+void GrpcUdpListener::OnCanWrite(grpc_error_handle error, void* do_write_arg) {
   if (error != GRPC_ERROR_NONE) {
     gpr_mu_lock(&server_->mu);
     if (0 == --server_->active_ports && server_->shutdown) {
@@ -630,7 +631,7 @@ int grpc_udp_server_add_port(grpc_udp_server* s, grpc_resolved_address* addr,
 
       /* Try listening on IPv6 first. */
       addr = &wild6;
-      // TODO(rjshade): Test and propagate the returned grpc_error*:
+      // TODO(rjshade): Test and propagate the returned grpc_error_handle:
       GRPC_ERROR_UNREF(grpc_create_dualstack_socket_using_factory(
           s->socket_factory, addr, SOCK_DGRAM, IPPROTO_UDP, &dsmode, &fd));
       allocated_port1 =
@@ -666,7 +667,7 @@ int grpc_udp_server_add_port(grpc_udp_server* s, grpc_resolved_address* addr,
       addr = &wild4;
     }
 
-    // TODO(rjshade): Test and propagate the returned grpc_error*:
+    // TODO(rjshade): Test and propagate the returned grpc_error_handle:
     GRPC_ERROR_UNREF(grpc_create_dualstack_socket_using_factory(
         s->socket_factory, addr, SOCK_DGRAM, IPPROTO_UDP, &dsmode, &fd));
     if (fd < 0) {

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

@@ -30,7 +30,7 @@
 
 #include "absl/strings/str_cat.h"
 
-#include "src/core/lib/iomgr/parse_address.h"
+#include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 
 #include <grpc/support/alloc.h>
@@ -42,7 +42,7 @@ 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(
+grpc_error_handle grpc_resolve_unix_domain_address(
     const char* name, grpc_resolved_addresses** addresses) {
   *addresses = static_cast<grpc_resolved_addresses*>(
       gpr_malloc(sizeof(grpc_resolved_addresses)));
@@ -52,7 +52,7 @@ grpc_error* grpc_resolve_unix_domain_address(
   return grpc_core::UnixSockaddrPopulate(name, (*addresses)->addrs);
 }
 
-grpc_error* grpc_resolve_unix_abstract_domain_address(
+grpc_error_handle grpc_resolve_unix_abstract_domain_address(
     const absl::string_view name, grpc_resolved_addresses** addresses) {
   *addresses = static_cast<grpc_resolved_addresses*>(
       gpr_malloc(sizeof(grpc_resolved_addresses)));

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

@@ -33,10 +33,10 @@
 
 void grpc_create_socketpair_if_unix(int sv[2]);
 
-grpc_error* grpc_resolve_unix_domain_address(
+grpc_error_handle grpc_resolve_unix_domain_address(
     const char* name, grpc_resolved_addresses** addresses);
 
-grpc_error* grpc_resolve_unix_abstract_domain_address(
+grpc_error_handle grpc_resolve_unix_abstract_domain_address(
     absl::string_view name, grpc_resolved_addresses** addresses);
 
 int grpc_is_unix_socket(const grpc_resolved_address* resolved_addr);

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

@@ -26,33 +26,36 @@
 
 #include <grpc/support/log.h>
 
-void grpc_create_socketpair_if_unix(int sv[2]) {
+void grpc_create_socketpair_if_unix(int /* sv */[2]) {
   // TODO: Either implement this for the non-Unix socket case or make
   // sure that it is never called in any such case. Until then, leave an
   // assertion to notify if this gets called inadvertently
   GPR_ASSERT(0);
 }
 
-grpc_error* grpc_resolve_unix_domain_address(
-    const char* name, grpc_resolved_addresses** addresses) {
+grpc_error_handle grpc_resolve_unix_domain_address(
+    const char* /* name */, grpc_resolved_addresses** addresses) {
   *addresses = NULL;
   return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
       "Unix domain sockets are not supported on Windows");
 }
 
-grpc_error* grpc_resolve_unix_abstract_domain_address(
+grpc_error_handle grpc_resolve_unix_abstract_domain_address(
     absl::string_view, grpc_resolved_addresses** addresses) {
   *addresses = NULL;
   return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
       "Unix domain sockets are not supported on Windows");
 }
 
-int grpc_is_unix_socket(const grpc_resolved_address* addr) { return false; }
+int grpc_is_unix_socket(const grpc_resolved_address* /* addr */) {
+  return false;
+}
 
-void grpc_unlink_if_unix_domain_socket(const grpc_resolved_address* addr) {}
+void grpc_unlink_if_unix_domain_socket(
+    const grpc_resolved_address* /* addr */) {}
 
 std::string grpc_sockaddr_to_uri_unix_if_possible(
-    const grpc_resolved_address* addr) {
+    const grpc_resolved_address* /* addr */) {
   return "";
 }
 

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

@@ -31,7 +31,7 @@
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
 #include "src/core/lib/profiling/timers.h"
 
-static grpc_error* eventfd_create(grpc_wakeup_fd* fd_info) {
+static grpc_error_handle eventfd_create(grpc_wakeup_fd* fd_info) {
   fd_info->read_fd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
   fd_info->write_fd = -1;
   if (fd_info->read_fd < 0) {
@@ -40,7 +40,7 @@ static grpc_error* eventfd_create(grpc_wakeup_fd* fd_info) {
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error* eventfd_consume(grpc_wakeup_fd* fd_info) {
+static grpc_error_handle eventfd_consume(grpc_wakeup_fd* fd_info) {
   eventfd_t value;
   int err;
   do {
@@ -52,7 +52,7 @@ static grpc_error* eventfd_consume(grpc_wakeup_fd* fd_info) {
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error* eventfd_wakeup(grpc_wakeup_fd* fd_info) {
+static grpc_error_handle eventfd_wakeup(grpc_wakeup_fd* fd_info) {
   GPR_TIMER_SCOPE("eventfd_wakeup", 0);
   int err;
   do {

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/iomgr/wakeup_fd_pipe.cc

@@ -33,14 +33,14 @@
 
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 
-static grpc_error* pipe_init(grpc_wakeup_fd* fd_info) {
+static grpc_error_handle pipe_init(grpc_wakeup_fd* fd_info) {
   int pipefd[2];
   int r = pipe(pipefd);
   if (0 != r) {
     gpr_log(GPR_ERROR, "pipe creation failed (%d): %s", errno, strerror(errno));
     return GRPC_OS_ERROR(errno, "pipe");
   }
-  grpc_error* err;
+  grpc_error_handle err;
   err = grpc_set_socket_nonblocking(pipefd[0], 1);
   if (err != GRPC_ERROR_NONE) return err;
   err = grpc_set_socket_nonblocking(pipefd[1], 1);
@@ -50,7 +50,7 @@ static grpc_error* pipe_init(grpc_wakeup_fd* fd_info) {
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error* pipe_consume(grpc_wakeup_fd* fd_info) {
+static grpc_error_handle pipe_consume(grpc_wakeup_fd* fd_info) {
   char buf[128];
   ssize_t r;
 
@@ -69,7 +69,7 @@ static grpc_error* pipe_consume(grpc_wakeup_fd* fd_info) {
   }
 }
 
-static grpc_error* pipe_wakeup(grpc_wakeup_fd* fd_info) {
+static grpc_error_handle pipe_wakeup(grpc_wakeup_fd* fd_info) {
   char c = 0;
   while (write(fd_info->write_fd, &c, 1) != 1 && errno == EINTR) {
   }

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

@@ -50,15 +50,15 @@ void grpc_wakeup_fd_global_destroy(void) { wakeup_fd_vtable = nullptr; }
 
 int grpc_has_wakeup_fd(void) { return has_real_wakeup_fd; }
 
-grpc_error* grpc_wakeup_fd_init(grpc_wakeup_fd* fd_info) {
+grpc_error_handle grpc_wakeup_fd_init(grpc_wakeup_fd* fd_info) {
   return wakeup_fd_vtable->init(fd_info);
 }
 
-grpc_error* grpc_wakeup_fd_consume_wakeup(grpc_wakeup_fd* fd_info) {
+grpc_error_handle grpc_wakeup_fd_consume_wakeup(grpc_wakeup_fd* fd_info) {
   return wakeup_fd_vtable->consume(fd_info);
 }
 
-grpc_error* grpc_wakeup_fd_wakeup(grpc_wakeup_fd* fd_info) {
+grpc_error_handle grpc_wakeup_fd_wakeup(grpc_wakeup_fd* fd_info) {
   return wakeup_fd_vtable->wakeup(fd_info);
 }
 

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

@@ -65,9 +65,9 @@ void grpc_enable_cv_wakeup_fds(int enable);
 typedef struct grpc_wakeup_fd grpc_wakeup_fd;
 
 typedef struct grpc_wakeup_fd_vtable {
-  grpc_error* (*init)(grpc_wakeup_fd* fd_info);
-  grpc_error* (*consume)(grpc_wakeup_fd* fd_info);
-  grpc_error* (*wakeup)(grpc_wakeup_fd* fd_info);
+  grpc_error_handle (*init)(grpc_wakeup_fd* fd_info);
+  grpc_error_handle (*consume)(grpc_wakeup_fd* fd_info);
+  grpc_error_handle (*wakeup)(grpc_wakeup_fd* fd_info);
   void (*destroy)(grpc_wakeup_fd* fd_info);
   /* Must be called before calling any other functions */
   int (*check_availability)(void);
@@ -83,10 +83,12 @@ extern int grpc_allow_pipe_wakeup_fd;
 
 #define GRPC_WAKEUP_FD_GET_READ_FD(fd_info) ((fd_info)->read_fd)
 
-grpc_error* grpc_wakeup_fd_init(grpc_wakeup_fd* fd_info) GRPC_MUST_USE_RESULT;
-grpc_error* grpc_wakeup_fd_consume_wakeup(grpc_wakeup_fd* fd_info)
+grpc_error_handle grpc_wakeup_fd_init(grpc_wakeup_fd* fd_info)
+    GRPC_MUST_USE_RESULT;
+grpc_error_handle grpc_wakeup_fd_consume_wakeup(grpc_wakeup_fd* fd_info)
+    GRPC_MUST_USE_RESULT;
+grpc_error_handle grpc_wakeup_fd_wakeup(grpc_wakeup_fd* fd_info)
     GRPC_MUST_USE_RESULT;
-grpc_error* grpc_wakeup_fd_wakeup(grpc_wakeup_fd* fd_info) GRPC_MUST_USE_RESULT;
 void grpc_wakeup_fd_destroy(grpc_wakeup_fd* fd_info);
 
 /* Defined in some specialized implementation's .c file, or by

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

@@ -20,6 +20,8 @@
 
 #include <functional>
 
+#include "absl/synchronization/mutex.h"
+
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/gprpp/debug_location.h"
@@ -43,12 +45,26 @@ namespace grpc_core {
 // other callbacks from other threads might also be executed before Run()
 // returns. Since an arbitrary set of callbacks might be executed when Run() is
 // called, generally no locks should be held while calling Run().
-class WorkSerializer {
+class ABSL_LOCKABLE WorkSerializer {
  public:
   WorkSerializer();
 
   ~WorkSerializer();
 
+  // Runs a given callback.
+  //
+  // If you want to use clang thread annotation to make sure that callback is
+  // called by WorkSerializer only, you need to add the annotation to both the
+  // lambda function given to Run and the actual callback function like;
+  //
+  //   void run_callback() {
+  //     work_serializer.Run(
+  //         []() ABSL_EXCLUSIVE_LOCKS_REQUIRED(work_serializer) {
+  //            callback();
+  //         }, DEBUG_LOCATION);
+  //   }
+  //   void callback() ABSL_EXCLUSIVE_LOCKS_REQUIRED(work_serializer) { ... }
+  //
   // TODO(yashkt): Replace grpc_core::DebugLocation with absl::SourceLocation
   // once we can start using it directly.
   void Run(std::function<void()> callback,

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

@@ -56,7 +56,7 @@ class Json {
   using Array = std::vector<Json>;
 
   // Parses JSON string from json_str.  On error, sets *error.
-  static Json Parse(absl::string_view json_str, grpc_error** error);
+  static Json Parse(absl::string_view json_str, grpc_error_handle* error);
 
   Json() = default;
 

data/src/core/lib/json/json_reader.cc

@@ -38,7 +38,7 @@ namespace {
 
 class JsonReader {
  public:
-  static grpc_error* Parse(absl::string_view input, Json* output);
+  static grpc_error_handle Parse(absl::string_view input, Json* output);
 
  private:
   enum class Status {
@@ -117,7 +117,7 @@ class JsonReader {
   bool container_just_begun_ = false;
   uint16_t unicode_char_ = 0;
   uint16_t unicode_high_surrogate_ = 0;
-  std::vector<grpc_error*> errors_;
+  std::vector<grpc_error_handle> errors_;
   bool truncated_errors_ = false;
 
   Json root_value_;
@@ -821,7 +821,7 @@ JsonReader::Status JsonReader::Run() {
   GPR_UNREACHABLE_CODE(return Status::GRPC_JSON_INTERNAL_ERROR);
 }
 
-grpc_error* JsonReader::Parse(absl::string_view input, Json* output) {
+grpc_error_handle JsonReader::Parse(absl::string_view input, Json* output) {
   JsonReader reader(input);
   Status status = reader.Run();
   if (reader.truncated_errors_) {
@@ -849,7 +849,7 @@ grpc_error* JsonReader::Parse(absl::string_view input, Json* output) {
 
 }  // namespace
 
-Json Json::Parse(absl::string_view json_str, grpc_error** error) {
+Json Json::Parse(absl::string_view json_str, grpc_error_handle* error) {
   Json value;
   *error = JsonReader::Parse(json_str, &value);
   return value;

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::kSafeRegex) {
+    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::kSafeRegex),
+      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::kSafeRegex) {
+    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::kSafeRegex) {
+    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::kSafeRegex) {
+    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::kSafeRegex) {
+    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::kSafeRegex) {
+    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::kExact:
+      return case_sensitive_ ? value == string_matcher_
+                             : absl::EqualsIgnoreCase(value, string_matcher_);
+    case StringMatcher::Type::kPrefix:
+      return case_sensitive_
+                 ? absl::StartsWith(value, string_matcher_)
+                 : absl::StartsWithIgnoreCase(value, string_matcher_);
+    case StringMatcher::Type::kSuffix:
+      return case_sensitive_ ? absl::EndsWith(value, string_matcher_)
+                             : absl::EndsWithIgnoreCase(value, string_matcher_);
+    case StringMatcher::Type::kContains:
+      return case_sensitive_
+                 ? absl::StrContains(value, string_matcher_)
+                 : absl::StrContains(absl::AsciiStrToLower(value),
+                                     absl::AsciiStrToLower(string_matcher_));
+    case StringMatcher::Type::kSafeRegex:
+      return RE2::FullMatch(std::string(value), *regex_matcher_);
+    default:
+      return false;
+  }
+}
+
+std::string StringMatcher::ToString() const {
+  switch (type_) {
+    case Type::kExact:
+      return absl::StrFormat("StringMatcher{exact=%s%s}", string_matcher_,
+                             case_sensitive_ ? "" : ", case_sensitive=false");
+    case Type::kPrefix:
+      return absl::StrFormat("StringMatcher{prefix=%s%s}", string_matcher_,
+                             case_sensitive_ ? "" : ", case_sensitive=false");
+    case Type::kSuffix:
+      return absl::StrFormat("StringMatcher{suffix=%s%s}", string_matcher_,
+                             case_sensitive_ ? "" : ", case_sensitive=false");
+    case Type::kContains:
+      return absl::StrFormat("StringMatcher{contains=%s%s}", string_matcher_,
+                             case_sensitive_ ? "" : ", case_sensitive=false");
+    case Type::kSafeRegex:
+      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::kRange) {
+    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::kRange),
+      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::kPresent),
+      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::kRange:
+      range_start_ = other.range_start_;
+      range_end_ = other.range_end_;
+      break;
+    case Type::kPresent:
+      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::kRange:
+      range_start_ = other.range_start_;
+      range_end_ = other.range_end_;
+      break;
+    case Type::kPresent:
+      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::kRange:
+      range_start_ = other.range_start_;
+      range_end_ = other.range_end_;
+      break;
+    case Type::kPresent:
+      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::kRange:
+      range_start_ = other.range_start_;
+      range_end_ = other.range_end_;
+      break;
+    case Type::kPresent:
+      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::kRange:
+      return range_start_ == other.range_start_ &&
+             range_end_ == other.range_end_;
+    case Type::kPresent:
+      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::kPresent) {
+    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::kRange) {
+    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::kRange:
+      return absl::StrFormat("HeaderMatcher{%s %srange=[%d, %d]}", name_,
+                             invert_match_ ? "not " : "", range_start_,
+                             range_end_);
+    case Type::kPresent:
+      return absl::StrFormat("HeaderMatcher{%s %spresent=%s}", name_,
+                             invert_match_ ? "not " : "",
+                             present_match_ ? "true" : "false");
+    case Type::kExact:
+    case Type::kPrefix:
+    case Type::kSuffix:
+    case Type::kSafeRegex:
+    case Type::kContains:
+      return absl::StrFormat("HeaderMatcher{%s %s%s}", name_,
+                             invert_match_ ? "not " : "", matcher_.ToString());
+    default:
+      return "";
+  }
+}
+
+}  // namespace grpc_core