Make current_user() a block call waiting for persistent cache to load on desktop.

* Each platform has its own implementation of current_user()
* Avoid calling current_user() internally, except during listener event, since it can potentially be a block call.
* Flip persistent_cache_load_pending in the beginning of AUTH_NOTIFY_LISTENERS() macro so that the user can call current_user() during OnAuthStateChanged() or OnIdTokenChanged().

Integration test: cl/247698227

PiperOrigin-RevId: 251526674

Author: chkuang-g

auth/src/android/auth_android.cc

@@ -524,6 +524,24 @@ Future<User*> Auth::CreateUserWithEmailAndPassword(const char* email,
   return MakeFuture(&futures, handle);
 }
 
+// It's safe to return a direct pointer to `current_user` because that class
+// holds nothing but a pointer to AuthData, which never changes.
+// All User functions that require synchronization go through AuthData's mutex.
+User* Auth::current_user() {
+  if (!auth_data_) return nullptr;
+  MutexLock lock(auth_data_->future_impl.mutex());
+
+  // auth_data_->current_user should be available after Auth is created because
+  // persistent is loaded during the constructor of Android FirebaseAuth.
+  // This may change to make FirebaseAuth.getCurrentUser() to block and wait for
+  // persistent loading.  However, it is safe to access auth_data_->current_user
+  // here since FirebaseAuth.getCurrentUser() (Android) is called in
+  // InitPlatformAuth().
+  User* user =
+      auth_data_->user_impl == nullptr ? nullptr : &auth_data_->current_user;
+  return user;
+}
+
 void Auth::SignOut() {
   JNIEnv* env = Env(auth_data_);
   env->CallVoidMethod(AuthImpl(auth_data_), auth::GetMethodId(auth::kSignOut));

auth/src/auth.cc

@@ -163,17 +163,6 @@ void Auth::DeleteInternal() {
 
 Auth::~Auth() { DeleteInternal(); }
 
-// It's safe to return a direct pointer to `current_user` because that class
-// holds nothing but a pointer to AuthData, which never changes.
-// All User functions that require synchronization go through AuthData's mutex.
-User* Auth::current_user() {
-  if (!auth_data_) return nullptr;
-  MutexLock lock(auth_data_->future_impl.mutex());
-  User* user =
-      auth_data_->user_impl == nullptr ? nullptr : &auth_data_->current_user;
-  return user;
-}
-
 // Always non-nullptr since set in constructor.
 App& Auth::app() {
   FIREBASE_ASSERT(auth_data_ != nullptr);
@@ -219,7 +208,9 @@ void Auth::AddAuthStateListener(AuthStateListener* listener) {
 
   // If the listener is registered successfully and persistent cache has been
   // loaded, trigger OnAuthStateChanged() immediately.  Otherwise, wait until
-  // the cache is loaded, through AuthStateListener event
+  // the cache is loaded, through AuthStateListener event.
+  // NOTE: This should be called synchronously or current_user() for desktop
+  // implementation may not work.
   if (added && !auth_data_->persistent_cache_load_pending) {
     listener->OnAuthStateChanged(this);
   }
@@ -321,6 +312,10 @@ static inline bool VectorContains(const T& entry, const std::vector<T>& v) {
   void notify_method_name(AuthData* auth_data) {                               \
     MutexLock lock(auth_data->listeners_mutex);                                \
                                                                                \
+    /* Auth should have loaded persistent cache if exists when the listener */ \
+    /* event is triggered for the first time. */                               \
+    auth_data->persistent_cache_load_pending = false;                          \
+                                                                               \
     /* Make a copy of the listener list in case it gets modified during */     \
     /* notification_method(). Note that modification is possible because */    \
     /* the same thread is allowed to reaquire the `listeners_mutex` */         \
@@ -340,10 +335,6 @@ static inline bool VectorContains(const T& entry, const std::vector<T>& v) {
       /* Notify the listener. */                                               \
       listener->notification_method(auth_data->auth);                          \
     }                                                                          \
-                                                                               \
-    /* Auth should have loaded persistent cache if exists when the listener */ \
-    /* event is triggered for the first time. */                               \
-    auth_data->persistent_cache_load_pending = false;                          \
   }
 
 AUTH_NOTIFY_LISTENERS(NotifyAuthStateListeners, "Auth state", listeners,

auth/src/desktop/auth_desktop.cc

@@ -371,6 +371,44 @@ void Auth::SignOut() {
   AuthenticationResult::SignOut(auth_data_);
 }
 
+// AuthStateListener to wait for current_user() until persistent cache load is
+// finished.
+class CurrentUserBlockListener : public firebase::auth::AuthStateListener {
+ public:
+  explicit CurrentUserBlockListener() : semaphore_(0) {}
+  ~CurrentUserBlockListener() override {}
+
+  void OnAuthStateChanged(Auth* auth) override { semaphore_.Post(); }
+
+  void WaitForEvent() { semaphore_.Wait(); }
+
+ private:
+  Semaphore semaphore_;
+};
+
+// It's safe to return a direct pointer to `current_user` because that class
+// holds nothing but a pointer to AuthData, which never changes.
+// All User functions that require synchronization go through AuthData's mutex.
+User* Auth::current_user() {
+  if (!auth_data_) return nullptr;
+
+  // Add a listener and wait for the first trigger.
+  CurrentUserBlockListener listener;
+  AddAuthStateListener(&listener);
+  // If the persistent cache has not be loaded, this would wait until the
+  // loading is finished and OnAuthStateChanged() is triggered.
+  // If it has been loaded, OnAuthStateChanged() should be triggered recursively
+  // and synchronously when AddAuthStateListener() is called.
+  listener.WaitForEvent();
+  RemoveAuthStateListener(&listener);
+
+  {
+    MutexLock lock(auth_data_->future_impl.mutex());
+    return auth_data_->user_impl == nullptr ? nullptr
+                                            : &auth_data_->current_user;
+  }
+}
+
 void InitializeTokenRefresher(AuthData* auth_data) {
   auto auth_impl = static_cast<AuthImpl*>(auth_data->auth_impl);
   auth_impl->token_refresh_thread.Initialize(auth_data);
@@ -448,7 +486,7 @@ void IdTokenRefreshThread::Initialize(AuthData* auth_data) {
           // lock, to prevent deadlocks!
           refresh_thread->ref_count_mutex_.Acquire();
           auth->auth_data_->future_impl.mutex().Acquire();
-          if (auth->current_user() && refresh_thread->ref_count_ > 0) {
+          if (auth->auth_data_->user_impl && refresh_thread->ref_count_ > 0) {
             // The internal identifier kInternalFn_GetTokenForRefresher,
             // ensures that we won't mess with the LastResult for the
             // user-facing one.
@@ -459,8 +497,8 @@ void IdTokenRefreshThread::Initialize(AuthData* auth_data) {
 
             if (ms_since_last_refresh >= kMsPerTokenRefresh) {
               Future<std::string> future =
-                  refresh_thread->auth->current_user()->GetTokenInternal(
-                      true, kInternalFn_GetTokenForRefresher);
+                  refresh_thread->auth->auth_data_->current_user
+                      .GetTokenInternal(true, kInternalFn_GetTokenForRefresher);
               auth->auth_data_->future_impl.mutex().Release();
               refresh_thread->ref_count_mutex_.Release();
 

auth/src/include/firebase/auth.h

@@ -137,17 +137,16 @@ class Auth {
   ~Auth();
 
   /// Synchronously gets the cached current user, or nullptr if there is none.
-  /// Current user might not be available immediately after Auth is created, if
-  /// a user has signed in before. It is recommended to use AuthStateListener as
-  /// the source of truth whether a user has logged in or not.
+  /// @note This function may block and wait until the Auth instance finishes
+  /// loading the saved user's state. This should only happen for a short
+  /// period of time after the Auth instance is created.
   /// <SWIG>
   /// @xmlonly
   /// <csproperty name="CurrentUser">
   /// Synchronously gets the cached current user, or null if there is none.
-  /// CurrentUser might not be available immediately after FirebaseAuth is
-  /// created, if a user has signed in before. It is recommended to use
-  /// StateChanged delegate as the source of truth whether a user has logged in
-  /// or not.
+  /// @note This function may block and wait until the Auth instance finishes
+  /// loading the saved user's state. This should only happen for a short
+  /// period of time after the Auth instance is created.
   /// </csproperty>
   /// @endxmlonly
   /// </SWIG>

auth/src/ios/auth_ios.mm

@@ -227,6 +227,20 @@ void UpdateCurrentUser(AuthData* auth_data) {
   return MakeFuture(&futures, handle);
 }
 
+// It's safe to return a direct pointer to `current_user` because that class
+// holds nothing but a pointer to AuthData, which never changes.
+// All User functions that require synchronization go through AuthData's mutex.
+User *Auth::current_user() {
+  if (!auth_data_) return nullptr;
+  MutexLock lock(auth_data_->future_impl.mutex());
+
+  // auth_data_->current_user should be available after Auth is created because
+  // [AuthImpl(auth_data) currentUser] is called during Auth::InitPlatformAuth()
+  // and it would block until persistence is loaded.
+  User *user = auth_data_->user_impl == nullptr ? nullptr : &auth_data_->current_user;
+  return user;
+}
+
 static User* AssignUser(FIRUser *_Nullable user, AuthData *auth_data) {
   // Update our pointer to the iOS user that we're wrapping.
   MutexLock lock(auth_data->future_impl.mutex());