Several change to Auth Function Registry for desktop

1. Add a new FnAuthGetTokenAsync which take a force_refresh(bool) and returns a Future<std::string>.
2. Add FindAuth(app) which only return existing Auth or nullptr.

PiperOrigin-RevId: 257889774

Author: chkuang-g

app/src/function_registry.h

@@ -33,7 +33,8 @@ namespace internal {
 enum FunctionId {
   FnAuthGetCurrentToken,
   FnAuthStartTokenListener,
-  FnAuthStopTokenListener
+  FnAuthStopTokenListener,
+  FnAuthGetTokenAsync
 };
 
 // Class for providing a generic way for firebase libraries to expose their

auth/src/auth.cc

@@ -68,11 +68,12 @@ Mutex g_auths_mutex;  // NOLINT
 Auth* Auth::GetAuth(App* app, InitResult* init_result_out) {
   MutexLock lock(g_auths_mutex);
   // Return the Auth if it already exists.
-  std::map<App*, Auth*>::iterator it = g_auths.find(app);
-  if (it != g_auths.end()) {
+  Auth* existing_auth = FindAuth(app);
+  if (existing_auth) {
     if (init_result_out != nullptr) *init_result_out = kInitResultSuccess;
-    return it->second;
+    return existing_auth;
   }
+
   FIREBASE_UTIL_RETURN_NULL_IF_GOOGLE_PLAY_UNAVAILABLE(*app, init_result_out);
 
   // Create the platform dependent version of Auth.
@@ -91,6 +92,17 @@ Auth* Auth::GetAuth(App* app, InitResult* init_result_out) {
   return auth;
 }
 
+// static
+Auth* Auth::FindAuth(App* app) {
+  MutexLock lock(g_auths_mutex);
+  // Return the Auth if it already exists.
+  std::map<App*, Auth*>::iterator it = g_auths.find(app);
+  if (it != g_auths.end()) {
+    return it->second;
+  }
+  return nullptr;
+}
+
 // Auth uses the pimpl mechanism to hide internal data types from the interface.
 Auth::Auth(App* app, void* auth_impl) : auth_data_(new AuthData) {
   FIREBASE_ASSERT(app != nullptr && auth_impl != nullptr);

auth/src/data.h

@@ -58,6 +58,7 @@ enum AuthApiFunction {
 
   // Internal functions that are still handles, but are only used internally:
   kInternalFn_GetTokenForRefresher,
+  kInternalFn_GetTokenForFunctionRegistry,
 
   kNumAuthFunctions
 };

auth/src/desktop/auth_desktop.cc

@@ -138,9 +138,11 @@ uint64_t IdTokenRefreshListener::GetTokenTimestamp() {
 // GetAuthToken function on the current auth object.
 bool Auth::GetAuthTokenForRegistry(App* app, void* /*unused*/, void* out) {
   if (!app) return false;
-  InitResult init_result;
-  Auth* auth = Auth::GetAuth(app, &init_result);
+  Auth* auth = Auth::FindAuth(app);
   if (auth) {
+    // Make sure the persistent cache is loaded.
+    auth->current_user();
+
     auto result = static_cast<std::string*>(out);
     MutexLock lock(auth->auth_data_->token_listener_mutex);
     auto auth_impl = static_cast<AuthImpl*>(auth->auth_data_->auth_impl);
@@ -150,11 +152,37 @@ bool Auth::GetAuthTokenForRegistry(App* app, void* /*unused*/, void* out) {
   return false;
 }
 
+// It basically just calls the public GetToken function on the current user and
+// output the Future.
+bool Auth::GetAuthTokenAsyncForRegistry(App* app, void* force_refresh,
+                                        void* out) {
+  Future<std::string>* out_future = static_cast<Future<std::string>*>(out);
+  // Reset the future
+  if (out_future) *out_future = Future<std::string>();
+  bool* in_force_refresh = static_cast<bool*>(force_refresh);
+
+  if (!app) return false;
+  assert(force_refresh);
+
+  Auth* auth = Auth::FindAuth(app);
+  if (auth) {
+    User* user = auth->current_user();
+    if (user) {
+      Future<std::string> future = user->GetTokenInternal(
+          *in_force_refresh, kInternalFn_GetTokenForFunctionRegistry);
+      if (out_future) {
+        *out_future = future;
+      }
+      return true;
+    }
+  }
+  return false;
+}
+
 bool Auth::StartTokenRefreshThreadForRegistry(App* app, void* /*unused*/,
                                               void* /*unused*/) {
   if (!app) return false;
-  InitResult init_result;
-  Auth* auth = Auth::GetAuth(app, &init_result);
+  Auth* auth = Auth::FindAuth(app);
   if (auth) {
     EnableTokenAutoRefresh(auth->auth_data_);
     return true;
@@ -165,8 +193,7 @@ bool Auth::StartTokenRefreshThreadForRegistry(App* app, void* /*unused*/,
 bool Auth::StopTokenRefreshThreadForRegistry(App* app, void* /*unused*/,
                                              void* /*unused*/) {
   if (!app) return false;
-  InitResult init_result;
-  Auth* auth = Auth::GetAuth(app, &init_result);
+  Auth* auth = Auth::FindAuth(app);
   if (auth) {
     DisableTokenAutoRefresh(auth->auth_data_);
     return true;
@@ -184,6 +211,8 @@ void Auth::InitPlatformAuth(AuthData* const auth_data) {
   auth_data->app->function_registry()->RegisterFunction(
       internal::FnAuthStopTokenListener,
       Auth::StopTokenRefreshThreadForRegistry);
+  auth_data->app->function_registry()->RegisterFunction(
+      internal::FnAuthGetTokenAsync, Auth::GetAuthTokenAsyncForRegistry);
 
   // Load existing UserData
   InitializeUserDataPersist(auth_data);
@@ -201,6 +230,9 @@ void Auth::DestroyPlatformAuth(AuthData* const auth_data) {
       internal::FnAuthStartTokenListener);
   auth_data->app->function_registry()->UnregisterFunction(
       internal::FnAuthStopTokenListener);
+  auth_data->app->function_registry()->UnregisterFunction(
+      internal::FnAuthGetTokenAsync);
+
   DestroyTokenRefresher(auth_data);
 
   {

auth/src/include/firebase/auth.h

@@ -494,10 +494,21 @@ class Auth {
   friend void ResetTokenRefreshCounter(AuthData* authData);
   /// @endcond
 
+  // Find Auth instance using App.  Return null if the instance does not exist.
+  static Auth* FindAuth(App* app);
+
   // Provides access to the auth token for the current user.  Returns the
   // current user's auth token, or an empty string, if there isn't one.
+  // Note that this can potentially return an expired token from the cache.
   static bool GetAuthTokenForRegistry(App* app, void* /*unused*/, void* out);
 
+  // Provides asynchronous access to the auth token for the current user. Allow
+  // the caller to force-refresh the token.  Even without force-refresh, this
+  // ensure the future contain a fresh current user's auth token.  This function
+  // returns invalid future if user data is not available.
+  static bool GetAuthTokenAsyncForRegistry(App* app, void* force_refresh,
+                                           void* out_future);
+
   // Starts and stops a thread to ensure that the cached auth token is never
   // kept long enough for it to expire.  Refcounted, so multiple classes can
   // register this without causing problems.

auth/src/include/firebase/auth/user.h

@@ -453,6 +453,7 @@ class User : public UserInfoInterface {
   /// @cond FIREBASE_APP_INTERNAL
   friend class IdTokenRefreshThread;
   friend class IdTokenRefreshListener;
+  friend class Auth;
   Future<std::string> GetTokenInternal(const bool force_refresh,
                                        const int future_identifier);
   /// @endcond