cc: Remove SanityCheckState from software image cache.

cc/tiles/software_image_decode_cache.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/tiles/software_image_decode_cache.h"
 
 #include <inttypes.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 256 matching lines @@
   // If we already have the image in cache, then we can return it.
   auto decoded_it = decoded_images_.Get(key);
   bool new_image_fits_in_memory =
       locked_images_budget_.AvailableMemoryBytes() >= key.locked_bytes();
   if (decoded_it != decoded_images_.end()) {
     bool image_was_locked = decoded_it->second->is_locked();
     if (image_was_locked ||
         (new_image_fits_in_memory && decoded_it->second->Lock())) {
       RefImage(key);
       *task = nullptr;
-      SanityCheckState(__LINE__, true);
 
       // If the image wasn't locked, then we just succeeded in locking it.
       if (!image_was_locked) {
         RecordLockExistingCachedImageHistogram(tracing_info.requesting_tile_bin,
                                                true);
       }
       return true;
     }
 
     // If the image fits in memory, then we at least tried to lock it and
@@ skipping 10 matching lines @@
   // If the task exists, return it. Note that if we always need to create a new
   // task, then just set |existing_task| to reference the passed in task (which
   // is set to nullptr above).
   scoped_refptr<TileTask>& existing_task =
       (task_type == DecodeTaskType::USE_IN_RASTER_TASKS)
           ? pending_in_raster_image_tasks_[key]
           : pending_out_of_raster_image_tasks_[key];
   if (existing_task) {
     RefImage(key);
     *task = existing_task;
-    SanityCheckState(__LINE__, true);
     return true;
   }
 
   // At this point, we have to create a new image/task, so we need to abort if
   // it doesn't fit into memory and there are currently no raster tasks that
   // would have already accounted for memory. The latter part is possible if
   // there's a running raster task that could not be canceled, and still has a
   // ref to the image that is now being reffed for the new schedule.
   if (!new_image_fits_in_memory && (decoded_images_ref_counts_.find(key) ==
                                     decoded_images_ref_counts_.end())) {
     *task = nullptr;
-    SanityCheckState(__LINE__, true);
     return false;
   }
 
   // Actually create the task. RefImage will account for memory on the first
   // ref.
   RefImage(key);
   existing_task = make_scoped_refptr(
       new ImageDecodeTaskImpl(this, key, image, task_type, tracing_info));
   *task = existing_task;
-  SanityCheckState(__LINE__, true);
   return true;
 }
 
 void SoftwareImageDecodeCache::RefImage(const ImageKey& key) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "SoftwareImageDecodeCache::RefImage", "key", key.ToString());
   lock_.AssertAcquired();
   int ref = ++decoded_images_ref_counts_[key];
   if (ref == 1) {
     DCHECK_GE(locked_images_budget_.AvailableMemoryBytes(), key.locked_bytes());
@@ skipping 17 matching lines @@
   DCHECK(ref_count_it != decoded_images_ref_counts_.end());
 
   --ref_count_it->second;
   if (ref_count_it->second == 0) {
     decoded_images_ref_counts_.erase(ref_count_it);
     locked_images_budget_.SubtractUsage(key.locked_bytes());
 
     auto decoded_image_it = decoded_images_.Peek(key);
     // If we've never decoded the image before ref reached 0, then we wouldn't
     // have it in our cache. This would happen if we canceled tasks.
-    if (decoded_image_it == decoded_images_.end()) {
-      SanityCheckState(__LINE__, true);
+    if (decoded_image_it == decoded_images_.end())
       return;
-    }
     DCHECK(decoded_image_it->second->is_locked());
     decoded_image_it->second->Unlock();
   }
-  SanityCheckState(__LINE__, true);
 }
 
 void SoftwareImageDecodeCache::DecodeImage(const ImageKey& key,
                                            const DrawImage& image,
                                            DecodeTaskType task_type) {
   TRACE_EVENT1("cc", "SoftwareImageDecodeCache::DecodeImage", "key",
                key.ToString());
   base::AutoLock lock(lock_);
   AutoRemoveKeyFromTaskMap remove_key_from_task_map(
       (task_type == DecodeTaskType::USE_IN_RASTER_TASKS)
@@ skipping 43 matching lines @@
 
   // We could have finished all of the raster tasks (cancelled) while this image
   // decode task was running, which means that we now have a locked image but no
   // ref counts. Unlock it immediately in this case.
   if (decoded_images_ref_counts_.find(key) ==
       decoded_images_ref_counts_.end()) {
     decoded_image->Unlock();
   }
 
   decoded_images_.Put(key, std::move(decoded_image));
-  SanityCheckState(__LINE__, true);
 }
 
 std::unique_ptr<SoftwareImageDecodeCache::DecodedImage>
 SoftwareImageDecodeCache::DecodeImageInternal(const ImageKey& key,
                                               const DrawImage& draw_image) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "SoftwareImageDecodeCache::DecodeImageInternal", "key",
                key.ToString());
   sk_sp<const SkImage> image = draw_image.image();
   if (!image)
