Automated g4 rollback of changelist 713678123.

*** Reason for rollback ***

Rolling forward cl/712628602 with fixes.

```
$ blaze --blazerc=/dev/null test //vr/c9/client/ar:c9_ar_app_test_x86 \
  --compilation_mode=opt --//third_party/android/ndk:min_sdk_version=28 \
  --define=PORTABLE_PROTO_TRANSITION_MODE=google3 --config=android_x86
```
http://sponge2/c3559a90-3f60-4b9b-9c86-af9cc8183953

*** Original change description ***

Automated g4 rollback of changelist 712628602.

*** Reason for rollback ***

Breaks TAP project vr.c9.unit.android.x86

*** Original change description ***

Moves the generic bug utility to QUICHE.

***

***

PiperOrigin-RevId: 713703088

Author: birenroy

build/source_list.bzl

@@ -10,6 +10,8 @@ protobuf_test_support = [
 ]
 quiche_core_hdrs = [
     "common/btree_scheduler.h",
+    "common/bug_utils.h",
+    "common/bug_utils_test_helper.h",
     "common/capsule.h",
     "common/http/http_header_block.h",
     "common/http/http_header_storage.h",
@@ -409,6 +411,7 @@ quiche_core_hdrs = [
     "web_transport/web_transport_priority_scheduler.h",
 ]
 quiche_core_srcs = [
+    "common/bug_utils.cc",
     "common/capsule.cc",
     "common/http/http_header_block.cc",
     "common/http/http_header_storage.cc",
@@ -1077,6 +1080,7 @@ quiche_tests_srcs = [
     "balsa/simple_buffer_test.cc",
     "binary_http/binary_http_message_test.cc",
     "common/btree_scheduler_test.cc",
+    "common/bug_utils_test.cc",
     "common/capsule_test.cc",
     "common/http/http_header_block_test.cc",
     "common/http/http_header_storage_test.cc",

build/source_list.gni

@@ -10,6 +10,8 @@ protobuf_test_support = [
 ]
 quiche_core_hdrs = [
     "src/quiche/common/btree_scheduler.h",
+    "src/quiche/common/bug_utils.h",
+    "src/quiche/common/bug_utils_test_helper.h",
     "src/quiche/common/capsule.h",
     "src/quiche/common/http/http_header_block.h",
     "src/quiche/common/http/http_header_storage.h",
@@ -409,6 +411,7 @@ quiche_core_hdrs = [
     "src/quiche/web_transport/web_transport_priority_scheduler.h",
 ]
 quiche_core_srcs = [
+    "src/quiche/common/bug_utils.cc",
     "src/quiche/common/capsule.cc",
     "src/quiche/common/http/http_header_block.cc",
     "src/quiche/common/http/http_header_storage.cc",
@@ -1078,6 +1081,7 @@ quiche_tests_srcs = [
     "src/quiche/balsa/simple_buffer_test.cc",
     "src/quiche/binary_http/binary_http_message_test.cc",
     "src/quiche/common/btree_scheduler_test.cc",
+    "src/quiche/common/bug_utils_test.cc",
     "src/quiche/common/capsule_test.cc",
     "src/quiche/common/http/http_header_block_test.cc",
     "src/quiche/common/http/http_header_storage_test.cc",

build/source_list.json

@@ -9,6 +9,8 @@
   ],
   "quiche_core_hdrs": [
     "quiche/common/btree_scheduler.h",
+    "quiche/common/bug_utils.h",
+    "quiche/common/bug_utils_test_helper.h",
     "quiche/common/capsule.h",
     "quiche/common/http/http_header_block.h",
     "quiche/common/http/http_header_storage.h",
@@ -408,6 +410,7 @@
     "quiche/web_transport/web_transport_priority_scheduler.h"
   ],
   "quiche_core_srcs": [
+    "quiche/common/bug_utils.cc",
     "quiche/common/capsule.cc",
     "quiche/common/http/http_header_block.cc",
     "quiche/common/http/http_header_storage.cc",
@@ -1077,6 +1080,7 @@
     "quiche/balsa/simple_buffer_test.cc",
     "quiche/binary_http/binary_http_message_test.cc",
     "quiche/common/btree_scheduler_test.cc",
+    "quiche/common/bug_utils_test.cc",
     "quiche/common/capsule_test.cc",
     "quiche/common/http/http_header_block_test.cc",
     "quiche/common/http/http_header_storage_test.cc",

quiche/common/bug_utils.cc

@@ -0,0 +1,64 @@
+#include "quiche/common/bug_utils.h"
+
+#include <atomic>
+#include <cstdint>
+#include <limits>
+#include <string>
+
+#include "absl/base/log_severity.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+
+namespace quiche {
+namespace internal {
+
+GenericBugStreamHandler::GenericBugStreamHandler(
+    const char* prefix, const char* bug_id, const GenericBugOptions& options)
+    : bug_id_(bug_id), options_(options) {
+  if (options_.condition_str.empty()) {
+    absl::StrAppend(&str_, prefix, "(", bug_id, "): ");
+  } else {
+    absl::StrAppend(&str_, prefix, "_IF(", bug_id, ", ", options_.condition_str,
+                    "): ");
+  }
+}
+
+GenericBugStreamHandler::~GenericBugStreamHandler() {
+  GenericBugStreamHandler::OverrideFunction override_function =
+      GetOverrideFunction();
+  if (options_.bug_listener != nullptr) {
+    options_.bug_listener->OnBug(bug_id_, options_.file_name, options_.line,
+                                 str_);
+  }
+  if (override_function != nullptr) {
+    override_function(options_.severity, options_.file_name, options_.line,
+                      str_);
+  }
+}
+
+// static
+void GenericBugStreamHandler::SetOverrideFunction(
+    GenericBugStreamHandler::OverrideFunction override_function) {
+  atomic_override_function_.store(override_function);
+}
+
+// static
+GenericBugStreamHandler::OverrideFunction
+GenericBugStreamHandler::GetOverrideFunction() {
+  return atomic_override_function_.load(std::memory_order_relaxed);
+}
+
+// static
+std::atomic<GenericBugStreamHandler::OverrideFunction>
+    GenericBugStreamHandler::atomic_override_function_ = nullptr;
+
+void GenericBugWithoutLog(const char* bug_id,
+                          const GenericBugOptions& options) {
+  if (options.bug_listener != nullptr) {
+    options.bug_listener->OnBug(bug_id, options.file_name, options.line,
+                                /*No bug message*/ "");
+  }
+}
+
+}  // namespace internal
+}  // namespace quiche

quiche/common/bug_utils.h

@@ -0,0 +1,151 @@
+#ifndef QUICHE_COMMON_BUG_UTILS_H_
+#define QUICHE_COMMON_BUG_UTILS_H_
+
+// This file contains macros for emitting bug log events when invariants are
+// violated.
+//
+// Each instance of a QUICHE_BUG and friends has an associated id, which can be
+// helpful for quickly finding the associated source code.
+//
+// The IDs are free form, but are expected to be unique. Best practice is to
+// provide a *short* description of the condition being detected, without
+// quotes, e.g.,
+//
+//    QUICHE_BUG(http2_decoder_invalid_parse_state) << "...";
+//
+// QUICHE_BUG is defined in platform/api/quiche_bug_tracker.h.
+//
+
+#include <atomic>
+#include <cstdint>
+#include <sstream>
+#include <string>
+#include <tuple>
+#include <type_traits>
+
+#include "absl/base/log_severity.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "quiche/common/platform/api/quiche_export.h"
+
+namespace quiche {
+namespace internal {
+
+class QUICHE_EXPORT GenericBugListener {
+ public:
+  virtual ~GenericBugListener() = default;
+  virtual void OnBug(const char* bug_id, const char* file, int line,
+                     absl::string_view bug_message) = 0;
+};
+
+struct QUICHE_NO_EXPORT GenericBugOptions {
+  explicit GenericBugOptions(absl::LogSeverity log_severity,
+                             const char* file_name, int line)
+      : severity(log_severity), file_name(file_name), line(line) {}
+
+  GenericBugOptions& SetCondition(absl::string_view condition) {
+    this->condition_str = condition;
+    return *this;
+  }
+
+  GenericBugOptions& SetBugListener(GenericBugListener* listener) {
+    this->bug_listener = listener;
+    return *this;
+  }
+
+  absl::LogSeverity severity;
+  const char* const file_name;
+  const int line;
+  // !empty() for conditional GENERIC_BUGs.
+  absl::string_view condition_str;
+  // If not nullptr, |bug_listener| will be notified of this GENERIC_BUG hit.
+  // Since GenericBugListener may be a temporary object, this is only safe to
+  // access from GenericBugStreamHandler, whose scope is strictly narrower.
+  GenericBugListener* bug_listener = nullptr;
+};
+
+QUICHE_EXPORT inline GenericBugOptions DefaultBugOptions(const char* file_name,
+                                                         int line) {
+  return GenericBugOptions(absl::kLogDebugFatal, file_name, line);
+}
+
+// Called if a GENERIC_BUG is hit, but logging is omitted.
+QUICHE_EXPORT void GenericBugWithoutLog(const char* bug_id,
+                                        const GenericBugOptions& options);
+
+// GenericBugStreamHandler exposes an interface similar to Abseil log objects,
+// and is used by GENERIC_BUG to trigger a function which can be overridden in
+// tests. By default, this class performs no action. SetOverrideFunction must be
+// called to accomplish anything interesting.
+class QUICHE_EXPORT GenericBugStreamHandler {
+ public:
+  // |prefix| and |bug_id| must be literal strings. They are used in the
+  // destructor.
+  explicit GenericBugStreamHandler(const char* prefix, const char* bug_id,
+                                   const GenericBugOptions& options);
+
+  ~GenericBugStreamHandler();
+
+  template <typename T,
+            std::enable_if_t<absl::HasAbslStringify<T>::value, bool> = true>
+  QUICHE_EXPORT GenericBugStreamHandler& operator<<(const T& v) {
+    absl::StrAppend(&str_, v);
+    return *this;
+  }
+
+  // For types that support only operator<<. There's a better solution in
+  // Abseil, but unfortunately OStringStream is in a namespace marked internal.
+  template <typename T,
+            std::enable_if_t<!absl::HasAbslStringify<T>::value, bool> = true>
+  QUICHE_EXPORT GenericBugStreamHandler& operator<<(const T& v) {
+    absl::StrAppend(&str_, (std::ostringstream() << v).view());
+    return *this;
+  }
+
+  // Interface similar to Abseil log objects.
+  GenericBugStreamHandler& stream() { return *this; }
+
+  using OverrideFunction = void (*)(absl::LogSeverity severity,
+                                    const char* file, int line,
+                                    absl::string_view log_message);
+
+  // Allows overriding the internal implementation. Call with nullptr to make
+  // this class a no-op. This getter and setter are thread-safe.
+  static void SetOverrideFunction(OverrideFunction override_function);
+  static OverrideFunction GetOverrideFunction();
+
+ private:
+  static std::atomic<OverrideFunction> atomic_override_function_;
+
+  const char* bug_id_;
+  std::string str_;
+  const GenericBugOptions& options_;
+};
+
+}  // namespace internal
+}  // namespace quiche
+
+// The GNU compiler emits a warning for code like:
+//
+//   if (foo)
+//     if (bar) { } else baz;
+//
+// because it thinks you might want the else to bind to the first if.  This
+// leads to problems with code like:
+//
+//   if (do_expr) GENERIC_BUG(bug_id) << "Some message";
+//
+// The "switch (0) case 0:" idiom is used to suppress this.
+#define GENERIC_BUG_UNBRACED_ELSE_BLOCKER \
+  switch (0)                              \
+  case 0:                                 \
+  default:
+
+#define GENERIC_BUG_IMPL(prefix, bug_id, skip_log_condition, options)       \
+  if (skip_log_condition) {                                                 \
+    ::quiche::internal::GenericBugWithoutLog(#bug_id, (options));           \
+  } else /* NOLINT */                                                       \
+    ::quiche::internal::GenericBugStreamHandler(prefix, #bug_id, (options)) \
+        .stream()
+
+#endif  // QUICHE_COMMON_BUG_UTILS_H_