Fix shared library bug in bag attributes

A ResTable_map entry has a name attribute, which
could be a dynamic reference if it comes from
a shared library. It was not being patched with
the correct package id.

Bug:16795890
Change-Id: Ia8df6a943269b2fefb2132c3ed74eb1997d7701b

1 files changed, 38 insertions, 20 deletions

diff --git a/libs/androidfw/tests/ResTable_test.cpp b/libs/androidfw/tests/ResTable_test.cpp
index 6bdf7034bd42..8016a82bd248 100644
--- a/libs/androidfw/tests/ResTable_test.cpp
+++ b/libs/androidfw/tests/ResTable_test.cpp
@@ -19,7 +19,8 @@
 #include <utils/String8.h>
 #include <utils/String16.h>
 #include "TestHelpers.h"
-#include "data/R.h"
+#include "data/basic/R.h"
+#include "data/lib/R.h"
 
 #include <gtest/gtest.h>
 
@@ -34,6 +35,8 @@ namespace {
  */
 #include "data/basic/basic_arsc.h"
 
+#include "data/lib/lib_arsc.h"
+
 enum { MAY_NOT_BE_BAG = false };
 
 TEST(ResTableTest, shouldLoadSuccessfully) {
@@ -46,7 +49,7 @@ TEST(ResTableTest, simpleTypeIsRetrievedCorrectly) {
     ASSERT_EQ(NO_ERROR, table.add(basic_arsc, basic_arsc_len));
 
     Res_value val;
-    ssize_t block = table.getResource(R::string::test1, &val, MAY_NOT_BE_BAG);
+    ssize_t block = table.getResource(base::R::string::test1, &val, MAY_NOT_BE_BAG);
 
     ASSERT_GE(block, 0);
     ASSERT_EQ(Res_value::TYPE_STRING, val.dataType);
@@ -66,7 +69,7 @@ TEST(ResTableTest, resourceNameIsResolved) {
                                              0, 0,
                                              defPackage.string(), defPackage.size());
     ASSERT_NE(uint32_t(0x00000000), resID);
-    ASSERT_EQ(R::string::test1, resID);
+    ASSERT_EQ(base::R::string::test1, resID);
 }
 
 TEST(ResTableTest, noParentThemeIsAppliedCorrectly) {
@@ -74,19 +77,19 @@ TEST(ResTableTest, noParentThemeIsAppliedCorrectly) {
     ASSERT_EQ(NO_ERROR, table.add(basic_arsc, basic_arsc_len));
 
     ResTable::Theme theme(table);
-    ASSERT_EQ(NO_ERROR, theme.applyStyle(R::style::Theme1));
+    ASSERT_EQ(NO_ERROR, theme.applyStyle(base::R::style::Theme1));
 
     Res_value val;
     uint32_t specFlags = 0;
-    ssize_t index = theme.getAttribute(R::attr::attr1, &val, &specFlags);
+    ssize_t index = theme.getAttribute(base::R::attr::attr1, &val, &specFlags);
     ASSERT_GE(index, 0);
     ASSERT_EQ(Res_value::TYPE_INT_DEC, val.dataType);
     ASSERT_EQ(uint32_t(100), val.data);
 
-    index = theme.getAttribute(R::attr::attr2, &val, &specFlags);
+    index = theme.getAttribute(base::R::attr::attr2, &val, &specFlags);
     ASSERT_GE(index, 0);
     ASSERT_EQ(Res_value::TYPE_REFERENCE, val.dataType);
-    ASSERT_EQ(R::integer::number1, val.data);
+    ASSERT_EQ(base::R::integer::number1, val.data);
 }
 
 TEST(ResTableTest, parentThemeIsAppliedCorrectly) {
@@ -94,19 +97,34 @@ TEST(ResTableTest, parentThemeIsAppliedCorrectly) {
     ASSERT_EQ(NO_ERROR, table.add(basic_arsc, basic_arsc_len));
 
     ResTable::Theme theme(table);
-    ASSERT_EQ(NO_ERROR, theme.applyStyle(R::style::Theme2));
+    ASSERT_EQ(NO_ERROR, theme.applyStyle(base::R::style::Theme2));
 
     Res_value val;
     uint32_t specFlags = 0;
-    ssize_t index = theme.getAttribute(R::attr::attr1, &val, &specFlags);
+    ssize_t index = theme.getAttribute(base::R::attr::attr1, &val, &specFlags);
     ASSERT_GE(index, 0);
     ASSERT_EQ(Res_value::TYPE_INT_DEC, val.dataType);
     ASSERT_EQ(uint32_t(300), val.data);
 
-    index = theme.getAttribute(R::attr::attr2, &val, &specFlags);
+    index = theme.getAttribute(base::R::attr::attr2, &val, &specFlags);
     ASSERT_GE(index, 0);
     ASSERT_EQ(Res_value::TYPE_REFERENCE, val.dataType);
-    ASSERT_EQ(R::integer::number1, val.data);
+    ASSERT_EQ(base::R::integer::number1, val.data);
+}
+
+TEST(ResTableTest, libraryThemeIsAppliedCorrectly) {
+    ResTable table;
+    ASSERT_EQ(NO_ERROR, table.add(lib_arsc, lib_arsc_len));
+
+    ResTable::Theme theme(table);
+    ASSERT_EQ(NO_ERROR, theme.applyStyle(lib::R::style::Theme));
+
+    Res_value val;
+    uint32_t specFlags = 0;
+    ssize_t index = theme.getAttribute(lib::R::attr::attr1, &val, &specFlags);
+    ASSERT_GE(index, 0);
+    ASSERT_EQ(Res_value::TYPE_INT_DEC, val.dataType);
+    ASSERT_EQ(uint32_t(700), val.data);
 }
 
 TEST(ResTableTest, referenceToBagIsNotResolved) {
@@ -114,15 +132,15 @@ TEST(ResTableTest, referenceToBagIsNotResolved) {
     ASSERT_EQ(NO_ERROR, table.add(basic_arsc, basic_arsc_len));
 
     Res_value val;
-    ssize_t block = table.getResource(R::integer::number2, &val, MAY_NOT_BE_BAG);
+    ssize_t block = table.getResource(base::R::integer::number2, &val, MAY_NOT_BE_BAG);
     ASSERT_GE(block, 0);
     ASSERT_EQ(Res_value::TYPE_REFERENCE, val.dataType);
-    ASSERT_EQ(R::array::integerArray1, val.data);
+    ASSERT_EQ(base::R::array::integerArray1, val.data);
 
     ssize_t newBlock = table.resolveReference(&val, block);
     EXPECT_EQ(block, newBlock);
     EXPECT_EQ(Res_value::TYPE_REFERENCE, val.dataType);
-    EXPECT_EQ(R::array::integerArray1, val.data);
+    EXPECT_EQ(base::R::array::integerArray1, val.data);
 }
 
 TEST(ResTableTest, resourcesStillAccessibleAfterParameterChange) {
@@ -130,12 +148,12 @@ TEST(ResTableTest, resourcesStillAccessibleAfterParameterChange) {
     ASSERT_EQ(NO_ERROR, table.add(basic_arsc, basic_arsc_len));
 
     Res_value val;
-    ssize_t block = table.getResource(R::integer::number1, &val, MAY_NOT_BE_BAG);
+    ssize_t block = table.getResource(base::R::integer::number1, &val, MAY_NOT_BE_BAG);
     ASSERT_GE(block, 0);
     ASSERT_EQ(Res_value::TYPE_INT_DEC, val.dataType);
 
     const ResTable::bag_entry* entry;
-    ssize_t count = table.lockBag(R::array::integerArray1, &entry);
+    ssize_t count = table.lockBag(base::R::array::integerArray1, &entry);
     ASSERT_GE(count, 0);
     table.unlockBag(entry);
 
@@ -144,11 +162,11 @@ TEST(ResTableTest, resourcesStillAccessibleAfterParameterChange) {
     param.density = 320;
     table.setParameters(&param);
 
-    block = table.getResource(R::integer::number1, &val, MAY_NOT_BE_BAG);
+    block = table.getResource(base::R::integer::number1, &val, MAY_NOT_BE_BAG);
     ASSERT_GE(block, 0);
     ASSERT_EQ(Res_value::TYPE_INT_DEC, val.dataType);
 
-    count = table.lockBag(R::array::integerArray1, &entry);
+    count = table.lockBag(base::R::array::integerArray1, &entry);
     ASSERT_GE(count, 0);
     table.unlockBag(entry);
 }
@@ -158,7 +176,7 @@ TEST(ResTableTest, resourceIsOverridenWithBetterConfig) {
     ASSERT_EQ(NO_ERROR, table.add(basic_arsc, basic_arsc_len));
 
     Res_value val;
-    ssize_t block = table.getResource(R::integer::number1, &val, MAY_NOT_BE_BAG);
+    ssize_t block = table.getResource(base::R::integer::number1, &val, MAY_NOT_BE_BAG);
     ASSERT_GE(block, 0);
     ASSERT_EQ(Res_value::TYPE_INT_DEC, val.dataType);
     ASSERT_EQ(uint32_t(200), val.data);
@@ -171,7 +189,7 @@ TEST(ResTableTest, resourceIsOverridenWithBetterConfig) {
     param.country[1] = 'E';
     table.setParameters(&param);
 
-    block = table.getResource(R::integer::number1, &val, MAY_NOT_BE_BAG);
+    block = table.getResource(base::R::integer::number1, &val, MAY_NOT_BE_BAG);
     ASSERT_GE(block, 0);
     ASSERT_EQ(Res_value::TYPE_INT_DEC, val.dataType);
     ASSERT_EQ(uint32_t(400), val.data);