Revert^2 "libandroidfw hardening for IncFs"

55ef6167a2c235bd88c7216238b2001b46795b79

Change-Id: I02d4890d181655dfd0a14c188468db512559d27b
Merged-In: I02d4890d181655dfd0a14c188468db512559d27b

12 files changed, 473 insertions, 595 deletions

diff --git a/libs/androidfw/tests/AssetManager2_bench.cpp b/libs/androidfw/tests/AssetManager2_bench.cpp
index 437e14772964..c7ae618991b9 100644
--- a/libs/androidfw/tests/AssetManager2_bench.cpp
+++ b/libs/androidfw/tests/AssetManager2_bench.cpp
@@ -139,9 +139,13 @@ static void BM_AssetManagerGetBag(benchmark::State& state) {
   assets.SetApkAssets({apk.get()});
 
   while (state.KeepRunning()) {
-    const ResolvedBag* bag = assets.GetBag(app::R::style::StyleTwo);
-    const auto bag_end = end(bag);
-    for (auto iter = begin(bag); iter != bag_end; ++iter) {
+    auto bag = assets.GetBag(app::R::style::StyleTwo);
+    if (!bag.has_value()) {
+      state.SkipWithError("Failed to load get bag");
+      return;
+    }
+    const auto bag_end = end(*bag);
+    for (auto iter = begin(*bag); iter != bag_end; ++iter) {
       uint32_t key = iter->key;
       Res_value value = iter->value;
       benchmark::DoNotOptimize(key);
diff --git a/libs/androidfw/tests/AssetManager2_test.cpp b/libs/androidfw/tests/AssetManager2_test.cpp
index 8c255d16fe1f..3638ce1f92d7 100644
--- a/libs/androidfw/tests/AssetManager2_test.cpp
+++ b/libs/androidfw/tests/AssetManager2_test.cpp
@@ -108,24 +108,18 @@ TEST_F(AssetManager2Test, FindsResourceFromSingleApkAssets) {
   assetmanager.SetConfiguration(desired_config);
   assetmanager.SetApkAssets({basic_assets_.get()});
 
-  Res_value value;
-  ResTable_config selected_config;
-  uint32_t flags;
-
-  ApkAssetsCookie cookie =
-      assetmanager.GetResource(basic::R::string::test1, false /*may_be_bag*/,
-                               0 /*density_override*/, &value, &selected_config, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
+  auto value = assetmanager.GetResource(basic::R::string::test1);
+  ASSERT_TRUE(value.has_value());
 
   // Came from our ApkAssets.
-  EXPECT_EQ(0, cookie);
+  EXPECT_EQ(0, value->cookie);
 
   // It is the default config.
-  EXPECT_EQ(0, selected_config.language[0]);
-  EXPECT_EQ(0, selected_config.language[1]);
+  EXPECT_EQ(0, value->config.language[0]);
+  EXPECT_EQ(0, value->config.language[1]);
 
   // It is a string.
-  EXPECT_EQ(Res_value::TYPE_STRING, value.dataType);
+  EXPECT_EQ(Res_value::TYPE_STRING, value->type);
 }
 
 TEST_F(AssetManager2Test, FindsResourceFromMultipleApkAssets) {
@@ -138,24 +132,18 @@ TEST_F(AssetManager2Test, FindsResourceFromMultipleApkAssets) {
   assetmanager.SetConfiguration(desired_config);
   assetmanager.SetApkAssets({basic_assets_.get(), basic_de_fr_assets_.get()});
 
-  Res_value value;
-  ResTable_config selected_config;
-  uint32_t flags;
-
-  ApkAssetsCookie cookie =
-      assetmanager.GetResource(basic::R::string::test1, false /*may_be_bag*/,
-                               0 /*density_override*/, &value, &selected_config, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
+  auto value = assetmanager.GetResource(basic::R::string::test1);
+  ASSERT_TRUE(value.has_value());
 
   // Came from our de_fr ApkAssets.
-  EXPECT_EQ(1, cookie);
+  EXPECT_EQ(1, value->cookie);
 
   // The configuration is German.
-  EXPECT_EQ('d', selected_config.language[0]);
-  EXPECT_EQ('e', selected_config.language[1]);
+  EXPECT_EQ('d', value->config.language[0]);
+  EXPECT_EQ('e', value->config.language[1]);
 
   // It is a string.
-  EXPECT_EQ(Res_value::TYPE_STRING, value.dataType);
+  EXPECT_EQ(Res_value::TYPE_STRING, value->type);
 }
 
 TEST_F(AssetManager2Test, FindsResourceFromSharedLibrary) {
@@ -166,44 +154,35 @@ TEST_F(AssetManager2Test, FindsResourceFromSharedLibrary) {
   assetmanager.SetApkAssets(
       {lib_two_assets_.get(), lib_one_assets_.get(), libclient_assets_.get()});
 
-  Res_value value;
-  ResTable_config selected_config;
-  uint32_t flags;
-
-  ApkAssetsCookie cookie =
-      assetmanager.GetResource(libclient::R::string::foo_one, false /*may_be_bag*/,
-                               0 /*density_override*/, &value, &selected_config, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
+  auto value = assetmanager.GetResource(libclient::R::string::foo_one);
+  ASSERT_TRUE(value.has_value());
 
   // Reference comes from libclient.
-  EXPECT_EQ(2, cookie);
-  EXPECT_EQ(Res_value::TYPE_REFERENCE, value.dataType);
+  EXPECT_EQ(2, value->cookie);
+  EXPECT_EQ(Res_value::TYPE_REFERENCE, value->type);
 
   // Lookup the reference.
-  cookie = assetmanager.GetResource(value.data, false /* may_be_bag */, 0 /* density_override*/,
-                                    &value, &selected_config, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
-  EXPECT_EQ(1, cookie);
-  EXPECT_EQ(Res_value::TYPE_STRING, value.dataType);
+  value = assetmanager.GetResource(value->data);
+  ASSERT_TRUE(value.has_value());
+  EXPECT_EQ(1, value->cookie);
+  EXPECT_EQ(Res_value::TYPE_STRING, value->type);
   EXPECT_EQ(std::string("Foo from lib_one"),
-            GetStringFromPool(assetmanager.GetStringPoolForCookie(cookie), value.data));
+            GetStringFromPool(assetmanager.GetStringPoolForCookie(value->cookie), value->data));
 
-  cookie = assetmanager.GetResource(libclient::R::string::foo_two, false /*may_be_bag*/,
-                                    0 /*density_override*/, &value, &selected_config, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
+  value = assetmanager.GetResource(libclient::R::string::foo_two);
+  ASSERT_TRUE(value.has_value());
 
   // Reference comes from libclient.
-  EXPECT_EQ(2, cookie);
-  EXPECT_EQ(Res_value::TYPE_REFERENCE, value.dataType);
+  EXPECT_EQ(2, value->cookie);
+  EXPECT_EQ(Res_value::TYPE_REFERENCE, value->type);
 
   // Lookup the reference.
-  cookie = assetmanager.GetResource(value.data, false /* may_be_bag */, 0 /* density_override*/,
-                                    &value, &selected_config, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
-  EXPECT_EQ(0, cookie);
-  EXPECT_EQ(Res_value::TYPE_STRING, value.dataType);
+  value = assetmanager.GetResource(value->data);
+  ASSERT_TRUE(value.has_value());
+  EXPECT_EQ(0, value->cookie);
+  EXPECT_EQ(Res_value::TYPE_STRING, value->type);
   EXPECT_EQ(std::string("Foo from lib_two"),
-            GetStringFromPool(assetmanager.GetStringPoolForCookie(cookie), value.data));
+            GetStringFromPool(assetmanager.GetStringPoolForCookie(value->cookie), value->data));
 }
 
 TEST_F(AssetManager2Test, FindsResourceFromAppLoadedAsSharedLibrary) {
@@ -211,16 +190,10 @@ TEST_F(AssetManager2Test, FindsResourceFromAppLoadedAsSharedLibrary) {
   assetmanager.SetApkAssets({appaslib_assets_.get()});
 
   // The appaslib package will have been assigned the package ID 0x02.
-
-  Res_value value;
-  ResTable_config selected_config;
-  uint32_t flags;
-  ApkAssetsCookie cookie = assetmanager.GetResource(
-      fix_package_id(appaslib::R::integer::number1, 0x02), false /*may_be_bag*/,
-      0u /*density_override*/, &value, &selected_config, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
-  EXPECT_EQ(Res_value::TYPE_REFERENCE, value.dataType);
-  EXPECT_EQ(fix_package_id(appaslib::R::array::integerArray1, 0x02), value.data);
+  auto value = assetmanager.GetResource(fix_package_id(appaslib::R::integer::number1, 0x02));
+  ASSERT_TRUE(value.has_value());
+  EXPECT_EQ(Res_value::TYPE_REFERENCE, value->type);
+  EXPECT_EQ(fix_package_id(appaslib::R::array::integerArray1, 0x02), value->data);
 }
 
 TEST_F(AssetManager2Test, AssignsOverlayPackageIdLast) {
@@ -238,40 +211,40 @@ TEST_F(AssetManager2Test, AssignsOverlayPackageIdLast) {
     return assetmanager.GetAssignedPackageId(apkAssets->GetLoadedArsc()->GetPackages()[0].get());
   };
 
-  ASSERT_EQ(get_first_package_id(overlayable_assets_.get()), 0x7f);
-  ASSERT_EQ(get_first_package_id(overlay_assets_.get()), 0x03);
-  ASSERT_EQ(get_first_package_id(lib_one_assets_.get()), 0x02);
+  ASSERT_EQ(0x7f, get_first_package_id(overlayable_assets_.get()));
+  ASSERT_EQ(0x03, get_first_package_id(overlay_assets_.get()));
+  ASSERT_EQ(0x02, get_first_package_id(lib_one_assets_.get()));
 }
 
 TEST_F(AssetManager2Test, GetSharedLibraryResourceName) {
   AssetManager2 assetmanager;
   assetmanager.SetApkAssets({lib_one_assets_.get()});
 
-  AssetManager2::ResourceName name;
-  ASSERT_TRUE(assetmanager.GetResourceName(lib_one::R::string::foo, &name));
-  std::string formatted_name = ToFormattedResourceString(&name);
-  ASSERT_EQ(formatted_name, "com.android.lib_one:string/foo");
+  auto name = assetmanager.GetResourceName(lib_one::R::string::foo);
+  ASSERT_TRUE(name.has_value());
+  ASSERT_EQ("com.android.lib_one:string/foo", ToFormattedResourceString(*name));
 }
 
 TEST_F(AssetManager2Test, FindsBagResourceFromSingleApkAssets) {
   AssetManager2 assetmanager;
   assetmanager.SetApkAssets({basic_assets_.get()});
 
-  const ResolvedBag* bag = assetmanager.GetBag(basic::R::array::integerArray1);
-  ASSERT_NE(nullptr, bag);
-  ASSERT_EQ(3u, bag->entry_count);
+  auto bag = assetmanager.GetBag(basic::R::array::integerArray1);
+  ASSERT_TRUE(bag.has_value());
+
+  ASSERT_EQ(3u, (*bag)->entry_count);
 
-  EXPECT_EQ(static_cast<uint8_t>(Res_value::TYPE_INT_DEC), bag->entries[0].value.dataType);
-  EXPECT_EQ(1u, bag->entries[0].value.data);
-  EXPECT_EQ(0, bag->entries[0].cookie);
+  EXPECT_EQ(static_cast<uint8_t>(Res_value::TYPE_INT_DEC), (*bag)->entries[0].value.dataType);
+  EXPECT_EQ(1u, (*bag)->entries[0].value.data);
+  EXPECT_EQ(0, (*bag)->entries[0].cookie);
 
-  EXPECT_EQ(static_cast<uint8_t>(Res_value::TYPE_INT_DEC), bag->entries[1].value.dataType);
-  EXPECT_EQ(2u, bag->entries[1].value.data);
-  EXPECT_EQ(0, bag->entries[1].cookie);
+  EXPECT_EQ(static_cast<uint8_t>(Res_value::TYPE_INT_DEC), (*bag)->entries[1].value.dataType);
+  EXPECT_EQ(2u, (*bag)->entries[1].value.data);
+  EXPECT_EQ(0, (*bag)->entries[1].cookie);
 
-  EXPECT_EQ(static_cast<uint8_t>(Res_value::TYPE_INT_DEC), bag->entries[2].value.dataType);
-  EXPECT_EQ(3u, bag->entries[2].value.data);
-  EXPECT_EQ(0, bag->entries[2].cookie);
+  EXPECT_EQ(static_cast<uint8_t>(Res_value::TYPE_INT_DEC), (*bag)->entries[2].value.dataType);
+  EXPECT_EQ(3u, (*bag)->entries[2].value.data);
+  EXPECT_EQ(0, (*bag)->entries[2].cookie);
 }
 
 TEST_F(AssetManager2Test, FindsBagResourceFromMultipleApkAssets) {}
@@ -284,15 +257,16 @@ TEST_F(AssetManager2Test, FindsBagResourceFromSharedLibrary) {
   assetmanager.SetApkAssets(
       {lib_two_assets_.get(), lib_one_assets_.get(), libclient_assets_.get()});
 
-  const ResolvedBag* bag = assetmanager.GetBag(fix_package_id(lib_one::R::style::Theme, 0x03));
-  ASSERT_NE(nullptr, bag);
-  ASSERT_GE(bag->entry_count, 2u);
+  auto bag = assetmanager.GetBag(fix_package_id(lib_one::R::style::Theme, 0x03));
+  ASSERT_TRUE(bag.has_value());
+
+  ASSERT_GE((*bag)->entry_count, 2u);
 
   // First two attributes come from lib_one.
-  EXPECT_EQ(1, bag->entries[0].cookie);
-  EXPECT_EQ(0x03, get_package_id(bag->entries[0].key));
-  EXPECT_EQ(1, bag->entries[1].cookie);
-  EXPECT_EQ(0x03, get_package_id(bag->entries[1].key));
+  EXPECT_EQ(1, (*bag)->entries[0].cookie);
+  EXPECT_EQ(0x03, get_package_id((*bag)->entries[0].key));
+  EXPECT_EQ(1, (*bag)->entries[1].cookie);
+  EXPECT_EQ(0x03, get_package_id((*bag)->entries[1].key));
 }
 
 TEST_F(AssetManager2Test, FindsBagResourceFromMultipleSharedLibraries) {
@@ -303,17 +277,17 @@ TEST_F(AssetManager2Test, FindsBagResourceFromMultipleSharedLibraries) {
   assetmanager.SetApkAssets(
       {lib_two_assets_.get(), lib_one_assets_.get(), libclient_assets_.get()});
 
-  const ResolvedBag* bag = assetmanager.GetBag(libclient::R::style::ThemeMultiLib);
-  ASSERT_NE(nullptr, bag);
-  ASSERT_EQ(bag->entry_count, 2u);
+  auto bag = assetmanager.GetBag(libclient::R::style::ThemeMultiLib);
+  ASSERT_TRUE(bag.has_value());
+  ASSERT_EQ((*bag)->entry_count, 2u);
 
   // First attribute comes from lib_two.
-  EXPECT_EQ(2, bag->entries[0].cookie);
-  EXPECT_EQ(0x02, get_package_id(bag->entries[0].key));
+  EXPECT_EQ(2, (*bag)->entries[0].cookie);
+  EXPECT_EQ(0x02, get_package_id((*bag)->entries[0].key));
 
   // The next two attributes come from lib_one.
-  EXPECT_EQ(2, bag->entries[1].cookie);
-  EXPECT_EQ(0x03, get_package_id(bag->entries[1].key));
+  EXPECT_EQ(2, (*bag)->entries[1].cookie);
+  EXPECT_EQ(0x03, get_package_id((*bag)->entries[1].key));
 }
 
 TEST_F(AssetManager2Test, FindsStyleResourceWithParentFromSharedLibrary) {
@@ -324,79 +298,79 @@ TEST_F(AssetManager2Test, FindsStyleResourceWithParentFromSharedLibrary) {
   assetmanager.SetApkAssets(
       {lib_two_assets_.get(), lib_one_assets_.get(), libclient_assets_.get()});
 
-  const ResolvedBag* bag = assetmanager.GetBag(libclient::R::style::Theme);
-  ASSERT_NE(nullptr, bag);
-  ASSERT_GE(bag->entry_count, 2u);
+  auto bag = assetmanager.GetBag(libclient::R::style::Theme);
+  ASSERT_TRUE(bag.has_value());
+  ASSERT_GE((*bag)->entry_count, 2u);
 
   // First two attributes come from lib_one.
-  EXPECT_EQ(1, bag->entries[0].cookie);
-  EXPECT_EQ(0x03, get_package_id(bag->entries[0].key));
-  EXPECT_EQ(1, bag->entries[1].cookie);
-  EXPECT_EQ(0x03, get_package_id(bag->entries[1].key));
+  EXPECT_EQ(1, (*bag)->entries[0].cookie);
+  EXPECT_EQ(0x03, get_package_id((*bag)->entries[0].key));
+  EXPECT_EQ(1, (*bag)->entries[1].cookie);
+  EXPECT_EQ(0x03, get_package_id((*bag)->entries[1].key));
 }
 
 TEST_F(AssetManager2Test, MergesStylesWithParentFromSingleApkAssets) {
   AssetManager2 assetmanager;
   assetmanager.SetApkAssets({style_assets_.get()});
 
-  const ResolvedBag* bag_one = assetmanager.GetBag(app::R::style::StyleOne);
-  ASSERT_NE(nullptr, bag_one);
-  ASSERT_EQ(2u, bag_one->entry_count);
+  auto bag_one = assetmanager.GetBag(app::R::style::StyleOne);
+  ASSERT_TRUE(bag_one.has_value());
+  ASSERT_EQ(2u, (*bag_one)->entry_count);
 
-  EXPECT_EQ(app::R::attr::attr_one, bag_one->entries[0].key);
-  EXPECT_EQ(Res_value::TYPE_INT_DEC, bag_one->entries[0].value.dataType);
-  EXPECT_EQ(1u, bag_one->entries[0].value.data);
-  EXPECT_EQ(0, bag_one->entries[0].cookie);
+  EXPECT_EQ(app::R::attr::attr_one, (*bag_one)->entries[0].key);
+  EXPECT_EQ(Res_value::TYPE_INT_DEC, (*bag_one)->entries[0].value.dataType);
+  EXPECT_EQ(1u, (*bag_one)->entries[0].value.data);
+  EXPECT_EQ(0, (*bag_one)->entries[0].cookie);
 
-  EXPECT_EQ(app::R::attr::attr_two, bag_one->entries[1].key);
-  EXPECT_EQ(Res_value::TYPE_INT_DEC, bag_one->entries[1].value.dataType);
-  EXPECT_EQ(2u, bag_one->entries[1].value.data);
-  EXPECT_EQ(0, bag_one->entries[1].cookie);
+  EXPECT_EQ(app::R::attr::attr_two, (*bag_one)->entries[1].key);
+  EXPECT_EQ(Res_value::TYPE_INT_DEC, (*bag_one)->entries[1].value.dataType);
+  EXPECT_EQ(2u, (*bag_one)->entries[1].value.data);
+  EXPECT_EQ(0, (*bag_one)->entries[1].cookie);
 
-  const ResolvedBag* bag_two = assetmanager.GetBag(app::R::style::StyleTwo);
-  ASSERT_NE(nullptr, bag_two);
-  ASSERT_EQ(6u, bag_two->entry_count);
+  auto bag_two = assetmanager.GetBag(app::R::style::StyleTwo);
+  ASSERT_TRUE(bag_two.has_value());
+  ASSERT_EQ(6u, (*bag_two)->entry_count);
 
   // attr_one is inherited from StyleOne.
-  EXPECT_EQ(app::R::attr::attr_one, bag_two->entries[0].key);
-  EXPECT_EQ(Res_value::TYPE_INT_DEC, bag_two->entries[0].value.dataType);
-  EXPECT_EQ(1u, bag_two->entries[0].value.data);
-  EXPECT_EQ(0, bag_two->entries[0].cookie);
-  EXPECT_EQ(app::R::style::StyleOne, bag_two->entries[0].style);
+  EXPECT_EQ(app::R::attr::attr_one, (*bag_two)->entries[0].key);
+  EXPECT_EQ(Res_value::TYPE_INT_DEC, (*bag_two)->entries[0].value.dataType);
+  EXPECT_EQ(1u, (*bag_two)->entries[0].value.data);
+  EXPECT_EQ(0, (*bag_two)->entries[0].cookie);
+  EXPECT_EQ(app::R::style::StyleOne, (*bag_two)->entries[0].style);
 
   // attr_two should be overridden from StyleOne by StyleTwo.
-  EXPECT_EQ(app::R::attr::attr_two, bag_two->entries[1].key);
-  EXPECT_EQ(Res_value::TYPE_STRING, bag_two->entries[1].value.dataType);
-  EXPECT_EQ(0, bag_two->entries[1].cookie);
-  EXPECT_EQ(app::R::style::StyleTwo, bag_two->entries[1].style);
+  EXPECT_EQ(app::R::attr::attr_two, (*bag_two)->entries[1].key);
+  EXPECT_EQ(Res_value::TYPE_STRING, (*bag_two)->entries[1].value.dataType);
+  EXPECT_EQ(0, (*bag_two)->entries[1].cookie);
+  EXPECT_EQ(app::R::style::StyleTwo, (*bag_two)->entries[1].style);
   EXPECT_EQ(std::string("string"), GetStringFromPool(assetmanager.GetStringPoolForCookie(0),
-                                                     bag_two->entries[1].value.data));
+                                                     (*bag_two)->entries[1].value.data));
 
   // The rest are new attributes.
 
-  EXPECT_EQ(app::R::attr::attr_three, bag_two->entries[2].key);
-  EXPECT_EQ(Res_value::TYPE_ATTRIBUTE, bag_two->entries[2].value.dataType);
-  EXPECT_EQ(app::R::attr::attr_indirect, bag_two->entries[2].value.data);
-  EXPECT_EQ(0, bag_two->entries[2].cookie);
-  EXPECT_EQ(app::R::style::StyleTwo, bag_two->entries[2].style);
-
-  EXPECT_EQ(app::R::attr::attr_five, bag_two->entries[3].key);
-  EXPECT_EQ(Res_value::TYPE_REFERENCE, bag_two->entries[3].value.dataType);
-  EXPECT_EQ(app::R::string::string_one, bag_two->entries[3].value.data);
-  EXPECT_EQ(0, bag_two->entries[3].cookie);
-  EXPECT_EQ(app::R::style::StyleTwo, bag_two->entries[3].style);
-
-  EXPECT_EQ(app::R::attr::attr_indirect, bag_two->entries[4].key);
-  EXPECT_EQ(Res_value::TYPE_INT_DEC, bag_two->entries[4].value.dataType);
-  EXPECT_EQ(3u, bag_two->entries[4].value.data);
-  EXPECT_EQ(0, bag_two->entries[4].cookie);
-  EXPECT_EQ(app::R::style::StyleTwo, bag_two->entries[4].style);
-
-  EXPECT_EQ(app::R::attr::attr_empty, bag_two->entries[5].key);
-  EXPECT_EQ(Res_value::TYPE_NULL, bag_two->entries[5].value.dataType);
-  EXPECT_EQ(Res_value::DATA_NULL_EMPTY, bag_two->entries[5].value.data);
-  EXPECT_EQ(0, bag_two->entries[5].cookie);
-  EXPECT_EQ(app::R::style::StyleTwo, bag_two->entries[5].style);
+  EXPECT_EQ(app::R::attr::attr_three, (*bag_two)->entries[2].key);
+  EXPECT_EQ(Res_value::TYPE_ATTRIBUTE, (*bag_two)->entries[2].value.dataType);
+  EXPECT_EQ(app::R::attr::attr_indirect, (*bag_two)->entries[2].value.data);
+  EXPECT_EQ(0, (*bag_two)->entries[2].cookie);
+  EXPECT_EQ(app::R::style::StyleTwo, (*bag_two)->entries[2].style);
+
+  EXPECT_EQ(app::R::attr::attr_five, (*bag_two)->entries[3].key);
+  EXPECT_EQ(Res_value::TYPE_REFERENCE, (*bag_two)->entries[3].value.dataType);
+  EXPECT_EQ(app::R::string::string_one, (*bag_two)->entries[3].value.data);
+  EXPECT_EQ(0, (*bag_two)->entries[3].cookie);
+  EXPECT_EQ(app::R::style::StyleTwo, (*bag_two)->entries[3].style);
+
+  EXPECT_EQ(app::R::attr::attr_indirect, (*bag_two)->entries[4].key);
+  EXPECT_EQ(Res_value::TYPE_INT_DEC, (*bag_two)->entries[4].value.dataType);
+  EXPECT_EQ(3u, (*bag_two)->entries[4].value.data);
+  EXPECT_EQ(0, (*bag_two)->entries[4].cookie);
+  EXPECT_EQ(app::R::style::StyleTwo, (*bag_two)->entries[4].style);
+
+  EXPECT_EQ(app::R::attr::attr_empty, (*bag_two)->entries[5].key);
+  EXPECT_EQ(Res_value::TYPE_NULL, (*bag_two)->entries[5].value.dataType);
+  EXPECT_EQ(Res_value::DATA_NULL_EMPTY, (*bag_two)->entries[5].value.data);
+  EXPECT_EQ(0, (*bag_two)->entries[5].cookie);
+  EXPECT_EQ(app::R::style::StyleTwo, (*bag_two)->entries[5].style);
 }
 
 TEST_F(AssetManager2Test, MergeStylesCircularDependency) {
@@ -405,55 +379,41 @@ TEST_F(AssetManager2Test, MergeStylesCircularDependency) {
 
   // GetBag should stop traversing the parents of styles when a circular
   // dependency is detected
-  const ResolvedBag* bag_one = assetmanager.GetBag(app::R::style::StyleFour);
-  ASSERT_NE(nullptr, bag_one);
-  ASSERT_EQ(3u, bag_one->entry_count);
+  auto bag = assetmanager.GetBag(app::R::style::StyleFour);
+  ASSERT_TRUE(bag.has_value());
+  ASSERT_EQ(3u, (*bag)->entry_count);
 }
 
 TEST_F(AssetManager2Test, ResolveReferenceToResource) {
   AssetManager2 assetmanager;
   assetmanager.SetApkAssets({basic_assets_.get()});
 
-  Res_value value;
-  ResTable_config selected_config;
-  uint32_t flags;
-  ApkAssetsCookie cookie =
-      assetmanager.GetResource(basic::R::integer::ref1, false /*may_be_bag*/,
-                               0u /*density_override*/, &value, &selected_config, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
-
-  EXPECT_EQ(Res_value::TYPE_REFERENCE, value.dataType);
-  EXPECT_EQ(basic::R::integer::ref2, value.data);
-
-  uint32_t last_ref = 0u;
-  cookie = assetmanager.ResolveReference(cookie, &value, &selected_config, &flags, &last_ref);
-  ASSERT_NE(kInvalidCookie, cookie);
-  EXPECT_EQ(Res_value::TYPE_INT_DEC, value.dataType);
-  EXPECT_EQ(12000u, value.data);
-  EXPECT_EQ(basic::R::integer::ref2, last_ref);
+  auto value = assetmanager.GetResource(basic::R::integer::ref1);
+  ASSERT_TRUE(value.has_value());
+  EXPECT_EQ(Res_value::TYPE_REFERENCE, value->type);
+  EXPECT_EQ(basic::R::integer::ref2, value->data);
+
+  auto result = assetmanager.ResolveReference(*value);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_EQ(Res_value::TYPE_INT_DEC, value->type);
+  EXPECT_EQ(12000u, value->data);
+  EXPECT_EQ(basic::R::integer::ref2, value->resid);
 }
 
 TEST_F(AssetManager2Test, ResolveReferenceToBag) {
   AssetManager2 assetmanager;
   assetmanager.SetApkAssets({basic_assets_.get()});
 
-  Res_value value;
-  ResTable_config selected_config;
-  uint32_t flags;
-  ApkAssetsCookie cookie =
-      assetmanager.GetResource(basic::R::integer::number2, true /*may_be_bag*/,
-                               0u /*density_override*/, &value, &selected_config, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
-
-  EXPECT_EQ(Res_value::TYPE_REFERENCE, value.dataType);
-  EXPECT_EQ(basic::R::array::integerArray1, value.data);
-
-  uint32_t last_ref = 0u;
-  cookie = assetmanager.ResolveReference(cookie, &value, &selected_config, &flags, &last_ref);
-  ASSERT_NE(kInvalidCookie, cookie);
-  EXPECT_EQ(Res_value::TYPE_REFERENCE, value.dataType);
-  EXPECT_EQ(basic::R::array::integerArray1, value.data);
-  EXPECT_EQ(basic::R::array::integerArray1, last_ref);
+  auto value = assetmanager.GetResource(basic::R::integer::number2, true /*may_be_bag*/);
+  ASSERT_TRUE(value.has_value());
+  EXPECT_EQ(Res_value::TYPE_REFERENCE, value->type);
+  EXPECT_EQ(basic::R::array::integerArray1, value->data);
+
+  auto result = assetmanager.ResolveReference(*value);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_EQ(Res_value::TYPE_REFERENCE, value->type);
+  EXPECT_EQ(basic::R::array::integerArray1, value->data);
+  EXPECT_EQ(basic::R::array::integerArray1, value->resid);
 }
 
 TEST_F(AssetManager2Test, ResolveDeepIdReference) {
@@ -461,31 +421,25 @@ TEST_F(AssetManager2Test, ResolveDeepIdReference) {
   assetmanager.SetApkAssets({basic_assets_.get()});
 
   // Set up the resource ids
-  const uint32_t high_ref = assetmanager
-      .GetResourceId("@id/high_ref", "values", "com.android.basic");
-  ASSERT_NE(high_ref, 0u);
-  const uint32_t middle_ref = assetmanager
-      .GetResourceId("@id/middle_ref", "values", "com.android.basic");
-  ASSERT_NE(middle_ref, 0u);
-  const uint32_t low_ref = assetmanager
-      .GetResourceId("@id/low_ref", "values", "com.android.basic");
-  ASSERT_NE(low_ref, 0u);
+  auto high_ref = assetmanager.GetResourceId("@id/high_ref", "values", "com.android.basic");
+  ASSERT_TRUE(high_ref.has_value());
+
+  auto middle_ref = assetmanager.GetResourceId("@id/middle_ref", "values", "com.android.basic");
+  ASSERT_TRUE(middle_ref.has_value());
+
+  auto low_ref = assetmanager.GetResourceId("@id/low_ref", "values", "com.android.basic");
+  ASSERT_TRUE(low_ref.has_value());
 
   // Retrieve the most shallow resource
-  Res_value value;
-  ResTable_config config;
-  uint32_t flags;
-  ApkAssetsCookie cookie = assetmanager.GetResource(high_ref, false /*may_be_bag*/,
-                                                    0 /*density_override*/,
-                                                    &value, &config, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
-  EXPECT_EQ(Res_value::TYPE_REFERENCE, value.dataType);
-  EXPECT_EQ(middle_ref, value.data);
+  auto value = assetmanager.GetResource(*high_ref);
+  ASSERT_TRUE(value.has_value());
+  EXPECT_EQ(Res_value::TYPE_REFERENCE, value->type);
+  EXPECT_EQ(*middle_ref, value->data);;
 
   // Check that resolving the reference resolves to the deepest id
-  uint32_t last_ref = high_ref;
-  assetmanager.ResolveReference(cookie, &value, &config, &flags, &last_ref);
-  EXPECT_EQ(last_ref, low_ref);
+  auto result = assetmanager.ResolveReference(*value);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_EQ(*low_ref, value->resid);
 }
 
 TEST_F(AssetManager2Test, KeepLastReferenceIdUnmodifiedIfNoReferenceIsResolved) {
@@ -495,16 +449,16 @@ TEST_F(AssetManager2Test, KeepLastReferenceIdUnmodifiedIfNoReferenceIsResolved)
   ResTable_config selected_config;
   memset(&selected_config, 0, sizeof(selected_config));
 
-  uint32_t flags = 0u;
+  // Create some kind of value that is NOT a reference.
+  AssetManager2::SelectedValue value{};
+  value.cookie = 1;
+  value.type = Res_value::TYPE_STRING;
+  value.resid = basic::R::string::test1;
 
-  // Create some kind of Res_value that is NOT a reference.
-  Res_value value;
-  value.dataType = Res_value::TYPE_STRING;
-  value.data = 0;
-
-  uint32_t last_ref = basic::R::string::test1;
-  EXPECT_EQ(1, assetmanager.ResolveReference(1, &value, &selected_config, &flags, &last_ref));
-  EXPECT_EQ(basic::R::string::test1, last_ref);
+  auto result = assetmanager.ResolveReference(value);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_EQ(1, value.cookie);
+  EXPECT_EQ(basic::R::string::test1, value.resid);
 }
 
 static bool IsConfigurationPresent(const std::set<ResTable_config>& configurations,
@@ -516,43 +470,45 @@ TEST_F(AssetManager2Test, GetResourceConfigurations) {
   AssetManager2 assetmanager;
   assetmanager.SetApkAssets({system_assets_.get(), basic_de_fr_assets_.get()});
 
-  std::set<ResTable_config> configurations = assetmanager.GetResourceConfigurations();
+  auto configurations = assetmanager.GetResourceConfigurations();
+  ASSERT_TRUE(configurations.has_value());
 
   // We expect the locale sv from the system assets, and de and fr from basic_de_fr assets.
   // And one extra for the default configuration.
-  EXPECT_EQ(4u, configurations.size());
+  EXPECT_EQ(4u, configurations->size());
 
   ResTable_config expected_config;
   memset(&expected_config, 0, sizeof(expected_config));
   expected_config.language[0] = 's';
   expected_config.language[1] = 'v';
-  EXPECT_TRUE(IsConfigurationPresent(configurations, expected_config));
+  EXPECT_TRUE(IsConfigurationPresent(*configurations, expected_config));
 
   expected_config.language[0] = 'd';
   expected_config.language[1] = 'e';
-  EXPECT_TRUE(IsConfigurationPresent(configurations, expected_config));
+  EXPECT_TRUE(IsConfigurationPresent(*configurations, expected_config));
 
   expected_config.language[0] = 'f';
   expected_config.language[1] = 'r';
-  EXPECT_TRUE(IsConfigurationPresent(configurations, expected_config));
+  EXPECT_TRUE(IsConfigurationPresent(*configurations, expected_config));
 
   // Take out the system assets.
   configurations = assetmanager.GetResourceConfigurations(true /* exclude_system */);
+  ASSERT_TRUE(configurations.has_value());
 
   // We expect de and fr from basic_de_fr assets.
-  EXPECT_EQ(2u, configurations.size());
+  EXPECT_EQ(2u, configurations->size());
 
   expected_config.language[0] = 's';
   expected_config.language[1] = 'v';
-  EXPECT_FALSE(IsConfigurationPresent(configurations, expected_config));
+  EXPECT_FALSE(IsConfigurationPresent(*configurations, expected_config));
 
   expected_config.language[0] = 'd';
   expected_config.language[1] = 'e';
-  EXPECT_TRUE(IsConfigurationPresent(configurations, expected_config));
+  EXPECT_TRUE(IsConfigurationPresent(*configurations, expected_config));
 
   expected_config.language[0] = 'f';
   expected_config.language[1] = 'r';
-  EXPECT_TRUE(IsConfigurationPresent(configurations, expected_config));
+  EXPECT_TRUE(IsConfigurationPresent(*configurations, expected_config));
 }
 
 TEST_F(AssetManager2Test, GetResourceLocales) {
@@ -578,12 +534,17 @@ TEST_F(AssetManager2Test, GetResourceId) {
   AssetManager2 assetmanager;
   assetmanager.SetApkAssets({basic_assets_.get()});
 
-  EXPECT_EQ(basic::R::layout::main,
-            assetmanager.GetResourceId("com.android.basic:layout/main", "", ""));
-  EXPECT_EQ(basic::R::layout::main,
-            assetmanager.GetResourceId("layout/main", "", "com.android.basic"));
-  EXPECT_EQ(basic::R::layout::main,
-            assetmanager.GetResourceId("main", "layout", "com.android.basic"));
+  auto resid = assetmanager.GetResourceId("com.android.basic:layout/main", "", "");
+  ASSERT_TRUE(resid.has_value());
+  EXPECT_EQ(basic::R::layout::main, *resid);
+
+  resid = assetmanager.GetResourceId("layout/main", "", "com.android.basic");
+  ASSERT_TRUE(resid.has_value());
+  EXPECT_EQ(basic::R::layout::main, *resid);
+
+  resid = assetmanager.GetResourceId("main", "layout", "com.android.basic");
+  ASSERT_TRUE(resid.has_value());
+  EXPECT_EQ(basic::R::layout::main, *resid);
 }
 
 TEST_F(AssetManager2Test, OpensFileFromSingleApkAssets) {
@@ -658,14 +619,8 @@ TEST_F(AssetManager2Test, GetLastPathWithoutEnablingReturnsEmpty) {
   assetmanager.SetApkAssets({basic_assets_.get()});
   assetmanager.SetResourceResolutionLoggingEnabled(false);
 
-  Res_value value;
-  ResTable_config selected_config;
-  uint32_t flags;
-
-  ApkAssetsCookie cookie =
-      assetmanager.GetResource(basic::R::string::test1, false /*may_be_bag*/,
-                               0 /*density_override*/, &value, &selected_config, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
+  auto value = assetmanager.GetResource(basic::R::string::test1);
+  ASSERT_TRUE(value.has_value());
 
   auto result = assetmanager.GetLastResourceResolution();
   EXPECT_EQ("", result);
@@ -693,17 +648,12 @@ TEST_F(AssetManager2Test, GetLastPathWithSingleApkAssets) {
   assetmanager.SetConfiguration(desired_config);
   assetmanager.SetApkAssets({basic_assets_.get()});
 
-  Res_value value;
-  ResTable_config selected_config;
-  uint32_t flags;
-
-  ApkAssetsCookie cookie =
-      assetmanager.GetResource(basic::R::string::test1, false /*may_be_bag*/,
-                               0 /*density_override*/, &value, &selected_config, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
+  auto value = assetmanager.GetResource(basic::R::string::test1);
+  ASSERT_TRUE(value.has_value());
 
   auto result = assetmanager.GetLastResourceResolution();
-  EXPECT_EQ("Resolution for 0x7f030000 com.android.basic:string/test1\n\tFor config -de\n\tFound initial: com.android.basic", result);
+  EXPECT_EQ("Resolution for 0x7f030000 com.android.basic:string/test1\n"
+            "\tFor config -de\n\tFound initial: com.android.basic", result);
 }
 
 TEST_F(AssetManager2Test, GetLastPathWithMultipleApkAssets) {
@@ -717,17 +667,14 @@ TEST_F(AssetManager2Test, GetLastPathWithMultipleApkAssets) {
   assetmanager.SetConfiguration(desired_config);
   assetmanager.SetApkAssets({basic_assets_.get(), basic_de_fr_assets_.get()});
 
-  Res_value value = Res_value();
-  ResTable_config selected_config;
-  uint32_t flags;
-
-  ApkAssetsCookie cookie =
-      assetmanager.GetResource(basic::R::string::test1, false /*may_be_bag*/,
-                               0 /*density_override*/, &value, &selected_config, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
+  auto value = assetmanager.GetResource(basic::R::string::test1);
+  ASSERT_TRUE(value.has_value());
 
   auto result = assetmanager.GetLastResourceResolution();
-  EXPECT_EQ("Resolution for 0x7f030000 com.android.basic:string/test1\n\tFor config -de\n\tFound initial: com.android.basic\n\tFound better: com.android.basic -de", result);
+  EXPECT_EQ("Resolution for 0x7f030000 com.android.basic:string/test1\n"
+            "\tFor config -de\n"
+            "\tFound initial: com.android.basic\n"
+            "\tFound better: com.android.basic -de", result);
 }
 
 TEST_F(AssetManager2Test, GetLastPathAfterDisablingReturnsEmpty) {
@@ -739,14 +686,8 @@ TEST_F(AssetManager2Test, GetLastPathAfterDisablingReturnsEmpty) {
   assetmanager.SetConfiguration(desired_config);
   assetmanager.SetApkAssets({basic_assets_.get()});
 
-  Res_value value = Res_value();
-  ResTable_config selected_config;
-  uint32_t flags;
-
-  ApkAssetsCookie cookie =
-      assetmanager.GetResource(basic::R::string::test1, false /*may_be_bag*/,
-                               0 /*density_override*/, &value, &selected_config, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
+  auto value = assetmanager.GetResource(basic::R::string::test1);
+  ASSERT_TRUE(value.has_value());
 
   auto resultEnabled = assetmanager.GetLastResourceResolution();
   ASSERT_NE("", resultEnabled);
diff --git a/libs/androidfw/tests/AttributeResolution_bench.cpp b/libs/androidfw/tests/AttributeResolution_bench.cpp
index fa300c50218a..ddd8ab820cb1 100644
--- a/libs/androidfw/tests/AttributeResolution_bench.cpp
+++ b/libs/androidfw/tests/AttributeResolution_bench.cpp
@@ -108,27 +108,20 @@ static void BM_ApplyStyleFramework(benchmark::State& state) {
   device_config.screenHeightDp = 1024;
   device_config.sdkVersion = 27;
 
-  Res_value value;
-  ResTable_config config;
-  uint32_t flags = 0u;
-  ApkAssetsCookie cookie =
-      assetmanager.GetResource(basic::R::layout::layoutt, false /*may_be_bag*/,
-                               0u /*density_override*/, &value, &config, &flags);
-  if (cookie == kInvalidCookie) {
+  auto value = assetmanager.GetResource(basic::R::layout::layoutt);
+  if (!value.has_value()) {
     state.SkipWithError("failed to find R.layout.layout");
     return;
   }
 
-  size_t len = 0u;
-  const char* layout_path =
-      assetmanager.GetStringPoolForCookie(cookie)->string8At(value.data, &len);
-  if (layout_path == nullptr || len == 0u) {
+  auto layout_path = assetmanager.GetStringPoolForCookie(value->cookie)->string8At(value->data);
+  if (!layout_path.has_value()) {
     state.SkipWithError("failed to lookup layout path");
     return;
   }
 
-  std::unique_ptr<Asset> asset = assetmanager.OpenNonAsset(
-      StringPiece(layout_path, len).to_string(), cookie, Asset::ACCESS_BUFFER);
+  std::unique_ptr<Asset> asset = assetmanager.OpenNonAsset(layout_path->to_string(), value->cookie,
+                                                           Asset::ACCESS_BUFFER);
   if (asset == nullptr) {
     state.SkipWithError("failed to load layout");
     return;
diff --git a/libs/androidfw/tests/AttributeResolution_test.cpp b/libs/androidfw/tests/AttributeResolution_test.cpp
index 24361b5817f4..bb9129ad01c8 100644
--- a/libs/androidfw/tests/AttributeResolution_test.cpp
+++ b/libs/androidfw/tests/AttributeResolution_test.cpp
@@ -77,9 +77,9 @@ TEST(AttributeResolutionLibraryTest, ApplyStyleWithDefaultStyleResId) {
       {fix_package_id(R::attr::attr_one, 0x02), fix_package_id(R::attr::attr_two, 0x02)}};
   std::array<uint32_t, attrs.size() * STYLE_NUM_ENTRIES> values;
   std::array<uint32_t, attrs.size() + 1> indices;
-  ApplyStyle(theme.get(), nullptr /*xml_parser*/, 0u /*def_style_attr*/,
-             fix_package_id(R::style::StyleOne, 0x02), attrs.data(), attrs.size(), values.data(),
-             indices.data());
+  ASSERT_TRUE(ApplyStyle(theme.get(), nullptr /*xml_parser*/, 0u /*def_style_attr*/,
+                         fix_package_id(R::style::StyleOne, 0x02), attrs.data(), attrs.size(),
+                         values.data(), indices.data()).has_value());
 
   const uint32_t public_flag = ResTable_typeSpec::SPEC_PUBLIC;
 
@@ -102,7 +102,7 @@ TEST(AttributeResolutionLibraryTest, ApplyStyleWithDefaultStyleResId) {
 
 TEST_F(AttributeResolutionTest, Theme) {
   std::unique_ptr<Theme> theme = assetmanager_.NewTheme();
-  ASSERT_TRUE(theme->ApplyStyle(R::style::StyleTwo));
+  ASSERT_TRUE(theme->ApplyStyle(R::style::StyleTwo).has_value());
 
   std::array<uint32_t, 5> attrs{{R::attr::attr_one, R::attr::attr_two, R::attr::attr_three,
                                  R::attr::attr_four, R::attr::attr_empty}};
@@ -110,7 +110,7 @@ TEST_F(AttributeResolutionTest, Theme) {
 
   ASSERT_TRUE(ResolveAttrs(theme.get(), 0u /*def_style_attr*/, 0u /*def_style_res*/,
                            nullptr /*src_values*/, 0 /*src_values_length*/, attrs.data(),
-                           attrs.size(), values.data(), nullptr /*out_indices*/));
+                           attrs.size(), values.data(), nullptr /*out_indices*/).has_value());
 
   const uint32_t public_flag = ResTable_typeSpec::SPEC_PUBLIC;
 
@@ -162,7 +162,7 @@ TEST_F(AttributeResolutionXmlTest, XmlParser) {
   std::array<uint32_t, attrs.size() * STYLE_NUM_ENTRIES> values;
 
   ASSERT_TRUE(RetrieveAttributes(&assetmanager_, &xml_parser_, attrs.data(), attrs.size(),
-                                 values.data(), nullptr /*out_indices*/));
+                                 values.data(), nullptr /*out_indices*/).has_value());
 
   uint32_t* values_cursor = values.data();
   EXPECT_EQ(Res_value::TYPE_NULL, values_cursor[STYLE_TYPE]);
@@ -207,15 +207,15 @@ TEST_F(AttributeResolutionXmlTest, XmlParser) {
 
 TEST_F(AttributeResolutionXmlTest, ThemeAndXmlParser) {
   std::unique_ptr<Theme> theme = assetmanager_.NewTheme();
-  ASSERT_TRUE(theme->ApplyStyle(R::style::StyleTwo));
+  ASSERT_TRUE(theme->ApplyStyle(R::style::StyleTwo).has_value());
 
   std::array<uint32_t, 6> attrs{{R::attr::attr_one, R::attr::attr_two, R::attr::attr_three,
                                  R::attr::attr_four, R::attr::attr_five, R::attr::attr_empty}};
   std::array<uint32_t, attrs.size() * STYLE_NUM_ENTRIES> values;
   std::array<uint32_t, attrs.size() + 1> indices;
 
-  ApplyStyle(theme.get(), &xml_parser_, 0u /*def_style_attr*/, 0u /*def_style_res*/, attrs.data(),
-             attrs.size(), values.data(), indices.data());
+  ASSERT_TRUE(ApplyStyle(theme.get(), &xml_parser_, 0u /*def_style_attr*/, 0u /*def_style_res*/,
+                         attrs.data(), attrs.size(), values.data(), indices.data()).has_value());
 
   const uint32_t public_flag = ResTable_typeSpec::SPEC_PUBLIC;
 
diff --git a/libs/androidfw/tests/BenchmarkHelpers.cpp b/libs/androidfw/tests/BenchmarkHelpers.cpp
index faddfe599af4..0fa0573bcbb8 100644
--- a/libs/androidfw/tests/BenchmarkHelpers.cpp
+++ b/libs/androidfw/tests/BenchmarkHelpers.cpp
@@ -71,15 +71,9 @@ void GetResourceBenchmark(const std::vector<std::string>& paths, const ResTable_
     assetmanager.SetConfiguration(*config);
   }
 
-  Res_value value;
-  ResTable_config selected_config;
-  uint32_t flags;
-  uint32_t last_id = 0u;
-
   while (state.KeepRunning()) {
-    ApkAssetsCookie cookie = assetmanager.GetResource(
-        resid, false /* may_be_bag */, 0u /* density_override */, &value, &selected_config, &flags);
-    assetmanager.ResolveReference(cookie, &value, &selected_config, &flags, &last_id);
+    auto value = assetmanager.GetResource(resid);
+    assetmanager.ResolveReference(*value);
   }
 }
 
diff --git a/libs/androidfw/tests/CommonHelpers.cpp b/libs/androidfw/tests/CommonHelpers.cpp
index faa5350f9ecc..3396729536a4 100644
--- a/libs/androidfw/tests/CommonHelpers.cpp
+++ b/libs/androidfw/tests/CommonHelpers.cpp
@@ -58,8 +58,9 @@ const std::string& GetTestDataPath() {
 }
 
 std::string GetStringFromPool(const ResStringPool* pool, uint32_t idx) {
-  String8 str = pool->string8ObjectAt(idx);
-  return std::string(str.string(), str.length());
+  auto str = pool->string8ObjectAt(idx);
+  CHECK(str.has_value()) << "failed to find string entry";
+  return std::string(str->string(), str->length());
 }
 
 }  // namespace android
diff --git a/libs/androidfw/tests/Idmap_test.cpp b/libs/androidfw/tests/Idmap_test.cpp
index 7aa0dbbafab3..3f0c7cbc8ffc 100644
--- a/libs/androidfw/tests/Idmap_test.cpp
+++ b/libs/androidfw/tests/Idmap_test.cpp
@@ -62,10 +62,10 @@ class IdmapTest : public ::testing::Test {
   std::unique_ptr<const ApkAssets> overlayable_assets_;
 };
 
-std::string GetStringFromApkAssets(const AssetManager2& asset_manager, const Res_value& value,
-                                   ApkAssetsCookie cookie) {
+std::string GetStringFromApkAssets(const AssetManager2& asset_manager,
+                                   const AssetManager2::SelectedValue& value) {
   auto assets = asset_manager.GetApkAssets();
-  const ResStringPool* string_pool = assets[cookie]->GetLoadedArsc()->GetStringPool();
+  const ResStringPool* string_pool = assets[value.cookie]->GetLoadedArsc()->GetStringPool();
   return GetStringFromPool(string_pool, value.data);
 }
 
@@ -75,117 +75,88 @@ TEST_F(IdmapTest, OverlayOverridesResourceValue) {
   AssetManager2 asset_manager;
   asset_manager.SetApkAssets({system_assets_.get(), overlayable_assets_.get(),
                               overlay_assets_.get()});
-  Res_value val;
-  ResTable_config config;
-  uint32_t flags;
-  ApkAssetsCookie cookie = asset_manager.GetResource(overlayable::R::string::overlayable5,
-                                                    false /* may_be_bag */,
-                                                    0 /* density_override */, &val, &config,
-                                                    &flags);
-  ASSERT_EQ(cookie, 2U);
-  ASSERT_EQ(val.dataType, Res_value::TYPE_STRING);
-  ASSERT_EQ(GetStringFromApkAssets(asset_manager, val, cookie), "Overlay One");
+
+  auto value = asset_manager.GetResource(overlayable::R::string::overlayable5);
+  ASSERT_TRUE(value.has_value());
+  ASSERT_EQ(value->cookie, 2U);
+  ASSERT_EQ(value->type, Res_value::TYPE_STRING);
+  ASSERT_EQ("Overlay One", GetStringFromApkAssets(asset_manager, *value));
 }
 
 TEST_F(IdmapTest, OverlayOverridesResourceValueUsingDifferentPackage) {
   AssetManager2 asset_manager;
   asset_manager.SetApkAssets({system_assets_.get(), overlayable_assets_.get(),
                               overlay_assets_.get()});
-  Res_value val;
-  ResTable_config config;
-  uint32_t flags;
-  ApkAssetsCookie cookie = asset_manager.GetResource(overlayable::R::string::overlayable10,
-                                                    false /* may_be_bag */,
-                                                    0 /* density_override */, &val, &config,
-                                                    &flags);
-  ASSERT_EQ(cookie, 0U);
-  ASSERT_EQ(val.dataType, Res_value::TYPE_STRING);
-  ASSERT_EQ(GetStringFromApkAssets(asset_manager, val, cookie), "yes");
+
+  auto value = asset_manager.GetResource(overlayable::R::string::overlayable10);
+  ASSERT_TRUE(value.has_value());
+  ASSERT_EQ(value->cookie, 0U);
+  ASSERT_EQ(value->type, Res_value::TYPE_STRING);
+  ASSERT_EQ("yes", GetStringFromApkAssets(asset_manager, *value));
 }
 
 TEST_F(IdmapTest, OverlayOverridesResourceValueUsingInternalResource) {
   AssetManager2 asset_manager;
   asset_manager.SetApkAssets({system_assets_.get(), overlayable_assets_.get(),
                               overlay_assets_.get()});
-  Res_value val;
-  ResTable_config config;
-  uint32_t flags;
-  ApkAssetsCookie cookie = asset_manager.GetResource(overlayable::R::string::overlayable8,
-                                                    false /* may_be_bag */,
-                                                    0 /* density_override */, &val, &config,
-                                                    &flags);
-  ASSERT_EQ(cookie, 2U);
-  ASSERT_EQ(val.dataType, Res_value::TYPE_REFERENCE);
-  ASSERT_EQ(val.data, (overlay::R::string::internal & 0x00ffffff) | (0x02 << 24));
+
+  auto value = asset_manager.GetResource(overlayable::R::string::overlayable8);
+  ASSERT_TRUE(value.has_value());
+  ASSERT_EQ(value->cookie, 2U);
+  ASSERT_EQ(value->type, Res_value::TYPE_REFERENCE);
+  ASSERT_EQ(value->data, (overlay::R::string::internal & 0x00ffffffU) | (0x02U << 24));
 }
 
 TEST_F(IdmapTest, OverlayOverridesResourceValueUsingInlineInteger) {
   AssetManager2 asset_manager;
   asset_manager.SetApkAssets({system_assets_.get(), overlayable_assets_.get(),
                               overlay_assets_.get()});
-  Res_value val;
-  ResTable_config config;
-  uint32_t flags;
-  ApkAssetsCookie cookie = asset_manager.GetResource(overlayable::R::integer::config_integer,
-                                                  false /* may_be_bag */,
-                                                  0 /* density_override */, &val, &config,
-                                                  &flags);
-  ASSERT_EQ(cookie, 2U);
-  ASSERT_EQ(val.dataType, Res_value::TYPE_INT_DEC);
-  ASSERT_EQ(val.data, 42);
+
+  auto value = asset_manager.GetResource(overlayable::R::integer::config_integer);
+  ASSERT_TRUE(value.has_value());
+  ASSERT_EQ(value->cookie, 2U);
+  ASSERT_EQ(value->type, Res_value::TYPE_INT_DEC);
+  ASSERT_EQ(value->data, 42);
 }
 
 TEST_F(IdmapTest, OverlayOverridesResourceValueUsingInlineString) {
   AssetManager2 asset_manager;
   asset_manager.SetApkAssets({system_assets_.get(), overlayable_assets_.get(),
                               overlay_assets_.get()});
-  Res_value val;
-  ResTable_config config;
-  uint32_t flags;
-
-  ApkAssetsCookie cookie = asset_manager.GetResource(overlayable::R::string::overlayable11,
-                                                  false /* may_be_bag */,
-                                                  0 /* density_override */, &val, &config,
-                                                  &flags);
-  ASSERT_EQ(cookie, 2U);
-  ASSERT_EQ(val.dataType, Res_value::TYPE_STRING);
-  ASSERT_EQ(GetStringFromApkAssets(asset_manager, val, cookie), "Hardcoded string");
+
+  auto value = asset_manager.GetResource(overlayable::R::string::overlayable11);
+  ASSERT_TRUE(value.has_value());
+  ASSERT_EQ(value->cookie, 2U);
+  ASSERT_EQ(value->type, Res_value::TYPE_STRING);
+  ASSERT_EQ("Hardcoded string", GetStringFromApkAssets(asset_manager, *value));
 }
 
 TEST_F(IdmapTest, OverlayOverridesResourceValueUsingOverlayingResource) {
   AssetManager2 asset_manager;
   asset_manager.SetApkAssets({system_assets_.get(), overlayable_assets_.get(),
                               overlay_assets_.get()});
-  Res_value val;
-  ResTable_config config;
-  uint32_t flags;
-  ApkAssetsCookie cookie = asset_manager.GetResource(overlayable::R::string::overlayable9,
-                                                    false /* may_be_bag */,
-                                                    0 /* density_override */, &val, &config,
-                                                    &flags);
-  ASSERT_EQ(cookie, 2U);
-  ASSERT_EQ(val.dataType, Res_value::TYPE_REFERENCE);
-  ASSERT_EQ(val.data, overlayable::R::string::overlayable7);
+
+  auto value = asset_manager.GetResource(overlayable::R::string::overlayable9);
+  ASSERT_TRUE(value.has_value());
+  ASSERT_EQ(value->cookie, 2U);
+  ASSERT_EQ(value->type, Res_value::TYPE_REFERENCE);
+  ASSERT_EQ(value->data, overlayable::R::string::overlayable7);
 }
 
 TEST_F(IdmapTest, OverlayOverridesXmlParser) {
   AssetManager2 asset_manager;
   asset_manager.SetApkAssets({system_assets_.get(), overlayable_assets_.get(),
                               overlay_assets_.get()});
-  Res_value val;
-  ResTable_config config;
-  uint32_t flags;
-  ApkAssetsCookie cookie = asset_manager.GetResource(overlayable::R::layout::hello_view,
-                                                    false /* may_be_bag */,
-                                                    0 /* density_override */, &val, &config,
-                                                    &flags);
-  ASSERT_EQ(cookie, 2U);
-  ASSERT_EQ(val.dataType, Res_value::TYPE_STRING);
-  ASSERT_EQ(GetStringFromApkAssets(asset_manager, val, cookie), "res/layout/hello_view.xml");
-
-  auto asset = asset_manager.OpenNonAsset("res/layout/hello_view.xml", cookie,
+
+  auto value = asset_manager.GetResource(overlayable::R::layout::hello_view);
+  ASSERT_TRUE(value.has_value());
+  ASSERT_EQ(value->cookie, 2U);
+  ASSERT_EQ(value->type, Res_value::TYPE_STRING);
+  ASSERT_EQ("res/layout/hello_view.xml", GetStringFromApkAssets(asset_manager, *value));
+
+  auto asset = asset_manager.OpenNonAsset("res/layout/hello_view.xml", value->cookie,
                                           Asset::ACCESS_RANDOM);
-  auto dynamic_ref_table = asset_manager.GetDynamicRefTableForCookie(cookie);
+  auto dynamic_ref_table = asset_manager.GetDynamicRefTableForCookie(value->cookie);
   auto xml_tree = util::make_unique<ResXMLTree>(std::move(dynamic_ref_table));
   status_t err = xml_tree->setTo(asset->getBuffer(true), asset->getLength(), false);
   ASSERT_EQ(err, NO_ERROR);
@@ -216,32 +187,24 @@ TEST_F(IdmapTest, OverlaidResourceHasSameName) {
   asset_manager.SetApkAssets({system_assets_.get(), overlayable_assets_.get(),
                               overlay_assets_.get()});
 
-  AssetManager2::ResourceName name;
-  ASSERT_TRUE(asset_manager.GetResourceName(overlayable::R::string::overlayable9, &name));
-  ASSERT_EQ(std::string(name.package), "com.android.overlayable");
-  ASSERT_EQ(String16(name.type16), u"string");
-  ASSERT_EQ(std::string(name.entry), "overlayable9");
+  auto name = asset_manager.GetResourceName(overlayable::R::string::overlayable9);
+  ASSERT_TRUE(name.has_value());
+  ASSERT_EQ("com.android.overlayable", std::string(name->package));
+  ASSERT_EQ(std::u16string(u"string"), std::u16string(name->type16));
+  ASSERT_EQ("overlayable9", std::string(name->entry));
 }
 
 TEST_F(IdmapTest, OverlayLoaderInterop) {
-  std::string contents;
   auto loader_assets = ApkAssets::LoadTable("loader/resources.arsc", PROPERTY_LOADER);
-
   AssetManager2 asset_manager;
   asset_manager.SetApkAssets({overlayable_assets_.get(), loader_assets.get(),
                               overlay_assets_.get()});
 
-  Res_value val;
-  ResTable_config config;
-  uint32_t flags;
-  ApkAssetsCookie cookie = asset_manager.GetResource(overlayable::R::string::overlayable11,
-                                                    false /* may_be_bag */,
-                                                    0 /* density_override */, &val, &config,
-                                                    &flags);
-  std::cout << asset_manager.GetLastResourceResolution();
-  ASSERT_EQ(cookie, 1U);
-  ASSERT_EQ(val.dataType, Res_value::TYPE_STRING);
-  ASSERT_EQ(GetStringFromApkAssets(asset_manager, val, cookie), "loader");
+  auto value = asset_manager.GetResource(overlayable::R::string::overlayable11);
+  ASSERT_TRUE(value.has_value());
+  ASSERT_EQ(1U, value->cookie);
+  ASSERT_EQ(Res_value::TYPE_STRING, value->type);
+  ASSERT_EQ("loader", GetStringFromApkAssets(asset_manager, *value));
 }
 
 TEST_F(IdmapTest, OverlayAssetsIsUpToDate) {
diff --git a/libs/androidfw/tests/LoadedArsc_test.cpp b/libs/androidfw/tests/LoadedArsc_test.cpp
index 2d69dfe4f429..63574110a817 100644
--- a/libs/androidfw/tests/LoadedArsc_test.cpp
+++ b/libs/androidfw/tests/LoadedArsc_test.cpp
@@ -50,7 +50,8 @@ TEST(LoadedArscTest, LoadSinglePackageArsc) {
   ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/styles/styles.apk", "resources.arsc",
                                       &contents));
 
-  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(StringPiece(contents));
+  auto loaded_arsc = LoadedArsc::Load(reinterpret_cast<const void*>(contents.data()),
+                                                                    contents.length());
   ASSERT_THAT(loaded_arsc, NotNull());
 
   const LoadedPackage* package =
@@ -66,9 +67,8 @@ TEST(LoadedArscTest, LoadSinglePackageArsc) {
   ASSERT_THAT(type_spec, NotNull());
   ASSERT_THAT(type_spec->type_count, Ge(1u));
 
-  const ResTable_type* type = type_spec->types[0];
-  ASSERT_THAT(type, NotNull());
-  ASSERT_THAT(LoadedPackage::GetEntry(type, entry_index), NotNull());
+  auto type = type_spec->types[0];
+  ASSERT_TRUE(LoadedPackage::GetEntry(type, entry_index).has_value());
 }
 
 TEST(LoadedArscTest, LoadSparseEntryApp) {
@@ -76,7 +76,8 @@ TEST(LoadedArscTest, LoadSparseEntryApp) {
   ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/sparse/sparse.apk", "resources.arsc",
                                       &contents));
 
-  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(StringPiece(contents));
+  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
+                                                                   contents.length());
   ASSERT_THAT(loaded_arsc, NotNull());
 
   const LoadedPackage* package =
@@ -90,9 +91,8 @@ TEST(LoadedArscTest, LoadSparseEntryApp) {
   ASSERT_THAT(type_spec, NotNull());
   ASSERT_THAT(type_spec->type_count, Ge(1u));
 
-  const ResTable_type* type = type_spec->types[0];
-  ASSERT_THAT(type, NotNull());
-  ASSERT_THAT(LoadedPackage::GetEntry(type, entry_index), NotNull());
+  auto type = type_spec->types[0];
+  ASSERT_TRUE(LoadedPackage::GetEntry(type, entry_index).has_value());
 }
 
 TEST(LoadedArscTest, LoadSharedLibrary) {
@@ -100,7 +100,8 @@ TEST(LoadedArscTest, LoadSharedLibrary) {
   ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/lib_one/lib_one.apk", "resources.arsc",
                                       &contents));
 
-  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(StringPiece(contents));
+  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
+                                                                   contents.length());
   ASSERT_THAT(loaded_arsc, NotNull());
 
   const auto& packages = loaded_arsc->GetPackages();
@@ -120,7 +121,8 @@ TEST(LoadedArscTest, LoadAppLinkedAgainstSharedLibrary) {
   ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/libclient/libclient.apk",
                                       "resources.arsc", &contents));
 
-  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(StringPiece(contents));
+  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
+                                                                   contents.length());
   ASSERT_THAT(loaded_arsc, NotNull());
 
   const auto& packages = loaded_arsc->GetPackages();
@@ -145,8 +147,10 @@ TEST(LoadedArscTest, LoadAppAsSharedLibrary) {
   ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/appaslib/appaslib.apk",
                                       "resources.arsc", &contents));
 
-  std::unique_ptr<const LoadedArsc> loaded_arsc =
-      LoadedArsc::Load(StringPiece(contents), nullptr /* loaded_idmap */, PROPERTY_DYNAMIC);
+  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
+                                                                   contents.length(),
+                                                                   nullptr /* loaded_idmap */,
+                                                                   PROPERTY_DYNAMIC);
   ASSERT_THAT(loaded_arsc, NotNull());
 
   const auto& packages = loaded_arsc->GetPackages();
@@ -159,7 +163,8 @@ TEST(LoadedArscTest, LoadFeatureSplit) {
   std::string contents;
   ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/feature/feature.apk", "resources.arsc",
                                       &contents));
-  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(StringPiece(contents));
+  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
+                                                                   contents.length());
   ASSERT_THAT(loaded_arsc, NotNull());
 
   const LoadedPackage* package =
@@ -172,15 +177,12 @@ TEST(LoadedArscTest, LoadFeatureSplit) {
   const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(type_index);
   ASSERT_THAT(type_spec, NotNull());
   ASSERT_THAT(type_spec->type_count, Ge(1u));
-  ASSERT_THAT(type_spec->types[0], NotNull());
 
-  size_t len;
-  const char16_t* type_name16 =
-      package->GetTypeStringPool()->stringAt(type_spec->type_spec->id - 1, &len);
-  ASSERT_THAT(type_name16, NotNull());
-  EXPECT_THAT(util::Utf16ToUtf8(StringPiece16(type_name16, len)), StrEq("string"));
+  auto type_name16 = package->GetTypeStringPool()->stringAt(type_spec->type_spec->id - 1);
+  ASSERT_TRUE(type_name16.has_value());
+  EXPECT_THAT(util::Utf16ToUtf8(*type_name16), StrEq("string"));
 
-  ASSERT_THAT(LoadedPackage::GetEntry(type_spec->types[0], entry_index), NotNull());
+  ASSERT_TRUE(LoadedPackage::GetEntry(type_spec->types[0], entry_index).has_value());
 }
 
 // AAPT(2) generates resource tables with chunks in a certain order. The rule is that
@@ -205,7 +207,8 @@ TEST(LoadedArscTest, LoadOutOfOrderTypeSpecs) {
       ReadFileFromZipToString(GetTestDataPath() + "/out_of_order_types/out_of_order_types.apk",
                               "resources.arsc", &contents));
 
-  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(StringPiece(contents));
+  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
+                                                                   contents.length());
   ASSERT_THAT(loaded_arsc, NotNull());
 
   ASSERT_THAT(loaded_arsc->GetPackages(), SizeIs(1u));
@@ -215,12 +218,10 @@ TEST(LoadedArscTest, LoadOutOfOrderTypeSpecs) {
   const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(0);
   ASSERT_THAT(type_spec, NotNull());
   ASSERT_THAT(type_spec->type_count, Ge(1u));
-  ASSERT_THAT(type_spec->types[0], NotNull());
 
   type_spec = package->GetTypeSpecByTypeIndex(1);
   ASSERT_THAT(type_spec, NotNull());
   ASSERT_THAT(type_spec->type_count, Ge(1u));
-  ASSERT_THAT(type_spec->types[0], NotNull());
 }
 
 TEST(LoadedArscTest, LoadOverlayable) {
@@ -228,7 +229,8 @@ TEST(LoadedArscTest, LoadOverlayable) {
   ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/overlayable/overlayable.apk",
                                       "resources.arsc", &contents));
 
-  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(StringPiece(contents));
+  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
+                                                                   contents.length());
 
   ASSERT_THAT(loaded_arsc, NotNull());
   const LoadedPackage* package = loaded_arsc->GetPackageById(
@@ -272,7 +274,8 @@ TEST(LoadedArscTest, ResourceIdentifierIterator) {
   ASSERT_TRUE(
       ReadFileFromZipToString(GetTestDataPath() + "/basic/basic.apk", "resources.arsc", &contents));
 
-  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(StringPiece(contents));
+  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
+                                                                   contents.length());
   ASSERT_NE(nullptr, loaded_arsc);
 
   const std::vector<std::unique_ptr<const LoadedPackage>>& packages = loaded_arsc->GetPackages();
@@ -320,7 +323,8 @@ TEST(LoadedArscTest, GetOverlayableMap) {
   ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/overlayable/overlayable.apk",
                                       "resources.arsc", &contents));
 
-  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(StringPiece(contents));
+  std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
+                                                                   contents.length());
   ASSERT_NE(nullptr, loaded_arsc);
 
   const std::vector<std::unique_ptr<const LoadedPackage>>& packages = loaded_arsc->GetPackages();
@@ -345,7 +349,7 @@ TEST(LoadedArscTest, LoadCustomLoader) {
       asset->getLength());
 
   std::unique_ptr<const LoadedArsc> loaded_arsc =
-      LoadedArsc::Load(data, nullptr, PROPERTY_LOADER);
+      LoadedArsc::Load(data.data(), data.length(), nullptr, PROPERTY_LOADER);
   ASSERT_THAT(loaded_arsc, NotNull());
 
   const LoadedPackage* package =
@@ -361,9 +365,8 @@ TEST(LoadedArscTest, LoadCustomLoader) {
   ASSERT_THAT(type_spec, NotNull());
   ASSERT_THAT(type_spec->type_count, Ge(1u));
 
-  const ResTable_type* type = type_spec->types[0];
-  ASSERT_THAT(type, NotNull());
-  ASSERT_THAT(LoadedPackage::GetEntry(type, entry_index), NotNull());
+  auto type = type_spec->types[0];
+  ASSERT_TRUE(LoadedPackage::GetEntry(type, entry_index).has_value());
 }
 
 // structs with size fields (like Res_value, ResTable_entry) should be
diff --git a/libs/androidfw/tests/ResTable_test.cpp b/libs/androidfw/tests/ResTable_test.cpp
index 326474e16e5d..9aeb00c47e63 100644
--- a/libs/androidfw/tests/ResTable_test.cpp
+++ b/libs/androidfw/tests/ResTable_test.cpp
@@ -442,22 +442,22 @@ TEST(ResTableTest, TruncatedEncodeLength) {
   ASSERT_LT(val.data, pool->size());
 
   // Make sure a string with a truncated length is read to its correct length
-  size_t str_len;
-  const char* target_str8 = pool->string8At(val.data, &str_len);
-  ASSERT_TRUE(target_str8 != NULL);
-  ASSERT_EQ(size_t(40076), String8(target_str8, str_len).size());
-  ASSERT_EQ(target_str8[40075], ']');
+  auto target_str8 = pool->string8At(val.data);
+  ASSERT_TRUE(target_str8.has_value());
+  ASSERT_EQ(size_t(40076), String8(target_str8->data(), target_str8->size()).size());
+  ASSERT_EQ(target_str8->data()[40075], ']');
 
-  const char16_t* target_str16 = pool->stringAt(val.data, &str_len);
-  ASSERT_TRUE(target_str16 != NULL);
-  ASSERT_EQ(size_t(40076), String16(target_str16, str_len).size());
-  ASSERT_EQ(target_str8[40075], (char16_t) ']');
+  auto target_str16 = pool->stringAt(val.data);
+  ASSERT_TRUE(target_str16.has_value());
+  ASSERT_EQ(size_t(40076), String16(target_str16->data(), target_str16->size()).size());
+  ASSERT_EQ(target_str8->data()[40075], (char16_t) ']');
 
   // Load an edited apk with the null terminator removed from the end of the
   // string
   std::string invalid_contents;
-  ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/length_decode/length_decode_invalid.apk",
-                                      "resources.arsc", &invalid_contents));
+  ASSERT_TRUE(ReadFileFromZipToString(
+      GetTestDataPath() + "/length_decode/length_decode_invalid.apk", "resources.arsc",
+      &invalid_contents));
   ResTable invalid_table;
   ASSERT_EQ(NO_ERROR, invalid_table.add(invalid_contents.data(), invalid_contents.size()));
 
@@ -472,8 +472,8 @@ TEST(ResTableTest, TruncatedEncodeLength) {
 
   // Make sure a string with a truncated length that is not null terminated errors
   // and does not return the string
-  ASSERT_TRUE(invalid_pool->string8At(invalid_val.data, &str_len) == NULL);
-  ASSERT_TRUE(invalid_pool->stringAt(invalid_val.data, &str_len) == NULL);
+  ASSERT_FALSE(invalid_pool->string8At(invalid_val.data).has_value());
+  ASSERT_FALSE(invalid_pool->stringAt(invalid_val.data).has_value());
 }
 
 }  // namespace android
diff --git a/libs/androidfw/tests/TestHelpers.cpp b/libs/androidfw/tests/TestHelpers.cpp
index a81bb6ffab06..10c0a4fc8316 100644
--- a/libs/androidfw/tests/TestHelpers.cpp
+++ b/libs/androidfw/tests/TestHelpers.cpp
@@ -73,11 +73,15 @@ AssertionResult IsStringEqual(const ResTable& table, uint32_t resource_id,
     return AssertionFailure() << "table has no string pool for block " << block;
   }
 
-  const String8 actual_str = pool->string8ObjectAt(val.data);
-  if (String8(expected_str) != actual_str) {
-    return AssertionFailure() << actual_str.string();
+  auto actual_str = pool->string8ObjectAt(val.data);
+  if (!actual_str.has_value()) {
+    return AssertionFailure() << "could not find string entry";
   }
-  return AssertionSuccess() << actual_str.string();
+
+  if (String8(expected_str) != *actual_str) {
+    return AssertionFailure() << actual_str->string();
+  }
+  return AssertionSuccess() << actual_str->string();
 }
 
 }  // namespace android
diff --git a/libs/androidfw/tests/Theme_bench.cpp b/libs/androidfw/tests/Theme_bench.cpp
index 594c39eb682f..f3d60bbe4f15 100644
--- a/libs/androidfw/tests/Theme_bench.cpp
+++ b/libs/androidfw/tests/Theme_bench.cpp
@@ -70,11 +70,8 @@ static void BM_ThemeGetAttribute(benchmark::State& state) {
   auto theme = assets.NewTheme();
   theme->ApplyStyle(kStyleId, false /* force */);
 
-  Res_value value;
-  uint32_t flags;
-
   while (state.KeepRunning()) {
-    theme->GetAttribute(kAttrId, &value, &flags);
+    theme->GetAttribute(kAttrId);
   }
 }
 BENCHMARK(BM_ThemeGetAttribute);
diff --git a/libs/androidfw/tests/Theme_test.cpp b/libs/androidfw/tests/Theme_test.cpp
index 16b9c75982fb..f658735da515 100644
--- a/libs/androidfw/tests/Theme_test.cpp
+++ b/libs/androidfw/tests/Theme_test.cpp
@@ -67,10 +67,7 @@ TEST_F(ThemeTest, EmptyTheme) {
   std::unique_ptr<Theme> theme = assetmanager.NewTheme();
   EXPECT_EQ(0u, theme->GetChangingConfigurations());
   EXPECT_EQ(&assetmanager, theme->GetAssetManager());
-
-  Res_value value;
-  uint32_t flags;
-  EXPECT_EQ(kInvalidCookie, theme->GetAttribute(app::R::attr::attr_one, &value, &flags));
+  EXPECT_FALSE(theme->GetAttribute(app::R::attr::attr_one).has_value());
 }
 
 TEST_F(ThemeTest, SingleThemeNoParent) {
@@ -78,23 +75,19 @@ TEST_F(ThemeTest, SingleThemeNoParent) {
   assetmanager.SetApkAssets({style_assets_.get()});
 
   std::unique_ptr<Theme> theme = assetmanager.NewTheme();
-  ASSERT_TRUE(theme->ApplyStyle(app::R::style::StyleOne));
-
-  Res_value value;
-  uint32_t flags;
-  ApkAssetsCookie cookie;
-
-  cookie = theme->GetAttribute(app::R::attr::attr_one, &value, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
-  EXPECT_EQ(Res_value::TYPE_INT_DEC, value.dataType);
-  EXPECT_EQ(1u, value.data);
-  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), flags);
-
-  cookie = theme->GetAttribute(app::R::attr::attr_two, &value, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
-  EXPECT_EQ(Res_value::TYPE_INT_DEC, value.dataType);
-  EXPECT_EQ(2u, value.data);
-  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), flags);
+  ASSERT_TRUE(theme->ApplyStyle(app::R::style::StyleOne).has_value());
+
+  auto value = theme->GetAttribute(app::R::attr::attr_one);
+  ASSERT_TRUE(value);
+  EXPECT_EQ(Res_value::TYPE_INT_DEC, value->type);
+  EXPECT_EQ(1u, value->data);
+  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), value->flags);
+
+  value = theme->GetAttribute(app::R::attr::attr_two);
+  ASSERT_TRUE(value);
+  EXPECT_EQ(Res_value::TYPE_INT_DEC, value->type);
+  EXPECT_EQ(2u, value->data);
+  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), value->flags);
 }
 
 TEST_F(ThemeTest, SingleThemeWithParent) {
@@ -102,32 +95,28 @@ TEST_F(ThemeTest, SingleThemeWithParent) {
   assetmanager.SetApkAssets({style_assets_.get()});
 
   std::unique_ptr<Theme> theme = assetmanager.NewTheme();
-  ASSERT_TRUE(theme->ApplyStyle(app::R::style::StyleTwo));
-
-  Res_value value;
-  uint32_t flags;
-  ApkAssetsCookie cookie;
-
-  cookie = theme->GetAttribute(app::R::attr::attr_one, &value, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
-  EXPECT_EQ(Res_value::TYPE_INT_DEC, value.dataType);
-  EXPECT_EQ(1u, value.data);
-  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), flags);
-
-  cookie = theme->GetAttribute(app::R::attr::attr_two, &value, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
-  EXPECT_EQ(Res_value::TYPE_STRING, value.dataType);
-  EXPECT_EQ(0, cookie);
+  ASSERT_TRUE(theme->ApplyStyle(app::R::style::StyleTwo).has_value());
+
+  auto value = theme->GetAttribute(app::R::attr::attr_one);
+  ASSERT_TRUE(value);
+  EXPECT_EQ(Res_value::TYPE_INT_DEC, value->type);
+  EXPECT_EQ(1u, value->data);
+  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), value->flags);
+
+  value = theme->GetAttribute(app::R::attr::attr_two);
+  ASSERT_TRUE(value);
+  EXPECT_EQ(Res_value::TYPE_STRING, value->type);
+  EXPECT_EQ(0, value->cookie);
   EXPECT_EQ(std::string("string"),
-            GetStringFromPool(assetmanager.GetStringPoolForCookie(0), value.data));
-  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), flags);
+            GetStringFromPool(assetmanager.GetStringPoolForCookie(0), value->data));
+  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), value->flags);
 
   // This attribute should point to an attr_indirect, so the result should be 3.
-  cookie = theme->GetAttribute(app::R::attr::attr_three, &value, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
-  EXPECT_EQ(Res_value::TYPE_INT_DEC, value.dataType);
-  EXPECT_EQ(3u, value.data);
-  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), flags);
+  value = theme->GetAttribute(app::R::attr::attr_three);
+  ASSERT_TRUE(value);
+  EXPECT_EQ(Res_value::TYPE_INT_DEC, value->type);
+  EXPECT_EQ(3u, value->data);
+  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), value->flags);
 }
 
 TEST_F(ThemeTest, TryToUseBadResourceId) {
@@ -135,11 +124,8 @@ TEST_F(ThemeTest, TryToUseBadResourceId) {
   assetmanager.SetApkAssets({style_assets_.get()});
 
   std::unique_ptr<Theme> theme = assetmanager.NewTheme();
-  ASSERT_TRUE(theme->ApplyStyle(app::R::style::StyleTwo));
-
-  Res_value value;
-  uint32_t flags;
-  ASSERT_EQ(kInvalidCookie, theme->GetAttribute(0x7f000001, &value, &flags));
+  ASSERT_TRUE(theme->ApplyStyle(app::R::style::StyleTwo).has_value());
+  ASSERT_FALSE(theme->GetAttribute(0x7f000001));
 }
 
 TEST_F(ThemeTest, MultipleThemesOverlaidNotForce) {
@@ -147,33 +133,29 @@ TEST_F(ThemeTest, MultipleThemesOverlaidNotForce) {
   assetmanager.SetApkAssets({style_assets_.get()});
 
   std::unique_ptr<Theme> theme = assetmanager.NewTheme();
-  ASSERT_TRUE(theme->ApplyStyle(app::R::style::StyleTwo));
-  ASSERT_TRUE(theme->ApplyStyle(app::R::style::StyleThree));
-
-  Res_value value;
-  uint32_t flags;
-  ApkAssetsCookie cookie;
+  ASSERT_TRUE(theme->ApplyStyle(app::R::style::StyleTwo).has_value());
+  ASSERT_TRUE(theme->ApplyStyle(app::R::style::StyleThree).has_value());
 
   // attr_one is still here from the base.
-  cookie = theme->GetAttribute(app::R::attr::attr_one, &value, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
-  EXPECT_EQ(Res_value::TYPE_INT_DEC, value.dataType);
-  EXPECT_EQ(1u, value.data);
-  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), flags);
+  auto value = theme->GetAttribute(app::R::attr::attr_one);
+  ASSERT_TRUE(value);
+  EXPECT_EQ(Res_value::TYPE_INT_DEC, value->type);
+  EXPECT_EQ(1u, value->data);
+  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), value->flags);
 
   // check for the new attr_six
-  cookie = theme->GetAttribute(app::R::attr::attr_six, &value, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
-  EXPECT_EQ(Res_value::TYPE_INT_DEC, value.dataType);
-  EXPECT_EQ(6u, value.data);
-  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), flags);
+  value = theme->GetAttribute(app::R::attr::attr_six);
+  ASSERT_TRUE(value);
+  EXPECT_EQ(Res_value::TYPE_INT_DEC, value->type);
+  EXPECT_EQ(6u, value->data);
+  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), value->flags);
 
   // check for the old attr_five (force=true was not used).
-  cookie = theme->GetAttribute(app::R::attr::attr_five, &value, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
-  EXPECT_EQ(Res_value::TYPE_REFERENCE, value.dataType);
-  EXPECT_EQ(app::R::string::string_one, value.data);
-  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), flags);
+  value = theme->GetAttribute(app::R::attr::attr_five);
+  ASSERT_TRUE(value);
+  EXPECT_EQ(Res_value::TYPE_REFERENCE, value->type);
+  EXPECT_EQ(app::R::string::string_one, value->data);
+  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), value->flags);
 }
 
 TEST_F(ThemeTest, MultipleThemesOverlaidForced) {
@@ -181,33 +163,29 @@ TEST_F(ThemeTest, MultipleThemesOverlaidForced) {
   assetmanager.SetApkAssets({style_assets_.get()});
 
   std::unique_ptr<Theme> theme = assetmanager.NewTheme();
-  ASSERT_TRUE(theme->ApplyStyle(app::R::style::StyleTwo));
-  ASSERT_TRUE(theme->ApplyStyle(app::R::style::StyleThree, true /* force */));
-
-  Res_value value;
-  uint32_t flags;
-  ApkAssetsCookie cookie;
+  ASSERT_TRUE(theme->ApplyStyle(app::R::style::StyleTwo).has_value());
+  ASSERT_TRUE(theme->ApplyStyle(app::R::style::StyleThree, true /* force */).has_value());
 
   // attr_one is still here from the base.
-  cookie = theme->GetAttribute(app::R::attr::attr_one, &value, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
-  EXPECT_EQ(Res_value::TYPE_INT_DEC, value.dataType);
-  EXPECT_EQ(1u, value.data);
-  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), flags);
+  auto value = theme->GetAttribute(app::R::attr::attr_one);
+  ASSERT_TRUE(value);
+  EXPECT_EQ(Res_value::TYPE_INT_DEC, value->type);
+  EXPECT_EQ(1u, value->data);
+  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), value->flags);
 
   // check for the new attr_six
