grpc 1.84.1 → 1.85.0.pre1

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

@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// SKIP_ABSL_INLINE_NAMESPACE_CHECK
+
 #ifndef ABSL_LOG_INTERNAL_LOG_IMPL_H_
 #define ABSL_LOG_INTERNAL_LOG_IMPL_H_
 
@@ -23,260 +25,256 @@
 // ABSL_LOG()
 #define ABSL_LOG_INTERNAL_LOG_IMPL(severity)             \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
-      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
 
 // ABSL_PLOG()
-#define ABSL_LOG_INTERNAL_PLOG_IMPL(severity)              \
-  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true)   \
-      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream() \
+#define ABSL_LOG_INTERNAL_PLOG_IMPL(severity)            \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
+      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()   \
           .WithPerror()
 
 // ABSL_DLOG()
 #ifndef NDEBUG
 #define ABSL_LOG_INTERNAL_DLOG_IMPL(severity)            \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
-      ABSL_LOGGING_INTERNAL_DLOG##severity.InternalStream()
+      ABSL_LOG_INTERNAL_DLOG##severity.InternalStream()
 #else
 #define ABSL_LOG_INTERNAL_DLOG_IMPL(severity)             \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, false) \
-      ABSL_LOGGING_INTERNAL_DLOG##severity.InternalStream()
+      ABSL_LOG_INTERNAL_DLOG##severity.InternalStream()
 #endif
 
 // The `switch` ensures that this expansion is the beginning of a statement (as
 // opposed to an expression). The use of both `case 0` and `default` is to
 // suppress a compiler warning.
-#define ABSL_LOG_INTERNAL_VLOG_IMPL(verbose_level)                         \
-  switch (const int absl_logging_internal_verbose_level = (verbose_level)) \
-  case 0:                                                                  \
-  default:                                                                 \
-    ABSL_LOG_INTERNAL_LOG_IF_IMPL(                                         \
-        _INFO, ABSL_VLOG_IS_ON(absl_logging_internal_verbose_level))       \
-        .WithVerbosity(absl_logging_internal_verbose_level)
+#define ABSL_LOG_INTERNAL_VLOG_IMPL(verbose_level)                     \
+  switch (const int absl_log_internal_verbose_level = (verbose_level)) \
+  case 0:                                                              \
+  default:                                                             \
+    ABSL_LOG_INTERNAL_LOG_IF_IMPL(                                     \
+        _INFO, ABSL_VLOG_IS_ON(absl_log_internal_verbose_level))       \
+        .WithVerbosity(absl_log_internal_verbose_level)
 
 #ifndef NDEBUG
-#define ABSL_LOG_INTERNAL_DVLOG_IMPL(verbose_level)                        \
-  switch (const int absl_logging_internal_verbose_level = (verbose_level)) \
-  case 0:                                                                  \
-  default:                                                                 \
-    ABSL_LOG_INTERNAL_DLOG_IF_IMPL(                                         \
-        _INFO, ABSL_VLOG_IS_ON(absl_logging_internal_verbose_level))       \
-        .WithVerbosity(absl_logging_internal_verbose_level)
+#define ABSL_LOG_INTERNAL_DVLOG_IMPL(verbose_level)                    \
+  switch (const int absl_log_internal_verbose_level = (verbose_level)) \
+  case 0:                                                              \
+  default:                                                             \
+    ABSL_LOG_INTERNAL_DLOG_IF_IMPL(                                    \
+        _INFO, ABSL_VLOG_IS_ON(absl_log_internal_verbose_level))       \
+        .WithVerbosity(absl_log_internal_verbose_level)
 #else
-#define ABSL_LOG_INTERNAL_DVLOG_IMPL(verbose_level)                           \
-  switch (const int absl_logging_internal_verbose_level = (verbose_level))    \
-  case 0:                                                                     \
-  default:                                                                    \
-    ABSL_LOG_INTERNAL_DLOG_IF_IMPL(                                            \
-        _INFO, false && ABSL_VLOG_IS_ON(absl_logging_internal_verbose_level)) \
-        .WithVerbosity(absl_logging_internal_verbose_level)
+#define ABSL_LOG_INTERNAL_DVLOG_IMPL(verbose_level)                       \
+  switch (const int absl_log_internal_verbose_level = (verbose_level))    \
+  case 0:                                                                 \
+  default:                                                                \
+    ABSL_LOG_INTERNAL_DLOG_IF_IMPL(                                       \
+        _INFO, false && ABSL_VLOG_IS_ON(absl_log_internal_verbose_level)) \
+        .WithVerbosity(absl_log_internal_verbose_level)
 #endif
 
 #define ABSL_LOG_INTERNAL_LOG_IF_IMPL(severity, condition)    \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, condition) \
