Moved EmbeddedFile out of util_android

* Moved util::ArrayToEmbeddedFiles to EmbeddedFile::ToVector
* Deleted util::FileTocsToEmbeddedFiles which have been obsolete since cl/121957846

PiperOrigin-RevId: 266261187

Author: smiles

admob/src/android/admob_android.cc

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#include "admob/src/android/admob_android.h"
+
 #include <jni.h>
 #include <stddef.h>
 
@@ -22,7 +24,6 @@
 
 #include "admob/admob_resources.h"
 #include "admob/src/android/ad_request_converter.h"
-#include "admob/src/android/admob_android.h"
 #include "admob/src/android/banner_view_internal_android.h"
 #include "admob/src/android/interstitial_ad_internal_android.h"
 #include "admob/src/android/native_express_ad_view_internal_android.h"
@@ -31,6 +32,7 @@
 #include "admob/src/include/firebase/admob.h"
 #include "admob/src/include/firebase/admob/types.h"
 #include "app/src/assert.h"
+#include "app/src/embedded_file.h"
 #include "app/src/include/google_play_services/availability.h"
 #include "app/src/reference_counted_future_impl.h"
 #include "app/src/util_android.h"
@@ -157,12 +159,12 @@ InitResult Initialize(JNIEnv* env, jobject activity, const char* admob_app_id) {
     return kInitResultFailedMissingDependency;
   }
 