-  cookie = theme->GetAttribute(app::R::attr::attr_six, &value, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
-  EXPECT_EQ(Res_value::TYPE_INT_DEC, value.dataType);
-  EXPECT_EQ(6u, value.data);
-  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), flags);
+  value = theme->GetAttribute(app::R::attr::attr_six);
+  ASSERT_TRUE(value);
+  EXPECT_EQ(Res_value::TYPE_INT_DEC, value->type);
+  EXPECT_EQ(6u, value->data);
+  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), value->flags);
 
   // check for the new attr_five (force=true was used).
-  cookie = theme->GetAttribute(app::R::attr::attr_five, &value, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
-  EXPECT_EQ(Res_value::TYPE_INT_DEC, value.dataType);
-  EXPECT_EQ(5u, value.data);
-  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), flags);
+  value = theme->GetAttribute(app::R::attr::attr_five);
+  ASSERT_TRUE(value);
+  EXPECT_EQ(Res_value::TYPE_INT_DEC, value->type);
+  EXPECT_EQ(5u, value->data);
+  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), value->flags);
 }
 
 TEST_F(ThemeTest, ResolveDynamicAttributesAndReferencesToSharedLibrary) {
@@ -216,28 +194,24 @@ TEST_F(ThemeTest, ResolveDynamicAttributesAndReferencesToSharedLibrary) {
       {lib_two_assets_.get(), lib_one_assets_.get(), libclient_assets_.get()});
 
   std::unique_ptr<Theme> theme = assetmanager.NewTheme();
-  ASSERT_TRUE(theme->ApplyStyle(libclient::R::style::Theme, false /*force*/));
-
-  Res_value value;
-  uint32_t flags;
-  ApkAssetsCookie cookie;
+  ASSERT_TRUE(theme->ApplyStyle(libclient::R::style::Theme, false /*force*/).has_value());
 
   // The attribute should be resolved to the final value.
-  cookie = theme->GetAttribute(libclient::R::attr::foo, &value, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
-  EXPECT_EQ(Res_value::TYPE_INT_DEC, value.dataType);
-  EXPECT_EQ(700u, value.data);
-  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), flags);
+  auto value = theme->GetAttribute(libclient::R::attr::foo);
+  ASSERT_TRUE(value);
+  EXPECT_EQ(Res_value::TYPE_INT_DEC, value->type);
+  EXPECT_EQ(700u, value->data);
+  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), value->flags);
 
   // The reference should be resolved to a TYPE_REFERENCE.
