Some conversions to UnorderedSet

Summary: This diff converts around 30% of the `std::unordered_set` references in the codebase.

Reviewed By: agampe

Differential Revision: D72061757

fbshipit-source-id: d2b06719b98645b9a882832b2c408464a80ce463

Author: Nikolai Tillmann

libredex/AnnoUtils.h

@@ -7,12 +7,11 @@
 
 #pragma once
 
+#include "DeterministicContainers.h"
 #include "DexAnnotation.h"
 #include "DexClass.h"
 #include "DexUtil.h"
 
-#include <unordered_set>
-
 /**
  * Parses the default value of an annotation given the annotation and the
  * element name.
@@ -88,7 +87,7 @@ DexAnnotation* get_annotation(const DexMember* member, DexType* anno_type) {
 
 template <class DexMember>
 bool has_any_annotation(DexMember* member,
-                        const std::unordered_set<DexType*>& anno_types) {
+                        const UnorderedSet<DexType*>& anno_types) {
   const auto& annos = member->get_anno_set();
   if (annos == nullptr) {
     return false;

libredex/ApkResources.cpp

@@ -924,7 +924,7 @@ std::string read_attribute_name_at_idx(const android::ResXMLTree& parser,
 void extract_classes_from_layout(
     const char* data,
     size_t size,
-    const std::unordered_set<std::string>& attributes_to_read,
+    const UnorderedSet<std::string>& attributes_to_read,
     resources::StringOrReferenceSet* out_classes,
     std::unordered_multimap<std::string, resources::StringOrReference>*
         out_attributes) {
@@ -1004,7 +1004,7 @@ void extract_classes_from_layout(
 
 void ApkResources::collect_layout_classes_and_attributes_for_file(
     const std::string& file_path,
-    const std::unordered_set<std::string>& attributes_to_read,
+    const UnorderedSet<std::string>& attributes_to_read,
     resources::StringOrReferenceSet* out_classes,
     std::unordered_multimap<std::string, resources::StringOrReference>*
         out_attributes) {
@@ -1031,7 +1031,7 @@ class XmlStringAttributeCollector : public arsc::SimpleXmlParser {
     return true;
   }
 
-  std::unordered_set<std::string> m_utf8s_values;
+  UnorderedSet<std::string> m_utf8s_values;
 };
 
 class XmlElementCollector : public arsc::SimpleXmlParser {
@@ -1063,7 +1063,7 @@ class XmlElementCollector : public arsc::SimpleXmlParser {
     return arsc::SimpleXmlParser::visit_start_tag(node, extension);
   }
 
-  std::unordered_set<std::string> m_element_names;
+  UnorderedSet<std::string> m_element_names;
 };
 
 // Rewrites node, extension, and attribute list to transform encountered
@@ -1176,13 +1176,12 @@ class NodeAttributeTransformer : public XmlElementCollector {
 } // namespace
 
 void ApkResources::collect_xml_attribute_string_values_for_file(
-    const std::string& file_path, std::unordered_set<std::string>* out) {
+    const std::string& file_path, UnorderedSet<std::string>* out) {
   redex::read_file_with_contents(file_path, [&](const char* data, size_t size) {
     if (arsc::is_binary_xml(data, size)) {
       XmlStringAttributeCollector collector;
       if (collector.visit((void*)data, size)) {
-        out->insert(collector.m_utf8s_values.begin(),
-                    collector.m_utf8s_values.end());
+        insert_unordered_iterable(*out, collector.m_utf8s_values);
       }
     }
   });
@@ -1346,13 +1345,13 @@ boost::optional<std::string> ApkResources::get_manifest_package_name() {
       });
 }
 
-std::unordered_set<std::string> ApkResources::get_service_loader_classes() {
+UnorderedSet<std::string> ApkResources::get_service_loader_classes() {
   const std::string meta_inf =
       (boost::filesystem::path(m_directory) / "META-INF/services/").string();
   return get_service_loader_classes_helper(meta_inf);
 }
 
-std::unordered_set<uint32_t> ApkResources::get_xml_reference_attributes(
+UnorderedSet<uint32_t> ApkResources::get_xml_reference_attributes(
     const std::string& filename) {
   if (is_raw_resource(filename)) {
     return {};
@@ -1421,13 +1420,11 @@ bool ApkResources::rename_classes_in_layout(
   return true;
 }
 
-std::unordered_set<std::string> ApkResources::find_all_xml_files() {
+UnorderedSet<std::string> ApkResources::find_all_xml_files() {
   std::string manifest_path = m_directory + "/AndroidManifest.xml";
-  std::unordered_set<std::string> all_xml_files;
+  UnorderedSet<std::string> all_xml_files;
   all_xml_files.emplace(manifest_path);
-  for (const std::string& path : get_xml_files(m_directory + "/res")) {
-    all_xml_files.emplace(path);
-  }
+  insert_unordered_iterable(all_xml_files, get_xml_files(m_directory + "/res"));
   return all_xml_files;
 }
 
@@ -1459,7 +1456,7 @@ namespace {
 
 void obfuscate_xml_attributes(
     const std::string& filename,
-    const std::unordered_set<std::string>& do_not_obfuscate_elements) {
+    const UnorderedSet<std::string>& do_not_obfuscate_elements) {
   auto file = RedexMappedFile::open(filename, false);
   apk::XmlFileEditor editor;
   always_assert_log(editor.visit((void*)file.data(), file.size()),
@@ -1498,8 +1495,8 @@ void obfuscate_xml_attributes(
 } // namespace
 
 void ApkResources::obfuscate_xml_files(
-    const std::unordered_set<std::string>& allowed_types,
-    const std::unordered_set<std::string>& do_not_obfuscate_elements) {
+    const UnorderedSet<std::string>& allowed_types,
+    const UnorderedSet<std::string>& do_not_obfuscate_elements) {
   using path_t = boost::filesystem::path;
   using dir_iterator = boost::filesystem::directory_iterator;
 
@@ -1513,9 +1510,7 @@ void ApkResources::obfuscate_xml_files(
       // TODO(T126661220): support obfuscated input.
       if (is_directory(entry_path) &&
           can_obfuscate_xml_file(allowed_types, entry_string)) {
-        for (const std::string& layout : get_xml_files(entry_string)) {
-          xml_paths.emplace(layout);
-        }
+        insert_unordered_iterable(xml_paths, get_xml_files(entry_string));
       }
     }
   }
@@ -1886,13 +1881,14 @@ void rebuild_string_pool(
 
 // Given the kept strings, build the mapping from old -> new in the projected
 // new string pool.
-void project_string_mapping(const std::unordered_set<uint32_t>& used_strings,
+void project_string_mapping(const UnorderedSet<uint32_t>& used_strings,
                             const android::ResStringPool& string_pool,
                             UnorderedMap<uint32_t, uint32_t>* kept_old_to_new,
                             bool sort_by_string_value = false) {
   always_assert(kept_old_to_new->empty());
 
-  std::vector<uint32_t> used_indices(used_strings.begin(), used_strings.end());
+  std::vector<uint32_t> used_indices;
+  insert_unordered_iterable(used_indices, used_indices.end(), used_strings);
   if (!sort_by_string_value) {
     std::sort(used_indices.begin(), used_indices.end());
   } else {
@@ -1962,7 +1958,7 @@ void ResourcesArscFile::finalize_resource_table(const ResourceConfig& config) {
   // 1) Collect all referenced global string indicies and key string indicies.
   PackageStringRefCollector collector;
   collector.visit(m_f.data(), m_arsc_len);
-  std::unordered_set<uint32_t> used_global_strings;
+  UnorderedSet<uint32_t> used_global_strings;
   for (const auto& value : collector.m_values) {
     used_global_strings.emplace(dtohl(value->data));
   }
@@ -1990,7 +1986,7 @@ void ResourcesArscFile::finalize_resource_table(const ResourceConfig& config) {
   // 4) Actually build the new global ResStringPool. While doing this, remap all
   //    span refs encountered (in case ResStringPool has copied its underlying
   //    data).
-  std::unordered_set<android::ResStringPool_span*> remapped_spans;
+  UnorderedSet<android::ResStringPool_span*> remapped_spans;
   auto remap_spans = [&global_old_to_new,
                       &remapped_spans](android::ResStringPool_span* span) {
     // Guard against span offsets that have been "canonicalized"
@@ -2023,7 +2019,7 @@ void ResourcesArscFile::finalize_resource_table(const ResourceConfig& config) {
       refs.insert(package_type_entries.begin(), package_type_entries.end());
     }
     auto key_string_pool = collector.m_package_key_strings.at(package);
-    std::unordered_set<uint32_t> used_key_strings;
+    UnorderedSet<uint32_t> used_key_strings;
     for (auto& ref : refs) {
       used_key_strings.emplace(dtohl(ref->index));
     }
@@ -2159,9 +2155,9 @@ void rebuild_string_pool_with_addition(
 size_t ResourcesArscFile::obfuscate_resource_and_serialize(
     const std::vector<std::string>& /* unused */,
     const std::map<std::string, std::string>& filepath_old_to_new,
