[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_;
 };