[Auth] refresh token after load

+ After load user data, call EnsureRefresh, which will refresh the token once it expires.
+ Modify the EnsureRefresh logic to not notify listener if it's called from persistence, since we will always notify listeners after load.
+ the static scheduler for secure manager will cancel all queued task before final destruct.
+ Replace Auth desktop async call from using thread to use scheduler, keep the async call counter to make sure all calls are done before auth desctruction
+ fix auth_test's desctruction, delete configSet last

PiperOrigin-RevId: 258621117

Author: cynthiajiang

auth/src/desktop/auth_desktop.h

@@ -18,6 +18,7 @@
 #include <memory>
 
 #include "app/rest/request.h"
+#include "app/src/scheduler.h"
 #include "app/src/semaphore.h"
 #include "app/src/thread.h"
 #include "app/src/time.h"
@@ -117,6 +118,9 @@ struct AuthImpl {
   Semaphore async_sem;
   Mutex async_mutex;
   int active_async_calls;
+
+  // Serializes all REST call from this object.
+  scheduler::Scheduler scheduler_;
 };
 
 // Constant, describing how often we automatically fetch a new auth token.

auth/src/desktop/auth_util.h

@@ -21,9 +21,10 @@
 #include "app/rest/request.h"
 #include "app/rest/transport_builder.h"
 #include "app/src/assert.h"
+#include "app/src/callback.h"
 #include "app/src/log.h"
+#include "app/src/scheduler.h"
 #include "app/src/semaphore.h"
-#include "app/src/thread.h"
 #include "auth/src/common.h"
 #include "auth/src/data.h"
 #include "auth/src/desktop/auth_constants.h"