-  cookie = theme->GetAttribute(libclient::R::attr::bar, &value, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
-  EXPECT_EQ(Res_value::TYPE_REFERENCE, value.dataType);
+  value = theme->GetAttribute(libclient::R::attr::bar);
+  ASSERT_TRUE(value);
+  EXPECT_EQ(Res_value::TYPE_REFERENCE, value->type);
 
   // lib_one is assigned package ID 0x03.
-  EXPECT_EQ(3u, get_package_id(value.data));
-  EXPECT_EQ(get_type_id(lib_one::R::string::foo), get_type_id(value.data));
-  EXPECT_EQ(get_entry_id(lib_one::R::string::foo), get_entry_id(value.data));
+  EXPECT_EQ(3u, get_package_id(value->data));
+  EXPECT_EQ(get_type_id(lib_one::R::string::foo), get_type_id(value->data));
+  EXPECT_EQ(get_entry_id(lib_one::R::string::foo), get_entry_id(value->data));
 }
 
 TEST_F(ThemeTest, CopyThemeSameAssetManager) {
@@ -245,24 +219,20 @@ TEST_F(ThemeTest, CopyThemeSameAssetManager) {
   assetmanager.SetApkAssets({style_assets_.get()});
 
   std::unique_ptr<Theme> theme_one = assetmanager.NewTheme();
-  ASSERT_TRUE(theme_one->ApplyStyle(app::R::style::StyleOne));
-
-  Res_value value;
-  uint32_t flags;
-  ApkAssetsCookie cookie;
+  ASSERT_TRUE(theme_one->ApplyStyle(app::R::style::StyleOne).has_value());
 
   // attr_one is still here from the base.
-  cookie = theme_one->GetAttribute(app::R::attr::attr_one, &value, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
-  EXPECT_EQ(Res_value::TYPE_INT_DEC, value.dataType);
-  EXPECT_EQ(1u, value.data);
-  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), flags);
+  auto value = theme_one->GetAttribute(app::R::attr::attr_one);
+  ASSERT_TRUE(value);
+  EXPECT_EQ(Res_value::TYPE_INT_DEC, value->type);
+  EXPECT_EQ(1u, value->data);
+  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), value->flags);
 
   // attr_six is not here.
