grpc 1.80.0 → 1.81.0

data/src/core/xds/grpc/xds_matcher.cc

@@ -21,8 +21,7 @@
 #include <vector>
 
 #include "src/core/util/match.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
+#include "src/core/util/string.h"
 
 namespace grpc_core {
 
@@ -52,18 +51,21 @@ bool XdsMatcher::OnMatch::operator==(const OnMatch& other) const {
 }
 
 std::string XdsMatcher::OnMatch::ToString() const {
-  std::vector<std::string> parts;
-  parts.push_back(Match(
+  std::string result = "{";
+  Match(
       action,
-      [](const std::unique_ptr<Action>& action) {
-        return absl::StrCat("action=", action->ToString());
+      [&](const std::unique_ptr<Action>& action) {
+        StrAppend(result, "action=");
+        StrAppend(result, action->ToString());
       },
-      [](const std::unique_ptr<XdsMatcher>& matcher) {
-        return absl::StrCat("matcher=", matcher->ToString());
-      }));
-  parts.push_back(
-      absl::StrCat("keep_matching=", keep_matching ? "true" : "false"));
-  return absl::StrCat("{", absl::StrJoin(parts, ", "), "}");
+      [&](const std::unique_ptr<XdsMatcher>& matcher) {
+        StrAppend(result, "matcher=");
+        StrAppend(result, matcher->ToString());
+      });
+  StrAppend(result, ", keep_matching=");
+  StrAppend(result, keep_matching ? "true" : "false");
+  StrAppend(result, "}");
+  return result;
 }
 
 bool XdsMatcher::OnMatch::FindMatches(const MatchContext& context,
@@ -106,14 +108,19 @@ bool XdsMatcherList::Equals(const XdsMatcher& other) const {
 }
 
 std::string XdsMatcherList::ToString() const {
-  std::vector<std::string> parts;
+  std::string result = "XdsMatcherList{";
+  bool is_first = true;
   for (const auto& matcher : matchers_) {
-    parts.push_back(matcher.ToString());
+    if (!is_first) StrAppend(result, ", ");
+    StrAppend(result, matcher.ToString());
+    is_first = false;
   }
   if (on_no_match_.has_value()) {
-    parts.push_back(absl::StrCat("on_no_match=", on_no_match_->ToString()));
+    StrAppend(result, ", on_no_match=");
+    StrAppend(result, on_no_match_->ToString());
   }
-  return absl::StrCat("XdsMatcherList{", absl::StrJoin(parts, ", "), "}");
+  StrAppend(result, "}");
+  return result;
 }
 
 bool XdsMatcherList::FindMatches(const MatchContext& context,
@@ -149,12 +156,29 @@ bool XdsMatcherList::AndPredicate::Equals(const Predicate& other) const {
   return true;
 }
 
-std::string XdsMatcherList::AndPredicate::ToString() const {
-  std::vector<std::string> parts;
-  for (const auto& predicate : predicates_) {
-    parts.push_back(predicate->ToString());
+namespace {
+
+// Code shared between AndPredicate::ToString() and OrPredicate::ToString().
+ABSL_ATTRIBUTE_NOINLINE std::string PredicateListToString(
+    absl::string_view type,
+    const std::vector<std::unique_ptr<XdsMatcherList::Predicate>>& predicates) {
+  std::string result;
+  StrAppend(result, type);
+  StrAppend(result, "{");
+  bool is_first = true;
+  for (const auto& predicate : predicates) {
+    if (!is_first) StrAppend(result, ", ");
+    StrAppend(result, predicate->ToString());
+    is_first = false;
   }
-  return absl::StrCat("And{", absl::StrJoin(parts, ", "), "}");
+  StrAppend(result, "}");
+  return result;
+}
+
+}  // namespace
+
+std::string XdsMatcherList::AndPredicate::ToString() const {
+  return PredicateListToString("And", predicates_);
 }
 
 bool XdsMatcherList::AndPredicate::Match(
@@ -176,11 +200,7 @@ bool XdsMatcherList::OrPredicate::Equals(const Predicate& other) const {
 }
 
 std::string XdsMatcherList::OrPredicate::ToString() const {
-  std::vector<std::string> parts;
-  for (const auto& predicate : predicates_) {
-    parts.push_back(predicate->ToString());
-  }
-  return absl::StrCat("Or{", absl::StrJoin(parts, ", "), "}");
+  return PredicateListToString("Or", predicates_);
 }
 
 bool XdsMatcherList::OrPredicate::Match(
@@ -203,20 +223,50 @@ bool XdsMatcherExactMap::Equals(const XdsMatcher& other) const {
   return on_no_match_ == o.on_no_match_;
 }
 
-std::string XdsMatcherExactMap::ToString() const {
-  std::vector<std::string> map_parts;
-  for (const auto& pair : map_) {
-    map_parts.push_back(
-        absl::StrCat("{\"", pair.first, "\": ", pair.second.ToString(), "}"));
+namespace {
+
+// Code shared between XdsMatcherExactMap::ToString() and
+// XdsMatcherPrefixMap::ToString().
+ABSL_ATTRIBUTE_NOINLINE std::string MatcherMapToString(
+    absl::string_view type,
+    const XdsMatcher::InputValue<absl::string_view>& input,
+    std::vector<std::pair<std::string, std::string>> map_entries,
+    const std::optional<XdsMatcher::OnMatch>& on_no_match) {
+  std::string result;
+  StrAppend(result, type);
+  StrAppend(result, "{input=");
+  StrAppend(result, input.ToString());
+  StrAppend(result, ", map={");
+  std::sort(map_entries.begin(), map_entries.end());
+  bool is_first = true;
+  for (const auto& [k, v] : map_entries) {
+    StrAppend(result, is_first ? "{\"" : ", {\"");
+    StrAppend(result, k);
+    StrAppend(result, "\": ");
+    StrAppend(result, v);
+    StrAppend(result, "}");
+    is_first = false;
   }
-  std::sort(map_parts.begin(), map_parts.end());
-  std::vector<std::string> parts;
-  parts.push_back(absl::StrCat("input=", input_->ToString()));
-  parts.push_back(absl::StrCat("map={", absl::StrJoin(map_parts, ", "), "}"));
-  if (on_no_match_.has_value()) {
-    parts.push_back(absl::StrCat("on_no_match=", on_no_match_->ToString()));
+  StrAppend(result, "}");
+  if (on_no_match.has_value()) {
+    StrAppend(result, ", on_no_match=");
+    StrAppend(result, on_no_match->ToString());
+  }
+  StrAppend(result, "}");
+  return result;
+}
+
+}  // namespace
+
+std::string XdsMatcherExactMap::ToString() const {
+  // Should be able to use absl::string_view for the key here, but then
+  // we'd need to add bloat by templatizing MatcherMapToString().
+  std::vector<std::pair<std::string, std::string>> map_entries;
+  for (const auto& [k, v] : map_) {
+    map_entries.emplace_back(k, v.ToString());
   }
-  return absl::StrCat("XdsMatcherExactMap{", absl::StrJoin(parts, ", "), "}");
+  return MatcherMapToString("XdsMatcherExactMap", *input_,
+                            std::move(map_entries), on_no_match_);
 }
 
 bool XdsMatcherExactMap::FindMatches(const MatchContext& context,
@@ -265,19 +315,12 @@ bool XdsMatcherPrefixMap::Equals(const XdsMatcher& other) const {
 }
 
 std::string XdsMatcherPrefixMap::ToString() const {
-  std::vector<std::string> map_parts;
+  std::vector<std::pair<std::string, std::string>> map_entries;
   root_.ForEach([&](absl::string_view key, const OnMatch& value) {
-    map_parts.push_back(
-        absl::StrCat("{\"", key, "\": ", value.ToString(), "}"));
+    map_entries.emplace_back(std::string(key), value.ToString());
   });
-  std::sort(map_parts.begin(), map_parts.end());
-  std::vector<std::string> parts;
-  parts.push_back(absl::StrCat("input=", input_->ToString()));
-  parts.push_back(absl::StrCat("map={", absl::StrJoin(map_parts, ", "), "}"));
-  if (on_no_match_.has_value()) {
-    parts.push_back(absl::StrCat("on_no_match=", on_no_match_->ToString()));
-  }
-  return absl::StrCat("XdsMatcherPrefixMap{", absl::StrJoin(parts, ", "), "}");
+  return MatcherMapToString("XdsMatcherPrefixMap", *input_,
+                            std::move(map_entries), on_no_match_);
 }
 
 bool XdsMatcherPrefixMap::FindMatches(const MatchContext& context,

data/src/core/xds/grpc/xds_metadata.cc

@@ -22,8 +22,7 @@
 #include <utility>
 
 #include "src/core/util/grpc_check.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
+#include "src/core/util/string.h"
 #include "absl/strings/string_view.h"
 
 namespace grpc_core {
@@ -52,12 +51,46 @@ bool XdsMetadataMap::operator==(const XdsMetadataMap& other) const {
 }
 
 std::string XdsMetadataMap::ToString() const {
-  std::vector<std::string> entries;
-  for (const auto& [key, value] : map_) {
-    entries.push_back(absl::StrCat(key, "=", value->ToString()));
+  std::vector<absl::string_view> keys;
+  for (const auto& [key, _] : map_) {
+    keys.push_back(key);
+  }
+  std::sort(keys.begin(), keys.end());
+  std::string result = "{";
+  for (size_t i = 0; i < keys.size(); ++i) {
+    auto it = map_.find(keys[i]);
+    if (it == map_.end()) continue;  // Should never happen.
+    if (i > 0) StrAppend(result, ", ");
+    StrAppend(result, keys[i]);
+    StrAppend(result, "=");
+    StrAppend(result, it->second->ToString());
   }
-  std::sort(entries.begin(), entries.end());
-  return absl::StrCat("{", absl::StrJoin(entries, ", "), "}");
+  StrAppend(result, "}");
+  return result;
+}
+
+std::string XdsStructMetadataValue::ToString() const {
+  std::string result = std::string(type());
+  StrAppend(result, "{");
+  StrAppend(result, JsonDump(json_));
+  StrAppend(result, "}");
+  return result;
+}
+
+std::string XdsGcpAuthnAudienceMetadataValue::ToString() const {
+  std::string result = std::string(type());
+  StrAppend(result, "{url=\"");
+  StrAppend(result, url_);
+  StrAppend(result, "\"}");
+  return result;
+}
+
+std::string XdsAddressMetadataValue::ToString() const {
+  std::string result = std::string(type());
+  StrAppend(result, "{address=\"");
+  StrAppend(result, address_);
+  StrAppend(result, "\"}");
+  return result;
 }
 
 }  // namespace grpc_core

data/src/core/xds/grpc/xds_metadata.h

@@ -26,7 +26,6 @@
 #include "src/core/util/json/json_writer.h"
 #include "src/core/util/validation_errors.h"
 #include "absl/container/flat_hash_map.h"
-#include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
 namespace grpc_core {
@@ -90,9 +89,7 @@ class XdsStructMetadataValue : public XdsMetadataValue {
 
   const Json& json() const { return json_; }
 
-  std::string ToString() const override {
-    return absl::StrCat(type(), "{", JsonDump(json_), "}");
-  }
+  std::string ToString() const override;
 
  private:
   bool Equals(const XdsMetadataValue& other) const override {
@@ -116,9 +113,7 @@ class XdsGcpAuthnAudienceMetadataValue : public XdsMetadataValue {
 
   const std::string& url() const { return url_; }
 
-  std::string ToString() const override {
-    return absl::StrCat(type(), "{url=\"", url_, "\"}");
-  }
+  std::string ToString() const override;
 
  private:
   bool Equals(const XdsMetadataValue& other) const override {
@@ -141,9 +136,7 @@ class XdsAddressMetadataValue : public XdsMetadataValue {
 
   const std::string& address() const { return address_; }
 
-  std::string ToString() const override {
-    return absl::StrCat(type(), "{address=\"", address_, "\"}");
-  }
+  std::string ToString() const override;
 
  private:
   bool Equals(const XdsMetadataValue& other) const override {