[asset_manager] add ability to get all files matching a pattern from

Asset Manager.

Gives Asset Manager the ability to find files matching a specific
pattern and uses that functionality to implement an entry point in
PersistantCache which retreives mappings for all skp files in the Asset
Bundle.

Author: freiling

assets/asset_manager.cc

@@ -51,6 +51,24 @@ std::unique_ptr<fml::Mapping> AssetManager::GetAsMapping(
   return nullptr;
 }
 
+// |AssetResolver|
+std::vector<std::unique_ptr<fml::Mapping>> AssetManager::GetAsMappings(
+    const std::string& asset_pattern) const {
+  std::vector<std::unique_ptr<fml::Mapping>> mappings;
+  if (asset_pattern.size() == 0) {
+    return mappings;
+  }
+  TRACE_EVENT1("flutter", "AssetManager::GetAsMappings", "pattern",
+               asset_pattern.c_str());
+  for (const auto& resolver : resolvers_) {
+    auto resolver_mappings = resolver->GetAsMappings(asset_pattern);
+    mappings.insert(mappings.end(),
+                    std::make_move_iterator(resolver_mappings.begin()),
+                    std::make_move_iterator(resolver_mappings.end()));
+  }
+  return mappings;
+}
+
 // |AssetResolver|
 bool AssetManager::IsValid() const {
   return resolvers_.size() > 0;

assets/asset_manager.h

@@ -37,6 +37,10 @@ class AssetManager final : public AssetResolver {
   std::unique_ptr<fml::Mapping> GetAsMapping(
       const std::string& asset_name) const override;
 
+  // |AssetResolver|
+  std::vector<std::unique_ptr<fml::Mapping>> GetAsMappings(
+      const std::string& asset_pattern) const override;
+
  private:
   std::deque<std::unique_ptr<AssetResolver>> resolvers_;
 

assets/asset_resolver.h

@@ -42,6 +42,11 @@ class AssetResolver {
   [[nodiscard]] virtual std::unique_ptr<fml::Mapping> GetAsMapping(
       const std::string& asset_name) const = 0;
 
+  // Same as GetAsMapping() but returns mappings for all files who's name
+  // matches |pattern|. Returns empty vector if no matching assets are found
+  [[nodiscard]] virtual std::vector<std::unique_ptr<fml::Mapping>>
+  GetAsMappings(const std::string& asset_pattern) const = 0;
+
  private:
   FML_DISALLOW_COPY_AND_ASSIGN(AssetResolver);
 };

assets/directory_asset_bundle.cc

@@ -4,6 +4,7 @@
 
 #include "flutter/assets/directory_asset_bundle.h"
 
+#include <regex>
 #include <utility>
 
 #include "flutter/fml/eintr_wrapper.h"
@@ -53,4 +54,32 @@ std::unique_ptr<fml::Mapping> DirectoryAssetBundle::GetAsMapping(
   return mapping;
 }
 
+std::vector<std::unique_ptr<fml::Mapping>> DirectoryAssetBundle::GetAsMappings(
+    const std::string& asset_pattern) const {
+  std::vector<std::unique_ptr<fml::Mapping>> mappings;
+  if (!is_valid_) {
+    FML_DLOG(WARNING) << "Asset bundle was not valid.";
+    return mappings;
+  }
+
+  std::regex asset_regex(asset_pattern);
+  fml::FileVisitor visitor = [&](const fml::UniqueFD& directory,
+                                 const std::string& filename) {
+    if (std::regex_match(filename, asset_regex)) {
+      auto mapping = std::make_unique<fml::FileMapping>(fml::OpenFile(
+          directory, filename.c_str(), false, fml::FilePermission::kRead));
+
+      if (mapping && mapping->IsValid()) {
+        mappings.push_back(std::move(mapping));
+      } else {
+        FML_LOG(ERROR) << "Mapping " << filename << " failed";
+      }
+    }
+    return true;
+  };
+  fml::VisitFilesRecursively(descriptor_, visitor);
+
+  return mappings;
+}
+
 }  // namespace flutter

assets/directory_asset_bundle.h

@@ -34,6 +34,10 @@ class DirectoryAssetBundle : public AssetResolver {
   std::unique_ptr<fml::Mapping> GetAsMapping(
       const std::string& asset_name) const override;
 
+  // |AssetResolver|
+  std::vector<std::unique_ptr<fml::Mapping>> GetAsMappings(
+      const std::string& asset_pattern) const override;
+
   FML_DISALLOW_COPY_AND_ASSIGN(DirectoryAssetBundle);
 };
 

shell/common/persistent_cache.cc

@@ -391,4 +391,14 @@ void PersistentCache::SetAssetManager(std::shared_ptr<AssetManager> value) {
   asset_manager_ = value;
 }
 
+std::vector<std::unique_ptr<fml::Mapping>>
+PersistentCache::GetSkpsFromAssetManager() const {
+  if (!asset_manager_) {
+    FML_LOG(ERROR)
+        << "PersistentCache::GetSkpsFromAssetManager: Asset manager not set!";
+    return std::vector<std::unique_ptr<fml::Mapping>>();
+  }
+  return asset_manager_->GetAsMappings(".*\\.skp$");
+}
+
 }  // namespace flutter

