Merge Android R (rvc-dev-plus-aosp-without-vendor@6692709)

Bug: 166295507
Merged-In: I3d92a6de21a938f6b352ec26dc23420c0fe02b27
Change-Id: Ifdb80563ef042738778ebb8a7581a97c4e3d96e2

1 files changed, 33 insertions, 44 deletions

diff --git a/libs/androidfw/LoadedArsc.cpp b/libs/androidfw/LoadedArsc.cpp
index 72873abc6a42..70bb441f94cb 100644
--- a/libs/androidfw/LoadedArsc.cpp
+++ b/libs/androidfw/LoadedArsc.cpp
@@ -51,9 +51,8 @@ namespace {
 // the Type structs.
 class TypeSpecPtrBuilder {
  public:
-  explicit TypeSpecPtrBuilder(const ResTable_typeSpec* header,
-                              const IdmapEntry_header* idmap_header)
-      : header_(header), idmap_header_(idmap_header) {
+  explicit TypeSpecPtrBuilder(const ResTable_typeSpec* header)
+      : header_(header) {
   }
 
   void AddType(const ResTable_type* type) {
@@ -70,7 +69,6 @@ class TypeSpecPtrBuilder {
     TypeSpec* type_spec =
         (TypeSpec*)::malloc(sizeof(TypeSpec) + (types_.size() * sizeof(ElementType)));
     type_spec->type_spec = header_;
-    type_spec->idmap_entries = idmap_header_;
     type_spec->type_count = types_.size();
     memcpy(type_spec + 1, types_.data(), types_.size() * sizeof(ElementType));
     return TypeSpecPtr(type_spec);
@@ -80,7 +78,6 @@ class TypeSpecPtrBuilder {
   DISALLOW_COPY_AND_ASSIGN(TypeSpecPtrBuilder);
 
   const ResTable_typeSpec* header_;
-  const IdmapEntry_header* idmap_header_;
   std::vector<const ResTable_type*> types_;
 };
 
@@ -400,8 +397,7 @@ const LoadedPackage* LoadedArsc::GetPackageById(uint8_t package_id) const {
 }
 
 std::unique_ptr<const LoadedPackage> LoadedPackage::Load(const Chunk& chunk,
-                                                         const LoadedIdmap* loaded_idmap,
-                                                         bool system, bool load_as_shared_library) {
+                                                         package_property_t property_flags) {
   ATRACE_NAME("LoadedPackage::Load");
   std::unique_ptr<LoadedPackage> loaded_package(new LoadedPackage());
 
@@ -415,19 +411,24 @@ std::unique_ptr<const LoadedPackage> LoadedPackage::Load(const Chunk& chunk,
     return {};
   }
 
-  loaded_package->system_ = system;
+  if ((property_flags & PROPERTY_SYSTEM) != 0) {
+    loaded_package->property_flags_ |= PROPERTY_SYSTEM;
+  }
 
-  loaded_package->package_id_ = dtohl(header->id);
-  if (loaded_package->package_id_ == 0 ||
-      (loaded_package->package_id_ == kAppPackageId && load_as_shared_library)) {
-    // Package ID of 0 means this is a shared library.
-    loaded_package->dynamic_ = true;
+  if ((property_flags & PROPERTY_LOADER) != 0) {
+    loaded_package->property_flags_ |= PROPERTY_LOADER;
   }
 
-  if (loaded_idmap != nullptr) {
-    // This is an overlay and so it needs to pretend to be the target package.
-    loaded_package->package_id_ = loaded_idmap->TargetPackageId();
-    loaded_package->overlay_ = true;
+  if ((property_flags & PROPERTY_OVERLAY) != 0) {
+    // Overlay resources must have an exclusive resource id space for referencing internal
+    // resources.
+    loaded_package->property_flags_ |= PROPERTY_OVERLAY | PROPERTY_DYNAMIC;
+  }
+
+  loaded_package->package_id_ = dtohl(header->id);
+  if (loaded_package->package_id_ == 0 ||
+      (loaded_package->package_id_ == kAppPackageId && (property_flags & PROPERTY_DYNAMIC) != 0)) {
+    loaded_package->property_flags_ |= PROPERTY_DYNAMIC;
   }
 
   if (header->header.headerSize >= sizeof(ResTable_package)) {
@@ -511,16 +512,9 @@ std::unique_ptr<const LoadedPackage> LoadedPackage::Load(const Chunk& chunk,
           return {};
         }
 
-        // If this is an overlay, associate the mapping of this type to the target type
-        // from the IDMAP.
-        const IdmapEntry_header* idmap_entry_header = nullptr;
-        if (loaded_idmap != nullptr) {
-          idmap_entry_header = loaded_idmap->GetEntryMapForType(type_spec->id);
-        }
-
         std::unique_ptr<TypeSpecPtrBuilder>& builder_ptr = type_builder_map[type_spec->id - 1];
         if (builder_ptr == nullptr) {
-          builder_ptr = util::make_unique<TypeSpecPtrBuilder>(type_spec, idmap_entry_header);
+          builder_ptr = util::make_unique<TypeSpecPtrBuilder>(type_spec);
           loaded_package->resource_ids_.set(type_spec->id, entry_count);
         } else {
           LOG(WARNING) << StringPrintf("RES_TABLE_TYPE_SPEC_TYPE already defined for ID %02x",
@@ -681,28 +675,24 @@ std::unique_ptr<const LoadedPackage> LoadedPackage::Load(const Chunk& chunk,
       return {};
     }
 
-    // We only add the type to the package if there is no IDMAP, or if the type is
-    // overlaying something.
-    if (loaded_idmap == nullptr || type_spec_ptr->idmap_entries != nullptr) {
-      // If this is an overlay, insert it at the target type ID.
-      if (type_spec_ptr->idmap_entries != nullptr) {
-        type_idx = dtohs(type_spec_ptr->idmap_entries->target_type_id) - 1;
-      }
-      loaded_package->type_specs_.editItemAt(type_idx) = std::move(type_spec_ptr);
-    }
+    loaded_package->type_specs_.editItemAt(type_idx) = std::move(type_spec_ptr);
   }
 
   return std::move(loaded_package);
 }
 
 bool LoadedArsc::LoadTable(const Chunk& chunk, const LoadedIdmap* loaded_idmap,
-                           bool load_as_shared_library) {
+                           package_property_t property_flags) {
   const ResTable_header* header = chunk.header<ResTable_header>();
   if (header == nullptr) {
     LOG(ERROR) << "RES_TABLE_TYPE too small.";
     return false;
   }
 
+  if (loaded_idmap != nullptr) {
+    global_string_pool_ = util::make_unique<OverlayStringPool>(loaded_idmap);
+  }
+
   const size_t package_count = dtohl(header->packageCount);
   size_t packages_seen = 0;
 
@@ -714,9 +704,9 @@ bool LoadedArsc::LoadTable(const Chunk& chunk, const LoadedIdmap* loaded_idmap,
     switch (child_chunk.type()) {
       case RES_STRING_POOL_TYPE:
         // Only use the first string pool. Ignore others.
-        if (global_string_pool_.getError() == NO_INIT) {
-          status_t err = global_string_pool_.setTo(child_chunk.header<ResStringPool_header>(),
-                                                   child_chunk.size());
+        if (global_string_pool_->getError() == NO_INIT) {
+          status_t err = global_string_pool_->setTo(child_chunk.header<ResStringPool_header>(),
+                                                    child_chunk.size());
           if (err != NO_ERROR) {
             LOG(ERROR) << "RES_STRING_POOL_TYPE corrupt.";
             return false;
@@ -735,7 +725,7 @@ bool LoadedArsc::LoadTable(const Chunk& chunk, const LoadedIdmap* loaded_idmap,
         packages_seen++;
 
         std::unique_ptr<const LoadedPackage> loaded_package =
-            LoadedPackage::Load(child_chunk, loaded_idmap, system_, load_as_shared_library);
+            LoadedPackage::Load(child_chunk, property_flags);
         if (!loaded_package) {
           return false;
         }
@@ -758,20 +748,19 @@ bool LoadedArsc::LoadTable(const Chunk& chunk, const LoadedIdmap* loaded_idmap,
 }
 
 std::unique_ptr<const LoadedArsc> LoadedArsc::Load(const StringPiece& data,
-                                                   const LoadedIdmap* loaded_idmap, bool system,
-                                                   bool load_as_shared_library) {
-  ATRACE_NAME("LoadedArsc::LoadTable");
+                                                   const LoadedIdmap* loaded_idmap,
+                                                   const package_property_t property_flags) {
+  ATRACE_NAME("LoadedArsc::Load");
 
   // Not using make_unique because the constructor is private.
   std::unique_ptr<LoadedArsc> loaded_arsc(new LoadedArsc());
-  loaded_arsc->system_ = system;
 
   ChunkIterator iter(data.data(), data.size());
   while (iter.HasNext()) {
     const Chunk chunk = iter.Next();
     switch (chunk.type()) {
       case RES_TABLE_TYPE:
-        if (!loaded_arsc->LoadTable(chunk, loaded_idmap, load_as_shared_library)) {
+        if (!loaded_arsc->LoadTable(chunk, loaded_idmap, property_flags)) {
           return {};
         }
         break;