Added ability to create a firebase::App for existing FIRApp/FirebaseApp.

iOS FIRApp and Android FirebaseApp objects are serialized and are
therefore restored when the application restarts. A firebase::App could
only be created if a FIRApp/FirebaseApp was not already present unless
the FirebaseApp was a default instance.  This prevented developers from
creating named firebase::App instances since upon application restart
it would not be possible to create a firebase::App as a FirebaseApp
would already exist with the same name. Furthermore, once a named
firebase::App object was destroyed it wasn't possible to recreate the
same object in the same session as a FIRApp/FirebaseApp with the same
name would be present.

This changes the behavior of firebase::App on iOS and Android to allow
connection with an existing FIRApp/FirebaseApp object. If the
FIRApp/FirebaseApp has different options than those requested by the
caller of firebase::App::Create(), the existing FIRApp/FirebaseApp object
is destroyed and recreated with the requested options.

PiperOrigin-RevId: 261147650

Author: smiles

app/src/app_android.cc

@@ -47,6 +47,10 @@
 #endif
 
 namespace FIREBASE_NAMESPACE {
+
+// Default app name.
+const char* const kDefaultAppName = "__FIRAPP_DEFAULT";
+
 namespace app_common {
 
 // clang-format=off
@@ -232,14 +236,13 @@ static std::map<std::string, UniquePtr<AppData>>* g_apps;
 static App* g_default_app = nullptr;
 LibraryRegistry* LibraryRegistry::library_registry_ = nullptr;
 
-App* AddApp(App* app, bool is_default,
-            std::map<std::string, InitResult>* results) {
+App* AddApp(App* app, std::map<std::string, InitResult>* results) {
   bool created_first_app = false;
   assert(app);
   App* existing_app = FindAppByName(app->name());
   FIREBASE_ASSERT_RETURN(nullptr, !existing_app);
   MutexLock lock(g_app_mutex);
-  if (is_default) {
+  if (IsDefaultAppName(app->name())) {
     assert(!g_default_app);
     g_default_app = app;
     created_first_app = true;
@@ -352,6 +355,11 @@ void DestroyAllApps() {
   }
 }
 
+// Determine whether the specified app name refers to the default app.
+bool IsDefaultAppName(const char* name) {
+  return strcmp(kDefaultAppName, name) == 0;
+}
+
 void RegisterLibrary(const char* library, const char* version) {
   MutexLock lock(g_app_mutex);
   LibraryRegistry* registry = LibraryRegistry::Initialize();

app/src/app_common.cc

@@ -29,6 +29,10 @@
 #endif
 
 namespace FIREBASE_NAMESPACE {
+
+// Default app name.
+extern const char* const kDefaultAppName;
+
 namespace app_common {
 
 // Prefix applied to components of Firebase user agent strings.
@@ -45,8 +49,7 @@ extern const char* kCpuArchitecture;
 extern const char* kApiClientHeader;
 
 // Add an app to the set of apps.
-App* AddApp(App* app, bool is_default,
-            std::map<std::string, InitResult>* results);
+App* AddApp(App* app, std::map<std::string, InitResult>* results);
 
 // Find an app in the set of apps.
 App* FindAppByName(const char* name);
@@ -65,6 +68,9 @@ void RemoveApp(App* app);
 // Destroy all apps.
 void DestroyAllApps();
 
+// Determine whether the specified app name refers to the default app.
+bool IsDefaultAppName(const char* name);
+
 // Register a library which uses this SDK.
 // Library registrations are not thread safe as we build the user agent string
 // once and return it from the UserAgent() method.

app/src/app_common.h

@@ -44,27 +44,15 @@ static std::string g_default_config_path;  // NOLINT
 
 }  // namespace internal
 
-// The default App name, the same string as what are used for Android and iOS.
-const char* const kDefaultAppName = "__FIRAPP_DEFAULT";
-
-App::App() {
-  LogDebug("Creating firebase::App for %s", kFirebaseVersionString);
-  data_ = new internal::PrivateAppData();
-}
-
-App::~App() {
-  app_common::RemoveApp(this);
-  // Once we use data_, we should delete it here.
-  delete static_cast<internal::PrivateAppData*>(data_);
-  data_ = nullptr;
-}
+namespace {
 
 // Size is arbitrary, just making sure that there is a sane limit.
-const int kMaxBuffersize = 1024 * 500;
+static const int kMaxBuffersize = 1024 * 500;
 
 // Attempts to load a config file from the path specified, and use it to
 // populate the AppOptions pointer.  Returns true on success, false otherwise.
-bool LoadFromJsonConfigFile(const char* path, AppOptions* options) {
+static bool LoadAppOptionsFromJsonConfigFile(const char* path,
+                                             AppOptions* options) {
   bool loaded_options = false;
   std::ifstream infile(path, std::ifstream::binary);
   if (infile) {
@@ -91,54 +79,79 @@ bool LoadFromJsonConfigFile(const char* path, AppOptions* options) {
   return loaded_options;
 }
 
-const char* kDefaultGoogleServicesNames[] = {"google-services-desktop.json",
-                                             "google-services.json"};
-
-// On desktop, if you create an app with no arguments, it will try to
-// load any data it can find from the google-services-desktop.json
-// file, or the google-services.json file, in that order.
-App* App::Create() {
+}  // namespace
+
+// Searches internal::g_default_config_path for filenames matching
+// kDefaultGoogleServicesNames attempting to load the app options from each
+// config file in turn.
+AppOptions* AppOptions::LoadDefault(AppOptions* options) {
+  static const char* kDefaultGoogleServicesNames[] = {
+    "google-services-desktop.json",
+    "google-services.json"
+  };
+  bool allocated_options;
+  if (options) {
+    allocated_options = false;
+  } else {
+    options = new AppOptions();
+    allocated_options = true;
+  }
   std::string config_files;
   size_t number_of_config_filenames = sizeof(kDefaultGoogleServicesNames) /
                                       sizeof(kDefaultGoogleServicesNames[0]);
   for (size_t i = 0; i < number_of_config_filenames; i++) {
-    AppOptions options;
-    std::string full_path =
-        internal::g_default_config_path + kDefaultGoogleServicesNames[i];
-
-    if (LoadFromJsonConfigFile(full_path.c_str(), &options)) {
-      return Create(options);
+    std::string full_path = internal::g_default_config_path +
+                            kDefaultGoogleServicesNames[i];
+    if (LoadAppOptionsFromJsonConfigFile(full_path.c_str(), options)) {
+      return options;
     }
     config_files += full_path;
     if (i < number_of_config_filenames - 1) config_files += ", ";
   }
-  LogError(
-      "Unable to load options for default app ([%s] are missing or "
-      "malformed)",
-      config_files.c_str());
+  if (allocated_options) delete options;
+  LogError("Unable to load Firebase app options ([%s] are missing or "
+           "malformed)", config_files.c_str());
   return nullptr;
 }
 
+App::App() {
+  data_ = new internal::PrivateAppData();
+}
+
+App::~App() {
+  app_common::RemoveApp(this);
+  // Once we use data_, we should delete it here.
+  delete static_cast<internal::PrivateAppData*>(data_);
+  data_ = nullptr;
+}
+
+// On desktop, if you create an app with no arguments, it will try to
+// load any data it can find from the google-services-desktop.json
+// file, or the google-services.json file, in that order.
+App* App::Create() {
+  AppOptions options;
+  return AppOptions::LoadDefault(&options) ? Create(options) : nullptr;
+}
+
 App* App::Create(const AppOptions& options) {  // NOLINT
   return Create(options, kDefaultAppName);
 }
 
 App* App::Create(const AppOptions& options, const char* name) {  // NOLINT
-  App* existing_app = GetInstance(name);
-  if (existing_app) {
-    LogError("firebase::App %s already created, options will not be applied.",
-             name);
-    return existing_app;
+  App* app = GetInstance(name);
+  if (app) {
+    LogError("App %s already created, options will not be applied.", name);
+    return app;
   }
-  bool is_default_app = strcmp(kDefaultAppName, name) == 0;
-  LogInfo("Firebase App initializing app %s (default %d).", name,
-          is_default_app ? 1 : 0);
-
-  App* new_app = new App();
-  new_app->name_ = name;
-  new_app->options_ = options;
-
-  return app_common::AddApp(new_app, is_default_app, &new_app->init_results_);
+  LogDebug("Creating Firebase App %s for %s", name, kFirebaseVersionString);
+  AppOptions options_with_defaults = options;
+  if (options_with_defaults.PopulateRequiredWithDefaults()) {
+    app = new App();
+    app->name_ = name;
+    app->options_ = options_with_defaults;
+    app = app_common::AddApp(app, &app->init_results_);
+  }
+  return app;
 }
 
 App* App::GetInstance() {  // NOLINT