grpc 1.72.0 → 1.74.0.pre2

data/third_party/abseil-cpp/absl/log/internal/log_message.h

@@ -17,27 +17,34 @@
 // -----------------------------------------------------------------------------
 //
 // This file declares `class absl::log_internal::LogMessage`. This class more or
-// less represents a particular log message. LOG/CHECK macros create a
-// temporary instance of `LogMessage` and then stream values to it.  At the end
-// of the LOG/CHECK statement, LogMessage instance goes out of scope and
-// `~LogMessage` directs the message to the registered log sinks.
-// Heap-allocation of `LogMessage` is unsupported.  Construction outside of a
-// `LOG` macro is unsupported.
+// less represents a particular log message. LOG/CHECK macros create a temporary
+// instance of `LogMessage` and then stream values to it.  At the end of the
+// LOG/CHECK statement, the LogMessage is voidified by operator&&, and `Flush()`
+// directs the message to the registered log sinks.  Heap-allocation of
+// `LogMessage` is unsupported.  Construction outside of a `LOG` macro is
+// unsupported.
 
 #ifndef ABSL_LOG_INTERNAL_LOG_MESSAGE_H_
 #define ABSL_LOG_INTERNAL_LOG_MESSAGE_H_
 
+#include <wchar.h>
+
+#include <cstddef>
 #include <ios>
 #include <memory>
 #include <ostream>
 #include <streambuf>
 #include <string>
+#include <string_view>
+#include <type_traits>
 
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
 #include "absl/base/internal/errno_saver.h"
 #include "absl/base/log_severity.h"
+#include "absl/base/nullability.h"
 #include "absl/log/internal/nullguard.h"
+#include "absl/log/internal/structured_proto.h"
 #include "absl/log/log_entry.h"
 #include "absl/log/log_sink.h"
 #include "absl/strings/has_absl_stringify.h"