-  EXPECT_EQ(kInvalidCookie, theme_one->GetAttribute(app::R::attr::attr_six, &value, &flags));
+  ASSERT_FALSE(theme_one->GetAttribute(app::R::attr::attr_six).has_value());
 
   std::unique_ptr<Theme> theme_two = assetmanager.NewTheme();
-  ASSERT_TRUE(theme_two->ApplyStyle(app::R::style::StyleThree));
+  ASSERT_TRUE(theme_two->ApplyStyle(app::R::style::StyleThree).has_value());
 
   // Copy the theme to theme_one.
   theme_one->SetTo(*theme_two);
@@ -271,14 +241,14 @@ TEST_F(ThemeTest, CopyThemeSameAssetManager) {
   theme_two->Clear();
 
   // attr_one is now not here.
-  EXPECT_EQ(kInvalidCookie, theme_one->GetAttribute(app::R::attr::attr_one, &value, &flags));
+  ASSERT_FALSE(theme_one->GetAttribute(app::R::attr::attr_one).has_value());
 
   // attr_six is now here because it was copied.
-  cookie = theme_one->GetAttribute(app::R::attr::attr_six, &value, &flags);
-  ASSERT_NE(kInvalidCookie, cookie);
-  EXPECT_EQ(Res_value::TYPE_INT_DEC, value.dataType);
-  EXPECT_EQ(6u, value.data);
-  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), flags);
+  value = theme_one->GetAttribute(app::R::attr::attr_six);
+  ASSERT_TRUE(value);
+  EXPECT_EQ(Res_value::TYPE_INT_DEC, value->type);
+  EXPECT_EQ(6u, value->data);
+  EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), value->flags);
 }
 
 TEST_F(ThemeTest, OnlyCopySameAssetsThemeWhenAssetManagersDiffer) {
@@ -291,39 +261,43 @@ TEST_F(ThemeTest, OnlyCopySameAssetsThemeWhenAssetManagersDiffer) {
                                  style_assets_.get()});
 
   auto theme_dst = assetmanager_dst.NewTheme();
