M2T3a: Adding ResComplexEntryBuilder for easier complex entry creation

Summary: Created a class called `ResComplexEntryBuilder` to easily create complex entries. These methods can be used to easily redefine styles and will eventually be used to edit styles in `.apk` Android apps.

Reviewed By: wsanville

Differential Revision: D77178719

fbshipit-source-id: 217be712c701a7528a49400832304016c12ec124

Author: aayushkapoor-meta

libresource/Serialize.cpp

@@ -149,10 +149,9 @@ void push_header_with_updated_size(android::ResChunk_header* header,
   auto start_pos = out->size();
   push_header(header, out);
   auto bytes_written = out->size() - start_pos;
-  LOG_ALWAYS_FATAL_IF(
-      bytes_written < sizeof(android::ResChunk_header),
-      "Expected at least %zu header bytes. Actual %zu.",
-      sizeof(android::ResChunk_header), bytes_written);
+  LOG_ALWAYS_FATAL_IF(bytes_written < sizeof(android::ResChunk_header),
+                      "Expected at least %zu header bytes. Actual %zu.",
+                      sizeof(android::ResChunk_header), bytes_written);
   write_long_at_pos(start_pos + 2 * sizeof(uint16_t), new_size, out);
 }
 
@@ -666,6 +665,24 @@ void ResTableTypeDefiner::serialize(android::Vector<char>* out) {
   write_short_at_pos(type_count_pos, type_count, out);
 }
 