-    const std::unordered_set<uint32_t>& allowed_types,
-    const std::unordered_set<std::string>& keep_resource_prefixes,
-    const std::unordered_set<std::string>& keep_resource_specific) {
+    const UnorderedSet<uint32_t>& allowed_types,
+    const UnorderedSet<std::string>& keep_resource_prefixes,
+    const UnorderedSet<std::string>& keep_resource_specific) {
   arsc::ResTableBuilder table_builder;
 
   // Find the global string pool and read its settings.
@@ -2261,11 +2257,9 @@ size_t ResourcesArscFile::obfuscate_resource_and_serialize(
         std::string old_string =
             arsc::get_string_from_pool(*key_string_pool, old);
         if (keep_resource_specific.count(old_string) > 0 ||
-            std::find_if(keep_resource_prefixes.begin(),
-                         keep_resource_prefixes.end(),
-                         [&](const std::string& v) {
-                           return old_string.find(v) == 0;
-                         }) != keep_resource_prefixes.end()) {
+            unordered_any_of(keep_resource_prefixes, [&](const std::string& v) {
+              return old_string.find(v) == 0;
+            })) {
           // Resource name matches block criteria; don't change the name.
           continue;
         }
@@ -2350,8 +2344,8 @@ uint64_t ResourcesArscFile::resource_value_count(uint32_t res_id) {
 void ResourcesArscFile::walk_references_for_resource(
     uint32_t resID,
     ResourcePathType path_type,
-    std::unordered_set<uint32_t>* nodes_visited,
-    std::unordered_set<std::string>* potential_file_paths) {
+    UnorderedSet<uint32_t>* nodes_visited,
+    UnorderedSet<std::string>* potential_file_paths) {
   if (nodes_visited->find(resID) != nodes_visited->end()) {
     return;
   }
@@ -2508,7 +2502,8 @@ size_t ResourcesArscFile::serialize() {
     for (auto& type_info : type_infos) {
       auto type_builder = std::make_shared<arsc::ResTableTypeProjector>(
           package_id, type_info.spec, type_info.configs);
-      type_builder->remove_ids(m_ids_to_remove, m_nullify_removed);
+      type_builder->remove_ids(unordered_unsafe_unwrap(m_ids_to_remove),
+                               m_nullify_removed);
       package_builder->add_type(type_builder);
     }
     // Append any new types
@@ -2654,8 +2649,8 @@ class EntryRemapper : public arsc::ResourceTableVisitor {
   const std::map<uint32_t, uint32_t>& m_old_to_new;
   // Tolerate a "canonicalized" version of a type, to make sure we don't double
   // remap.
-  std::unordered_set<android::Res_value*> m_seen_values;
-  std::unordered_set<android::ResTable_ref*> m_seen_refs;
+  UnorderedSet<android::Res_value*> m_seen_values;
+  UnorderedSet<android::ResTable_ref*> m_seen_refs;
 };
 } // namespace
 
@@ -2672,13 +2667,13 @@ void ResourcesArscFile::get_type_names(std::vector<std::string>* type_names) {
   table_snapshot.get_type_names(APPLICATION_PACKAGE, type_names);
 }
 
-std::unordered_set<uint32_t> ResourcesArscFile::get_types_by_name(
-    const std::unordered_set<std::string>& type_names) {
+UnorderedSet<uint32_t> ResourcesArscFile::get_types_by_name(
+    const UnorderedSet<std::string>& type_names) {
   auto& table_snapshot = get_table_snapshot();
   std::vector<std::string> all_types;
   table_snapshot.get_type_names(APPLICATION_PACKAGE, &all_types);
 
-  std::unordered_set<uint32_t> type_ids;
+  UnorderedSet<uint32_t> type_ids;
   for (size_t i = 0; i < all_types.size(); ++i) {
     if (type_names.count(all_types.at(i)) == 1) {
       type_ids.emplace((i + 1) << TYPE_INDEX_BIT_SHIFT);
@@ -2687,19 +2682,18 @@ std::unordered_set<uint32_t> ResourcesArscFile::get_types_by_name(
   return type_ids;
 }
 
-std::unordered_set<uint32_t> ResourcesArscFile::get_types_by_name_prefixes(
-    const std::unordered_set<std::string>& type_name_prefixes) {
+UnorderedSet<uint32_t> ResourcesArscFile::get_types_by_name_prefixes(
+    const UnorderedSet<std::string>& type_name_prefixes) {
   auto& table_snapshot = get_table_snapshot();
   std::vector<std::string> all_types;
   table_snapshot.get_type_names(APPLICATION_PACKAGE, &all_types);
 
-  std::unordered_set<uint32_t> type_ids;
+  UnorderedSet<uint32_t> type_ids;
   for (size_t i = 0; i < all_types.size(); ++i) {
     const auto& type_name = all_types.at(i);
-    if (std::find_if(type_name_prefixes.begin(), type_name_prefixes.end(),
-                     [&](const std::string& prefix) {
-                       return type_name.find(prefix) == 0;
-                     }) != type_name_prefixes.end()) {
+    if (unordered_any_of(type_name_prefixes, [&](const std::string& prefix) {
+          return type_name.find(prefix) == 0;
+        })) {
       type_ids.emplace((i + 1) << TYPE_INDEX_BIT_SHIFT);
     }
   }
@@ -2712,7 +2706,7 @@ namespace {
 // references encountered will be resolved and handled recursively.
 void resolve_string_index_for_id(apk::TableSnapshot& table_snapshot,
                                  uint32_t id,
-                                 std::unordered_set<uint32_t>* seen,
+                                 UnorderedSet<uint32_t>* seen,
                                  std::set<uint32_t>* out_idx) {
   // Annoyingly, Android build tools allow references to have cycles in them
   // without failing at build time. At runtime, such a situation would just loop
@@ -2742,7 +2736,7 @@ std::vector<std::string> ResourcesArscFile::get_resource_strings_by_name(
   auto& table_snapshot = get_table_snapshot();
   auto it = name_to_ids.find(res_name);
   if (it != name_to_ids.end()) {
-    std::unordered_set<uint32_t> seen;
+    UnorderedSet<uint32_t> seen;
     std::set<uint32_t> string_idx;
     for (uint32_t id : it->second) {
       resolve_string_index_for_id(table_snapshot, id, &seen, &string_idx);
@@ -2760,7 +2754,7 @@ std::vector<std::string> ResourcesArscFile::get_resource_strings_by_name(
 void ResourcesArscFile::resolve_string_values_for_resource_reference(
     uint32_t ref, std::vector<std::string>* values) {
   auto& table_snapshot = get_table_snapshot();
-  std::unordered_set<uint32_t> seen;
+  UnorderedSet<uint32_t> seen;
   std::set<uint32_t> string_idx;
   resolve_string_index_for_id(table_snapshot, ref, &seen, &string_idx);
   for (const auto& i : string_idx) {
@@ -2868,7 +2862,7 @@ ResourcesArscFile::get_inlinable_resource_values() {
   return inlinable_resources;
 }
 
-std::unordered_set<uint32_t> ResourcesArscFile::get_overlayable_id_roots() {
+UnorderedSet<uint32_t> ResourcesArscFile::get_overlayable_id_roots() {
   auto& table_snapshot = get_table_snapshot();
   auto& parsed_table = table_snapshot.get_parsed_table();
   return parsed_table.m_overlayable_ids;