Write (more) directly into the structured buffer from StringifySink, including…

Write (more) directly into the structured buffer from StringifySink, including for (size_t, char) overload.

PiperOrigin-RevId: 491456410
Change-Id: I76dec24b0bd02204fa38419af9247cee38b1cf50

absl/log/check_test.cc

@@ -93,7 +93,7 @@ TEST(CHECKTest, TestBoolConvertible) {
 
 #if GTEST_HAS_DEATH_TEST
 
-TEST(CHECKDeathTest, TestChecksWithSideeffects) {
+TEST(CHECKDeathTest, TestChecksWithSideEffects) {
   int var = 0;
   CHECK([&var]() {
     ++var;

absl/log/internal/append_truncated.h

@@ -33,6 +33,13 @@ inline size_t AppendTruncated(absl::string_view src, absl::Span<char> &dst) {
   dst.remove_prefix(src.size());
   return src.size();
 }
+// Likewise, but `n` copies of `c`.
+inline size_t AppendTruncated(char c, size_t n, absl::Span<char> &dst) {
+  if (n > dst.size()) n = dst.size();
+  memset(dst.data(), c, n);
+  dst.remove_prefix(n);
+  return n;
+}
 }  // namespace log_internal
 ABSL_NAMESPACE_END
 }  // namespace absl

absl/log/internal/log_message.cc

@@ -540,6 +540,27 @@ void LogMessage::CopyToEncodedBuffer(absl::string_view str,
     data_->encoded_remaining.remove_suffix(data_->encoded_remaining.size());
   }
 }
+void LogMessage::CopyToEncodedBuffer(char ch, size_t num, StringType str_type) {
+  auto encoded_remaining_copy = data_->encoded_remaining;
+  auto value_start = EncodeMessageStart(
+      EventTag::kValue, BufferSizeFor(WireType::kLengthDelimited) + num,
+      &encoded_remaining_copy);
+  auto str_start = EncodeMessageStart(str_type == StringType::kLiteral
+                                          ? ValueTag::kStringLiteral
+                                          : ValueTag::kString,
+                                      num, &encoded_remaining_copy);
+  if (str_start.data()) {
+    // The field headers fit.
+    log_internal::AppendTruncated(ch, num, encoded_remaining_copy);
+    EncodeMessageLength(str_start, &encoded_remaining_copy);
+    EncodeMessageLength(value_start, &encoded_remaining_copy);
+    data_->encoded_remaining = encoded_remaining_copy;
+  } else {
+    // The field header(s) did not fit; zero `encoded_remaining` so we don't
+    // write anything else later.
+    data_->encoded_remaining.remove_suffix(data_->encoded_remaining.size());
+  }
+}
 
 LogMessageFatal::LogMessageFatal(const char* file, int line)
     : LogMessage(file, line, absl::LogSeverity::kFatal) {}

absl/log/internal/log_message.h

@@ -47,8 +47,6 @@
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace log_internal {
-class AsLiteralImpl;
-
 constexpr int kLogMessageBufferSize = 15000;
 
 class LogMessage {
@@ -195,6 +193,7 @@ class LogMessage {
  private:
   struct LogMessageData;  // Opaque type containing message state
   friend class AsLiteralImpl;
+  friend class StringifySink;
 
   // This streambuf writes directly into the structured logging buffer so that
   // arbitrary types can be encoded as string data (using
@@ -222,6 +221,8 @@ class LogMessage {
   };
   void CopyToEncodedBuffer(absl::string_view str,
                            StringType str_type) ABSL_ATTRIBUTE_NOINLINE;
+  void CopyToEncodedBuffer(char ch, size_t num,
+                           StringType str_type) ABSL_ATTRIBUTE_NOINLINE;
 
   // Returns `true` if the message is fatal or enabled debug-fatal.
   bool IsFatal() const;
@@ -250,9 +251,14 @@ class StringifySink final {
  public:
   explicit StringifySink(LogMessage& message) : message_(message) {}
 
-  void Append(size_t count, char ch) { message_ << std::string(count, ch); }
+  void Append(size_t count, char ch) {
+    message_.CopyToEncodedBuffer(ch, count,
+                                 LogMessage::StringType::kNotLiteral);
+  }
 
-  void Append(absl::string_view v) { message_ << v; }
+  void Append(absl::string_view v) {
+    message_.CopyToEncodedBuffer(v, LogMessage::StringType::kNotLiteral);
+  }
 
   // For types that implement `AbslStringify` using `absl::Format()`.
   friend void AbslFormatFlush(StringifySink* sink, absl::string_view v) {