[Auth] desktop load will update auth_data->persistent_cache_load_pending

+ trigger both auth state listener and token listener if load is done and no valid user loaded. If load a valid user, set that as the current user will automatically trigger these listeners.
+ rename the flag to more properly reflect the operation
+ Add linux internal failure log.

PiperOrigin-RevId: 250543873

Author: cynthiajiang

auth/src/auth.cc

@@ -195,8 +195,7 @@ static bool PushBackIfMissing(const T& entry, std::vector<T>* v) {
 // Return whether the listener is added.
 template <typename T>
 static bool AddListener(T listener, std::vector<T>* listener_vector, Auth* auth,
-                        std::vector<Auth*>* auth_vector, Mutex* mutex) {
-  MutexLock lock(*mutex);
+                        std::vector<Auth*>* auth_vector) {
   // Add to array of listeners if not already there.
   const bool listener_added = PushBackIfMissing(listener, listener_vector);
   // Add auth to array of Auths if not already there.
@@ -212,28 +211,35 @@ static bool AddListener(T listener, std::vector<T>* listener_vector, Auth* auth,
 
 void Auth::AddAuthStateListener(AuthStateListener* listener) {
   if (!auth_data_) return;
-  bool added = AddListener(listener, &auth_data_->listeners, this,
-                           &listener->auths_, &auth_data_->listeners_mutex);
+  // Would have to lock mutex till the method ends to protect on race
+  // conditions.
+  MutexLock lock(auth_data_->listeners_mutex);
+  bool added =
+      AddListener(listener, &auth_data_->listeners, this, &listener->auths_);
+
   // 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
-  if (added && auth_data_->persistent_cache_loaded) {
+  if (added && !auth_data_->persistent_cache_load_pending) {
     listener->OnAuthStateChanged(this);
   }
 }
 
 void Auth::AddIdTokenListener(IdTokenListener* listener) {
   if (!auth_data_) return;
+  // Would have to lock mutex till the method ends to protect on race
+  // conditions.
+  MutexLock lock(auth_data_->listeners_mutex);
   bool added = AddListener(listener, &auth_data_->id_token_listeners, this,
-                           &listener->auths_, &auth_data_->listeners_mutex);
+                           &listener->auths_);
   // AddListener is valid even if the listener is already registered.
   // This makes sure that we only increase the reference count if a listener
   // was actually added.
   if (added) {
     // 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
-    if (auth_data_->persistent_cache_loaded) {
+    if (!auth_data_->persistent_cache_load_pending) {
       listener->OnIdTokenChanged(this);
     }
     EnableTokenAutoRefresh(auth_data_);
@@ -337,7 +343,7 @@ static inline bool VectorContains(const T& entry, const std::vector<T>& v) {
                                                                                \
     /* Auth should have loaded persistent cache if exists when the listener */ \
     /* event is triggered for the first time. */                               \
-    auth_data->persistent_cache_loaded = true;                                 \
+    auth_data->persistent_cache_load_pending = false;                          \
   }
 
 AUTH_NOTIFY_LISTENERS(NotifyAuthStateListeners, "Auth state", listeners,

auth/src/data.h

@@ -79,7 +79,7 @@ struct AuthData {
         listener_impl(nullptr),
         id_token_listener_impl(nullptr),
         expect_id_token_listener_callback(false),
-        persistent_cache_loaded(false) {}
+        persistent_cache_load_pending(true) {}
 
   ~AuthData() {
     ClearUserInfos(this);
@@ -155,6 +155,7 @@ struct AuthData {
   /// Mutex protecting the `listeners`, `id_token_listeners`, and
   /// `phone_auth_provider.data_->listeners vectors`.
   /// 'listeners' are added and removed and accessed on different threads.
+  /// This is also protecting persistent_cache_load_pending flag.
   Mutex listeners_mutex;
 
   // Mutex for changes to the internal token listener state.
@@ -163,8 +164,8 @@ struct AuthData {
   // Tracks if the Id Token listener is expecting a callback to occur.
   bool expect_id_token_listener_callback;
 
-  // Tracks if the persistent cache has been loaded.
-  bool persistent_cache_loaded;
+  // Tracks if the persistent cache load is pending.
+  bool persistent_cache_load_pending;
 
   // Mutex protecting `expect_id_token_listener_callback`
   Mutex expect_id_token_mutex;

auth/src/desktop/auth_desktop.cc

@@ -184,10 +184,10 @@ void Auth::InitPlatformAuth(AuthData* const auth_data) {
   auth_data->app->function_registry()->RegisterFunction(
       internal::FnAuthStopTokenListener,
       Auth::StopTokenRefreshThreadForRegistry);
-#ifdef FIREBASE_EARLY_ACCESS_PREVIEW
+
   // Load existing UserData
   InitializeUserDataPersist(auth_data);
-#endif  //  FIREBASE_EARLY_ACCESS_PREVIEW
+
   InitializeTokenRefresher(auth_data);
 }
 
@@ -211,9 +211,7 @@ void Auth::DestroyPlatformAuth(AuthData* const auth_data) {
     auth_data->id_token_listeners.clear();
   }
 
-#ifdef FIREBASE_EARLY_ACCESS_PREVIEW
   DestroyUserDataPersist(auth_data);
-#endif  //  FIREBASE_EARLY_ACCESS_PREVIEW
 
   UserView::ClearUser(auth_data);
 
@@ -418,6 +416,15 @@ void DestroyUserDataPersist(AuthData* auth_data) {
   auth_data->auth->RemoveAuthStateListener(auth_impl->user_data_persist.get());
 }
 
+void LoadFinishTriggerListeners(AuthData* auth_data) {
+  // We would have to block other listener changes to protect race condition
+  // on how many times a listener should be triggered. We would rely on first
+  // listener trigger to flip the persistence loading bit.
+  MutexLock lock(auth_data->listeners_mutex);
+  NotifyAuthStateListeners(auth_data);
+  NotifyIdTokenListeners(auth_data);
+}
+
 void IdTokenRefreshThread::WakeThread() { wakeup_sem_.Post(); }
 
 IdTokenRefreshThread::IdTokenRefreshThread()

auth/src/desktop/auth_desktop.h

@@ -127,6 +127,7 @@ const int kMsPerTokenRefresh =
 
 void InitializeUserDataPersist(AuthData* auth_data);
 void DestroyUserDataPersist(AuthData* auth_data);
+void LoadFinishTriggerListeners(AuthData* auth_data);
 
 }  // namespace auth
 }  // namespace firebase

auth/src/desktop/user_desktop.cc

@@ -412,7 +412,10 @@ void UserDataPersist::OnAuthStateChanged(Auth* auth) {  // NOLINT
   }
 }
 
-void AssignLoadedData(const Future<std::string>& future, void* auth_data) {
+void AssignLoadedData(const Future<std::string>& future, AuthData* auth_data) {
+  // This function will change the persistent_cache_load_pending, which is
+  // a critical flag to decide listener trigger event, so lock listener_mutex
+  // to protect it.
   if (future.error() == firebase::app::secure::kNoEntry) {
     LogDebug(future.error_message());
     return;
@@ -463,7 +466,13 @@ void AssignLoadedData(const Future<std::string>& future, void* auth_data) {
   loaded_user.last_sign_in_timestamp = userData->last_sign_in_timestamp();
   loaded_user.creation_timestamp = userData->creation_timestamp();
 
-  UserView::ResetUser(static_cast<AuthData*>(auth_data), loaded_user);
+  UserView::ResetUser(auth_data, loaded_user);
+}
+
+void HandleLoadedData(const Future<std::string>& future, void* auth_data) {
+  auto cast_auth_data = static_cast<AuthData*>(auth_data);
+  AssignLoadedData(future, cast_auth_data);
+  LoadFinishTriggerListeners(cast_auth_data);
 }
 
 Future<std::string> UserDataPersist::LoadUserData(AuthData* auth_data) {
@@ -473,7 +482,7 @@ Future<std::string> UserDataPersist::LoadUserData(AuthData* auth_data) {
 
   Future<std::string> future =
       user_secure_manager_->LoadUserData(auth_data->app->name());
-  future.OnCompletion(AssignLoadedData, auth_data);
+  future.OnCompletion(HandleLoadedData, auth_data);
   return future;
 }
 

auth/src/include/firebase/auth.h

@@ -487,6 +487,8 @@ class Auth {
   friend class IdTokenRefreshListener;
   friend class IdTokenRefreshThread;
   friend class UserDataPersist;
+  friend class UserDesktopTest;
+  friend class AuthDesktopTest;
 
   friend void EnableTokenAutoRefresh(AuthData* authData);
   friend void DisableTokenAutoRefresh(AuthData* authData);