+void ResComplexEntryBuilder::serialize(android::Vector<char>* out) {
+  android::ResTable_map_entry entry;
+  entry.size = sizeof(android::ResTable_map_entry);
+  entry.flags = android::ResTable_entry::FLAG_COMPLEX;
+  entry.key.index = m_key_string_index;
+  entry.parent.ident = m_parent_id;
+  entry.count = m_attributes.size();
+
+  push_struct(entry, out);
+
+  for (const auto& attr : m_attributes) {
+    android::ResTable_map map;
+    map.name.ident = attr.first;
+    map.value = attr.second;
+    push_struct(map, out);
+  }
+}
+
 void ResStringPoolBuilder::add_string(const char* s, size_t len) {
   StringHolder holder(s, len);
   m_strings.emplace_back(std::move(holder));

libresource/utils/Serialize.h

@@ -373,6 +373,38 @@ class ResTableTypeDefiner : public ResTableTypeBuilder {
   const std::vector<uint32_t> m_flags;
 };
 
+/**
+ * Builder for creating a complex entry (ResTable_map_entry) which is used to
+ * represent styles in the resource table.
+ */
+class ResComplexEntryBuilder {
+ public:
+  ResComplexEntryBuilder() : m_key_string_index(0), m_parent_id(0) {}
+
+  void set_key_string_index(uint32_t index) { m_key_string_index = index; }
+  void set_parent_id(uint32_t id) { m_parent_id = id; }
+  void add(uint32_t attr_id, const android::Res_value& value) {
+    m_attributes.emplace_back(attr_id, value);
+  }
+  void add(const android::ResTable_map* map) {
+    m_attributes.emplace_back(map->name.ident, map->value);
+  }
+  void add(uint32_t attr_id, uint8_t data_type, uint32_t data) {
+    android::Res_value value;
+    value.size = sizeof(android::Res_value);
+    value.dataType = data_type;
+    value.data = data;
+    m_attributes.emplace_back(attr_id, value);
+  }
+
+  void serialize(android::Vector<char>* out);
+
+ private:
+  uint32_t m_key_string_index;
+  uint32_t m_parent_id;
+  std::vector<std::pair<uint32_t, android::Res_value>> m_attributes;
+};
+
 // Struct for defining an existing type and the collection of entries in all
 // configs.
 struct TypeInfo {

test/unit/ResourceSerializationTest.cpp

@@ -925,15 +925,27 @@ void build_arsc_file_and_validate(
       foo_package.id, 2, style_configs, style_flags);
   package_builder->add_type(style_type_definer);
 
-  style.item0.name.ident = 0x01010098; // android:textColor
-  style.item0.value.dataType = android::Res_value::TYPE_INT_COLOR_RGB8;
-  style.item0.value.data = 0xFF0000FF;
+  arsc::ResComplexEntryBuilder complex_entry_builder;
+  complex_entry_builder.set_key_string_index(3);
+  complex_entry_builder.set_parent_id(0);
+
+  std::vector<std::tuple<uint8_t, uint32_t, uint32_t>> attributes = {
+      {android::Res_value::TYPE_INT_COLOR_RGB8, 0xFF0000FF, 0x01010098},
+      {android::Res_value::TYPE_INT_COLOR_RGB8, 0xFF00FF00, 0x010100d4}};
+
+  for (const auto& [data_type, data_value, attr_id] : attributes) {
+    android::Res_value value;
+    value.size = sizeof(android::Res_value);
+    value.dataType = data_type;
+    value.data = data_value;
+    complex_entry_builder.add(attr_id, value);
+  }
 
-  style.item1.name.ident = 0x010100d4; // android:background
-  style.item1.value.dataType = android::Res_value::TYPE_INT_COLOR_RGB8;
-  style.item1.value.data = 0xFF00FF00;
+  android::Vector<char> complex_entry_data;
+  complex_entry_builder.serialize(&complex_entry_data);
 
-  style_type_definer->add(&xxhdpi_config, &style);
+  style_type_definer->add(&xxhdpi_config, {(uint8_t*)complex_entry_data.array(),
+                                           complex_entry_data.size()});
 
   // Write to a file, give the callback the temp dir and file to validate
   // against.
@@ -1005,7 +1017,7 @@ std::vector<arsc::TypeInfo> load_types(const RedexMappedFile& arsc_file) {
     EXPECT_EQ((expected).value.data, __actual_value.data);          \
   })
 // Assert values in the table match the two items expecrted in the
-// "MapEntryAndValues"
+// "MapEntryAndTwoValues"
 #define ASSERT_MAP_ENTRY_VALUES(table, config_str, entry_str, expected) \
   ({                                                                    \
     uint32_t __id = (table).get_identifier(entry_str);                  \
@@ -1081,9 +1093,21 @@ TEST(ResTable, ComputeSizes) {
   EntryAndValue simple(0, android::Res_value::TYPE_DIMENSION, 1000);
   EXPECT_EQ(arsc::compute_entry_value_length(&simple.entry),
             sizeof(EntryAndValue));
-  MapEntryAndValues complex(1, 0);
-  EXPECT_EQ(arsc::compute_entry_value_length(&complex.entry),
-            sizeof(MapEntryAndValues));
+
+  arsc::ResComplexEntryBuilder complex_builder;
+  complex_builder.set_key_string_index(1);
+  complex_builder.add(0x01010098, android::Res_value::TYPE_INT_COLOR_RGB8,
+                      0xff0000ff);
+
+  android::Vector<char> complex_entry_data;
+  complex_builder.serialize(&complex_entry_data);
+
+  android::ResTable_entry* complex_entry_ptr =
+      (android::ResTable_entry*)complex_entry_data.array();
+
+  size_t expected_size =
+      sizeof(android::ResTable_map_entry) + sizeof(android::ResTable_map);
+  EXPECT_EQ(arsc::compute_entry_value_length(complex_entry_ptr), expected_size);
 }
 
 TEST(ResTable, DeleteAllEntriesInType) {

test/unit/arsc/TestStructures.cpp

@@ -8,6 +8,7 @@
 #include "TestStructures.h"
 
 #include "androidfw/ResourceTypes.h"
+#include "utils/Serialize.h"
 
 // Sample data for building arsc test cases
 EntryAndValue e0(0, android::Res_value::TYPE_DIMENSION, 1000);
@@ -17,7 +18,20 @@ EntryAndValue e2(2, android::Res_value::TYPE_REFERENCE, 0x7f010001);
 EntryAndValue id_0(0, android::Res_value::TYPE_INT_BOOLEAN, 0);
 EntryAndValue id_1(1, android::Res_value::TYPE_INT_BOOLEAN, 0);
 EntryAndValue id_2(2, android::Res_value::TYPE_INT_BOOLEAN, 0);
-MapEntryAndValues style(3, 0);
+
+MapEntryAndTwoValues create_style() {
+  arsc::ResComplexEntryBuilder complex_builder;
+  complex_builder.set_key_string_index(3);
+
+  complex_builder.add(0x01010098, android::Res_value::TYPE_INT_COLOR_RGB8,
+                      0xFF0000FF); // android:textColor
+  complex_builder.add(0x010100d4, android::Res_value::TYPE_INT_COLOR_RGB8,
+                      0xFF00FF00); // android:background
+
+  return MapEntryAndTwoValues(complex_builder);
+}
+
+MapEntryAndTwoValues style = create_style();
 
 // The package that many unit tests will be in.
 android::ResTable_package foo_package{.id = 0x7f,

test/unit/arsc/TestStructures.h

@@ -9,6 +9,7 @@
 
 #include "Util.h"
 #include "androidfw/ResourceTypes.h"
+#include "utils/Serialize.h"
 
 // Data that is used to write many test cases against. Meant to be included from
 // individual test cpp files that want to code against it.
@@ -26,18 +27,51 @@ PACKED(struct EntryAndValue {
 });
 
 // For testing simplicity, a map that has two items in it.
-struct MapEntryAndValues {
+struct MapEntryAndTwoValues {
   android::ResTable_map_entry entry{};
   android::ResTable_map item0{};
   android::ResTable_map item1{};
-  MapEntryAndValues(uint32_t key_string_idx, uint32_t parent_ident) {
-    entry.size = sizeof(android::ResTable_map_entry);
-    entry.count = 2;
-    entry.flags = android::ResTable_entry::FLAG_COMPLEX;
-    entry.key.index = key_string_idx;
-    entry.parent.ident = parent_ident;
-    item0.value.size = sizeof(android::Res_value);
-    item1.value.size = sizeof(android::Res_value);
+
+  template <typename T>
+  static bool extract_at(const android::Vector<char>& data,
+                         size_t index,
+                         T* result) {
+    static_assert(std::is_trivially_copyable_v<T>,
+                  "Not trivially copyable, can't safely memcpy");
+    const size_t size = sizeof(T);
+    const size_t offset = index * size;
+
+    if (offset + size <= data.size()) {
+      memcpy(result, data.array() + offset, size);
+      return true;
+    }
+    return false;
+  }
+
+  explicit MapEntryAndTwoValues(arsc::ResComplexEntryBuilder builder) {
+    android::Vector<char> complex_entry_data;
+    builder.serialize(&complex_entry_data);
+
+    const size_t entry_size = sizeof(android::ResTable_map_entry);
+    const size_t map_size = sizeof(android::ResTable_map);
+
+    if (entry_size <= complex_entry_data.size()) {
+      memcpy(&entry,
+             complex_entry_data.array(),
+             sizeof(android::ResTable_map_entry));
+
+      auto count = entry.count;
+      if (count > 0 && entry_size + map_size <= complex_entry_data.size()) {
+        memcpy(&item0, complex_entry_data.array() + entry_size, map_size);
+
+        if (count > 1 &&
+            entry_size + 2 * map_size <= complex_entry_data.size()) {
+          memcpy(&item1,
+                 complex_entry_data.array() + entry_size + map_size,
+                 map_size);
+        }
+      }
+    }
   }
 };
 
@@ -49,7 +83,7 @@ extern EntryAndValue e2;
 extern EntryAndValue id_0;
 extern EntryAndValue id_1;
 extern EntryAndValue id_2;
-extern MapEntryAndValues style;
+extern MapEntryAndTwoValues style;
 
 // A package called "foo"
 extern android::ResTable_package foo_package;