-  const std::vector<util::EmbeddedFile> embedded_files =
-      util::CacheEmbeddedFiles(
-          env, activity,
-          util::ArrayToEmbeddedFiles(firebase_admob::admob_resources_filename,
-                                     firebase_admob::admob_resources_data,
-                                     firebase_admob::admob_resources_size));
+  const std::vector<firebase::internal::EmbeddedFile> embedded_files =
+      util::CacheEmbeddedFiles(env, activity,
+                               firebase::internal::EmbeddedFile::ToVector(
+                                   firebase_admob::admob_resources_filename,
+                                   firebase_admob::admob_resources_data,
+                                   firebase_admob::admob_resources_size));
 
   if (!(mobile_ads::CacheMethodIds(env, activity) &&
         ad_request_helper::CacheClassFromFiles(env, activity,

app/CMakeLists.txt

@@ -83,28 +83,44 @@ build_flatbuffers("${CMAKE_CURRENT_LIST_DIR}/google_services.fbs"
                   "")
 
 set(log_common_SRCS
-    src/log.cc)
+    src/log.cc
+    set/log.h)
+set(log_common_HDRS)
 set(log_android_SRCS
     src/jobject_reference.cc
     src/log_android.cc
     src/log_android_callback.cc
     src/util_android.cc)
+set(log_android_HDRS
+    src/jobject_reference.h
+    src/util_android.h)
 set(log_ios_SRCS
     src/log_ios.mm)
+set(log_ios_HDRS)
 set(log_desktop_SRCS
     src/log_stdio.cc)
+set(log_desktop_HDRS)
 if(ANDROID)
   set(log_SRCS
       "${log_common_SRCS}"
       "${log_android_SRCS}")
+  set(log_HDRS
+      "${log_common_HDRS}"
+      "${log_android_HDRS}")
 elseif(IOS)
   set(log_SRCS
       "${log_common_SRCS}"
       "${log_ios_SRCS}")
+  set(log_HDRS
+      "${log_common_HDRS}"
+      "${log_ios_HDRS}")
 else()
   set(log_SRCS
       "${log_common_SRCS}"
       "${log_desktop_SRCS}")
+  set(log_HDRS
+      "${log_common_HDRS}"
+      "${log_desktop_HDRS}")
 endif()
 
 set(common_SRCS
@@ -199,6 +215,7 @@ set(utility_common_HDRS
     ${build_type_header}
     src/callback.h
     src/cleanup_notifier.h
+    src/embedded_file.h
     src/function_registry.h
     src/future_manager.h
     src/log.h
@@ -258,6 +275,7 @@ endif()
 
 add_library(firebase_app STATIC
     ${log_SRCS}
+    ${log_HDRS}
     ${common_SRCS}
     ${invites_SRCS}
     ${app_platform_SRCS}

app/src/embedded_file.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2019 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FIREBASE_APP_CLIENT_CPP_SRC_EMBEDDED_FILE_H_
+#define FIREBASE_APP_CLIENT_CPP_SRC_EMBEDDED_FILE_H_
+
+#include <stddef.h>
+
+#include <vector>
+
+#if !defined(FIREBASE_NAMESPACE)
+#define FIREBASE_NAMESPACE firebase
+#endif  // !defined(FIREBASE_NAMESPACE)
+
+namespace FIREBASE_NAMESPACE {
+namespace internal {
+
+// File embedded in the binary.
+struct EmbeddedFile {
+  EmbeddedFile() : name(nullptr), data(nullptr), size(0) {}
+  EmbeddedFile(const char* _name, const unsigned char* _data, size_t _size)
+      : name(_name), data(_data), size(_size) {}
+
+  const char* name;
+  const unsigned char* data;
+  size_t size;
+
+  // Create a vector with a single EmbeddedFile structure.
+  static std::vector<EmbeddedFile> ToVector(const char* name,
+                                            const unsigned char* data,
+                                            size_t size) {
+    std::vector<EmbeddedFile> vector;
+    vector.push_back(EmbeddedFile(name, data, size));
+    return vector;
+  }
+};
+
+}  // namespace internal
+}  // namespace FIREBASE_NAMESPACE
+
+#endif  // FIREBASE_APP_CLIENT_CPP_SRC_EMBEDDED_FILE_H_

app/src/google_play_services/availability_android.cc

@@ -17,9 +17,11 @@
 #include "app/src/google_play_services/availability_android.h"
 
 #include <jni.h>
+
 #include <map>
 
 #include "app/google_api_resources.h"
+#include "app/src/embedded_file.h"
 #include "app/src/log.h"
 #include "app/src/reference_counted_future_impl.h"
 #include "app/src/util_android.h"
@@ -158,10 +160,10 @@ bool Initialize(JNIEnv* env, jobject activity) {
     if (availability_class != nullptr) {
       env->DeleteLocalRef(availability_class);
       // Cache embedded files and load embedded classes.
-      const std::vector<firebase::util::EmbeddedFile> embedded_files =
+      const std::vector<firebase::internal::EmbeddedFile> embedded_files =
           firebase::util::CacheEmbeddedFiles(
               env, activity,
-              firebase::util::ArrayToEmbeddedFiles(
+              firebase::internal::EmbeddedFile::ToVector(
                   google_api::google_api_resources_filename,
                   google_api::google_api_resources_data,
                   google_api::google_api_resources_size));

app/src/invites/android/invites_android_helper.cc

@@ -20,6 +20,7 @@
 #include <string.h>
 
 #include "app/invites_resources.h"
+#include "app/src/embedded_file.h"
 #include "app/src/invites/receiver_interface.h"
 #include "app/src/invites/sender_receiver_interface.h"
 #include "app/src/log.h"
@@ -64,10 +65,10 @@ AndroidHelper::AndroidHelper(const ::firebase::App& app,
            reinterpret_cast<void*>(
                &Java_com_google_firebase_dynamiclinks_internal_cpp_DynamicLinksNativeWrapper_receivedDynamicLinkCallback)}  // NOLINT
       };
-      const std::vector<util::EmbeddedFile> embedded_files =
+      const std::vector<firebase::internal::EmbeddedFile> embedded_files =
           util::CacheEmbeddedFiles(
               env, app_->activity(),
-              util::ArrayToEmbeddedFiles(
+              firebase::internal::EmbeddedFile::ToVector(
                   firebase_invites::invites_resources_filename,
                   firebase_invites::invites_resources_data,
                   firebase_invites::invites_resources_size));

app/src/util_android.cc

@@ -28,11 +28,12 @@
 #include <list>
 #include <map>
 #include <string>
-#include <vector>
 #include <utility>
+#include <vector>
 
 #include "app/app_resources.h"
 #include "app/src/app_common.h"
+#include "app/src/embedded_file.h"
 #include "app/src/log.h"
 
 #if !defined(FIREBASE_NAMESPACE)
@@ -269,15 +270,6 @@ static const char kMissingJavaMethodFieldError[] =
     "in your app.";
 // LINT.ThenChange(//depot_firebase_cpp/app/client/unity/src/swig/app.SWIG)
 
-std::vector<EmbeddedFile> ArrayToEmbeddedFiles(const char* filename,
-                                               const unsigned char* data,
-                                               size_t size) {
-  std::vector<EmbeddedFile> embedded_files;
-  EmbeddedFile embedded_file = {filename, data, size};
-  embedded_files.push_back(embedded_file);
-  return embedded_files;
-}
-
 // Create a global reference to the specified class loader add it to the
 // list
 // of class loaders and release the local reference.
@@ -507,11 +499,12 @@ bool Initialize(JNIEnv* env, jobject activity_object) {
 #endif  // defined(FIREBASE_ANDROID_FOR_DESKTOP)
 
   // Cache embedded files and load embedded classes.
-  const std::vector<EmbeddedFile> embedded_files = util::CacheEmbeddedFiles(
-      env, activity_object,
-      ArrayToEmbeddedFiles(firebase_app::app_resources_filename,
-                           firebase_app::app_resources_data,
-                           firebase_app::app_resources_size));
+  const std::vector<internal::EmbeddedFile> embedded_files =
+      util::CacheEmbeddedFiles(
+          env, activity_object,
+          internal::EmbeddedFile::ToVector(firebase_app::app_resources_filename,
+                                           firebase_app::app_resources_data,
+                                           firebase_app::app_resources_size));
 
   // Cache the Log class and register the native log method.
   if (!(log::CacheClassFromFiles(env, activity_object, &embedded_files) !=
@@ -1348,7 +1341,7 @@ bool JavaThreadContext::AcquireExecuteCancelLock() {
 
 bool JavaThreadContext::Initialize(
     JNIEnv* env, jobject activity_object,
-    const std::vector<EmbeddedFile>& embedded_files) {
+    const std::vector<internal::EmbeddedFile>& embedded_files) {
   static const JNINativeMethod kCppThreadMethods[] = {
       {"nativeFunction", "(JJ)V",
        reinterpret_cast<void*>(CppThreadDispatcherContext_nativeFunction)}};
@@ -1483,9 +1476,10 @@ void CancelCallbacks(JNIEnv* env, const char* api_identifier) {
 
 // Find a class and retrieve a global reference to it.
 // NOTE: This method will assert if the class isn't found.
-jclass FindClassGlobal(JNIEnv* env, jobject activity_object,
-                       const std::vector<EmbeddedFile>* embedded_files,
-                       const char* class_name, ClassRequirement optional) {
+jclass FindClassGlobal(
+    JNIEnv* env, jobject activity_object,
+    const std::vector<internal::EmbeddedFile>* embedded_files,
+    const char* class_name, ClassRequirement optional) {
   LogDebug("Looking up class %s", class_name);
   jclass local_class = FindClass(env, class_name);
   if (!local_class && embedded_files) {
@@ -1529,14 +1523,14 @@ jclass FindClass(JNIEnv* env, const char* class_name) {
 }
 
 // Cache a list of embedded files to the activity's cache directory.
-const std::vector<EmbeddedFile>& CacheEmbeddedFiles(
+const std::vector<internal::EmbeddedFile>& CacheEmbeddedFiles(
     JNIEnv* env, jobject activity_object,
-    const std::vector<EmbeddedFile>& embedded_files) {
+    const std::vector<internal::EmbeddedFile>& embedded_files) {
   jobject cache_dir = env->CallObjectMethod(
       activity_object, activity::GetMethodId(activity::kGetCacheDir));
   CheckAndClearJniExceptions(env);
   // Write each file in the resources to the cache.
-  for (std::vector<util::EmbeddedFile>::const_iterator it =
+  for (std::vector<internal::EmbeddedFile>::const_iterator it =
            embedded_files.begin();
        it != embedded_files.end(); ++it) {
     LogDebug("Caching %s", it->name);
@@ -1582,9 +1576,10 @@ const std::vector<EmbeddedFile>& CacheEmbeddedFiles(
 
 // Attempt to load a class from a set of files which have been cached to local
 // storage using CacheEmbeddedFiles().
-jclass FindClassInFiles(JNIEnv* env, jobject activity_object,
-                        const std::vector<EmbeddedFile>& embedded_files,
-                        const char* class_name) {
+jclass FindClassInFiles(
+    JNIEnv* env, jobject activity_object,
+    const std::vector<internal::EmbeddedFile>& embedded_files,
+    const char* class_name) {
   if (!embedded_files.size()) {
     return nullptr;
   }
@@ -1657,7 +1652,7 @@ jclass FindClassInFiles(JNIEnv* env, jobject activity_object,
   env->DeleteLocalRef(cache_dir);
 
   std::string dex_path;
-  for (std::vector<util::EmbeddedFile>::const_iterator it =
+  for (std::vector<internal::EmbeddedFile>::const_iterator it =
            embedded_files.begin();
        it != embedded_files.end(); ++it) {
     dex_path += cache_dir_path + kPathSeparator + std::string(it->name);