Tweak some code in raster cache

flow/raster_cache.cc

@@ -405,63 +405,37 @@ void RasterCache::PrepareNewFrame() {
   display_list_cached_this_frame_ = 0;
 }
 
-void RasterCache::SweepOneCacheAfterFrame(RasterCacheKey::Map<Entry>& cache,
-                                          RasterCacheMetrics& picture_metrics,
-                                          RasterCacheMetrics& layer_metrics) {
+void RasterCache::SweepCacheAfterFrame() {
   std::vector<RasterCacheKey::Map<Entry>::iterator> dead;
 
-  for (auto it = cache.begin(); it != cache.end(); ++it) {
+  for (auto it = cache_.begin(); it != cache_.end(); ++it) {
     Entry& entry = it->second;
     if (!entry.used_this_frame) {
       if (entry.unused_count < entry.unused_threshold()) {
         entry.unused_count++;
         if (entry.image) {
-          RasterCacheKeyKind kind = it->first.kind();
-          switch (kind) {
-            case RasterCacheKeyKind::kPictureMetrics:
-              picture_metrics.unused_count++;
-              picture_metrics.unused_bytes += entry.image->image_bytes();
-              break;
-            case RasterCacheKeyKind::kLayerMetrics:
-              layer_metrics.unused_count++;
-              layer_metrics.unused_bytes += entry.image->image_bytes();
-              break;
-          }
+          RasterCacheMetrics& metrics = GetMetricsForKind(it->first.kind());
+          metrics.unused_count++;
+          metrics.unused_bytes += entry.image->image_bytes();
         }
       } else {
         dead.push_back(it);
       }
     } else if (entry.image) {
-      RasterCacheKeyKind kind = it->first.kind();
-      switch (kind) {
-        case RasterCacheKeyKind::kPictureMetrics:
-          picture_metrics.in_use_count++;
-          picture_metrics.in_use_bytes += entry.image->image_bytes();
-          break;
-        case RasterCacheKeyKind::kLayerMetrics:
-          layer_metrics.in_use_count++;
-          layer_metrics.in_use_bytes += entry.image->image_bytes();
-          break;
-      }
+      RasterCacheMetrics& metrics = GetMetricsForKind(it->first.kind());
+      metrics.in_use_count++;
+      metrics.in_use_bytes += entry.image->image_bytes();
     }
     entry.used_this_frame = false;
   }
 
   for (auto it : dead) {
     if (it->second.image) {
-      RasterCacheKeyKind kind = it->first.kind();
-      switch (kind) {
-        case RasterCacheKeyKind::kPictureMetrics:
-          picture_metrics.eviction_count++;
-          picture_metrics.eviction_bytes += it->second.image->image_bytes();
-          break;
-        case RasterCacheKeyKind::kLayerMetrics:
-          layer_metrics.eviction_count++;
-          layer_metrics.eviction_bytes += it->second.image->image_bytes();
-          break;
-      }
+      RasterCacheMetrics& metrics = GetMetricsForKind(it->first.kind());
+      metrics.eviction_count++;
+      metrics.eviction_bytes += it->second.image->image_bytes();
     }
-    cache.erase(it);
+    cache_.erase(it);
   }
 }
 
@@ -470,7 +444,7 @@ void RasterCache::CleanupAfterFrame() {
   layer_metrics_ = {};
   {
     TRACE_EVENT0("flutter", "RasterCache::SweepCaches");
-    SweepOneCacheAfterFrame(cache_, picture_metrics_, layer_metrics_);
+    SweepCacheAfterFrame();
   }
   TraceStatsToTimeline();
 }
@@ -481,6 +455,15 @@ void RasterCache::Clear() {
   layer_metrics_ = {};
 }
 
+RasterCacheMetrics& RasterCache::GetMetricsForKind(RasterCacheKeyKind kind) {
+  switch (kind) {
+    case RasterCacheKeyKind::kPictureMetrics:
+      return picture_metrics_;
+    case RasterCacheKeyKind::kLayerMetrics:
+      return layer_metrics_;
+  }
+}
+
 size_t RasterCache::GetCachedEntriesCount() const {
   return cache_.size();
 }

flow/raster_cache.h

@@ -102,6 +102,9 @@ class RasterCache {
   // on that frame. This limit allows us to throttle the cache and distribute
   // the work across multiple frames.
   static constexpr int kDefaultPictureAndDispLayListCacheLimitPerFrame = 3;
+  // The default number of frames the high-priority entry which is high priority
+  // survives if it is not used.
+  static constexpr int kHighPriorityEvictionThreshold = 3;
 
   explicit RasterCache(size_t access_threshold = 3,
                        size_t picture_and_display_list_cache_limit_per_frame =
@@ -310,7 +313,9 @@ class RasterCache {
     std::unique_ptr<RasterCacheResult> image;
     // Return the number of frames the entry survives if it is not used. If the
     // number is 0, then it will be evicted when not in use.
-    size_t unused_threshold() const { return is_high_priority ? 3 : 0; }
+    size_t unused_threshold() const {
+      return is_high_priority ? kHighPriorityEvictionThreshold : 0;
+    }
   };
 
   void Touch(const RasterCacheKey& cache_key);
@@ -319,9 +324,9 @@ class RasterCache {
             SkCanvas& canvas,
             const SkPaint* paint) const;
 
-  void SweepOneCacheAfterFrame(RasterCacheKey::Map<Entry>& cache,
-                               RasterCacheMetrics& picture_metrics,
-                               RasterCacheMetrics& layer_metrics);
+  void SweepCacheAfterFrame();
+
+  RasterCacheMetrics& GetMetricsForKind(RasterCacheKeyKind kind);
 
   bool GenerateNewCacheInThisFrame() const {
     // Disabling caching when access_threshold is zero is historic behavior.