@@ -49,6 +56,8 @@ ABSL_NAMESPACE_BEGIN
 namespace log_internal {
 constexpr int kLogMessageBufferSize = 15000;
 
+enum class StructuredStringType;
+
 class LogMessage {
  public:
   struct InfoTag {};
@@ -56,15 +65,15 @@ class LogMessage {
   struct ErrorTag {};
 
   // Used for `LOG`.
-  LogMessage(const char* file, int line,
+  LogMessage(const char* absl_nonnull file, int line,
              absl::LogSeverity severity) ABSL_ATTRIBUTE_COLD;
   // These constructors are slightly smaller/faster to call; the severity is
   // curried into the function pointer.
-  LogMessage(const char* file, int line,
+  LogMessage(const char* absl_nonnull file, int line,
              InfoTag) ABSL_ATTRIBUTE_COLD ABSL_ATTRIBUTE_NOINLINE;
-  LogMessage(const char* file, int line,
+  LogMessage(const char* absl_nonnull file, int line,
              WarningTag) ABSL_ATTRIBUTE_COLD ABSL_ATTRIBUTE_NOINLINE;
-  LogMessage(const char* file, int line,
+  LogMessage(const char* absl_nonnull file, int line,
              ErrorTag) ABSL_ATTRIBUTE_COLD ABSL_ATTRIBUTE_NOINLINE;
   LogMessage(const LogMessage&) = delete;
   LogMessage& operator=(const LogMessage&) = delete;
@@ -95,59 +104,73 @@ class LogMessage {
   // of `errno`.
   LogMessage& WithPerror();
   // Sends this message to `*sink` in addition to whatever other sinks it would
-  // otherwise have been sent to.  `sink` must not be null.
-  LogMessage& ToSinkAlso(absl::LogSink* sink);
-  // Sends this message to `*sink` and no others.  `sink` must not be null.
-  LogMessage& ToSinkOnly(absl::LogSink* sink);
+  // otherwise have been sent to.
+  LogMessage& ToSinkAlso(absl::LogSink* absl_nonnull sink);
+  // Sends this message to `*sink` and no others.
+  LogMessage& ToSinkOnly(absl::LogSink* absl_nonnull sink);
 
   // Don't call this method from outside this library.
   LogMessage& InternalStream() { return *this; }
 
   // By-value overloads for small, common types let us overlook common failures
   // to define globals and static data members (i.e. in a .cc file).
-  // clang-format off
-  // The CUDA toolchain cannot handle these <<<'s:
+  // NOLINTBEGIN(runtime/int)
+  // NOLINTBEGIN(google-runtime-int)
+  // clang-format off:  The CUDA toolchain cannot handle these <<<'s
   LogMessage& operator<<(char v) { return operator<< <char>(v); }
   LogMessage& operator<<(signed char v) { return operator<< <signed char>(v); }
   LogMessage& operator<<(unsigned char v) {
     return operator<< <unsigned char>(v);
   }
-  LogMessage& operator<<(signed short v) {  // NOLINT
-    return operator<< <signed short>(v);  // NOLINT
+  LogMessage& operator<<(signed short v) {
+    return operator<< <signed short>(v);
   }
   LogMessage& operator<<(signed int v) { return operator<< <signed int>(v); }
-  LogMessage& operator<<(signed long v) {  // NOLINT
-    return operator<< <signed long>(v);  // NOLINT
+  LogMessage& operator<<(signed long v) {
+    return operator<< <signed long>(v);
   }
-  LogMessage& operator<<(signed long long v) {  // NOLINT
-    return operator<< <signed long long>(v);  // NOLINT
+  LogMessage& operator<<(signed long long v) {
+    return operator<< <signed long long>(v);
   }
-  LogMessage& operator<<(unsigned short v) {  // NOLINT
-    return operator<< <unsigned short>(v);  // NOLINT
+  LogMessage& operator<<(unsigned short v) {
+    return operator<< <unsigned short>(v);
   }
   LogMessage& operator<<(unsigned int v) {
     return operator<< <unsigned int>(v);
   }
-  LogMessage& operator<<(unsigned long v) {  // NOLINT
-    return operator<< <unsigned long>(v);  // NOLINT
+  LogMessage& operator<<(unsigned long v) {
+    return operator<< <unsigned long>(v);
+  }
+  LogMessage& operator<<(unsigned long long v) {
+    return operator<< <unsigned long long>(v);
+  }
+  LogMessage& operator<<(void* absl_nullable  v) {
+    return operator<< <void*>(v);
   }
-  LogMessage& operator<<(unsigned long long v) {  // NOLINT
-    return operator<< <unsigned long long>(v);  // NOLINT
+  LogMessage& operator<<(const void* absl_nullable  v) {
+    return operator<< <const void*>(v);
   }
-  LogMessage& operator<<(void* v) { return operator<< <void*>(v); }
-  LogMessage& operator<<(const void* v) { return operator<< <const void*>(v); }
   LogMessage& operator<<(float v) { return operator<< <float>(v); }
   LogMessage& operator<<(double v) { return operator<< <double>(v); }
   LogMessage& operator<<(bool v) { return operator<< <bool>(v); }
   // clang-format on
+  // NOLINTEND(google-runtime-int)
+  // NOLINTEND(runtime/int)
 
   // These overloads are more efficient since no `ostream` is involved.
   LogMessage& operator<<(const std::string& v);
   LogMessage& operator<<(absl::string_view v);
 
+  // Wide string overloads (since std::ostream does not provide them).
+  LogMessage& operator<<(const std::wstring& v);
+  LogMessage& operator<<(std::wstring_view v);
+  // `const wchar_t*` is handled by `operator<< <const wchar_t*>`.
+  LogMessage& operator<<(wchar_t* absl_nullable v);
+  LogMessage& operator<<(wchar_t v);
+
   // Handle stream manipulators e.g. std::endl.
-  LogMessage& operator<<(std::ostream& (*m)(std::ostream& os));
-  LogMessage& operator<<(std::ios_base& (*m)(std::ios_base& os));
+  LogMessage& operator<<(std::ostream& (*absl_nonnull m)(std::ostream& os));
+  LogMessage& operator<<(std::ios_base& (*absl_nonnull m)(std::ios_base& os));
 
   // Literal strings.  This allows us to record C string literals as literals in
   // the logging.proto.Value.
@@ -156,31 +179,30 @@ class LogMessage {
   // this template for every value of `SIZE` encountered in each source code
   // file. That significantly increases linker input sizes. Inlining is cheap
   // because the argument to this overload is almost always a string literal so
-  // the call to `strlen` can be replaced at compile time. The overload for
-  // `char[]` below should not be inlined. The compiler typically does not have
-  // the string at compile time and cannot replace the call to `strlen` so
-  // inlining it increases the binary size. See the discussion on
+  // the call to `strlen` can be replaced at compile time. The overloads for
+  // `char[]`/`wchar_t[]` below should not be inlined. The compiler typically
+  // does not have the string at compile time and cannot replace the call to
+  // `strlen` so inlining it increases the binary size. See the discussion on
   // cl/107527369.
   template <int SIZE>
   LogMessage& operator<<(const char (&buf)[SIZE]);
+  template <int SIZE>
+  LogMessage& operator<<(const wchar_t (&buf)[SIZE]);
 
   // This prevents non-const `char[]` arrays from looking like literals.
   template <int SIZE>
   LogMessage& operator<<(char (&buf)[SIZE]) ABSL_ATTRIBUTE_NOINLINE;
+  // `wchar_t[SIZE]` is handled by `operator<< <const wchar_t*>`.
 
   // Types that support `AbslStringify()` are serialized that way.
-  template <typename T,
-            typename std::enable_if<absl::HasAbslStringify<T>::value,
-                                    int>::type = 0>
-  LogMessage& operator<<(const T& v) ABSL_ATTRIBUTE_NOINLINE;
-
   // Types that don't support `AbslStringify()` but do support streaming into a
   // `std::ostream&` are serialized that way.
-  template <typename T,
-            typename std::enable_if<!absl::HasAbslStringify<T>::value,
-                                    int>::type = 0>
+  template <typename T>
   LogMessage& operator<<(const T& v) ABSL_ATTRIBUTE_NOINLINE;
 
+  // Dispatches the completed `absl::LogEntry` to applicable `absl::LogSink`s.
+  void Flush();
+
   // Note: We explicitly do not support `operator<<` for non-const references
   // because it breaks logging of non-integer bitfield types (i.e., enums).
 
@@ -193,11 +215,6 @@ class LogMessage {
   // the process with an error exit code.
   [[noreturn]] static void FailQuietly();
 
-  // Dispatches the completed `absl::LogEntry` to applicable `absl::LogSink`s.
-  // This might as well be inlined into `~LogMessage` except that
-  // `~LogMessageFatal` needs to call it early.
-  void Flush();
-
   // After this is called, failures are done as quiet as possible for this log
   // message.
   void SetFailQuietly();
@@ -206,6 +223,10 @@ class LogMessage {
   struct LogMessageData;  // Opaque type containing message state
   friend class AsLiteralImpl;
   friend class StringifySink;
+  template <StructuredStringType str_type>
+  friend class AsStructuredStringTypeImpl;
+  template <typename T>
+  friend class AsStructuredValueImpl;
 
   // This streambuf writes directly into the structured logging buffer so that
   // arbitrary types can be encoded as string data (using
@@ -235,6 +256,15 @@ class LogMessage {
   void CopyToEncodedBuffer(absl::string_view str) ABSL_ATTRIBUTE_NOINLINE;
   template <StringType str_type>
   void CopyToEncodedBuffer(char ch, size_t num) ABSL_ATTRIBUTE_NOINLINE;
+  template <StringType str_type>
+  void CopyToEncodedBuffer(std::wstring_view str) ABSL_ATTRIBUTE_NOINLINE;
+
+  // Copies `field` to the encoded buffer, then appends `str` after it
+  // (truncating `str` if necessary to fit).
+  template <StringType str_type>
+  void CopyToEncodedBufferWithStructuredProtoField(StructuredProtoField field,
+                                                   absl::string_view str)
+      ABSL_ATTRIBUTE_NOINLINE;
 
   // Returns `true` if the message is fatal or enabled debug-fatal.
   bool IsFatal() const;
@@ -255,9 +285,25 @@ class LogMessage {
 
   // We keep the data in a separate struct so that each instance of `LogMessage`
   // uses less stack space.
-  std::unique_ptr<LogMessageData> data_;
+  absl_nonnull std::unique_ptr<LogMessageData> data_;
 };
 
+// Explicitly specializes the generic operator<< for `const wchar_t*`
+// arguments.
+//
+// This method is used instead of a non-template `const wchar_t*` overload,
+// as the latter was found to take precedence over the array template
+// (`operator<<(const wchar_t(&)[SIZE])`) when handling string literals.
+// This specialization ensures the array template now correctly processes
+// literals.
+template <>
+LogMessage& LogMessage::operator<< <const wchar_t*>(
+    const wchar_t* absl_nullable const& v);
+
+inline LogMessage& LogMessage::operator<<(wchar_t* absl_nullable v) {
+  return operator<<(const_cast<const wchar_t*>(v));
+}
+
 // Helper class so that `AbslStringify()` can modify the LogMessage.
 class StringifySink final {
  public:
@@ -273,7 +319,8 @@ class StringifySink final {
   }
 
   // For types that implement `AbslStringify` using `absl::Format()`.
-  friend void AbslFormatFlush(StringifySink* sink, absl::string_view v) {
+  friend void AbslFormatFlush(StringifySink* absl_nonnull sink,
+                              absl::string_view v) {
     sink->Append(v);
   }
 
@@ -282,26 +329,27 @@ class StringifySink final {
 };
 
 // Note: the following is declared `ABSL_ATTRIBUTE_NOINLINE`
-template <typename T,
-          typename std::enable_if<absl::HasAbslStringify<T>::value, int>::type>
+template <typename T>
 LogMessage& LogMessage::operator<<(const T& v) {
-  StringifySink sink(*this);
-  // Replace with public API.
-  AbslStringify(sink, v);
+  if constexpr (absl::HasAbslStringify<T>::value) {
+    StringifySink sink(*this);
+    // Replace with public API.
+    AbslStringify(sink, v);
+  } else {
+    OstreamView view(*data_);
+    view.stream() << log_internal::NullGuard<T>().Guard(v);
+  }
   return *this;
 }
 
-// Note: the following is declared `ABSL_ATTRIBUTE_NOINLINE`
-template <typename T,
-          typename std::enable_if<!absl::HasAbslStringify<T>::value, int>::type>
-LogMessage& LogMessage::operator<<(const T& v) {
-  OstreamView view(*data_);
-  view.stream() << log_internal::NullGuard<T>().Guard(v);
+template <int SIZE>
+LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
+  CopyToEncodedBuffer<StringType::kLiteral>(buf);
   return *this;
 }
 
 template <int SIZE>
-LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
+LogMessage& LogMessage::operator<<(const wchar_t (&buf)[SIZE]) {
   CopyToEncodedBuffer<StringType::kLiteral>(buf);
   return *this;
 }
@@ -315,27 +363,28 @@ LogMessage& LogMessage::operator<<(char (&buf)[SIZE]) {
 // We instantiate these specializations in the library's TU to save space in
 // other TUs.  Since the template is marked `ABSL_ATTRIBUTE_NOINLINE` we will be
 // emitting a function call either way.
+// NOLINTBEGIN(runtime/int)
+// NOLINTBEGIN(google-runtime-int)
 extern template LogMessage& LogMessage::operator<<(const char& v);
 extern template LogMessage& LogMessage::operator<<(const signed char& v);
 extern template LogMessage& LogMessage::operator<<(const unsigned char& v);
-extern template LogMessage& LogMessage::operator<<(const short& v);  // NOLINT
-extern template LogMessage& LogMessage::operator<<(
-    const unsigned short& v);  // NOLINT
+extern template LogMessage& LogMessage::operator<<(const short& v);
+extern template LogMessage& LogMessage::operator<<(const unsigned short& v);
 extern template LogMessage& LogMessage::operator<<(const int& v);
+extern template LogMessage& LogMessage::operator<<(const unsigned int& v);
+extern template LogMessage& LogMessage::operator<<(const long& v);
+extern template LogMessage& LogMessage::operator<<(const unsigned long& v);
+extern template LogMessage& LogMessage::operator<<(const long long& v);
+extern template LogMessage& LogMessage::operator<<(const unsigned long long& v);
 extern template LogMessage& LogMessage::operator<<(
-    const unsigned int& v);                                         // NOLINT
-extern template LogMessage& LogMessage::operator<<(const long& v);  // NOLINT
+    void* absl_nullable const& v);
 extern template LogMessage& LogMessage::operator<<(
-    const unsigned long& v);  // NOLINT
-extern template LogMessage& LogMessage::operator<<(
-    const long long& v);  // NOLINT
-extern template LogMessage& LogMessage::operator<<(
-    const unsigned long long& v);  // NOLINT
-extern template LogMessage& LogMessage::operator<<(void* const& v);
-extern template LogMessage& LogMessage::operator<<(const void* const& v);
+    const void* absl_nullable const& v);
 extern template LogMessage& LogMessage::operator<<(const float& v);
 extern template LogMessage& LogMessage::operator<<(const double& v);
 extern template LogMessage& LogMessage::operator<<(const bool& v);
+// NOLINTEND(google-runtime-int)
+// NOLINTEND(runtime/int)
 
 extern template void LogMessage::CopyToEncodedBuffer<
     LogMessage::StringType::kLiteral>(absl::string_view str);
@@ -346,14 +395,18 @@ LogMessage::CopyToEncodedBuffer<LogMessage::StringType::kLiteral>(char ch,
                                                                   size_t num);
 extern template void LogMessage::CopyToEncodedBuffer<
     LogMessage::StringType::kNotLiteral>(char ch, size_t num);
+extern template void LogMessage::CopyToEncodedBuffer<
+    LogMessage::StringType::kLiteral>(std::wstring_view str);
+extern template void LogMessage::CopyToEncodedBuffer<
+    LogMessage::StringType::kNotLiteral>(std::wstring_view str);
 
 // `LogMessageFatal` ensures the process will exit in failure after logging this
 // message.
 class LogMessageFatal final : public LogMessage {
  public:
-  LogMessageFatal(const char* file, int line) ABSL_ATTRIBUTE_COLD;
-  LogMessageFatal(const char* file, int line,
-                  absl::string_view failure_msg) ABSL_ATTRIBUTE_COLD;
+  LogMessageFatal(const char* absl_nonnull file, int line) ABSL_ATTRIBUTE_COLD;
+  LogMessageFatal(const char* absl_nonnull file, int line,
+                  const char* absl_nonnull failure_msg) ABSL_ATTRIBUTE_COLD;
   [[noreturn]] ~LogMessageFatal();
 };
 
@@ -362,7 +415,8 @@ class LogMessageFatal final : public LogMessage {
 // for DLOG(FATAL) variants.
 class LogMessageDebugFatal final : public LogMessage {
  public:
-  LogMessageDebugFatal(const char* file, int line) ABSL_ATTRIBUTE_COLD;
+  LogMessageDebugFatal(const char* absl_nonnull file,
+                       int line) ABSL_ATTRIBUTE_COLD;
   ~LogMessageDebugFatal();
 };
 
@@ -371,16 +425,19 @@ class LogMessageQuietlyDebugFatal final : public LogMessage {
   // DLOG(QFATAL) calls this instead of LogMessageQuietlyFatal to make sure the
   // destructor is not [[noreturn]] even if this is always FATAL as this is only
   // invoked when DLOG() is enabled.
-  LogMessageQuietlyDebugFatal(const char* file, int line) ABSL_ATTRIBUTE_COLD;
+  LogMessageQuietlyDebugFatal(const char* absl_nonnull file,
+                              int line) ABSL_ATTRIBUTE_COLD;
   ~LogMessageQuietlyDebugFatal();
 };
 
 // Used for LOG(QFATAL) to make sure it's properly understood as [[noreturn]].
 class LogMessageQuietlyFatal final : public LogMessage {
  public:
-  LogMessageQuietlyFatal(const char* file, int line) ABSL_ATTRIBUTE_COLD;
-  LogMessageQuietlyFatal(const char* file, int line,
-                         absl::string_view failure_msg) ABSL_ATTRIBUTE_COLD;
+  LogMessageQuietlyFatal(const char* absl_nonnull file,
+                         int line) ABSL_ATTRIBUTE_COLD;
+  LogMessageQuietlyFatal(const char* absl_nonnull file, int line,
+                         const char* absl_nonnull failure_msg)
+      ABSL_ATTRIBUTE_COLD;
   [[noreturn]] ~LogMessageQuietlyFatal();
 };
 

data/third_party/abseil-cpp/absl/log/internal/nullstream.h

@@ -79,6 +79,7 @@ class NullStream {
     return *this;
   }
   NullStream& InternalStream() { return *this; }
+  void Flush() {}
 };
 template <typename T>
 inline NullStream& operator<<(NullStream& str, const T&) {

data/third_party/abseil-cpp/absl/log/internal/proto.cc

@@ -35,9 +35,6 @@ void EncodeRawVarint(uint64_t value, size_t size, absl::Span<char> *buf) {
   }
   buf->remove_prefix(size);
 }
-constexpr uint64_t MakeTagType(uint64_t tag, WireType type) {
-  return tag << 3 | static_cast<uint64_t>(type);
-}
 }  // namespace
 
 bool EncodeVarint(uint64_t tag, uint64_t value, absl::Span<char> *buf) {
@@ -126,8 +123,9 @@ bool EncodeBytesTruncate(uint64_t tag, absl::Span<const char> value,
   return true;
 }
 
-ABSL_MUST_USE_RESULT absl::Span<char> EncodeMessageStart(
-    uint64_t tag, uint64_t max_size, absl::Span<char> *buf) {
+[[nodiscard]] absl::Span<char> EncodeMessageStart(uint64_t tag,
+                                                  uint64_t max_size,
+                                                  absl::Span<char> *buf) {
   const uint64_t tag_type = MakeTagType(tag, WireType::kLengthDelimited);
   const size_t tag_type_size = VarintSize(tag_type);
   max_size = std::min<uint64_t>(max_size, buf->size());

data/third_party/abseil-cpp/absl/log/internal/proto.h

@@ -169,9 +169,9 @@ inline bool EncodeStringTruncate(uint64_t tag, absl::string_view value,
 // safe to pass to `EncodeMessageLength` but need not be.
 // Used for string, bytes, message, and packed-repeated field type.
 // Consumes up to kMaxVarintSize * 2 bytes (20).
-ABSL_MUST_USE_RESULT absl::Span<char> EncodeMessageStart(uint64_t tag,
-                                                         uint64_t max_size,
-                                                         absl::Span<char> *buf);
+[[nodiscard]] absl::Span<char> EncodeMessageStart(uint64_t tag,
+                                                  uint64_t max_size,
+                                                  absl::Span<char> *buf);
 
 // Finalizes the length field in `msg` so that it encompasses all data encoded
 // since the call to `EncodeMessageStart` which returned `msg`.  Does nothing if
@@ -199,23 +199,33 @@ constexpr uint64_t MaxVarintForSize(size_t size) {
   return size >= 10 ? (std::numeric_limits<uint64_t>::max)()
                     : (static_cast<uint64_t>(1) << size * 7) - 1;
 }
+constexpr uint64_t MakeTagType(uint64_t tag, WireType type) {
+  return tag << 3 | static_cast<uint64_t>(type);
+}
 
 // `BufferSizeFor` returns a number of bytes guaranteed to be sufficient to
-// store encoded fields of the specified WireTypes regardless of tag numbers and
-// data values.  This only makes sense for `WireType::kLengthDelimited` if you
-// add in the length of the contents yourself, e.g. for string and bytes fields
-// by adding the lengths of any encoded strings to the return value or for
-// submessage fields by enumerating the fields you may encode into their
-// contents.
-constexpr size_t BufferSizeFor() { return 0; }
-template <typename... T>
-constexpr size_t BufferSizeFor(WireType type, T... tail) {
-  // tag_type + data + ...
-  return MaxVarintSize() +
-         (type == WireType::kVarint ? MaxVarintSize() :              //
-              type == WireType::k64Bit ? 8 :                         //
-                  type == WireType::k32Bit ? 4 : MaxVarintSize()) +  //
-         BufferSizeFor(tail...);
+// store encoded fields as `(tag, WireType)`, regardless of data values.  This
+// only makes sense for `WireType::kLengthDelimited` if you add in the length of
+// the contents yourself, e.g. for string and bytes fields by adding the lengths
+// of any encoded strings to the return value or for submessage fields by
+// enumerating the fields you may encode into their contents.
+constexpr size_t BufferSizeFor(uint64_t tag, WireType type) {
+  size_t buffer_size = VarintSize(MakeTagType(tag, type));
+  switch (type) {
+    case WireType::kVarint:
+      buffer_size += MaxVarintSize();
+      break;
+    case WireType::k64Bit:
+      buffer_size += size_t{8};
+      break;
+    case WireType::kLengthDelimited:
+      buffer_size += MaxVarintSize();
+      break;
+    case WireType::k32Bit:
+      buffer_size += size_t{4};
+      break;
+  }
+  return buffer_size;
 }
 
 // absl::Span<const char> represents a view into the un-processed space in a

data/third_party/abseil-cpp/absl/log/internal/strip.h

@@ -15,7 +15,8 @@
 // -----------------------------------------------------------------------------
 // File: log/internal/strip.h
 // -----------------------------------------------------------------------------
-//
+
+// SKIP_ABSL_INLINE_NAMESPACE_CHECK
 
 #ifndef ABSL_LOG_INTERNAL_STRIP_H_
 #define ABSL_LOG_INTERNAL_STRIP_H_
@@ -31,15 +32,6 @@
 // logging in subtly different ways for subtly different reasons (see below).
 #if defined(STRIP_LOG) && STRIP_LOG
 
-// Attribute for marking variables used in implementation details of logging
-// macros as unused, but only when `STRIP_LOG` is defined.
-// With `STRIP_LOG` on, not marking them triggers `-Wunused-but-set-variable`,
-// With `STRIP_LOG` off, marking them triggers `-Wused-but-marked-unused`.
-//
-// TODO(b/290784225): Replace this macro with attribute [[maybe_unused]] when
-// Abseil stops supporting C++14.
-#define ABSL_LOG_INTERNAL_ATTRIBUTE_UNUSED_IF_STRIP_LOG ABSL_ATTRIBUTE_UNUSED
-
 #define ABSL_LOGGING_INTERNAL_LOG_INFO ::absl::log_internal::NullStream()
 #define ABSL_LOGGING_INTERNAL_LOG_WARNING ::absl::log_internal::NullStream()
 #define ABSL_LOGGING_INTERNAL_LOG_ERROR ::absl::log_internal::NullStream()
@@ -62,8 +54,6 @@
 
 #else  // !defined(STRIP_LOG) || !STRIP_LOG
 
-#define ABSL_LOG_INTERNAL_ATTRIBUTE_UNUSED_IF_STRIP_LOG
-
 #define ABSL_LOGGING_INTERNAL_LOG_INFO \
   ::absl::log_internal::LogMessage(    \
       __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
@@ -105,4 +95,6 @@
 #define ABSL_LOGGING_INTERNAL_DLOG_DFATAL ABSL_LOGGING_INTERNAL_LOG_DFATAL
 #define ABSL_LOGGING_INTERNAL_DLOG_LEVEL ABSL_LOGGING_INTERNAL_LOG_LEVEL
 
+#define ABSL_LOGGING_INTERNAL_LOG_DO_NOT_SUBMIT ABSL_LOGGING_INTERNAL_LOG_ERROR
+
 #endif  // ABSL_LOG_INTERNAL_STRIP_H_

data/third_party/abseil-cpp/absl/log/internal/structured_proto.cc

@@ -0,0 +1,115 @@
+//
+// Copyright 2024 The Abseil 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
+//
+//      https://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 "absl/log/internal/structured_proto.h"
+
+#include <cstdint>
+
+#include "absl/base/config.h"
+#include "absl/log/internal/proto.h"
+#include "absl/types/span.h"
+#include "absl/types/variant.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace log_internal {
+
+namespace {
+
+// Handles protobuf-encoding a type contained inside
+// `StructuredProtoField::Varint`.
+struct VarintEncoderVisitor final {
+  template <typename T>
+  bool operator()(T value) const {
+    return EncodeVarint(field_number, value, &buf);
+  }
+
+  uint64_t field_number;
+  absl::Span<char>& buf;
+};
+
+// Handles protobuf-encoding a type contained inside
+// `StructuredProtoField::I64`.
+struct I64EncoderVisitor final {
+  bool operator()(uint64_t value) const {
+    return Encode64Bit(field_number, value, &buf);
+  }
+
+  bool operator()(int64_t value) const {
+    return Encode64Bit(field_number, value, &buf);
+  }
+
+  bool operator()(double value) const {
+    return EncodeDouble(field_number, value, &buf);
+  }
+
+  uint64_t field_number;
+  absl::Span<char>& buf;
+};
+
+// Handles protobuf-encoding a type contained inside
+// `StructuredProtoField::I32`.
+struct I32EncoderVisitor final {
+  bool operator()(uint32_t value) const {
+    return Encode32Bit(field_number, value, &buf);
+  }
+
+  bool operator()(int32_t value) const {
+    return Encode32Bit(field_number, value, &buf);
+  }
+
+  bool operator()(float value) const {
+    return EncodeFloat(field_number, value, &buf);
+  }
+
+  uint64_t field_number;
+  absl::Span<char>& buf;
+};
+
+// Handles protobuf-encoding a type contained inside `StructuredProtoField`.
+struct EncoderVisitor final {
+  bool operator()(StructuredProtoField::Varint varint) {
+    return absl::visit(VarintEncoderVisitor{field_number, buf}, varint);
+  }
+
+  bool operator()(StructuredProtoField::I64 i64) {
+    return absl::visit(I64EncoderVisitor{field_number, buf}, i64);
+  }
+
+  bool operator()(StructuredProtoField::LengthDelimited length_delimited) {
+    // No need for a visitor, since `StructuredProtoField::LengthDelimited` is
+    // just `absl::Span<const char>`.
+    return EncodeBytes(field_number, length_delimited, &buf);
+  }
+
+  bool operator()(StructuredProtoField::I32 i32) {
+    return absl::visit(I32EncoderVisitor{field_number, buf}, i32);
+  }
+
+  uint64_t field_number;
+  absl::Span<char>& buf;
+};
+
+}  // namespace
+
+bool EncodeStructuredProtoField(StructuredProtoField field,
+                                absl::Span<char>& buf) {
+  return absl::visit(EncoderVisitor{field.field_number, buf}, field.value);
+}
+
+}  // namespace log_internal
+
+ABSL_NAMESPACE_END
+}  // namespace absl