Unstub Unity desktop builds.

Summary of changes:

1. Remove `firestore_google3` target so that all builds use `firestore`. To achieve this, Firestore on Android now unconditionally uses `timestamp_portable.cc` and `geo_point_portable.cc`. While it's unfortunate not to use the canonical versions from GitHub, doing so significantly simplifies build configuration.

2. In `core/BUILD` under `third_party/`, merge most finer-grained library targets that previously were dependencies of `util` into `util`. This simplifies the build.

3. Fix deadlock while initializing credentials provider. The problem was that credentials provider was registering an Auth listener and then calling `Auth::current_user` for the first time. The first invocation of `Auth::current_user` may trigger Auth listeners and block until they are done; the credentials provider' Auth listener tries to call `Auth::current_user` again, leading to a deadlock.

4. Clear C#-to-C++ callbacks when the C# Firestore instance is destroyed. This prevents assertions from triggering.

5. Register the C# Firestore instance to listen to the event when Firebase App is disposed and clean up accordingly.

PiperOrigin-RevId: 292995447

Author: var-const

firestore/src/android/firestore_android_test_main.cc

@@ -35,12 +35,12 @@
 
 // non-google3 code should include "firebase/app.h" instead.
 #include "app/src/include/firebase/app.h"
+#include "app/src/assert.h"
 #include "firestore/src/include/firebase/firestore.h"
 #include "firestore/src/android/firestore_android.h"
 // non-google3 code should include "gtest/gtest.h" instead.
 #include "testing/base/public/gunit.h"
 // For GTEST_FLAG(filter).
-#include "Firestore/core/src/firebase/firestore/util/hard_assert.h"
 #include "third_party/googletest/googletest/src/gtest-internal-inl.h"
 
 #ifndef NATIVE_FUNCTION_NAME
@@ -87,7 +87,7 @@ App* GetApp(const char* name) {
     return App::Create(g_env, g_activity);
   } else {
     App* default_app = App::GetInstance();
-    HARD_ASSERT(default_app,
+    FIREBASE_ASSERT_MESSAGE(default_app,
                 "Cannot create a named app before the default app");
     return App::Create(default_app->options(), name, g_env, g_activity);
   }

firestore/src/include/firebase/csharp/document_event_listener.cc

@@ -25,6 +25,11 @@ void DocumentEventListener::OnEvent(const DocumentSnapshot& value,
 void DocumentEventListener::SetCallback(
     DocumentEventListenerCallback callback) {
   MutexLock lock(g_mutex);
+  if (!callback) {
+    g_document_snapshot_event_listener_callback = nullptr;
+    return;
+  }
+
   if (g_document_snapshot_event_listener_callback) {
     FIREBASE_ASSERT(g_document_snapshot_event_listener_callback == callback);
   } else {

firestore/src/include/firebase/csharp/query_event_listener.cc

@@ -22,6 +22,11 @@ void QueryEventListener::OnEvent(const QuerySnapshot& value, Error error) {
 /* static */
 void QueryEventListener::SetCallback(QueryEventListenerCallback callback) {
   MutexLock lock(g_mutex);
+  if (!callback) {
+    g_query_snapshot_event_listener_callback = nullptr;
+    return;
+  }
+
   if (g_query_snapshot_event_listener_callback) {
     FIREBASE_ASSERT(g_query_snapshot_event_listener_callback == callback);
   } else {

firestore/src/include/firebase/csharp/unity_transaction_function.cc

@@ -26,6 +26,11 @@ Error UnityTransactionFunction::Apply(Transaction* transaction,
 void UnityTransactionFunction::SetCallback(
     UnityTransactionFunctionCallback callback) {
   MutexLock lock(*mutex_);
+  if (!callback) {
+    transaction_function_callback_ = nullptr;
+    return;
+  }
+
   if (transaction_function_callback_) {
     FIREBASE_ASSERT(transaction_function_callback_ == callback);
   } else {

firestore/src/ios/credentials_provider_ios.cc

@@ -63,9 +63,6 @@ void OnToken(const Future<std::string>& future_token, Auth* firebase_auth,
 FirebaseCppCredentialsProvider::FirebaseCppCredentialsProvider(
     Auth* firebase_auth)
     : contents_(std::make_shared<Contents>(NOT_NULL(firebase_auth))) {
-  // Always listen to Auth events -- if there is no `change_listener_` set, the
-  // events will simply be ignored.
-  contents_->firebase_auth->AddAuthStateListener(this);
 }
 
 void FirebaseCppCredentialsProvider::SetCredentialChangeListener(
@@ -76,12 +73,22 @@ void FirebaseCppCredentialsProvider::SetCredentialChangeListener(
     HARD_ASSERT_IOS(change_listener_,
                     "Change listener removed without being set!");
     change_listener_ = {};
+    // Note: not removing the Auth listener here because the Auth might already
+    // be destroyed. Note that Auth listeners unregister themselves upon
+    // destruction anyway.
     return;
   }
 
   HARD_ASSERT_IOS(!change_listener_, "Set change listener twice!");
   change_listener_ = std::move(listener);
   change_listener_(GetCurrentUser(contents_->firebase_auth));
+
+  // Note: make sure to only register the Auth listener _after_ calling
+  // `Auth::current_user` for the first time. The reason is that upon the only
+  // first call only, `Auth::current_user` might block as it would
+  // asynchronously notify Auth listeners; getting the Firestore listener
+  // notified while `Auth::current_user` is pending can lead to a deadlock.
+  contents_->firebase_auth->AddAuthStateListener(this);
 }
 
 void FirebaseCppCredentialsProvider::GetToken(TokenListener listener) {

firestore/src/ios/credentials_provider_ios.h

@@ -67,6 +67,9 @@ class FirebaseCppCredentialsProvider
     // mutex is always already locked. The mutex is recursive to avoid one
     // potential case of deadlock (attaching a continuation to a `Future` which
     // may be invoked immediately or asynchronously).
+    //
+    // TODO(b/148688333): make sure not to hold the mutex while calling methods
+    // on `firebase_auth`.
     std::recursive_mutex mutex;
 
     ::firebase::auth::Auth* firebase_auth = nullptr;