-  ASSERT_TRUE(theme_dst->ApplyStyle(app::R::style::StyleOne));
+  ASSERT_TRUE(theme_dst->ApplyStyle(app::R::style::StyleOne).has_value());
 
   auto theme_src = assetmanager_src.NewTheme();
-  ASSERT_TRUE(theme_src->ApplyStyle(R::style::Theme_One));
-  ASSERT_TRUE(theme_src->ApplyStyle(app::R::style::StyleTwo));
+  ASSERT_TRUE(theme_src->ApplyStyle(R::style::Theme_One).has_value());
+  ASSERT_TRUE(theme_src->ApplyStyle(app::R::style::StyleTwo).has_value());
   ASSERT_TRUE(theme_src->ApplyStyle(fix_package_id(lib_one::R::style::Theme, 0x03),
-                                    false /*force*/));
+                                    false /*force*/).has_value());
   ASSERT_TRUE(theme_src->ApplyStyle(fix_package_id(lib_two::R::style::Theme, 0x02),
-                                    false /*force*/));
+                                    false /*force*/).has_value());
 
   theme_dst->SetTo(*theme_src);
 
-  Res_value value;
-  uint32_t flags;
-
   // System resources (present in destination asset manager).
-  EXPECT_EQ(0, theme_dst->GetAttribute(R::attr::foreground, &value, &flags));
+  auto value = theme_dst->GetAttribute(R::attr::foreground);
+  ASSERT_TRUE(value.has_value());
+  EXPECT_EQ(0, value->cookie);
 
   // The cookie of the style asset is 3 in the source and 2 in the destination.
   // Check that the cookie has been rewritten to the destination values.