-      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
 #define ABSL_LOG_INTERNAL_PLOG_IF_IMPL(severity, condition)   \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, condition) \
-      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()    \
+      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()        \
           .WithPerror()
 
 #ifndef NDEBUG
 #define ABSL_LOG_INTERNAL_DLOG_IF_IMPL(severity, condition)   \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, condition) \
-      ABSL_LOGGING_INTERNAL_DLOG##severity.InternalStream()
+      ABSL_LOG_INTERNAL_DLOG##severity.InternalStream()
 #else
 #define ABSL_LOG_INTERNAL_DLOG_IF_IMPL(severity, condition)              \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, false && (condition)) \
-      ABSL_LOGGING_INTERNAL_DLOG##severity.InternalStream()
+      ABSL_LOG_INTERNAL_DLOG##severity.InternalStream()
 #endif
 
 // ABSL_LOG_EVERY_N
 #define ABSL_LOG_INTERNAL_LOG_EVERY_N_IMPL(severity, n)            \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, true)(EveryN, n) \
-      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
 
 // ABSL_LOG_FIRST_N
 #define ABSL_LOG_INTERNAL_LOG_FIRST_N_IMPL(severity, n)            \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, true)(FirstN, n) \
-      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
 
 // ABSL_LOG_EVERY_POW_2
 #define ABSL_LOG_INTERNAL_LOG_EVERY_POW_2_IMPL(severity)           \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, true)(EveryPow2) \
-      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
 
 // ABSL_LOG_EVERY_N_SEC
 #define ABSL_LOG_INTERNAL_LOG_EVERY_N_SEC_IMPL(severity, n_seconds)           \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, true)(EveryNSec, n_seconds) \
-      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
 
 #define ABSL_LOG_INTERNAL_PLOG_EVERY_N_IMPL(severity, n)           \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, true)(EveryN, n) \
-      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()         \
+      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()             \
           .WithPerror()
 
 #define ABSL_LOG_INTERNAL_PLOG_FIRST_N_IMPL(severity, n)           \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, true)(FirstN, n) \
-      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()         \
+      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()             \
           .WithPerror()
 
 #define ABSL_LOG_INTERNAL_PLOG_EVERY_POW_2_IMPL(severity)          \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, true)(EveryPow2) \
-      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()         \
+      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()             \
           .WithPerror()
 
 #define ABSL_LOG_INTERNAL_PLOG_EVERY_N_SEC_IMPL(severity, n_seconds)          \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, true)(EveryNSec, n_seconds) \
-      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()                    \
+      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()                        \
           .WithPerror()
 
 #ifndef NDEBUG
 #define ABSL_LOG_INTERNAL_DLOG_EVERY_N_IMPL(severity, n) \
   ABSL_LOG_INTERNAL_CONDITION_INFO(STATEFUL, true)       \
-  (EveryN, n) ABSL_LOGGING_INTERNAL_DLOG##severity.InternalStream()
+  (EveryN, n) ABSL_LOG_INTERNAL_DLOG##severity.InternalStream()
 
 #define ABSL_LOG_INTERNAL_DLOG_FIRST_N_IMPL(severity, n) \
   ABSL_LOG_INTERNAL_CONDITION_INFO(STATEFUL, true)       \
-  (FirstN, n) ABSL_LOGGING_INTERNAL_DLOG##severity.InternalStream()
+  (FirstN, n) ABSL_LOG_INTERNAL_DLOG##severity.InternalStream()
 
 #define ABSL_LOG_INTERNAL_DLOG_EVERY_POW_2_IMPL(severity) \
   ABSL_LOG_INTERNAL_CONDITION_INFO(STATEFUL, true)        \
-  (EveryPow2) ABSL_LOGGING_INTERNAL_DLOG##severity.InternalStream()
+  (EveryPow2) ABSL_LOG_INTERNAL_DLOG##severity.InternalStream()
 
 #define ABSL_LOG_INTERNAL_DLOG_EVERY_N_SEC_IMPL(severity, n_seconds) \
   ABSL_LOG_INTERNAL_CONDITION_INFO(STATEFUL, true)                   \
-  (EveryNSec, n_seconds) ABSL_LOGGING_INTERNAL_DLOG##severity.InternalStream()
+  (EveryNSec, n_seconds) ABSL_LOG_INTERNAL_DLOG##severity.InternalStream()
 
 #else  // def NDEBUG
 #define ABSL_LOG_INTERNAL_DLOG_EVERY_N_IMPL(severity, n) \
   ABSL_LOG_INTERNAL_CONDITION_INFO(STATEFUL, false)      \
