grpc 1.31.0.pre1 → 1.33.0.pre1

data/src/core/lib/transport/static_metadata.h

@@ -36,7 +36,7 @@
 static_assert(
     std::is_trivially_destructible<grpc_core::StaticMetadataSlice>::value,
     "grpc_core::StaticMetadataSlice must be trivially destructible.");
-#define GRPC_STATIC_MDSTR_COUNT 108
+#define GRPC_STATIC_MDSTR_COUNT 110
 
 void grpc_init_static_metadata_ctx(void);
 void grpc_destroy_static_metadata_ctx(void);
@@ -132,154 +132,161 @@ inline const grpc_core::StaticMetadataSlice* grpc_static_slice_table() {
 /* "/envoy.service.load_stats.v2.LoadReportingService/StreamLoadStats" */
 #define GRPC_MDSTR_SLASH_ENVOY_DOT_SERVICE_DOT_LOAD_STATS_DOT_V2_DOT_LOADREPORTINGSERVICE_SLASH_STREAMLOADSTATS \
   (grpc_static_slice_table()[35])
+/* "/envoy.service.load_stats.v3.LoadReportingService/StreamLoadStats" */
+#define GRPC_MDSTR_SLASH_ENVOY_DOT_SERVICE_DOT_LOAD_STATS_DOT_V3_DOT_LOADREPORTINGSERVICE_SLASH_STREAMLOADSTATS \
+  (grpc_static_slice_table()[36])
 /* "/grpc.health.v1.Health/Watch" */
 #define GRPC_MDSTR_SLASH_GRPC_DOT_HEALTH_DOT_V1_DOT_HEALTH_SLASH_WATCH \
-  (grpc_static_slice_table()[36])
+  (grpc_static_slice_table()[37])
 /* "/envoy.service.discovery.v2.AggregatedDiscoveryService/StreamAggregatedResources"
  */
 #define GRPC_MDSTR_SLASH_ENVOY_DOT_SERVICE_DOT_DISCOVERY_DOT_V2_DOT_AGGREGATEDDISCOVERYSERVICE_SLASH_STREAMAGGREGATEDRESOURCES \
-  (grpc_static_slice_table()[37])
+  (grpc_static_slice_table()[38])
+/* "/envoy.service.discovery.v3.AggregatedDiscoveryService/StreamAggregatedResources"
+ */
+#define GRPC_MDSTR_SLASH_ENVOY_DOT_SERVICE_DOT_DISCOVERY_DOT_V3_DOT_AGGREGATEDDISCOVERYSERVICE_SLASH_STREAMAGGREGATEDRESOURCES \
+  (grpc_static_slice_table()[39])
 /* "deflate" */
-#define GRPC_MDSTR_DEFLATE (grpc_static_slice_table()[38])
+#define GRPC_MDSTR_DEFLATE (grpc_static_slice_table()[40])
 /* "gzip" */
-#define GRPC_MDSTR_GZIP (grpc_static_slice_table()[39])
+#define GRPC_MDSTR_GZIP (grpc_static_slice_table()[41])
 /* "stream/gzip" */
-#define GRPC_MDSTR_STREAM_SLASH_GZIP (grpc_static_slice_table()[40])
+#define GRPC_MDSTR_STREAM_SLASH_GZIP (grpc_static_slice_table()[42])
 /* "GET" */
-#define GRPC_MDSTR_GET (grpc_static_slice_table()[41])
+#define GRPC_MDSTR_GET (grpc_static_slice_table()[43])
 /* "POST" */
-#define GRPC_MDSTR_POST (grpc_static_slice_table()[42])
+#define GRPC_MDSTR_POST (grpc_static_slice_table()[44])
 /* "/" */
-#define GRPC_MDSTR_SLASH (grpc_static_slice_table()[43])
+#define GRPC_MDSTR_SLASH (grpc_static_slice_table()[45])
 /* "/index.html" */
-#define GRPC_MDSTR_SLASH_INDEX_DOT_HTML (grpc_static_slice_table()[44])
+#define GRPC_MDSTR_SLASH_INDEX_DOT_HTML (grpc_static_slice_table()[46])
 /* "http" */
-#define GRPC_MDSTR_HTTP (grpc_static_slice_table()[45])
+#define GRPC_MDSTR_HTTP (grpc_static_slice_table()[47])
 /* "https" */
-#define GRPC_MDSTR_HTTPS (grpc_static_slice_table()[46])
+#define GRPC_MDSTR_HTTPS (grpc_static_slice_table()[48])
 /* "200" */
-#define GRPC_MDSTR_200 (grpc_static_slice_table()[47])
+#define GRPC_MDSTR_200 (grpc_static_slice_table()[49])
 /* "204" */
-#define GRPC_MDSTR_204 (grpc_static_slice_table()[48])
+#define GRPC_MDSTR_204 (grpc_static_slice_table()[50])
 /* "206" */
-#define GRPC_MDSTR_206 (grpc_static_slice_table()[49])
+#define GRPC_MDSTR_206 (grpc_static_slice_table()[51])
 /* "304" */
-#define GRPC_MDSTR_304 (grpc_static_slice_table()[50])
+#define GRPC_MDSTR_304 (grpc_static_slice_table()[52])
 /* "400" */
-#define GRPC_MDSTR_400 (grpc_static_slice_table()[51])
+#define GRPC_MDSTR_400 (grpc_static_slice_table()[53])
 /* "404" */
-#define GRPC_MDSTR_404 (grpc_static_slice_table()[52])
+#define GRPC_MDSTR_404 (grpc_static_slice_table()[54])
 /* "500" */
-#define GRPC_MDSTR_500 (grpc_static_slice_table()[53])
+#define GRPC_MDSTR_500 (grpc_static_slice_table()[55])
 /* "accept-charset" */
-#define GRPC_MDSTR_ACCEPT_CHARSET (grpc_static_slice_table()[54])
+#define GRPC_MDSTR_ACCEPT_CHARSET (grpc_static_slice_table()[56])
 /* "gzip, deflate" */
-#define GRPC_MDSTR_GZIP_COMMA_DEFLATE (grpc_static_slice_table()[55])
+#define GRPC_MDSTR_GZIP_COMMA_DEFLATE (grpc_static_slice_table()[57])
 /* "accept-language" */
-#define GRPC_MDSTR_ACCEPT_LANGUAGE (grpc_static_slice_table()[56])
+#define GRPC_MDSTR_ACCEPT_LANGUAGE (grpc_static_slice_table()[58])
 /* "accept-ranges" */
-#define GRPC_MDSTR_ACCEPT_RANGES (grpc_static_slice_table()[57])
+#define GRPC_MDSTR_ACCEPT_RANGES (grpc_static_slice_table()[59])
 /* "accept" */
-#define GRPC_MDSTR_ACCEPT (grpc_static_slice_table()[58])
+#define GRPC_MDSTR_ACCEPT (grpc_static_slice_table()[60])
 /* "access-control-allow-origin" */
-#define GRPC_MDSTR_ACCESS_CONTROL_ALLOW_ORIGIN (grpc_static_slice_table()[59])
+#define GRPC_MDSTR_ACCESS_CONTROL_ALLOW_ORIGIN (grpc_static_slice_table()[61])
 /* "age" */
-#define GRPC_MDSTR_AGE (grpc_static_slice_table()[60])
+#define GRPC_MDSTR_AGE (grpc_static_slice_table()[62])
 /* "allow" */
-#define GRPC_MDSTR_ALLOW (grpc_static_slice_table()[61])
+#define GRPC_MDSTR_ALLOW (grpc_static_slice_table()[63])
 /* "authorization" */
-#define GRPC_MDSTR_AUTHORIZATION (grpc_static_slice_table()[62])
+#define GRPC_MDSTR_AUTHORIZATION (grpc_static_slice_table()[64])
 /* "cache-control" */
-#define GRPC_MDSTR_CACHE_CONTROL (grpc_static_slice_table()[63])
+#define GRPC_MDSTR_CACHE_CONTROL (grpc_static_slice_table()[65])
 /* "content-disposition" */
-#define GRPC_MDSTR_CONTENT_DISPOSITION (grpc_static_slice_table()[64])
+#define GRPC_MDSTR_CONTENT_DISPOSITION (grpc_static_slice_table()[66])
 /* "content-language" */
-#define GRPC_MDSTR_CONTENT_LANGUAGE (grpc_static_slice_table()[65])
+#define GRPC_MDSTR_CONTENT_LANGUAGE (grpc_static_slice_table()[67])
 /* "content-length" */
-#define GRPC_MDSTR_CONTENT_LENGTH (grpc_static_slice_table()[66])
+#define GRPC_MDSTR_CONTENT_LENGTH (grpc_static_slice_table()[68])
 /* "content-location" */
-#define GRPC_MDSTR_CONTENT_LOCATION (grpc_static_slice_table()[67])
+#define GRPC_MDSTR_CONTENT_LOCATION (grpc_static_slice_table()[69])
 /* "content-range" */
-#define GRPC_MDSTR_CONTENT_RANGE (grpc_static_slice_table()[68])
+#define GRPC_MDSTR_CONTENT_RANGE (grpc_static_slice_table()[70])
 /* "cookie" */
-#define GRPC_MDSTR_COOKIE (grpc_static_slice_table()[69])
+#define GRPC_MDSTR_COOKIE (grpc_static_slice_table()[71])
 /* "date" */
-#define GRPC_MDSTR_DATE (grpc_static_slice_table()[70])
+#define GRPC_MDSTR_DATE (grpc_static_slice_table()[72])
 /* "etag" */
-#define GRPC_MDSTR_ETAG (grpc_static_slice_table()[71])
+#define GRPC_MDSTR_ETAG (grpc_static_slice_table()[73])
 /* "expect" */
-#define GRPC_MDSTR_EXPECT (grpc_static_slice_table()[72])
+#define GRPC_MDSTR_EXPECT (grpc_static_slice_table()[74])
 /* "expires" */
-#define GRPC_MDSTR_EXPIRES (grpc_static_slice_table()[73])
+#define GRPC_MDSTR_EXPIRES (grpc_static_slice_table()[75])
 /* "from" */
-#define GRPC_MDSTR_FROM (grpc_static_slice_table()[74])
+#define GRPC_MDSTR_FROM (grpc_static_slice_table()[76])
 /* "if-match" */
-#define GRPC_MDSTR_IF_MATCH (grpc_static_slice_table()[75])
+#define GRPC_MDSTR_IF_MATCH (grpc_static_slice_table()[77])
 /* "if-modified-since" */
-#define GRPC_MDSTR_IF_MODIFIED_SINCE (grpc_static_slice_table()[76])
+#define GRPC_MDSTR_IF_MODIFIED_SINCE (grpc_static_slice_table()[78])
 /* "if-none-match" */
-#define GRPC_MDSTR_IF_NONE_MATCH (grpc_static_slice_table()[77])
+#define GRPC_MDSTR_IF_NONE_MATCH (grpc_static_slice_table()[79])
 /* "if-range" */
-#define GRPC_MDSTR_IF_RANGE (grpc_static_slice_table()[78])
+#define GRPC_MDSTR_IF_RANGE (grpc_static_slice_table()[80])
 /* "if-unmodified-since" */
-#define GRPC_MDSTR_IF_UNMODIFIED_SINCE (grpc_static_slice_table()[79])
+#define GRPC_MDSTR_IF_UNMODIFIED_SINCE (grpc_static_slice_table()[81])
 /* "last-modified" */
-#define GRPC_MDSTR_LAST_MODIFIED (grpc_static_slice_table()[80])
+#define GRPC_MDSTR_LAST_MODIFIED (grpc_static_slice_table()[82])
 /* "link" */
-#define GRPC_MDSTR_LINK (grpc_static_slice_table()[81])
+#define GRPC_MDSTR_LINK (grpc_static_slice_table()[83])
 /* "location" */
-#define GRPC_MDSTR_LOCATION (grpc_static_slice_table()[82])
+#define GRPC_MDSTR_LOCATION (grpc_static_slice_table()[84])
 /* "max-forwards" */
-#define GRPC_MDSTR_MAX_FORWARDS (grpc_static_slice_table()[83])
+#define GRPC_MDSTR_MAX_FORWARDS (grpc_static_slice_table()[85])
 /* "proxy-authenticate" */
-#define GRPC_MDSTR_PROXY_AUTHENTICATE (grpc_static_slice_table()[84])
+#define GRPC_MDSTR_PROXY_AUTHENTICATE (grpc_static_slice_table()[86])
 /* "proxy-authorization" */
-#define GRPC_MDSTR_PROXY_AUTHORIZATION (grpc_static_slice_table()[85])
+#define GRPC_MDSTR_PROXY_AUTHORIZATION (grpc_static_slice_table()[87])
 /* "range" */
-#define GRPC_MDSTR_RANGE (grpc_static_slice_table()[86])
+#define GRPC_MDSTR_RANGE (grpc_static_slice_table()[88])
 /* "referer" */
-#define GRPC_MDSTR_REFERER (grpc_static_slice_table()[87])
+#define GRPC_MDSTR_REFERER (grpc_static_slice_table()[89])
 /* "refresh" */
-#define GRPC_MDSTR_REFRESH (grpc_static_slice_table()[88])
+#define GRPC_MDSTR_REFRESH (grpc_static_slice_table()[90])
 /* "retry-after" */
-#define GRPC_MDSTR_RETRY_AFTER (grpc_static_slice_table()[89])
+#define GRPC_MDSTR_RETRY_AFTER (grpc_static_slice_table()[91])
 /* "server" */
-#define GRPC_MDSTR_SERVER (grpc_static_slice_table()[90])
+#define GRPC_MDSTR_SERVER (grpc_static_slice_table()[92])
 /* "set-cookie" */
-#define GRPC_MDSTR_SET_COOKIE (grpc_static_slice_table()[91])
+#define GRPC_MDSTR_SET_COOKIE (grpc_static_slice_table()[93])
 /* "strict-transport-security" */
-#define GRPC_MDSTR_STRICT_TRANSPORT_SECURITY (grpc_static_slice_table()[92])
+#define GRPC_MDSTR_STRICT_TRANSPORT_SECURITY (grpc_static_slice_table()[94])
 /* "transfer-encoding" */
-#define GRPC_MDSTR_TRANSFER_ENCODING (grpc_static_slice_table()[93])
+#define GRPC_MDSTR_TRANSFER_ENCODING (grpc_static_slice_table()[95])
 /* "vary" */
-#define GRPC_MDSTR_VARY (grpc_static_slice_table()[94])
+#define GRPC_MDSTR_VARY (grpc_static_slice_table()[96])
 /* "via" */
-#define GRPC_MDSTR_VIA (grpc_static_slice_table()[95])
+#define GRPC_MDSTR_VIA (grpc_static_slice_table()[97])
 /* "www-authenticate" */
-#define GRPC_MDSTR_WWW_AUTHENTICATE (grpc_static_slice_table()[96])
+#define GRPC_MDSTR_WWW_AUTHENTICATE (grpc_static_slice_table()[98])
 /* "0" */
-#define GRPC_MDSTR_0 (grpc_static_slice_table()[97])
+#define GRPC_MDSTR_0 (grpc_static_slice_table()[99])
 /* "identity" */
-#define GRPC_MDSTR_IDENTITY (grpc_static_slice_table()[98])
+#define GRPC_MDSTR_IDENTITY (grpc_static_slice_table()[100])
 /* "trailers" */
-#define GRPC_MDSTR_TRAILERS (grpc_static_slice_table()[99])
+#define GRPC_MDSTR_TRAILERS (grpc_static_slice_table()[101])
 /* "application/grpc" */
-#define GRPC_MDSTR_APPLICATION_SLASH_GRPC (grpc_static_slice_table()[100])
+#define GRPC_MDSTR_APPLICATION_SLASH_GRPC (grpc_static_slice_table()[102])
 /* "grpc" */
-#define GRPC_MDSTR_GRPC (grpc_static_slice_table()[101])
+#define GRPC_MDSTR_GRPC (grpc_static_slice_table()[103])
 /* "PUT" */
-#define GRPC_MDSTR_PUT (grpc_static_slice_table()[102])
+#define GRPC_MDSTR_PUT (grpc_static_slice_table()[104])
 /* "lb-cost-bin" */
-#define GRPC_MDSTR_LB_COST_BIN (grpc_static_slice_table()[103])
+#define GRPC_MDSTR_LB_COST_BIN (grpc_static_slice_table()[105])
 /* "identity,deflate" */
-#define GRPC_MDSTR_IDENTITY_COMMA_DEFLATE (grpc_static_slice_table()[104])
+#define GRPC_MDSTR_IDENTITY_COMMA_DEFLATE (grpc_static_slice_table()[106])
 /* "identity,gzip" */
-#define GRPC_MDSTR_IDENTITY_COMMA_GZIP (grpc_static_slice_table()[105])
+#define GRPC_MDSTR_IDENTITY_COMMA_GZIP (grpc_static_slice_table()[107])
 /* "deflate,gzip" */
-#define GRPC_MDSTR_DEFLATE_COMMA_GZIP (grpc_static_slice_table()[106])
+#define GRPC_MDSTR_DEFLATE_COMMA_GZIP (grpc_static_slice_table()[108])
 /* "identity,deflate,gzip" */
 #define GRPC_MDSTR_IDENTITY_COMMA_DEFLATE_COMMA_GZIP \
-  (grpc_static_slice_table()[107])
+  (grpc_static_slice_table()[109])
 
 namespace grpc_core {
 struct StaticSliceRefcount;

data/src/core/lib/transport/transport.h

@@ -459,4 +459,11 @@ grpc_transport_op* grpc_make_transport_op(grpc_closure* on_consumed);
 grpc_transport_stream_op_batch* grpc_make_transport_stream_op(
     grpc_closure* on_consumed);
 
+namespace grpc_core {
+// This is the key to be used for loading/storing keepalive_throttling in the
+// absl::Status object.
+constexpr const char* kKeepaliveThrottlingKey =
+    "grpc.internal.keepalive_throttling";
+}  // namespace grpc_core
+
 #endif /* GRPC_CORE_LIB_TRANSPORT_TRANSPORT_H */

data/src/core/lib/uri/uri_parser.cc

@@ -38,11 +38,12 @@
 /** a size_t default value... maps to all 1's */
 #define NOT_SET (~(size_t)0)
 
-static grpc_uri* bad_uri(const char* uri_text, size_t pos, const char* section,
-                         bool suppress_errors) {
+static grpc_uri* bad_uri(absl::string_view uri_text, size_t pos,
+                         const char* section, bool suppress_errors) {
   if (!suppress_errors) {
     std::string line_prefix = absl::StrFormat("bad uri.%s: '", section);
-    gpr_log(GPR_ERROR, "%s%s'", line_prefix.c_str(), uri_text);
+    gpr_log(GPR_ERROR, "%s%s'", line_prefix.c_str(),
+            std::string(uri_text).c_str());
     size_t pfx_len = line_prefix.size() + pos;
     gpr_log(GPR_ERROR, "%s^ here", std::string(pfx_len, ' ').c_str());
   }
@@ -50,12 +51,12 @@ static grpc_uri* bad_uri(const char* uri_text, size_t pos, const char* section,
 }
 
 /** Returns a copy of percent decoded \a src[begin, end) */
-static char* decode_and_copy_component(const char* src, size_t begin,
+static char* decode_and_copy_component(absl::string_view src, size_t begin,
                                        size_t end) {
   grpc_slice component =
       (begin == NOT_SET || end == NOT_SET)
           ? grpc_empty_slice()
-          : grpc_slice_from_copied_buffer(src + begin, end - begin);
+          : grpc_slice_from_copied_buffer(src.data() + begin, end - begin);
   grpc_slice decoded_component =
       grpc_permissive_percent_decode_slice(component);
   char* out = grpc_dump_slice(decoded_component, GPR_DUMP_ASCII);
@@ -72,7 +73,7 @@ static bool valid_hex(char c) {
 /** Returns how many chars to advance if \a uri_text[i] begins a valid \a pchar
  * production. If \a uri_text[i] introduces an invalid \a pchar (such as percent
  * sign not followed by two hex digits), NOT_SET is returned. */
-static size_t parse_pchar(const char* uri_text, size_t i) {
+static size_t parse_pchar(absl::string_view uri_text, size_t i) {
   /* pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
    * unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
    * pct-encoded = "%" HEXDIG HEXDIG
@@ -105,7 +106,8 @@ static size_t parse_pchar(const char* uri_text, size_t i) {
     case '=':
       return 1;
     case '%': /* pct-encoded */
-      if (valid_hex(uri_text[i + 1]) && valid_hex(uri_text[i + 2])) {
+      if (uri_text.size() > i + 2 && valid_hex(uri_text[i + 1]) &&
+          valid_hex(uri_text[i + 2])) {
         return 2;
       }
       return NOT_SET;
@@ -114,9 +116,8 @@ static size_t parse_pchar(const char* uri_text, size_t i) {
 }
 
 /* *( pchar / "?" / "/" ) */
-static int parse_fragment_or_query(const char* uri_text, size_t* i) {
-  char c;
-  while ((c = uri_text[*i]) != 0) {
+static int parse_fragment_or_query(absl::string_view uri_text, size_t* i) {
+  while (uri_text.size() > *i) {
     const size_t advance = parse_pchar(uri_text, *i); /* pchar */
     switch (advance) {
       case 0: /* uri_text[i] isn't in pchar */
@@ -178,7 +179,7 @@ static void parse_query_parts(grpc_uri* uri) {
   }
 }
 
-grpc_uri* grpc_uri_parse(const char* uri_text, bool suppress_errors) {
+grpc_uri* grpc_uri_parse(absl::string_view uri_text, bool suppress_errors) {
   grpc_uri* uri;
   size_t scheme_begin = 0;
   size_t scheme_end = NOT_SET;
@@ -192,7 +193,7 @@ grpc_uri* grpc_uri_parse(const char* uri_text, bool suppress_errors) {
   size_t fragment_end = NOT_SET;
   size_t i;
 
-  for (i = scheme_begin; uri_text[i] != 0; i++) {
+  for (i = scheme_begin; i < uri_text.size(); ++i) {
     if (uri_text[i] == ':') {
       scheme_end = i;
       break;
@@ -211,15 +212,16 @@ grpc_uri* grpc_uri_parse(const char* uri_text, bool suppress_errors) {
     return bad_uri(uri_text, i, "scheme", suppress_errors);
   }
 
-  if (uri_text[scheme_end + 1] == '/' && uri_text[scheme_end + 2] == '/') {
+  if (uri_text.size() > scheme_end + 2 && uri_text[scheme_end + 1] == '/' &&
+      uri_text[scheme_end + 2] == '/') {
     authority_begin = scheme_end + 3;
-    for (i = authority_begin; uri_text[i] != 0 && authority_end == NOT_SET;
+    for (i = authority_begin; uri_text.size() > i && authority_end == NOT_SET;
          i++) {
       if (uri_text[i] == '/' || uri_text[i] == '?' || uri_text[i] == '#') {
         authority_end = i;
       }
     }
-    if (authority_end == NOT_SET && uri_text[i] == 0) {
+    if (authority_end == NOT_SET && uri_text.size() == i) {
       authority_end = i;
     }
     if (authority_end == NOT_SET) {
@@ -231,34 +233,34 @@ grpc_uri* grpc_uri_parse(const char* uri_text, bool suppress_errors) {
     path_begin = scheme_end + 1;
   }
 
-  for (i = path_begin; uri_text[i] != 0; i++) {
+  for (i = path_begin; i < uri_text.size(); ++i) {
     if (uri_text[i] == '?' || uri_text[i] == '#') {
       path_end = i;
       break;
     }
   }
-  if (path_end == NOT_SET && uri_text[i] == 0) {
+  if (path_end == NOT_SET && uri_text.size() == i) {
     path_end = i;
   }
   if (path_end == NOT_SET) {
     return bad_uri(uri_text, i, "path", suppress_errors);
   }
 
-  if (uri_text[i] == '?') {
+  if (uri_text.size() > i && uri_text[i] == '?') {
     query_begin = ++i;
     if (!parse_fragment_or_query(uri_text, &i)) {
       return bad_uri(uri_text, i, "query", suppress_errors);
-    } else if (uri_text[i] != 0 && uri_text[i] != '#') {
+    } else if (uri_text.size() > i && uri_text[i] != '#') {
       /* We must be at the end or at the beginning of a fragment */
       return bad_uri(uri_text, i, "query", suppress_errors);
     }
     query_end = i;
   }
-  if (uri_text[i] == '#') {
+  if (uri_text.size() > i && uri_text[i] == '#') {
     fragment_begin = ++i;
     if (!parse_fragment_or_query(uri_text, &i)) {
       return bad_uri(uri_text, i - fragment_end, "fragment", suppress_errors);
-    } else if (uri_text[i] != 0) {
+    } else if (uri_text.size() > i) {
       /* We must be at the end */
       return bad_uri(uri_text, i, "fragment", suppress_errors);
     }

data/src/core/lib/uri/uri_parser.h

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/strings/string_view.h"
+
 #include <stddef.h>
 
 struct grpc_uri {
@@ -37,7 +39,7 @@ struct grpc_uri {
   char* fragment;
 };
 /** parse a uri, return NULL on failure */
-grpc_uri* grpc_uri_parse(const char* uri_text, bool suppress_errors);
+grpc_uri* grpc_uri_parse(absl::string_view uri_text, bool suppress_errors);
 
 /** return the part of a query string after the '=' in "?key=xxx&...", or NULL
  * if key is not present */

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -34,18 +34,10 @@ void grpc_resolver_fake_init(void);
 void grpc_resolver_fake_shutdown(void);
 void grpc_lb_policy_grpclb_init(void);
 void grpc_lb_policy_grpclb_shutdown(void);
-void grpc_lb_policy_cds_init(void);
-void grpc_lb_policy_cds_shutdown(void);
-void grpc_lb_policy_eds_init(void);
-void grpc_lb_policy_eds_shutdown(void);
-void grpc_lb_policy_lrs_init(void);
-void grpc_lb_policy_lrs_shutdown(void);
 void grpc_lb_policy_priority_init(void);
 void grpc_lb_policy_priority_shutdown(void);
 void grpc_lb_policy_weighted_target_init(void);
 void grpc_lb_policy_weighted_target_shutdown(void);
-void grpc_lb_policy_xds_routing_init(void);
-void grpc_lb_policy_xds_routing_shutdown(void);
 void grpc_lb_policy_pick_first_init(void);
 void grpc_lb_policy_pick_first_shutdown(void);
 void grpc_lb_policy_round_robin_init(void);
@@ -56,8 +48,6 @@ void grpc_resolver_dns_native_init(void);
 void grpc_resolver_dns_native_shutdown(void);
 void grpc_resolver_sockaddr_init(void);
 void grpc_resolver_sockaddr_shutdown(void);
-void grpc_resolver_xds_init(void);
-void grpc_resolver_xds_shutdown(void);
 void grpc_client_idle_filter_init(void);
 void grpc_client_idle_filter_shutdown(void);
 void grpc_max_age_filter_init(void);
@@ -71,6 +61,25 @@ void grpc_client_authority_filter_shutdown(void);
 void grpc_workaround_cronet_compression_filter_init(void);
 void grpc_workaround_cronet_compression_filter_shutdown(void);
 
+#ifndef GRPC_NO_XDS
+namespace grpc_core {
+void XdsClientGlobalInit();
+void XdsClientGlobalShutdown();
+}  // namespace grpc_core
+void grpc_certificate_provider_registry_init(void);
+void grpc_certificate_provider_registry_shutdown(void);
+void grpc_lb_policy_cds_init(void);
+void grpc_lb_policy_cds_shutdown(void);
+void grpc_lb_policy_eds_init(void);
+void grpc_lb_policy_eds_shutdown(void);
+void grpc_lb_policy_eds_drop_init(void);
+void grpc_lb_policy_eds_drop_shutdown(void);
+void grpc_lb_policy_xds_cluster_manager_init(void);
+void grpc_lb_policy_xds_cluster_manager_shutdown(void);
+void grpc_resolver_xds_init(void);
+void grpc_resolver_xds_shutdown(void);
+#endif
+
 void grpc_register_built_in_plugins(void) {
   grpc_register_plugin(grpc_http_filters_init,
                        grpc_http_filters_shutdown);
@@ -86,18 +95,10 @@ void grpc_register_built_in_plugins(void) {
                        grpc_resolver_fake_shutdown);
   grpc_register_plugin(grpc_lb_policy_grpclb_init,
                        grpc_lb_policy_grpclb_shutdown);
-  grpc_register_plugin(grpc_lb_policy_cds_init,
-                       grpc_lb_policy_cds_shutdown);
-  grpc_register_plugin(grpc_lb_policy_eds_init,
-                       grpc_lb_policy_eds_shutdown);
-  grpc_register_plugin(grpc_lb_policy_lrs_init,
-                       grpc_lb_policy_lrs_shutdown);
   grpc_register_plugin(grpc_lb_policy_priority_init,
                        grpc_lb_policy_priority_shutdown);
   grpc_register_plugin(grpc_lb_policy_weighted_target_init,
                        grpc_lb_policy_weighted_target_shutdown);
-  grpc_register_plugin(grpc_lb_policy_xds_routing_init,
-                       grpc_lb_policy_xds_routing_shutdown);
   grpc_register_plugin(grpc_lb_policy_pick_first_init,
                        grpc_lb_policy_pick_first_shutdown);
   grpc_register_plugin(grpc_lb_policy_round_robin_init,
@@ -108,8 +109,6 @@ void grpc_register_built_in_plugins(void) {
                        grpc_resolver_dns_native_shutdown);
   grpc_register_plugin(grpc_resolver_sockaddr_init,
                        grpc_resolver_sockaddr_shutdown);
-  grpc_register_plugin(grpc_resolver_xds_init,
-                       grpc_resolver_xds_shutdown);
   grpc_register_plugin(grpc_client_idle_filter_init,
                        grpc_client_idle_filter_shutdown);
   grpc_register_plugin(grpc_max_age_filter_init,
@@ -122,4 +121,20 @@ void grpc_register_built_in_plugins(void) {
                        grpc_client_authority_filter_shutdown);
   grpc_register_plugin(grpc_workaround_cronet_compression_filter_init,
                        grpc_workaround_cronet_compression_filter_shutdown);
+#ifndef GRPC_NO_XDS
+  grpc_register_plugin(grpc_core::XdsClientGlobalInit,
+                       grpc_core::XdsClientGlobalShutdown);
+  grpc_register_plugin(grpc_certificate_provider_registry_init,
+                       grpc_certificate_provider_registry_shutdown);
+  grpc_register_plugin(grpc_lb_policy_cds_init,
+                       grpc_lb_policy_cds_shutdown);
+  grpc_register_plugin(grpc_lb_policy_eds_init,
+                       grpc_lb_policy_eds_shutdown);
+  grpc_register_plugin(grpc_lb_policy_eds_drop_init,
+                       grpc_lb_policy_eds_drop_shutdown);
+  grpc_register_plugin(grpc_lb_policy_xds_cluster_manager_init,
+                       grpc_lb_policy_xds_cluster_manager_shutdown);
+  grpc_register_plugin(grpc_resolver_xds_init,
+                       grpc_resolver_xds_shutdown);
+#endif
 }