@@ skipping 37 matching lines @@
   auto decoded_images_it = decoded_images_.Get(key);
   // If we found the image and it's locked, then return it. If it's not locked,
   // erase it from the cache since it might be put into the at-raster cache.
   std::unique_ptr<DecodedImage> scoped_decoded_image;
   DecodedImage* decoded_image = nullptr;
   if (decoded_images_it != decoded_images_.end()) {
     decoded_image = decoded_images_it->second.get();
     if (decoded_image->is_locked()) {
       RefImage(key);
       decoded_image->mark_used();
-      SanityCheckState(__LINE__, true);
       return DecodedDrawImage(
           decoded_image->image(), decoded_image->src_rect_offset(),
           GetScaleAdjustment(key), GetDecodedFilterQuality(key));
     } else {
       scoped_decoded_image = std::move(decoded_images_it->second);
       decoded_images_.Erase(decoded_images_it);
     }
   }
 
   // See if another thread already decoded this image at raster time. If so, we
   // can just use that result directly.
   auto at_raster_images_it = at_raster_decoded_images_.Get(key);
   if (at_raster_images_it != at_raster_decoded_images_.end()) {
     DCHECK(at_raster_images_it->second->is_locked());
     RefAtRasterImage(key);
-    SanityCheckState(__LINE__, true);
     DecodedImage* at_raster_decoded_image = at_raster_images_it->second.get();
     at_raster_decoded_image->mark_used();
     auto decoded_draw_image =
         DecodedDrawImage(at_raster_decoded_image->image(),
                          at_raster_decoded_image->src_rect_offset(),
                          GetScaleAdjustment(key), GetDecodedFilterQuality(key));
     decoded_draw_image.set_at_raster_decode(true);
     return decoded_draw_image;
   }
 
@@ skipping 33 matching lines @@
   }
 
   // If we really are the first ones, or if the other thread already unlocked
   // the image, then put our work into at-raster time cache.
   if (scoped_decoded_image)
     at_raster_decoded_images_.Put(key, std::move(scoped_decoded_image));
 
   DCHECK(decoded_image);
   DCHECK(decoded_image->is_locked());
   RefAtRasterImage(key);
-  SanityCheckState(__LINE__, true);
   decoded_image->mark_used();
   auto decoded_draw_image =
       DecodedDrawImage(decoded_image->image(), decoded_image->src_rect_offset(),
                        GetScaleAdjustment(key), GetDecodedFilterQuality(key));
   decoded_draw_image.set_at_raster_decode(true);
   return decoded_draw_image;
 }
 
 std::unique_ptr<SoftwareImageDecodeCache::DecodedImage>
 SoftwareImageDecodeCache::GetOriginalImageDecode(sk_sp<const SkImage> image) {
@@ skipping 163 matching lines @@
                "SoftwareImageDecodeCache::DrawWithImageFinished", "key",
                ImageKey::FromDrawImage(image).ToString());
   ImageKey key = ImageKey::FromDrawImage(image);
   if (!decoded_image.image())
     return;
 
   if (decoded_image.is_at_raster_decode())
     UnrefAtRasterImage(key);
   else
     UnrefImage(image);
-  SanityCheckState(__LINE__, false);
 }
 
 void SoftwareImageDecodeCache::RefAtRasterImage(const ImageKey& key) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "SoftwareImageDecodeCache::RefAtRasterImage", "key",
                key.ToString());
   DCHECK(at_raster_decoded_images_.Peek(key) !=
          at_raster_decoded_images_.end());
   ++at_raster_decoded_images_ref_counts_[key];
 }
@@ skipping 123 matching lines @@
         image_pair.second->memory()->CreateMemoryAllocatorDump(
             dump_name.c_str(), pmd);
     DCHECK(dump);
     size_t locked_bytes =
         image_pair.second->is_locked() ? image_pair.first.locked_bytes() : 0u;
     dump->AddScalar("locked_size", MemoryAllocatorDump::kUnitsBytes,
                     locked_bytes);
   }
 }
 
-void SoftwareImageDecodeCache::SanityCheckState(int line, bool lock_acquired) {
-#if DCHECK_IS_ON()
-  if (!lock_acquired) {
-    base::AutoLock lock(lock_);
-    SanityCheckState(line, true);
-    return;
-  }
-
-  MemoryBudget budget(locked_images_budget_.total_limit_bytes());
-  for (const auto& image_pair : decoded_images_) {
-    const auto& key = image_pair.first;
-    const auto& image = image_pair.second;
-
-    auto ref_it = decoded_images_ref_counts_.find(key);
-    if (image->is_locked()) {
-      budget.AddUsage(key.locked_bytes());
-      DCHECK(ref_it != decoded_images_ref_counts_.end()) << line;
-    } else {
-      DCHECK(ref_it == decoded_images_ref_counts_.end() ||
-             pending_in_raster_image_tasks_.find(key) !=
-                 pending_in_raster_image_tasks_.end() ||
-             pending_out_of_raster_image_tasks_.find(key) !=
-                 pending_out_of_raster_image_tasks_.end())
-          << line;
-    }
-  }
-  DCHECK_GE(budget.AvailableMemoryBytes(),
-            locked_images_budget_.AvailableMemoryBytes())
-      << line;
-#endif  // DCHECK_IS_ON()
-}
-
 // SoftwareImageDecodeCacheKey
 ImageDecodeCacheKey ImageDecodeCacheKey::FromDrawImage(const DrawImage& image) {
   const SkSize& scale = image.scale();
   // If the src_rect falls outside of the image, we need to clip it since
   // otherwise we might end up with uninitialized memory in the decode process.
   // Note that the scale is still unchanged and the target size is now a
   // function of the new src_rect.
   const gfx::Rect& src_rect = GetSrcRect(image);
   gfx::Size target_size(
       SkScalarRoundToInt(std::abs(src_rect.width() * scale.width())),
@@ skipping 263 matching lines @@
     }
   }
 }
 
 void SoftwareImageDecodeCache::OnPurgeMemory() {
   base::AutoLock lock(lock_);
   ReduceCacheUsageUntilWithinLimit(0);
 }
 
 }  // namespace cc