@@ -39,6 +40,8 @@
 namespace firebase {
 namespace auth {
 
+using firebase::callback::NewCallback;
+
 const char* GetApiKey(const AuthData& auth_data);
 
 // Completes the given promise by translating the AuthenticationResult. If the
@@ -99,14 +102,17 @@ inline Future<ResultT> CallAsync(
 
   StartAsyncFunction(auth_data->auth_impl);
   typedef AuthDataHandle<ResultT, RequestT> HandleT;
-  firebase::Thread(
+
+  auto scheduler_callback = NewCallback(
       [](HandleT* const raw_auth_data_handle) {
         std::unique_ptr<HandleT> handle(raw_auth_data_handle);
         handle->callback(handle.get());
         EndAsyncFunction(handle->auth_data->auth_impl);
       },
-      new HandleT(auth_data, promise, std::move(request), callback))
-      .Detach();
+      new HandleT(auth_data, promise, std::move(request), callback));
+  auto auth_impl = static_cast<AuthImpl*>(auth_data->auth_impl);
+  auth_impl->scheduler_.Schedule(scheduler_callback);
+
   return promise.future();
 }
 

auth/src/desktop/user_desktop.cc

@@ -19,9 +19,10 @@
 
 #include "app/rest/transport_builder.h"
 #include "app/rest/util.h"
+#include "app/src/callback.h"
 #include "app/src/include/firebase/future.h"
+#include "app/src/scheduler.h"
 #include "app/src/secure/user_secure_manager.h"
-#include "app/src/thread.h"
 #include "auth/src/common.h"
 #include "auth/src/data.h"
 #include "auth/src/desktop/auth_data_handle.h"
@@ -54,6 +55,7 @@ namespace firebase {
 namespace auth {
 
 using firebase::app::secure::UserSecureManager;
+using firebase::callback::NewCallback;
 
 namespace {
 
@@ -112,7 +114,8 @@ GetTokenResult GetTokenIfFresh(const UserView::Reader& user,
 // Note: this is a blocking call! The caller is supposed to call this function
 // on the appropriate thread.
 GetTokenResult EnsureFreshToken(AuthData* const auth_data,
-                                const bool force_refresh) {
+                                const bool force_refresh,
+                                const bool notify_listener) {
   FIREBASE_ASSERT_RETURN(GetTokenResult(kAuthErrorFailure), auth_data);
 
   GetTokenResult old_token(kAuthErrorFailure);
@@ -149,13 +152,18 @@ GetTokenResult EnsureFreshToken(AuthData* const auth_data,
       return GetTokenResult(kAuthErrorNoSignedInUser);
     }
   }
-  if (has_token_changed) {
+  if (has_token_changed && notify_listener) {
     NotifyIdTokenListeners(auth_data);
   }
 
   return GetTokenResult(response.id_token());
 }
 
+GetTokenResult EnsureFreshToken(AuthData* const auth_data,
+                                const bool force_refresh) {
+  return EnsureFreshToken(auth_data, force_refresh, true);
+}
+
 // Checks whether there is a currently logged in user. If no user is signed in,
 // fails the given promise and returns false. Otherwise, doesn't touch the
 // promise and returns true.
@@ -181,7 +189,8 @@ Future<ResultT> CallAsyncWithFreshToken(
   StartAsyncFunction(auth_data->auth_impl);
 
   typedef AuthDataHandle<ResultT, RequestT> HandleT;
-  firebase::Thread(
+
+  auto scheduler_callback = NewCallback(
       [](HandleT* const raw_auth_data_handle) {
         std::unique_ptr<HandleT> handle(raw_auth_data_handle);
 
@@ -197,8 +206,10 @@ Future<ResultT> CallAsyncWithFreshToken(
         handle->callback(handle.get());
         EndAsyncFunction(handle->auth_data->auth_impl);
       },
-      new HandleT(auth_data, promise, std::move(request), callback))
-      .Detach();
+      new HandleT(auth_data, promise, std::move(request), callback));
+  auto auth_impl = static_cast<AuthImpl*>(auth_data->auth_impl);
+  auth_impl->scheduler_.Schedule(scheduler_callback);
+
   return promise.LastResult();
 }
 
@@ -472,14 +483,37 @@ void AssignLoadedData(const Future<std::string>& future, AuthData* auth_data) {
 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);
+
+  // End async call for LoadUserData
+  EndAsyncFunction(cast_auth_data->auth_impl);
+
+  auto scheduler_callback = NewCallback(
+      [](AuthData* callback_auth_data) {
+        // Don't trigger token listeners if token get refreshed, since
+        // it will get triggered inside LoadFinishTriggerListeners anyways.
+        const GetTokenResult get_token_result =
+            EnsureFreshToken(callback_auth_data, false, false);
+        LoadFinishTriggerListeners(callback_auth_data);
+        EndAsyncFunction(callback_auth_data->auth_impl);
+      },
+      cast_auth_data);
+  // Start Async call for EnsureFreshToken
+  StartAsyncFunction(cast_auth_data->auth_impl);
+  auto auth_impl = static_cast<AuthImpl*>(cast_auth_data->auth_impl);
+  auth_impl->scheduler_.Schedule(scheduler_callback);
+}
+
+void HandlePersistenceComplete(const Future<void>& future, void* auth_data) {
+  auto cast_auth_data = static_cast<AuthData*>(auth_data);
+  EndAsyncFunction(cast_auth_data->auth_impl);
 }
 
 Future<std::string> UserDataPersist::LoadUserData(AuthData* auth_data) {
   if (auth_data == nullptr) {
     return Future<std::string>();
   }
 
+  StartAsyncFunction(auth_data->auth_impl);
   Future<std::string> future =
       user_secure_manager_->LoadUserData(auth_data->app->name());
   future.OnCompletion(HandleLoadedData, auth_data);
@@ -531,11 +565,11 @@ Future<void> UserDataPersist::SaveUserData(AuthData* auth_data) {
 }
 
 Future<void> UserDataPersist::DeleteUserData(AuthData* auth_data) {
-  return user_secure_manager_->DeleteUserData(auth_data->app->name());
-}
-
-Future<void> UserDataPersist::DeleteAllData() {
-  return user_secure_manager_->DeleteAllData();
+  StartAsyncFunction(auth_data->auth_impl);
+  Future<void> future =
+      user_secure_manager_->DeleteUserData(auth_data->app->name());
+  future.OnCompletion(HandlePersistenceComplete, auth_data);
+  return future;
 }
 
 User::~User() {

auth/src/desktop/user_desktop.h

@@ -111,8 +111,6 @@ class UserDataPersist : public firebase::auth::AuthStateListener {
   Future<std::string> LoadUserData(AuthData* auth_data);
   Future<void> DeleteUserData(AuthData* auth_data);
 
-  Future<void> DeleteAllData();
-
  private:
   UniquePtr<firebase::app::secure::UserSecureManager> user_secure_manager_;
 };