-  (EveryN, n) ABSL_LOGGING_INTERNAL_DLOG##severity.InternalStream()
+  (EveryN, n) ABSL_LOG_INTERNAL_DLOG##severity.InternalStream()
 
 #define ABSL_LOG_INTERNAL_DLOG_FIRST_N_IMPL(severity, n) \
   ABSL_LOG_INTERNAL_CONDITION_INFO(STATEFUL, false)      \
-  (FirstN, n) ABSL_LOGGING_INTERNAL_DLOG##severity.InternalStream()
+  (FirstN, n) ABSL_LOG_INTERNAL_DLOG##severity.InternalStream()
 
 #define ABSL_LOG_INTERNAL_DLOG_EVERY_POW_2_IMPL(severity) \
   ABSL_LOG_INTERNAL_CONDITION_INFO(STATEFUL, false)       \
-  (EveryPow2) ABSL_LOGGING_INTERNAL_DLOG##severity.InternalStream()
+  (EveryPow2) ABSL_LOG_INTERNAL_DLOG##severity.InternalStream()
 
 #define ABSL_LOG_INTERNAL_DLOG_EVERY_N_SEC_IMPL(severity, n_seconds) \
   ABSL_LOG_INTERNAL_CONDITION_INFO(STATEFUL, false)                  \
-  (EveryNSec, n_seconds) ABSL_LOGGING_INTERNAL_DLOG##severity.InternalStream()
+  (EveryNSec, n_seconds) ABSL_LOG_INTERNAL_DLOG##severity.InternalStream()
 #endif  // def NDEBUG
 
-#define ABSL_LOG_INTERNAL_VLOG_EVERY_N_IMPL(verbose_level, n)                \
-  switch (const int absl_logging_internal_verbose_level = (verbose_level))   \
-  case 0:                                                                    \
-  default:                                                                   \
-    ABSL_LOG_INTERNAL_CONDITION_INFO(                                        \
-        STATEFUL, ABSL_VLOG_IS_ON(absl_logging_internal_verbose_level))      \
-  (EveryN, n) ABSL_LOGGING_INTERNAL_LOG_INFO.InternalStream().WithVerbosity( \
-      absl_logging_internal_verbose_level)
-
-#define ABSL_LOG_INTERNAL_VLOG_FIRST_N_IMPL(verbose_level, n)                \
-  switch (const int absl_logging_internal_verbose_level = (verbose_level))   \
-  case 0:                                                                    \
-  default:                                                                   \
-    ABSL_LOG_INTERNAL_CONDITION_INFO(                                        \
-        STATEFUL, ABSL_VLOG_IS_ON(absl_logging_internal_verbose_level))      \
-  (FirstN, n) ABSL_LOGGING_INTERNAL_LOG_INFO.InternalStream().WithVerbosity( \
-      absl_logging_internal_verbose_level)
-
-#define ABSL_LOG_INTERNAL_VLOG_EVERY_POW_2_IMPL(verbose_level)               \
-  switch (const int absl_logging_internal_verbose_level = (verbose_level))   \
-  case 0:                                                                    \
-  default:                                                                   \
-    ABSL_LOG_INTERNAL_CONDITION_INFO(                                        \
-        STATEFUL, ABSL_VLOG_IS_ON(absl_logging_internal_verbose_level))      \
-  (EveryPow2) ABSL_LOGGING_INTERNAL_LOG_INFO.InternalStream().WithVerbosity( \
-      absl_logging_internal_verbose_level)
-
-#define ABSL_LOG_INTERNAL_VLOG_EVERY_N_SEC_IMPL(verbose_level, n_seconds)  \
-  switch (const int absl_logging_internal_verbose_level = (verbose_level)) \
-  case 0:                                                                  \
-  default:                                                                 \
-    ABSL_LOG_INTERNAL_CONDITION_INFO(                                      \
-        STATEFUL, ABSL_VLOG_IS_ON(absl_logging_internal_verbose_level))    \
-  (EveryNSec, n_seconds) ABSL_LOGGING_INTERNAL_LOG_INFO.InternalStream()   \
-      .WithVerbosity(absl_logging_internal_verbose_level)
+#define ABSL_LOG_INTERNAL_VLOG_EVERY_N_IMPL(verbose_level, n)            \
+  switch (const int absl_log_internal_verbose_level = (verbose_level))   \
+  case 0:                                                                \
+  default:                                                               \
+    ABSL_LOG_INTERNAL_CONDITION_INFO(                                    \
+        STATEFUL, ABSL_VLOG_IS_ON(absl_log_internal_verbose_level))      \
+  (EveryN, n) ABSL_LOG_INTERNAL_LOG_INFO.InternalStream().WithVerbosity( \
+      absl_log_internal_verbose_level)
+
+#define ABSL_LOG_INTERNAL_VLOG_FIRST_N_IMPL(verbose_level, n)            \
+  switch (const int absl_log_internal_verbose_level = (verbose_level))   \
+  case 0:                                                                \
+  default:                                                               \
+    ABSL_LOG_INTERNAL_CONDITION_INFO(                                    \
+        STATEFUL, ABSL_VLOG_IS_ON(absl_log_internal_verbose_level))      \
+  (FirstN, n) ABSL_LOG_INTERNAL_LOG_INFO.InternalStream().WithVerbosity( \
+      absl_log_internal_verbose_level)
+
+#define ABSL_LOG_INTERNAL_VLOG_EVERY_POW_2_IMPL(verbose_level)           \
+  switch (const int absl_log_internal_verbose_level = (verbose_level))   \
+  case 0:                                                                \
+  default:                                                               \
+    ABSL_LOG_INTERNAL_CONDITION_INFO(                                    \
+        STATEFUL, ABSL_VLOG_IS_ON(absl_log_internal_verbose_level))      \
+  (EveryPow2) ABSL_LOG_INTERNAL_LOG_INFO.InternalStream().WithVerbosity( \
+      absl_log_internal_verbose_level)
+
+#define ABSL_LOG_INTERNAL_VLOG_EVERY_N_SEC_IMPL(verbose_level, n_seconds) \
+  switch (const int absl_log_internal_verbose_level = (verbose_level))    \
+  case 0:                                                                 \
+  default:                                                                \
+    ABSL_LOG_INTERNAL_CONDITION_INFO(                                     \
+        STATEFUL, ABSL_VLOG_IS_ON(absl_log_internal_verbose_level))       \
+  (EveryNSec, n_seconds) ABSL_LOG_INTERNAL_LOG_INFO.InternalStream()      \
+      .WithVerbosity(absl_log_internal_verbose_level)
 
 #define ABSL_LOG_INTERNAL_LOG_IF_EVERY_N_IMPL(severity, condition, n)   \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(EveryN, n) \
