grpc 1.72.0 → 1.73.0

data/src/core/util/dual_ref_counted.h

@@ -250,6 +250,49 @@ class DualRefCounted : public Impl {
     }
   }
 
+  GRPC_MUST_USE_RESULT WeakRefCountedPtr<Child> WeakRefIfNonZero() {
+    uint64_t prev_ref_pair = refs_.load(std::memory_order_acquire);
+    do {
+      const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
+      const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
+#ifndef NDEBUG
+      if (trace_ != nullptr) {
+        VLOG(2) << trace_ << ":" << this << " ref_if_non_zero " << strong_refs
+                << " -> " << strong_refs + 1 << " (weak_refs=" << weak_refs
+                << ")";
+      }
+#endif
+      if (strong_refs == 0 && weak_refs == 0) return nullptr;
+    } while (!refs_.compare_exchange_weak(
+        prev_ref_pair, prev_ref_pair + MakeRefPair(0, 1),
+        std::memory_order_acq_rel, std::memory_order_acquire));
+    return WeakRefCountedPtr<Child>(static_cast<Child*>(this));
+  }
+  GRPC_MUST_USE_RESULT WeakRefCountedPtr<Child> WeakRefIfNonZero(
+      const DebugLocation& location, const char* reason) {
+    uint64_t prev_ref_pair = refs_.load(std::memory_order_acquire);
+    do {
+      const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
+      const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
+#ifndef NDEBUG
+      if (trace_ != nullptr) {
+        VLOG(2) << trace_ << ":" << this << " " << location.file() << ":"
+                << location.line() << " ref_if_non_zero " << strong_refs
+                << " -> " << strong_refs + 1 << " (weak_refs=" << weak_refs
+                << ") " << reason;
+      }
+#else
+      // Avoid unused-parameter warnings for debug-only parameters
+      (void)location;
+      (void)reason;
+#endif
+      if (strong_refs == 0 && weak_refs == 0) return nullptr;
+    } while (!refs_.compare_exchange_weak(
+        prev_ref_pair, prev_ref_pair + MakeRefPair(0, 1),
+        std::memory_order_acq_rel, std::memory_order_acquire));
+    return WeakRefCountedPtr<Child>(static_cast<Child*>(this));
+  }
+
  protected:
   // Note: Tracing is a no-op in non-debug builds.
   explicit DualRefCounted(
@@ -273,6 +316,11 @@ class DualRefCounted : public Impl {
   // Note: Depending on the Impl used, this dtor can be implicitly virtual.
   ~DualRefCounted() = default;
 
+  // Debug check to validate that this object is still strongly owned
+  void AssertStronglyOwned() const {
+    DCHECK_NE(GetStrongRefs(refs_.load(std::memory_order_relaxed)), 0u);
+  }
+
  private:
   // Allow RefCountedPtr<> to access IncrementRefCount().
   template <typename T>

data/src/core/util/function_signature.h

@@ -0,0 +1,66 @@
+// Copyright 2025 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.
+
+#ifndef GRPC_SRC_CORE_UTIL_FUNCTION_SIGNATURE_H
+#define GRPC_SRC_CORE_UTIL_FUNCTION_SIGNATURE_H
+
+#include "absl/strings/string_view.h"
+
+// Macros defined:
+// GRPC_FUNCTION_SIGNATURE
+//   - a c-string variable that contains a reasonable rendering of the function
+//     name
+// GRPC_FUNCTION_SIGNATURE_CAPTURES_LAMBDA_FILENAMES
+//   - a bool that indicates if a lambda is captured, will it contain the
+//     filename - this can be used for tests that want to check the filename
+//     is there on some platforms
+
+#if defined(_MSC_VER)
+#define GRPC_FUNCTION_SIGNATURE __FUNCSIG__
+#elif defined(__GNUC__)
+#define GRPC_FUNCTION_SIGNATURE __PRETTY_FUNCTION__
+#else
+#define GRPC_FUNCTION_SIGNATURE "???()"
+#endif
+
+namespace grpc_core {
+
+// Debug helper function to extract a string type name from a C++ type.
+// This is absolutely best effort and certainly doesn't actually work on some
+// platforms. Do not use this for actual functionality, but it's super useful
+// for exporting debug/trace information.
+template <typename T>
+static constexpr inline absl::string_view TypeName() {
+#if defined(__clang__)
+  constexpr absl::string_view kPrefix{"[T = "};
+  constexpr absl::string_view kSuffix{"]"};
+#elif defined(__GNUC__)
+  constexpr absl::string_view kPrefix{"[with T = "};
+  constexpr absl::string_view kSuffix{";"};
+#elif defined(_MSC_VER)
+  constexpr absl::string_view kPrefix{"TypeName<"};
+  constexpr absl::string_view kSuffix{">(void)"};
+#else
+  return "unknown";
+#endif
+  constexpr absl::string_view kFunction{GRPC_FUNCTION_SIGNATURE};
+  constexpr size_t kStart = kFunction.find(kPrefix) + kPrefix.size();
+  constexpr size_t kEnd = kFunction.rfind(kSuffix);
+  static_assert(kStart < kEnd);
+  return kFunction.substr(kStart, (kEnd - kStart));
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_UTIL_FUNCTION_SIGNATURE_H

data/src/core/util/gcp_metadata_query.cc

@@ -68,8 +68,9 @@ GcpMetadataQuery::GcpMetadataQuery(
       attribute_(std::move(attribute)),
       callback_(std::move(callback)) {
   GRPC_CLOSURE_INIT(&on_done_, OnDone, this, nullptr);
-  auto uri = URI::Create("http", std::move(metadata_server_name), attribute_,
-                         {} /* query params */, "" /* fragment */);
+  auto uri =
+      URI::Create("http", /*user_info=*/"", std::move(metadata_server_name),
+                  attribute_, {} /* query params */, "" /* fragment */);
   CHECK(uri.ok());  // params are hardcoded
   grpc_http_request request;
   memset(&request, 0, sizeof(grpc_http_request));

data/src/core/util/http_client/httpcli_security_connector.cc

@@ -90,7 +90,8 @@ class grpc_httpcli_ssl_channel_security_connector final
     if (handshaker_factory_ != nullptr) {
       tsi_result result = tsi_ssl_client_handshaker_factory_create_handshaker(
           handshaker_factory_, secure_peer_name_, /*network_bio_buf_size=*/0,
-          /*ssl_bio_buf_size=*/0, &handshaker);
+          /*ssl_bio_buf_size=*/0,
+          args.GetOwnedString(GRPC_ARG_TRANSPORT_PROTOCOLS), &handshaker);
       if (result != TSI_OK) {
         LOG(ERROR) << "Handshaker creation failed with error "
                    << tsi_result_to_string(result);

data/src/core/util/json/json_object_loader.h

@@ -373,11 +373,11 @@ class AutoLoader<std::vector<bool>> final : public LoaderInterface {
 };
 
 // Specializations of AutoLoader for maps.
-template <typename T>
-class AutoLoader<std::map<std::string, T>> final : public LoadMap {
+template <typename T, typename C>
+class AutoLoader<std::map<std::string, T, C>> final : public LoadMap {
  private:
   void* Insert(const std::string& name, void* dst) const final {
-    return &static_cast<std::map<std::string, T>*>(dst)
+    return &static_cast<std::map<std::string, T, C>*>(dst)
                 ->emplace(name, T())
                 .first->second;
   };

data/src/core/util/latent_see.cc

@@ -23,6 +23,7 @@
 #include <vector>
 
 #include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 #include "src/core/util/ring_buffer.h"
 #include "src/core/util/sync.h"
@@ -38,6 +39,27 @@ std::atomic<uintptr_t> Log::free_bins_{0};
 const std::chrono::steady_clock::time_point start_time =
     std::chrono::steady_clock::now();
 
+void Log::InstallAtExitHandler() {
+  atexit([] {
+    auto& log = Log::Get();
+    auto json = log.TryGenerateJson();
+    if (!json.has_value()) {
+      LOG(INFO) << "Failed to generate latent_see.json (contention with "
+                   "another writer)";
+      return;
+    }
+    if (log.stats_flusher_ != nullptr) {
+      log.stats_flusher_(*json);
+      return;
+    }
+    LOG(INFO) << "Writing latent_see.json in " << get_current_dir_name();
+    FILE* f = fopen("latent_see.json", "w");
+    if (f == nullptr) return;
+    fprintf(f, "%s", json->c_str());
+    fclose(f);
+  });
+}
+
 void Log::TryPullEventsAndFlush(
     absl::FunctionRef<void(absl::Span<const RecordedEvent>)> callback) {
   // Try to lock... if we fail then clear the active events.
@@ -115,13 +137,17 @@ std::optional<std::string> Log::TryGenerateJson() {
         absl::StrAppend(
             &json, "{\"name\": \"", event.event.metadata->name,
             "\", \"ph\": \"", phase, "\", \"ts\": ",
-            Nanos(event.event.timestamp - start_time).count() / 1000.0,
+            absl::StrFormat(
+                "%.12g",
+                Nanos(event.event.timestamp - start_time).count() / 1000.0),
             ", \"pid\": 0, \"tid\": ", event.thread_id);
       } else {
         absl::StrAppend(
             &json, "{\"name\": ", event.event.metadata->name, ", \"ph\": \"",
             phase, "\", \"ts\": ",
-            Nanos(event.event.timestamp - start_time).count() / 1000.0,
+            absl::StrFormat(
+                "%.12g",
+                Nanos(event.event.timestamp - start_time).count() / 1000.0),
             ", \"pid\": 0, \"tid\": ", event.thread_id);
       }
 

data/src/core/util/latent_see.h

@@ -119,26 +119,7 @@ class Log {
   static Bin* CurrentThreadBin() { return bin_; }
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Log& Get() {
-    static Log* log = []() {
-      atexit([] {
-        auto json = log->TryGenerateJson();
-        if (!json.has_value()) {
-          LOG(INFO) << "Failed to generate latent_see.json (contention with "
-                       "another writer)";
-          return;
-        }
-        if (log->stats_flusher_ != nullptr) {
-          log->stats_flusher_(*json);
-          return;
-        }
-        LOG(INFO) << "Writing latent_see.json in " << get_current_dir_name();
-        FILE* f = fopen("latent_see.json", "w");
-        if (f == nullptr) return;
-        fprintf(f, "%s", json->c_str());
-        fclose(f);
-      });
-      return new Log();
-    }();
+    static Log* log = new Log();
     return *log;
   }
 
@@ -151,6 +132,10 @@ class Log {
     stats_flusher_ = std::move(stats_exporter);
   }
 
+  // Install an atexit callback that will log to latent_see.json in the working
+  // directory
+  static void InstallAtExitHandler();
+
  private:
   Log() = default;
 
@@ -297,9 +282,12 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto Promise(const Metadata* md_poll,
 // scope.
 #define GRPC_LATENT_SEE_MARK(name) \
   grpc_core::latent_see::Mark(GRPC_LATENT_SEE_METADATA(name))
-#define GRPC_LATENT_SEE_PROMISE(name, promise)                           \
-  grpc_core::latent_see::Promise(GRPC_LATENT_SEE_METADATA("Poll:" name), \
-                                 GRPC_LATENT_SEE_METADATA(name), promise)
+#define GRPC_LATENT_SEE_PROMISE(name, promise)                                 \
+  grpc_core::latent_see::Promise(GRPC_LATENT_SEE_METADATA("Poll:" name),       \
+                                 GRPC_LATENT_SEE_METADATA(name), [&]() {       \
+                                   GRPC_LATENT_SEE_INNER_SCOPE("Setup:" name); \
+                                   return promise;                             \
+                                 }())
 #else  // !def(GRPC_ENABLE_LATENT_SEE)
 namespace grpc_core {
 namespace latent_see {

data/src/core/util/linux/env.cc

@@ -37,10 +37,12 @@ namespace grpc_core {
 
 std::optional<std::string> GetEnv(const char* name) {
   char* result = nullptr;
-#if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 17)
+#if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 17)) && \
+    !defined(GRPC_FORCE_UNSECURE_GETENV)
   result = secure_getenv(name);
 #else
   result = getenv(name);
+
 #endif
   if (result == nullptr) return std::nullopt;
   return result;

data/src/core/util/ref_counted_ptr.h

@@ -404,6 +404,7 @@ struct RefCountedPtrHash {
     return absl::Hash<WeakRefCountedPtr<T>>{}(p);
   }
   size_t operator()(T* p) const { return absl::Hash<T*>{}(p); }
+  size_t operator()(const T* p) const { return absl::Hash<const T*>{}(p); }
 };
 template <typename T>
 struct RefCountedPtrEq {
@@ -438,6 +439,31 @@ struct RefCountedPtrEq {
   }
 };
 
+// Heterogenous lookup support.
+template <typename T>
+struct WeakRefCountedPtrHash {
+  using is_transparent = void;
+  size_t operator()(const WeakRefCountedPtr<T>& p) const {
+    return absl::Hash<WeakRefCountedPtr<T>>{}(p);
+  }
+  size_t operator()(T* p) const { return absl::Hash<T*>{}(p); }
+  size_t operator()(const T* p) const { return absl::Hash<const T*>{}(p); }
+};
+template <typename T>
+struct WeakRefCountedPtrEq {
+  using is_transparent = void;
+  bool operator()(const WeakRefCountedPtr<T>& p1,
+                  const WeakRefCountedPtr<T>& p2) const {
+    return p1 == p2;
+  }
+  bool operator()(const WeakRefCountedPtr<T>& p1, const T* p2) const {
+    return p1 == p2;
+  }
+  bool operator()(const T* p1, const WeakRefCountedPtr<T>& p2) const {
+    return p2 == p1;
+  }
+};
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_UTIL_REF_COUNTED_PTR_H

data/src/core/util/shared_bit_gen.cc

@@ -0,0 +1,21 @@
+// Copyright 2025 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 "src/core/util/shared_bit_gen.h"
+
+namespace grpc_core {
+
+thread_local absl::BitGen SharedBitGen::bit_gen_;
+
+}  // namespace grpc_core

data/src/core/util/shared_bit_gen.h

@@ -0,0 +1,44 @@
+// Copyright 2025 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.
+
+#ifndef GRPC_SRC_CORE_UTIL_SHARED_BIT_GEN_H
+#define GRPC_SRC_CORE_UTIL_SHARED_BIT_GEN_H
+
+#include "absl/random/random.h"
+
+namespace grpc_core {
+
+class SharedBitGen {
+ public:
+  SharedBitGen() = default;
+  SharedBitGen(const SharedBitGen&) = delete;
+  SharedBitGen& operator=(const SharedBitGen&) = delete;
+  SharedBitGen(SharedBitGen&&) = default;
+  SharedBitGen& operator=(SharedBitGen&&) = default;
+
+  using result_type = absl::BitGen::result_type;
+  result_type operator()() { return bit_gen_(); }
+
+  static constexpr auto min() { return absl::BitGen::min(); }
+  static constexpr auto max() { return absl::BitGen::max(); }
+
+ private:
+  // TODO(ctiller): Perhaps use per-cpu storage? Would add additional overhead
+  // for the mutex acquisition.
+  static thread_local absl::BitGen bit_gen_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_UTIL_SHARED_BIT_GEN_H

data/src/core/util/single_set_ptr.h

@@ -21,6 +21,7 @@
 #include <memory>
 
 #include "absl/log/check.h"
+#include "src/core/util/ref_counted_ptr.h"
 
 namespace grpc_core {
 
@@ -61,10 +62,7 @@ class SingleSetPtr {
   // Clear the pointer.
   void Reset() { Delete(p_.exchange(nullptr, std::memory_order_acq_rel)); }
 
-  bool is_set() const {
-    T* p = Get();
-    return p != nullptr;
-  }
+  bool is_set() const { return p_.load(std::memory_order_relaxed) != nullptr; }
 
   T* Get() const { return p_.load(std::memory_order_acquire); }
 
@@ -84,6 +82,39 @@ class SingleSetPtr {
   std::atomic<T*> p_{nullptr};
 };
 
+template <class T>
+class SingleSetRefCountedPtr {
+ public:
+  SingleSetRefCountedPtr() = default;
+  explicit SingleSetRefCountedPtr(RefCountedPtr<T> p) : p_{p.Release()} {}
+
+  bool is_set() const { return p_.is_set(); }
+
+  RefCountedPtr<T> GetOrCreate() {
+    T* p = Get();
+    if (p == nullptr) p = Set(MakeRefCounted<T>());
+    return p->Ref();
+  }
+  T* Get() const { return p_.Get(); }
+
+  T* operator->() const {
+    T* p = Get();
+    DCHECK_NE(p, nullptr);
+    return p;
+  }
+
+  T& operator*() const { return *Get(); }
+
+ private:
+  struct UnrefDeleter {
+    void operator()(T* p) { p->Unref(); }
+  };
+
+  T* Set(RefCountedPtr<T> p) { return p_.Set(p.release()); }
+
+  SingleSetPtr<T, UnrefDeleter> p_;
+};
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_UTIL_SINGLE_SET_PTR_H

data/src/core/util/uri.cc

@@ -103,6 +103,29 @@ bool IsAuthorityChar(char c) {
   return false;
 }
 
+// Returns true for any character in user_info, as defined in:
+// https://datatracker.ietf.org/doc/html/rfc3986#section-3.2.1
+bool IsUserInfoChar(char c) {
+  if (IsUnreservedChar(c)) return true;
+  if (IsSubDelimChar(c)) return true;
+  if (c == ':') return true;
+  return false;
+}
+
+// Returns true for any character in host_port, as defined in:
+// https://datatracker.ietf.org/doc/html/rfc3986#section-3.2.2
+bool IsHostPortChar(char c) {
+  if (IsUnreservedChar(c)) return true;
+  if (IsSubDelimChar(c)) return true;
+  switch (c) {
+    case ':':
+    case '[':
+    case ']':
+      return true;
+  }
+  return false;
+}
+
 // Returns true for any character in pchar, as defined in:
 // https://datatracker.ietf.org/doc/html/rfc3986#section-3.3
 bool IsPChar(char c) {
@@ -204,6 +227,13 @@ std::string URI::PercentDecode(absl::string_view str) {
   return out;
 }
 
+std::string URI::authority() const {
+  if (!user_info_.empty()) {
+    return absl::StrCat(user_info_, "@", host_port_);
+  }
+  return host_port_;
+}
+
 absl::StatusOr<URI> URI::Parse(absl::string_view uri_text) {
   absl::string_view remaining = uri_text;
   // parse scheme
@@ -225,10 +255,23 @@ absl::StatusOr<URI> URI::Parse(absl::string_view uri_text) {
   }
   remaining.remove_prefix(offset + 1);
   // parse authority
-  std::string authority;
+  std::string user_info;
+  std::string host_port;
   if (absl::ConsumePrefix(&remaining, "//")) {
     offset = remaining.find_first_of("/?#");
-    authority = PercentDecode(remaining.substr(0, offset));
+    absl::string_view encoded_authority = (remaining.substr(0, offset));
+    // parse user_info and host_port
+    absl::string_view encoded_user_info;
+    absl::string_view encoded_host_port;
+    size_t at_pos = encoded_authority.rfind('@');
+    if (at_pos == absl::string_view::npos) {
+      encoded_host_port = encoded_authority;
+    } else {
+      encoded_user_info = encoded_authority.substr(0, at_pos);
+      encoded_host_port = encoded_authority.substr(at_pos + 1);
+    }
+    user_info = PercentDecode(encoded_user_info);
+    host_port = PercentDecode(encoded_host_port);
     if (offset == remaining.npos) {
       remaining = "";
     } else {
@@ -279,29 +322,38 @@ absl::StatusOr<URI> URI::Parse(absl::string_view uri_text) {
     }
     fragment = PercentDecode(remaining);
   }
-  return URI(std::move(scheme), std::move(authority), std::move(path),
-             std::move(query_param_pairs), std::move(fragment));
+  return URI(std::move(scheme), std::move(user_info), std::move(host_port),
+             std::move(path), std::move(query_param_pairs),
+             std::move(fragment));
 }
 
-absl::StatusOr<URI> URI::Create(std::string scheme, std::string authority,
-                                std::string path,
+absl::StatusOr<URI> URI::Create(std::string scheme, std::string user_info,
+                                std::string host_port, std::string path,
                                 std::vector<QueryParam> query_parameter_pairs,
                                 std::string fragment) {
-  if (!authority.empty() && !path.empty() && path[0] != '/') {
+  if (!host_port.empty() && !path.empty() && path[0] != '/') {
     return absl::InvalidArgumentError(
-        "if authority is present, path must start with a '/'");
+        "if host_port is present, path must start with a '/'");
   }
-  return URI(std::move(scheme), std::move(authority), std::move(path),
-             std::move(query_parameter_pairs), std::move(fragment));
+  if (!user_info.empty() && host_port.empty()) {
+    return absl::InvalidArgumentError(
+        "if user_info is present, host_port must be present");
+  }
+  return URI(std::move(scheme), std::move(user_info), std::move(host_port),
+             std::move(path), std::move(query_parameter_pairs),
+             std::move(fragment));
 }
 
-URI::URI(std::string scheme, std::string authority, std::string path,
-         std::vector<QueryParam> query_parameter_pairs, std::string fragment)
+URI::URI(std::string scheme, std::string user_info, std::string host_port,
+         std::string path, std::vector<QueryParam> query_parameter_pairs,
+         std::string fragment)
     : scheme_(std::move(scheme)),
-      authority_(std::move(authority)),
+      user_info_(std::move(user_info)),
+      host_port_(std::move(host_port)),
       path_(std::move(path)),
       query_parameter_pairs_(std::move(query_parameter_pairs)),
       fragment_(std::move(fragment)) {
+  absl::AsciiStrToLower(&scheme_);
   for (const auto& kv : query_parameter_pairs_) {
     query_parameter_map_[kv.key] = kv.value;
   }
@@ -309,7 +361,8 @@ URI::URI(std::string scheme, std::string authority, std::string path,
 
 URI::URI(const URI& other)
     : scheme_(other.scheme_),
-      authority_(other.authority_),
+      user_info_(other.user_info_),
+      host_port_(other.host_port_),
       path_(other.path_),
       query_parameter_pairs_(other.query_parameter_pairs_),
       fragment_(other.fragment_) {
@@ -323,7 +376,8 @@ URI& URI::operator=(const URI& other) {
     return *this;
   }
   scheme_ = other.scheme_;
-  authority_ = other.authority_;
+  user_info_ = other.user_info_;
+  host_port_ = other.host_port_;
   path_ = other.path_;
   query_parameter_pairs_ = other.query_parameter_pairs_;
   fragment_ = other.fragment_;
@@ -350,9 +404,13 @@ std::string URI::ToString() const {
   std::vector<std::string> parts = {PercentEncode(scheme_, IsSchemeChar), ":"};
   // If path starts with '//' we need to encode the authority to ensure that
   // we can round-trip the URI through a parse/encode/parse loop.
-  if (!authority_.empty() || absl::StartsWith(path_, "//")) {
+  if (!host_port_.empty() || absl::StartsWith(path_, "//")) {
     parts.emplace_back("//");
-    parts.emplace_back(PercentEncode(authority_, IsAuthorityChar));
+    if (!user_info_.empty()) {
+      parts.emplace_back(PercentEncode(user_info_, IsUserInfoChar));
+      parts.emplace_back("@");
+    }
+    parts.emplace_back(PercentEncode(host_port_, IsHostPortChar));
   }
   parts.emplace_back(EncodedPathAndQueryParams());
   if (!fragment_.empty()) {

data/src/core/util/uri.h

@@ -48,8 +48,9 @@ class URI {
   static absl::StatusOr<URI> Parse(absl::string_view uri_text);
   // Creates a URI from components. Returns an InvalidArgumentError on failure.
   static absl::StatusOr<URI> Create(
-      std::string scheme, std::string authority, std::string path,
-      std::vector<QueryParam> query_parameter_pairs, std::string fragment);
+      std::string scheme, std::string user_info, std::string host_port,
+      std::string path, std::vector<QueryParam> query_parameter_pairs,
+      std::string fragment);
 
   URI() = default;
 
@@ -66,7 +67,9 @@ class URI {
   static std::string PercentDecode(absl::string_view str);
 
   const std::string& scheme() const { return scheme_; }
-  const std::string& authority() const { return authority_; }
+  std::string authority() const;
+  const std::string& user_info() const { return user_info_; }
+  const std::string& host_port() const { return host_port_; }
   const std::string& path() const { return path_; }
   // Stores the *last* value appearing for each repeated key in the query
   // string. If you need to capture repeated query parameters, use
@@ -90,18 +93,20 @@ class URI {
   std::string EncodedPathAndQueryParams() const;
 
   bool operator==(const URI& other) const {
-    return scheme_ == other.scheme_ && authority_ == other.authority_ &&
-           path_ == other.path_ &&
+    return scheme_ == other.scheme_ && user_info_ == other.user_info_ &&
+           host_port_ == other.host_port_ && path_ == other.path_ &&
            query_parameter_pairs_ == other.query_parameter_pairs_ &&
            fragment_ == other.fragment_;
   }
 
  private:
-  URI(std::string scheme, std::string authority, std::string path,
-      std::vector<QueryParam> query_parameter_pairs, std::string fragment);
+  URI(std::string scheme, std::string user_info, std::string host_port,
+      std::string path, std::vector<QueryParam> query_parameter_pairs,
+      std::string fragment);
 
   std::string scheme_;
-  std::string authority_;
+  std::string user_info_;
+  std::string host_port_;
   std::string path_;
   std::map<absl::string_view, absl::string_view> query_parameter_map_;
   std::vector<QueryParam> query_parameter_pairs_;