Move PersistentCache to flow/

PersistentCache no longer manages its version internally.  It is the
client's responsibility to inject a version directory at its discretion.

shell/gpu/ no longer depends on shell/common after this, so there is no
need to permute it for product / non-product configurations.

BUG: fxb/52961, flutter/flutter#53399

Author: arbreng

assets/BUILD.gn

@@ -12,7 +12,6 @@ source_set("assets") {
   ]
 
   deps = [
-    "//flutter/common",
     "//flutter/fml",
   ]
 

flow/BUILD.gn

@@ -54,6 +54,8 @@ source_set_maybe_fuchsia_legacy("flow") {
     "matrix_decomposition.h",
     "paint_utils.cc",
     "paint_utils.h",
+    "persistent_cache.cc",
+    "persistent_cache.h",
     "raster_cache.cc",
     "raster_cache.h",
     "raster_cache_key.cc",
@@ -73,8 +75,9 @@ source_set_maybe_fuchsia_legacy("flow") {
   public_configs = [ "//flutter:config" ]
 
   deps = [
-    "//flutter/common",
+    "//flutter/assets",
     "//flutter/fml",
+    "//third_party/rapidjson",
     "//third_party/skia",
   ]
 
@@ -151,6 +154,7 @@ if (enable_unittests) {
       "layers/transform_layer_unittests.cc",
       "matrix_decomposition_unittests.cc",
       "mutators_stack_unittests.cc",
+      "persistent_cache_unittests.cc",
       "raster_cache_unittests.cc",
       "rtree_unittests.cc",
       "skia_gpu_object_unittests.cc",
@@ -161,6 +165,7 @@ if (enable_unittests) {
 
     deps = [
       ":flow_fixtures",
+      "//flutter/assets",
       "//flutter/fml",
       "//flutter/testing:skia",
       "//flutter/testing:testing_lib",

shell/common/persistent_cache.cc renamed to flow/persistent_cache.cc

@@ -2,28 +2,27 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "flutter/shell/common/persistent_cache.h"
+#include "flutter/flow/persistent_cache.h"
 
 #include <future>
 #include <memory>
 #include <string>
 #include <string_view>
 
-#include "rapidjson/document.h"
-#include "third_party/skia/include/utils/SkBase64.h"
-
 #include "flutter/fml/base32.h"
 #include "flutter/fml/file.h"
 #include "flutter/fml/logging.h"
 #include "flutter/fml/make_copyable.h"
 #include "flutter/fml/mapping.h"
 #include "flutter/fml/paths.h"
 #include "flutter/fml/trace_event.h"
-#include "flutter/shell/version/version.h"
+#include "third_party/rapidjson/include/rapidjson/document.h"
+#include "third_party/skia/include/utils/SkBase64.h"
 
 namespace flutter {
 
 std::string PersistentCache::cache_base_path_;
+std::string PersistentCache::cache_version_;
 
 std::shared_ptr<AssetManager> PersistentCache::asset_manager_;
 
@@ -75,10 +74,14 @@ void PersistentCache::ResetCacheForProcess() {
   strategy_set_ = false;
 }
 
-void PersistentCache::SetCacheDirectoryPath(std::string path) {
+void PersistentCache::SetCacheDirectoryPath(const std::string& path) {
   cache_base_path_ = path;
 }
 
+void PersistentCache::SetCacheVersion(const std::string& version) {
+  cache_version_ = version;
+}
+
 bool PersistentCache::Purge() {
   // Make sure that this is called after the worker task runner setup so all the
   // file system modifications would happen on that single thread to avoid
@@ -100,31 +103,29 @@ bool PersistentCache::Purge() {
 
 namespace {
 
-constexpr char kEngineComponent[] = "flutter_engine";
-
-static void FreeOldCacheDirectory(const fml::UniqueFD& cache_base_dir) {
-  fml::UniqueFD engine_dir =
-      fml::OpenDirectoryReadOnly(cache_base_dir, kEngineComponent);
-  if (!engine_dir.is_valid()) {
-    return;
-  }
-  fml::VisitFiles(engine_dir, [](const fml::UniqueFD& directory,
-                                 const std::string& filename) {
-    if (filename != GetFlutterEngineVersion()) {
-      auto dir = fml::OpenDirectory(directory, filename.c_str(), false,
-                                    fml::FilePermission::kReadWrite);
-      if (dir.is_valid()) {
-        fml::RemoveDirectoryRecursively(directory, filename.c_str());
-      }
-    }
-    return true;
-  });
+static void FreeOldCacheDirectory(const fml::UniqueFD& cache_base_dir,
+                                  const std::string& cache_version) {
+  fml::VisitFiles(
+      cache_base_dir, [cache_version](const fml::UniqueFD& directory,
+                                      const std::string& filename) {
+        if (filename != cache_version) {
+          auto dir = fml::OpenDirectory(directory, filename.c_str(), false,
+                                        fml::FilePermission::kReadWrite);
+          if (dir.is_valid()) {
+            fml::RemoveDirectoryRecursively(directory, filename.c_str());
+          }
+        }
+        return true;
+      });
 }
 
 static std::shared_ptr<fml::UniqueFD> MakeCacheDirectory(
     const std::string& global_cache_base_path,
+    const std::string& cache_version,
     bool read_only,
     bool cache_sksl) {
+  FML_CHECK(cache_version.length()) << "Cache version unspecified";
+
   fml::UniqueFD cache_base_dir;
   if (global_cache_base_path.length()) {
     cache_base_dir = fml::OpenDirectory(global_cache_base_path.c_str(), false,
@@ -134,9 +135,8 @@ static std::shared_ptr<fml::UniqueFD> MakeCacheDirectory(
   }
 
   if (cache_base_dir.is_valid()) {
-    FreeOldCacheDirectory(cache_base_dir);
-    std::vector<std::string> components = {
-        kEngineComponent, GetFlutterEngineVersion(), "skia", GetSkiaVersion()};
+    FreeOldCacheDirectory(cache_base_dir, cache_version);
+    std::vector<std::string> components = {cache_version};
     if (cache_sksl) {
       components.push_back(PersistentCache::kSkSLSubdirName);
     }
@@ -198,9 +198,9 @@ std::vector<PersistentCache::SkSLCache> PersistentCache::LoadSkSLs() {
     mapping = asset_manager_->GetAsMapping(kAssetFileName);
   }
   if (mapping == nullptr) {
-    FML_LOG(INFO) << "No sksl asset found.";
+    FML_DLOG(INFO) << "No sksl asset found.";
   } else {
-    FML_LOG(INFO) << "Found sksl asset. Loading SkSLs from it...";
+    FML_DLOG(INFO) << "Found sksl asset. Loading SkSLs from it...";
     rapidjson::Document json_doc;
     rapidjson::ParseResult parse_result =
         json_doc.Parse(reinterpret_cast<const char*>(mapping->GetMapping()),
@@ -225,9 +225,14 @@ std::vector<PersistentCache::SkSLCache> PersistentCache::LoadSkSLs() {
 
 PersistentCache::PersistentCache(bool read_only)
     : is_read_only_(read_only),
-      cache_directory_(MakeCacheDirectory(cache_base_path_, read_only, false)),
-      sksl_cache_directory_(
-          MakeCacheDirectory(cache_base_path_, read_only, true)) {
+      cache_directory_(MakeCacheDirectory(cache_base_path_,
+                                          cache_version_,
+                                          read_only,
+                                          false)),
+      sksl_cache_directory_(MakeCacheDirectory(cache_base_path_,
+                                               cache_version_,
+                                               read_only,
+                                               true)) {
   if (!IsValid()) {
     FML_LOG(WARNING) << "Could not acquire the persistent cache directory. "
                         "Caching of GPU resources on disk is disabled.";
@@ -341,7 +346,7 @@ void PersistentCache::DumpSkp(const SkData& data) {
   auto ticks = fml::TimePoint::Now().ToEpochDelta().ToNanoseconds();
   name_stream << "shader_dump_" << std::to_string(ticks) << ".skp";
   std::string file_name = name_stream.str();
-  FML_LOG(INFO) << "Dumping " << file_name;
+  FML_DLOG(INFO) << "Dumping " << file_name;
   auto mapping = std::make_unique<fml::DataMapping>(
       std::vector<uint8_t>{data.bytes(), data.bytes() + data.size()});
   PersistentCacheStore(GetWorkerTaskRunner(), cache_directory_,

shell/common/persistent_cache.h renamed to flow/persistent_cache.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef FLUTTER_SHELL_COMMON_PERSISTENT_CACHE_H_
-#define FLUTTER_SHELL_COMMON_PERSISTENT_CACHE_H_
+#ifndef FLUTTER_FLOW_PERSISTENT_CACHE_H_
+#define FLUTTER_FLOW_PERSISTENT_CACHE_H_
 
 #include <memory>
 #include <mutex>
@@ -35,7 +35,11 @@ class PersistentCache : public GrContextOptions::PersistentCache {
 
   // This must be called before |GetCacheForProcess|. Otherwise, it won't
   // affect the cache directory returned by |GetCacheForProcess|.
-  static void SetCacheDirectoryPath(std::string path);
+  static void SetCacheDirectoryPath(const std::string& path);
+
+  // This must be called before |GetCacheForProcess|. Otherwise, it won't
+  // affect the cache directory returned by |GetCacheForProcess|.
+  static void SetCacheVersion(const std::string& version);
 
   // Convert a binary SkData key into a Base32 encoded string.
   //
@@ -83,6 +87,7 @@ class PersistentCache : public GrContextOptions::PersistentCache {
 
  private:
   static std::string cache_base_path_;
+  static std::string cache_version_;
 
   static std::shared_ptr<AssetManager> asset_manager_;
 
@@ -125,4 +130,4 @@ class PersistentCache : public GrContextOptions::PersistentCache {
 
 }  // namespace flutter
 
-#endif  // FLUTTER_SHELL_COMMON_PERSISTENT_CACHE_H_
+#endif  // FLUTTER_FLOW_PERSISTENT_CACHE_H_