-      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
 
 #define ABSL_LOG_INTERNAL_LOG_IF_FIRST_N_IMPL(severity, condition, n)   \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(FirstN, n) \
-      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
 
 #define ABSL_LOG_INTERNAL_LOG_IF_EVERY_POW_2_IMPL(severity, condition)  \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(EveryPow2) \
-      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
 
-#define ABSL_LOG_INTERNAL_LOG_IF_EVERY_N_SEC_IMPL(severity, condition,  \
-                                                  n_seconds)            \
-  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(EveryNSec, \
-                                                             n_seconds) \
-      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()
+#define ABSL_LOG_INTERNAL_LOG_IF_EVERY_N_SEC_IMPL(severity, condition, \
+                                                  n_seconds)           \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(          \
+      EveryNSec, n_seconds) ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
 
 #define ABSL_LOG_INTERNAL_PLOG_IF_EVERY_N_IMPL(severity, condition, n)  \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(EveryN, n) \
-      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()              \
+      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()                  \
           .WithPerror()
 
 #define ABSL_LOG_INTERNAL_PLOG_IF_FIRST_N_IMPL(severity, condition, n)  \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(FirstN, n) \
-      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()              \
+      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()                  \
           .WithPerror()
 
 #define ABSL_LOG_INTERNAL_PLOG_IF_EVERY_POW_2_IMPL(severity, condition) \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(EveryPow2) \
-      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()              \
+      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()                  \
           .WithPerror()
 
-#define ABSL_LOG_INTERNAL_PLOG_IF_EVERY_N_SEC_IMPL(severity, condition, \
-                                                   n_seconds)           \
-  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(EveryNSec, \
-                                                             n_seconds) \
-      ABSL_LOGGING_INTERNAL_LOG##severity.InternalStream()              \
-          .WithPerror()
+#define ABSL_LOG_INTERNAL_PLOG_IF_EVERY_N_SEC_IMPL(severity, condition,      \
+                                                   n_seconds)                \
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(                \
+      EveryNSec, n_seconds) ABSL_LOG_INTERNAL_LOG##severity.InternalStream() \
+      .WithPerror()
 
 #ifndef NDEBUG
 #define ABSL_LOG_INTERNAL_DLOG_IF_EVERY_N_IMPL(severity, condition, n)  \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(EveryN, n) \
-      ABSL_LOGGING_INTERNAL_DLOG##severity.InternalStream()
+      ABSL_LOG_INTERNAL_DLOG##severity.InternalStream()
 
 #define ABSL_LOG_INTERNAL_DLOG_IF_FIRST_N_IMPL(severity, condition, n)  \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(FirstN, n) \
