Allow overriding of the default failure handler (#3793)

Author: rsgowman

Firestore/Source/API/FIRFirestore.mm

@@ -46,6 +46,8 @@
 #include "Firestore/core/src/firebase/firestore/util/async_queue.h"
 #include "Firestore/core/src/firebase/firestore/util/error_apple.h"
 #include "Firestore/core/src/firebase/firestore/util/executor_libdispatch.h"
+#include "Firestore/core/src/firebase/firestore/util/hard_assert.h"
+#include "Firestore/core/src/firebase/firestore/util/hard_assert_apple.h"
 #include "Firestore/core/src/firebase/firestore/util/log.h"
 #include "Firestore/core/src/firebase/firestore/util/status.h"
 #include "Firestore/core/src/firebase/firestore/util/string_apple.h"
@@ -57,7 +59,9 @@
 using firebase::firestore::api::ThrowInvalidArgument;
 using firebase::firestore::auth::CredentialsProvider;
 using firebase::firestore::model::DatabaseId;
+using firebase::firestore::util::ObjcFailureHandler;
 using firebase::firestore::util::AsyncQueue;
+using firebase::firestore::util::SetFailureHandler;
 
 NS_ASSUME_NONNULL_BEGIN
 
@@ -75,6 +79,12 @@ @implementation FIRFirestore {
   __weak id<FSTFirestoreInstanceRegistry> _registry;
 }
 
++ (void)initialize {
+  if (self == [FIRFirestore class]) {
+    SetFailureHandler(ObjcFailureHandler);
+  }
+}
+
 + (instancetype)firestore {
   FIRApp *app = [FIRApp defaultApp];
   if (!app) {

Firestore/core/src/firebase/firestore/util/CMakeLists.txt

@@ -67,7 +67,7 @@ cc_select(
 cc_library(
   firebase_firestore_util_base_stdio
   SOURCES
-    hard_assert_stdio.cc
+    hard_assert.cc
     hard_assert.h
     log.h
     log_stdio.cc
@@ -84,7 +84,9 @@ cc_library(
 cc_library(
   firebase_firestore_util_base_apple
   SOURCES
+    hard_assert.cc
     hard_assert.h
+    hard_assert_apple.h
     hard_assert_apple.mm
     log.h
     log_apple.mm

Firestore/core/src/firebase/firestore/util/hard_assert_stdio.cc renamed to Firestore/core/src/firebase/firestore/util/hard_assert.cc

@@ -26,12 +26,11 @@
 namespace firebase {
 namespace firestore {
 namespace util {
-namespace internal {
 
-void Fail(const char* file,
-          const char* func,
-          const int line,
-          const std::string& message) {
+ABSL_ATTRIBUTE_NORETURN void DefaultFailureHandler(const char* file,
+                                                   const char* func,
+                                                   const int line,
+                                                   const std::string& message) {
   std::string failure =
       StringFormat("ASSERT: %s(%s) %s: %s", file, line, func, message);
 
@@ -44,6 +43,29 @@ void Fail(const char* file,
 #endif
 }
 
+namespace {
+FailureHandler failure_handler = DefaultFailureHandler;
+}  // namespace
+
+FailureHandler SetFailureHandler(FailureHandler callback) {
+  FailureHandler previous = failure_handler;
+  failure_handler = callback;
+  return previous;
+}
+
+namespace internal {
+
+void Fail(const char* file,
+          const char* func,
+          const int line,
+          const std::string& message) {
+  failure_handler(file, func, line, message);
+
+  // It's expected that the failure handler above does not return. But if it
+  // does, just terminate.
+  std::terminate();
+}
+
 void Fail(const char* file,
           const char* func,
           const int line,

Firestore/core/src/firebase/firestore/util/hard_assert.h

@@ -101,6 +101,35 @@
 namespace firebase {
 namespace firestore {
 namespace util {
+
+using FailureHandler = void (*)(const char* file,
+                                const char* func,
+                                const int line,
+                                const std::string& failure_message);
+
+/**
+ * Overrides the default failure handler.
+ *
+ * The default essentially just calls std::terminate. While reasonable for C++,
+ * this isn't optimal for platforms that merely use the C++ core as their
+ * implementation and would otherwise be expected to throw a platform specific
+ * exception.
+ *
+ * @param callback A function that will handle the failure. This function is
+ *     not expected to return. (If it does, std::terminate() will be called
+ *     immediately after it does so.)
+ * @return A pointer to the previous failure handler.
+ */
+FailureHandler SetFailureHandler(FailureHandler callback);
+
+/**
+ * Default failure handler. This should typically not be called directly.
+ */
+ABSL_ATTRIBUTE_NORETURN void DefaultFailureHandler(const char* file,
+                                                   const char* func,
+                                                   const int line,
+                                                   const std::string& message);
+
 namespace internal {
 
 // A no-return helper function. To raise an assertion, use Macro instead.

Firestore/core/src/firebase/firestore/util/hard_assert_apple.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2019 Google
+ *
+ * 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 FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_UTIL_HARD_ASSERT_APPLE_H_
+#define FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_UTIL_HARD_ASSERT_APPLE_H_
+
+#include <string>
+
+#include "Firestore/core/src/firebase/firestore/util/hard_assert.h"
+#include "absl/base/attributes.h"
+
+namespace firebase {
+namespace firestore {
+namespace util {
+
+/**
+ * Default failure handler for ObjC/Swift. Typically shouldn't be used
+ * directly.
+ */
+ABSL_ATTRIBUTE_NORETURN void ObjcFailureHandler(const char* file,
+                                                const char* func,
+                                                const int line,
+                                                const std::string& message);
+
+}  // namespace util
+}  // namespace firestore
+}  // namespace firebase
+
+#endif  // FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_UTIL_HARD_ASSERT_APPLE_H_

Firestore/core/src/firebase/firestore/util/hard_assert_apple.mm

@@ -14,23 +14,20 @@
  * limitations under the License.
  */
 
-#include "Firestore/core/src/firebase/firestore/util/hard_assert.h"
+#include "Firestore/core/src/firebase/firestore/util/hard_assert_apple.h"
 
 #import <Foundation/Foundation.h>
 
-#include <string>
-
 #include "Firestore/core/src/firebase/firestore/util/string_apple.h"
 
 namespace firebase {
 namespace firestore {
 namespace util {
-namespace internal {
 
-void Fail(const char* file,
-          const char* func,
-          const int line,
-          const std::string& message) {
+ABSL_ATTRIBUTE_NORETURN void ObjcFailureHandler(const char* file,
+                                                const char* func,
+                                                const int line,
+                                                const std::string& message) {
   [[NSAssertionHandler currentHandler]
       handleFailureInFunction:MakeNSString(func)
                          file:MakeNSString(file)
@@ -40,21 +37,6 @@ void Fail(const char* file,
   abort();
 }
 
-void Fail(const char* file,
-          const char* func,
-          const int line,
-          const std::string& message,
-          const char* condition) {
-  std::string failure;
-  if (message.empty()) {
-    failure = condition;
-  } else {
-    failure = StringFormat("%s (expected %s)", message, condition);
-  }
-  Fail(file, func, line, failure);
-}
-
-}  // namespace internal
 }  // namespace util
 }  // namespace firestore
 }  // namespace firebase

Firestore/core/test/firebase/firestore/util/hard_assert_test.cc

@@ -47,6 +47,29 @@ TEST(HardAssertTest, WithMessage) {
   EXPECT_ANY_THROW(AssertWithMessage(false));
 }
 
+TEST(HardAssertTest, NonDefaultFailureHandler) {
+  // Used to ensure the original failure handler is restored.
+  class FailureHandlerRestorer {
+   public:
+    explicit FailureHandlerRestorer(FailureHandler orig) : orig_(orig) {
+    }
+    ~FailureHandlerRestorer() {
+      SetFailureHandler(orig_);
+    }
+
+   private:
+    FailureHandler orig_;
+  };
+
+  struct FakeException {};
+  FailureHandler prev =
+      SetFailureHandler([](const char*, const char*, const int,
+                           const std::string&) { throw FakeException(); });
+  FailureHandlerRestorer _(prev);
+
+  EXPECT_THROW(Assert(false), FakeException);
+}
+
 }  //  namespace util
 }  //  namespace firestore
 }  //  namespace firebase