use CacheInfo struct to simplify return values

Author: flar

flow/layers/display_list_layer_unittests.cc

@@ -540,7 +540,7 @@ TEST_F(DisplayListLayerTest, OverflowCachedDisplayListOpacityInheritance) {
         offset, SkiaGPUObject(display_list, unref_queue()), true, false);
     opacity_layer->Add(layers[i]);
   }
-  for (int j = 0; j < context->raster_cache->access_threshold(); j++) {
+  for (size_t j = 0; j < context->raster_cache->access_threshold(); j++) {
     context->raster_cache->BeginFrame();
     for (int i = 0; i < layer_count; i++) {
       context->renderable_state_flags = 0;

flow/layers/display_list_raster_cache_item.cc

@@ -105,12 +105,13 @@ void DisplayListRasterCacheItem::PrerollFinalize(PrerollContext* context,
   auto* raster_cache = context->raster_cache;
   SkRect bounds = display_list_->bounds().makeOffset(offset_.x(), offset_.y());
   bool visible = !context->state_stack.content_culled(bounds);
-  bool has_image = false;
-  int accesses = raster_cache->MarkSeen(key_id_, matrix, visible, &has_image);
-  if (!visible || accesses <= raster_cache->access_threshold()) {
+  RasterCache::CacheInfo cache_info =
+      raster_cache->MarkSeen(key_id_, matrix, visible);
+  if (!visible ||
+      cache_info.accesses_since_visible <= raster_cache->access_threshold()) {
     cache_state_ = kNone;
   } else {
-    if (has_image) {
+    if (cache_info.has_image) {
       context->renderable_state_flags |=
           LayerStateStack::kCallerCanApplyOpacity;
     }

flow/raster_cache.cc

@@ -110,21 +110,17 @@ bool RasterCache::UpdateCacheEntry(
   return entry.image != nullptr;
 }
 
-int RasterCache::MarkSeen(const RasterCacheKeyID& id,
-                          const SkMatrix& matrix,
-                          bool visible,
-                          bool* has_image) const {
+RasterCache::CacheInfo RasterCache::MarkSeen(const RasterCacheKeyID& id,
+                                             const SkMatrix& matrix,
+                                             bool visible) const {
   RasterCacheKey key = RasterCacheKey(id, matrix);
   Entry& entry = cache_[key];
   entry.encountered_this_frame = true;
   entry.visible_this_frame = visible;
   if (visible || entry.accesses_since_visible > 0) {
     entry.accesses_since_visible++;
   }
-  if (has_image) {
-    *has_image = (entry.image != nullptr);
-  }
-  return entry.accesses_since_visible;
+  return {entry.accesses_since_visible, entry.image != nullptr};
 }
 
 int RasterCache::GetAccessCount(const RasterCacheKeyID& id,

flow/raster_cache.h

@@ -121,6 +121,10 @@ class RasterCache {
     const SkRect& logical_rect;
     const char* flow_type;
   };
+  struct CacheInfo {
+    const size_t accesses_since_visible;
+    const bool has_image;
+  };
 
   std::unique_ptr<RasterCacheResult> Rasterize(
       const RasterCache::Context& context,
@@ -203,7 +207,7 @@ class RasterCache {
    * If the number is one, then it must be prepared and drawn on 1 frame
    * and it will then be cached on the next frame if it is prepared.
    */
-  int access_threshold() const { return access_threshold_; }
+  size_t access_threshold() const { return access_threshold_; }
 
   bool GenerateNewCacheInThisFrame() const {
     // Disabling caching when access_threshold is zero is historic behavior.
@@ -221,10 +225,9 @@ class RasterCache {
    * @return the number of times the entry has been hit since it was created.
    * For a new entry that will be 1 if it is visible, or zero if non-visible.
    */
-  int MarkSeen(const RasterCacheKeyID& id,
-               const SkMatrix& matrix,
-               bool visible,
-               bool* has_image = nullptr) const;
+  CacheInfo MarkSeen(const RasterCacheKeyID& id,
+                     const SkMatrix& matrix,
+                     bool visible) const;
 
   /**
    * Returns the access count (i.e. accesses_since_visible) for the given

flow/testing/mock_raster_cache.cc

@@ -65,7 +65,7 @@ void MockRasterCache::AddMockPicture(int width, int height) {
 
   DisplayListRasterCacheItem display_list_item(display_list.get(), SkPoint(),
                                                true, false);
-  for (int i = 0; i < access_threshold(); i++) {
+  for (size_t i = 0; i < access_threshold(); i++) {
     AutoCache(&display_list_item, &preroll_context_, ctm);
   }
   RasterCache::Context r_context = {