-      ABSL_LOGGING_INTERNAL_DLOG##severity.InternalStream()
+      ABSL_LOG_INTERNAL_DLOG##severity.InternalStream()
 
 #define ABSL_LOG_INTERNAL_DLOG_IF_EVERY_POW_2_IMPL(severity, condition) \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(EveryPow2) \
-      ABSL_LOGGING_INTERNAL_DLOG##severity.InternalStream()
+      ABSL_LOG_INTERNAL_DLOG##severity.InternalStream()
 
 #define ABSL_LOG_INTERNAL_DLOG_IF_EVERY_N_SEC_IMPL(severity, condition, \
                                                    n_seconds)           \
-  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(EveryNSec, \
-                                                             n_seconds) \
-      ABSL_LOGGING_INTERNAL_DLOG##severity.InternalStream()
+  ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, condition)(           \
+      EveryNSec, n_seconds) ABSL_LOG_INTERNAL_DLOG##severity.InternalStream()
 
 #else  // def NDEBUG
 #define ABSL_LOG_INTERNAL_DLOG_IF_EVERY_N_IMPL(severity, condition, n)   \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, false && (condition))( \
-      EveryN, n) ABSL_LOGGING_INTERNAL_DLOG##severity.InternalStream()
+      EveryN, n) ABSL_LOG_INTERNAL_DLOG##severity.InternalStream()
 
 #define ABSL_LOG_INTERNAL_DLOG_IF_FIRST_N_IMPL(severity, condition, n)   \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, false && (condition))( \
-      FirstN, n) ABSL_LOGGING_INTERNAL_DLOG##severity.InternalStream()
+      FirstN, n) ABSL_LOG_INTERNAL_DLOG##severity.InternalStream()
 
 #define ABSL_LOG_INTERNAL_DLOG_IF_EVERY_POW_2_IMPL(severity, condition)  \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, false && (condition))( \
-      EveryPow2) ABSL_LOGGING_INTERNAL_DLOG##severity.InternalStream()
+      EveryPow2) ABSL_LOG_INTERNAL_DLOG##severity.InternalStream()
 
 #define ABSL_LOG_INTERNAL_DLOG_IF_EVERY_N_SEC_IMPL(severity, condition,  \
                                                    n_seconds)            \
   ABSL_LOG_INTERNAL_CONDITION##severity(STATEFUL, false && (condition))( \
-      EveryNSec, n_seconds)                                              \
-      ABSL_LOGGING_INTERNAL_DLOG##severity.InternalStream()
+      EveryNSec, n_seconds) ABSL_LOG_INTERNAL_DLOG##severity.InternalStream()
 #endif  // def NDEBUG
 
 #endif  // ABSL_LOG_INTERNAL_LOG_IMPL_H_

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