-  EXPECT_EQ(2, theme_dst->GetAttribute(app::R::attr::attr_one, &value, &flags));
+  value = theme_dst->GetAttribute(app::R::attr::attr_one);
+  ASSERT_TRUE(value.has_value());
+  EXPECT_EQ(2, value->cookie);
 
   // The cookie of the lib_one asset is 2 in the source and 1 in the destination.
   // The package id of the lib_one package is 0x03 in the source and 0x02 in the destination
   // Check that the cookie and packages have been rewritten to the destination values.
-  EXPECT_EQ(1, theme_dst->GetAttribute(fix_package_id(lib_one::R::attr::attr1, 0x02), &value,
-                                       &flags));
-  EXPECT_EQ(1, theme_dst->GetAttribute(fix_package_id(lib_one::R::attr::attr2, 0x02), &value,
-                                       &flags));
+  value = theme_dst->GetAttribute(fix_package_id(lib_one::R::attr::attr1, 0x02));
+  ASSERT_TRUE(value.has_value());
+  EXPECT_EQ(1, value->cookie);
+
+  value = theme_dst->GetAttribute(fix_package_id(lib_one::R::attr::attr2, 0x02));
+  ASSERT_TRUE(value.has_value());
+  EXPECT_EQ(1, value->cookie);
 
   // attr2 references an attribute in lib_one. Check that the resolution of the attribute value is
   // correct after the value of attr2 had its package id rewritten to the destination package id.