shell/common/persistent_cache.h

@@ -74,6 +74,9 @@ class PersistentCache : public GrContextOptions::PersistentCache {
   /// Load all the SkSL shader caches in the right directory.
   std::vector<SkSLCache> LoadSkSLs();
 
+  // Return mappings for all skp's accessible through the AssetManager
+  std::vector<std::unique_ptr<fml::Mapping>> GetSkpsFromAssetManager() const;
+
   /// Set the asset manager from which PersistentCache can load SkLSs. A nullptr
   /// can be provided to clear the asset manager.
   static void SetAssetManager(std::shared_ptr<AssetManager> value);

shell/common/shell_unittests.cc

@@ -10,6 +10,7 @@
 #include <future>
 #include <memory>
 
+#include "assets/directory_asset_bundle.h"
 #include "flutter/flow/layers/layer_tree.h"
 #include "flutter/flow/layers/picture_layer.h"
 #include "flutter/flow/layers/transform_layer.h"
@@ -2208,5 +2209,70 @@ TEST_F(ShellTest, EngineRootIsolateLaunchesDontTakeVMDataSettings) {
   isolate_create_latch.Wait();
 }
 
+TEST_F(ShellTest, AssetManagerSingle) {
+  fml::ScopedTemporaryDirectory asset_dir;
+  fml::UniqueFD asset_dir_fd = fml::OpenDirectory(
+      asset_dir.path().c_str(), false, fml::FilePermission::kRead);
+
+  std::string filename = "test";
+
+  bool success = fml::WriteAtomically(asset_dir_fd, filename.c_str(),
+                                      fml::DataMapping(filename));
+  ASSERT_TRUE(success);
+
+  AssetManager asset_manager;
+  asset_manager.PushBack(
+      std::make_unique<DirectoryAssetBundle>(std::move(asset_dir_fd), false));
+
+  auto mapping = asset_manager.GetAsMapping(filename);
+  ASSERT_TRUE(mapping != nullptr);
+
+  std::string result(reinterpret_cast<const char*>(mapping->GetMapping()),
+                     mapping->GetSize());
+
+  ASSERT_TRUE(result == filename);
+}
+TEST_F(ShellTest, AssetManagerMulti) {
+  fml::ScopedTemporaryDirectory asset_dir;
+  fml::UniqueFD asset_dir_fd = fml::OpenDirectory(
+      asset_dir.path().c_str(), false, fml::FilePermission::kRead);
+
+  std::vector<std::string> filenames = {
+      "good0",
+      "bad0",
+      "good1",
+      "bad1",
+  };
+
+  for (auto filename : filenames) {
+    bool success = fml::WriteAtomically(asset_dir_fd, filename.c_str(),
+                                        fml::DataMapping(filename));
+    ASSERT_TRUE(success);
+  }
+
+  AssetManager asset_manager;
+  asset_manager.PushBack(
+      std::make_unique<DirectoryAssetBundle>(std::move(asset_dir_fd), false));
+
+  auto mappings = asset_manager.GetAsMappings("(.*)");
+  ASSERT_TRUE(mappings.size() == 4);
+
+  std::vector<std::string> expected_results = {
+      "good0",
+      "good1",
+  };
+
+  mappings = asset_manager.GetAsMappings("(.*)good(.*)");
+  ASSERT_TRUE(mappings.size() == expected_results.size());
+
+  for (auto& mapping : mappings) {
+    std::string result(reinterpret_cast<const char*>(mapping->GetMapping()),
+                       mapping->GetSize());
+    ASSERT_NE(
+        std::find(expected_results.begin(), expected_results.end(), result),
+        expected_results.end());
+  }
+}
+
 }  // namespace testing
 }  // namespace flutter