@@ -150,7 +150,7 @@ void WriteToStream(const char* data, void* os) {
 }  // namespace
 
 struct LogMessage::LogMessageData final {
-  LogMessageData(const char* absl_nonnull file, int line,
+  LogMessageData(absl::string_view file, int line,
                  absl::LogSeverity severity, absl::Time timestamp);
   LogMessageData(const LogMessageData&) = delete;
   LogMessageData& operator=(const LogMessageData&) = delete;
@@ -202,7 +202,7 @@ struct LogMessage::LogMessageData final {
   void FinalizeEncodingAndFormat();
 };
 
-LogMessage::LogMessageData::LogMessageData(const char* absl_nonnull file,
+LogMessage::LogMessageData::LogMessageData(absl::string_view file,
                                            int line, absl::LogSeverity severity,
                                            absl::Time timestamp)
     : extra_sinks_only(false), manipulated(nullptr) {
@@ -227,7 +227,8 @@ void LogMessage::LogMessageData::InitializeEncodingAndFormat() {
   EncodeVarint(EventTag::kSeverity,
                ProtoSeverity(entry.log_severity(), entry.verbosity()),
                &encoded_remaining());
-  EncodeVarint(EventTag::kThreadId, entry.tid(), &encoded_remaining());
+  EncodeVarint(EventTag::kThreadId, static_cast<uint64_t>(entry.tid()),
+               &encoded_remaining());
 }
 
 void LogMessage::LogMessageData::FinalizeEncodingAndFormat() {
@@ -275,8 +276,11 @@ void LogMessage::LogMessageData::FinalizeEncodingAndFormat() {
 
 LogMessage::LogMessage(const char* absl_nonnull file, int line,
                        absl::LogSeverity severity)
-    : data_(absl::make_unique<LogMessageData>(file, line, severity,
-                                              absl::Now())) {
+  : LogMessage(absl::string_view(file), line, severity) {}
+LogMessage::LogMessage(absl::string_view file, int line,
+                       absl::LogSeverity severity)
+    : data_(
+          std::make_unique<LogMessageData>(file, line, severity, absl::Now())) {
   data_->first_fatal = false;
   data_->is_perror = false;
   data_->fail_quietly = false;
@@ -717,7 +721,7 @@ void LogMessage::CopyToEncodedBufferWithStructuredProtoField(
   }
 
   // Write the string, truncating if necessary.
-  if (!EncodeStringTruncate(ValueTag::kString, str, &encoded_remaining_copy)) {
+  if (!EncodeStringTruncate(tag_value, str, &encoded_remaining_copy)) {
     // The length of the string itself did not fit; zero `encoded_remaining()`
     // so the value is not encoded at all.
     data_->encoded_remaining().remove_suffix(data_->encoded_remaining().size());

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

@@ -50,6 +50,8 @@
 #include "absl/strings/has_absl_stringify.h"
 #include "absl/strings/string_view.h"
 #include "absl/time/time.h"
+#include "absl/types/source_location.h"
+#include "absl/types/span.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -64,9 +66,13 @@ class LogMessage {
   struct WarningTag {};
   struct ErrorTag {};
 
-  // Used for `LOG`.
+  // Used for `LOG`.  Taking `const char *` instead of `string_view` keeps
+  // callsites a little bit smaller at the cost of doing `strlen` at runtime.
   LogMessage(const char* absl_nonnull file, int line,
              absl::LogSeverity severity) ABSL_ATTRIBUTE_COLD;
+  // Used for FFI integrations that don't have a NUL-terminated string.
+  LogMessage(absl::string_view 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* absl_nonnull file, int line,
@@ -82,6 +88,11 @@ class LogMessage {
   // Overrides the location inferred from the callsite.  The string pointed to
   // by `file` must be valid until the end of the statement.
   LogMessage& AtLocation(absl::string_view file, int line);
+  // `loc` doesn't default to `absl::SourceLocation::current()` here since the
+  // callsite is already the default location for `LOG` statements.
+  LogMessage& AtLocation(absl::SourceLocation loc) {
+    return AtLocation(loc.file_name(), static_cast<int>(loc.line()));
+  }
   // Omits the prefix from this line.  The prefix includes metadata about the
   // logged data such as source code location and timestamp.
   LogMessage& NoPrefix();
@@ -168,6 +179,13 @@ class LogMessage {
   LogMessage& operator<<(wchar_t* absl_nullable v);
   LogMessage& operator<<(wchar_t v);
 
+  // Overload for absl::SourceLocation or the std::source_location alias.
+  LogMessage& operator<<(const absl::SourceLocation& loc) {
+    OstreamView view(*data_);
+    view.stream() << loc.file_name() << ':' << loc.line();
+    return *this;
+  }
+
   // Handle stream manipulators e.g. std::endl.
   LogMessage& operator<<(std::ostream& (*absl_nonnull m)(std::ostream& os));
   LogMessage& operator<<(std::ios_base& (*absl_nonnull m)(std::ios_base& os));

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

@@ -192,7 +192,7 @@ class GlobalLogSinkSet final {
         absl::log_internal::WriteToStderr(
             entry.text_message_with_prefix_and_newline(), entry.log_severity());
       } else {
-        absl::ReaderMutexLock global_sinks_lock(&guard_);
+        absl::ReaderMutexLock global_sinks_lock(guard_);
         ThreadIsLoggingStatus() = true;
         // Ensure the "thread is logging" status is reverted upon leaving the
         // scope even in case of exceptions.
@@ -205,7 +205,7 @@ class GlobalLogSinkSet final {
 
   void AddLogSink(absl::LogSink* sink) ABSL_LOCKS_EXCLUDED(guard_) {
     {
-      absl::WriterMutexLock global_sinks_lock(&guard_);
+      absl::WriterMutexLock global_sinks_lock(guard_);
       auto pos = std::find(sinks_.begin(), sinks_.end(), sink);
       if (pos == sinks_.end()) {
         sinks_.push_back(sink);
@@ -217,7 +217,7 @@ class GlobalLogSinkSet final {
 
   void RemoveLogSink(absl::LogSink* sink) ABSL_LOCKS_EXCLUDED(guard_) {
     {
-      absl::WriterMutexLock global_sinks_lock(&guard_);
+      absl::WriterMutexLock global_sinks_lock(guard_);
       auto pos = std::find(sinks_.begin(), sinks_.end(), sink);
       if (pos != sinks_.end()) {
         sinks_.erase(pos);
@@ -235,7 +235,7 @@ class GlobalLogSinkSet final {
       guard_.AssertReaderHeld();
       FlushLogSinksLocked();
     } else {
-      absl::ReaderMutexLock global_sinks_lock(&guard_);
+      absl::ReaderMutexLock global_sinks_lock(guard_);
       // In case if LogSink::Flush overload decides to log
       ThreadIsLoggingStatus() = true;
       // Ensure the "thread is logging" status is reverted upon leaving the

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

@@ -125,4 +125,4 @@ class NullStreamFatal final : public NullStream {
 ABSL_NAMESPACE_END
 }  // namespace absl
 
-#endif  // ABSL_LOG_INTERNAL_GLOBALS_H_
+#endif  // ABSL_LOG_INTERNAL_NULLSTREAM_H_

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

@@ -12,6 +12,19 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// All of the data that passes through this code is trusted because it flows
+// through a closed loop within the absl::LogMessage object. It is not a robust
+// protocol buffer encoder or decoder.
+//
+// Encoding: When `LOG(INFO) << "foo"` is called, the library uses the Encode*
+// functions to build a protocol buffer in a private, fixed-size internal buffer
+// (`LogMessageData::encoded_buf`).
+//
+// Decoding: During the same logging call, `LogMessage::Flush()` calls
+// `FinalizeEncodingAndFormat()`, which uses `ProtoField::DecodeFrom` to parse
+// that same internal buffer to generate the human-readable string for
+// text-based log sinks.
+
 #include "absl/log/internal/proto.h"
 
 #include <algorithm>

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

@@ -26,57 +26,56 @@
 #include "absl/log/internal/log_message.h"
 #include "absl/log/internal/nullstream.h"
 
-// `ABSL_LOGGING_INTERNAL_LOG_*` evaluates to a temporary `LogMessage` object or
+// `ABSL_LOG_INTERNAL_LOG_*` evaluates to a temporary `LogMessage` object or
 // to a related object with a compatible API but different behavior.  This set
 // of defines comes in three flavors: vanilla, plus two variants that strip some
 // logging in subtly different ways for subtly different reasons (see below).
 #if defined(STRIP_LOG) && STRIP_LOG
 
-#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()
-#define ABSL_LOGGING_INTERNAL_LOG_FATAL ::absl::log_internal::NullStreamFatal()
-#define ABSL_LOGGING_INTERNAL_LOG_QFATAL ::absl::log_internal::NullStreamFatal()
-#define ABSL_LOGGING_INTERNAL_LOG_DFATAL \
+#define ABSL_LOG_INTERNAL_LOG_INFO ::absl::log_internal::NullStream()
+#define ABSL_LOG_INTERNAL_LOG_WARNING ::absl::log_internal::NullStream()
+#define ABSL_LOG_INTERNAL_LOG_ERROR ::absl::log_internal::NullStream()
+#define ABSL_LOG_INTERNAL_LOG_FATAL ::absl::log_internal::NullStreamFatal()
+#define ABSL_LOG_INTERNAL_LOG_QFATAL ::absl::log_internal::NullStreamFatal()
+#define ABSL_LOG_INTERNAL_LOG_DFATAL \
   ::absl::log_internal::NullStreamMaybeFatal(::absl::kLogDebugFatal)
-#define ABSL_LOGGING_INTERNAL_LOG_LEVEL(severity) \
+#define ABSL_LOG_INTERNAL_LOG_LEVEL(severity) \
   ::absl::log_internal::NullStreamMaybeFatal(absl_log_internal_severity)
 
 // Fatal `DLOG`s expand a little differently to avoid being `[[noreturn]]`.
-#define ABSL_LOGGING_INTERNAL_DLOG_FATAL \
+#define ABSL_LOG_INTERNAL_DLOG_FATAL \
   ::absl::log_internal::NullStreamMaybeFatal(::absl::LogSeverity::kFatal)
-#define ABSL_LOGGING_INTERNAL_DLOG_QFATAL \
+#define ABSL_LOG_INTERNAL_DLOG_QFATAL \
   ::absl::log_internal::NullStreamMaybeFatal(::absl::LogSeverity::kFatal)
 
-#define ABSL_LOG_INTERNAL_CHECK(failure_message) ABSL_LOGGING_INTERNAL_LOG_FATAL
-#define ABSL_LOG_INTERNAL_QCHECK(failure_message) \
-  ABSL_LOGGING_INTERNAL_LOG_QFATAL
+#define ABSL_LOG_INTERNAL_CHECK(failure_message) ABSL_LOG_INTERNAL_LOG_FATAL
+#define ABSL_LOG_INTERNAL_QCHECK(failure_message) ABSL_LOG_INTERNAL_LOG_QFATAL
 
 #else  // !defined(STRIP_LOG) || !STRIP_LOG
 
-#define ABSL_LOGGING_INTERNAL_LOG_INFO \
-  ::absl::log_internal::LogMessage(    \
+#define ABSL_LOG_INTERNAL_LOG_INFO  \
+  ::absl::log_internal::LogMessage( \
       __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
-#define ABSL_LOGGING_INTERNAL_LOG_WARNING \
-  ::absl::log_internal::LogMessage(       \
+#define ABSL_LOG_INTERNAL_LOG_WARNING \
+  ::absl::log_internal::LogMessage(   \
       __FILE__, __LINE__, ::absl::log_internal::LogMessage::WarningTag{})
-#define ABSL_LOGGING_INTERNAL_LOG_ERROR \
-  ::absl::log_internal::LogMessage(     \
+#define ABSL_LOG_INTERNAL_LOG_ERROR \
+  ::absl::log_internal::LogMessage( \
       __FILE__, __LINE__, ::absl::log_internal::LogMessage::ErrorTag{})
-#define ABSL_LOGGING_INTERNAL_LOG_FATAL \
+#define ABSL_LOG_INTERNAL_LOG_FATAL \
   ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__)
-#define ABSL_LOGGING_INTERNAL_LOG_QFATAL \
+#define ABSL_LOG_INTERNAL_LOG_QFATAL \
   ::absl::log_internal::LogMessageQuietlyFatal(__FILE__, __LINE__)
-#define ABSL_LOGGING_INTERNAL_LOG_DFATAL \
+#define ABSL_LOG_INTERNAL_LOG_DFATAL \
   ::absl::log_internal::LogMessage(__FILE__, __LINE__, ::absl::kLogDebugFatal)
-#define ABSL_LOGGING_INTERNAL_LOG_LEVEL(severity)      \
+#define ABSL_LOG_INTERNAL_LOG_LEVEL(severity)          \
   ::absl::log_internal::LogMessage(__FILE__, __LINE__, \
                                    absl_log_internal_severity)
 
 // Fatal `DLOG`s expand a little differently to avoid being `[[noreturn]]`.
-#define ABSL_LOGGING_INTERNAL_DLOG_FATAL \
+#define ABSL_LOG_INTERNAL_DLOG_FATAL \
   ::absl::log_internal::LogMessageDebugFatal(__FILE__, __LINE__)
-#define ABSL_LOGGING_INTERNAL_DLOG_QFATAL \
+#define ABSL_LOG_INTERNAL_DLOG_QFATAL \
   ::absl::log_internal::LogMessageQuietlyDebugFatal(__FILE__, __LINE__)
 
 // These special cases dispatch to special-case constructors that allow us to
@@ -89,12 +88,12 @@
 #endif  // !defined(STRIP_LOG) || !STRIP_LOG
 
 // This part of a non-fatal `DLOG`s expands the same as `LOG`.
-#define ABSL_LOGGING_INTERNAL_DLOG_INFO ABSL_LOGGING_INTERNAL_LOG_INFO
-#define ABSL_LOGGING_INTERNAL_DLOG_WARNING ABSL_LOGGING_INTERNAL_LOG_WARNING
-#define ABSL_LOGGING_INTERNAL_DLOG_ERROR ABSL_LOGGING_INTERNAL_LOG_ERROR
-#define ABSL_LOGGING_INTERNAL_DLOG_DFATAL ABSL_LOGGING_INTERNAL_LOG_DFATAL
-#define ABSL_LOGGING_INTERNAL_DLOG_LEVEL ABSL_LOGGING_INTERNAL_LOG_LEVEL
+#define ABSL_LOG_INTERNAL_DLOG_INFO ABSL_LOG_INTERNAL_LOG_INFO
+#define ABSL_LOG_INTERNAL_DLOG_WARNING ABSL_LOG_INTERNAL_LOG_WARNING
+#define ABSL_LOG_INTERNAL_DLOG_ERROR ABSL_LOG_INTERNAL_LOG_ERROR
+#define ABSL_LOG_INTERNAL_DLOG_DFATAL ABSL_LOG_INTERNAL_LOG_DFATAL
+#define ABSL_LOG_INTERNAL_DLOG_LEVEL ABSL_LOG_INTERNAL_LOG_LEVEL
 
-#define ABSL_LOGGING_INTERNAL_LOG_DO_NOT_SUBMIT ABSL_LOGGING_INTERNAL_LOG_ERROR
+#define ABSL_LOG_INTERNAL_LOG_DO_NOT_SUBMIT ABSL_LOG_INTERNAL_LOG_ERROR
 
 #endif  // ABSL_LOG_INTERNAL_STRIP_H_