-  EXPECT_EQ(700, value.data);
+  EXPECT_EQ(700, value->data);
 }
 
 TEST_F(ThemeTest, CopyNonReferencesWhenPackagesDiffer) {
@@ -335,28 +309,32 @@ TEST_F(ThemeTest, CopyNonReferencesWhenPackagesDiffer) {
 
   auto theme_dst = assetmanager_dst.NewTheme();
   auto theme_src = assetmanager_src.NewTheme();
-  ASSERT_TRUE(theme_src->ApplyStyle(app::R::style::StyleSeven));
+  ASSERT_TRUE(theme_src->ApplyStyle(app::R::style::StyleSeven).has_value());
   theme_dst->SetTo(*theme_src);
 
-  Res_value value;
-  uint32_t flags;
-
   // Allow inline resource values to be copied even if the source apk asset is not present in the
   // destination.
-  EXPECT_EQ(0, theme_dst->GetAttribute(0x0101021b /* android:versionCode */, &value, &flags));
+  auto value = theme_dst->GetAttribute(0x0101021b /* android:versionCode */);
+  ASSERT_TRUE(value.has_value());
+  EXPECT_EQ(0, value->cookie);
 
   // Do not copy strings since the data is an index into the values string pool of the source apk
   // asset.
-  EXPECT_EQ(-1, theme_dst->GetAttribute(0x01010001 /* android:label */, &value, &flags));
+  EXPECT_FALSE(theme_dst->GetAttribute(0x01010001 /* android:label */).has_value());
 
   // Do not copy values that reference another resource if the resource is not present in the
   // destination.
-  EXPECT_EQ(-1, theme_dst->GetAttribute(0x01010002 /* android:icon */, &value, &flags));
-  EXPECT_EQ(-1, theme_dst->GetAttribute(0x010100d1 /* android:tag */, &value, &flags));
+  EXPECT_FALSE(theme_dst->GetAttribute(0x01010002 /* android:icon */).has_value());
+  EXPECT_FALSE(theme_dst->GetAttribute(0x010100d1 /* android:tag */).has_value());
 
   // Allow @empty to and @null to be copied.
-  EXPECT_EQ(0, theme_dst->GetAttribute(0x010100d0 /* android:id */, &value, &flags));
-  EXPECT_EQ(0, theme_dst->GetAttribute(0x01010000 /* android:theme */, &value, &flags));
+  value = theme_dst->GetAttribute(0x010100d0 /* android:id */);
+  ASSERT_TRUE(value.has_value());
+  EXPECT_EQ(0, value->cookie);
+
+  value = theme_dst->GetAttribute(0x01010000 /* android:theme */);
+  ASSERT_TRUE(value.has_value());
+  EXPECT_EQ(0, value->cookie);
 }
 
 }  // namespace android