cc: Add cache purging to software image decode controller.

cc/tiles/software_image_decode_controller.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_controller.h"
 
 #include <inttypes.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 19 matching lines @@
 
 namespace cc {
 namespace {
 
 // The largest single high quality image to try and process. Images above this
 // size will drop down to medium quality.
 const size_t kMaxHighQualityImageSizeBytes = 64 * 1024 * 1024;
 
 // The number of entries to keep around in the cache. This limit can be breached
 // if more items are locked. That is, locked items ignore this limit.
+// Depending on the memory state of the system, we limit the amount of items
+// differently.
 const size_t kMaxItemsInCache = 1000;
+const size_t kThrottledMaxItemsInCache = 100;
+const size_t kSuspectedMaxItemsInCache = 0;

[ericrk, 2016/09/23 20:18:52]

I suspect you meant suspended :D

 
 // If the size of the original sized image breaches kMemoryRatioToSubrect but we
 // don't need to scale the image, consider caching only the needed subrect.
 // The second part that much be true is that we cache only the needed subrect if
 // the total size needed for the subrect is at most kMemoryRatioToSubrect *
 // (size needed for the full original image).
 const size_t kMemoryThresholdToSubrect = 64 * 1024 * 1024;
 const float kMemoryRatioToSubrect = 0.5f;
 
 class AutoRemoveKeyFromTaskMap {
@@ skipping 689 matching lines @@
       decoded_images_.Erase(image_it);
       decoded_images_.Put(key, std::move(at_raster_image_it->second));
     }
     at_raster_decoded_images_.Erase(at_raster_image_it);
   }
 }
 
 void SoftwareImageDecodeController::ReduceCacheUsage() {
   TRACE_EVENT0("cc", "SoftwareImageDecodeController::ReduceCacheUsage");
   base::AutoLock lock(lock_);
-  size_t num_to_remove = (decoded_images_.size() > kMaxItemsInCache)
-                             ? (decoded_images_.size() - kMaxItemsInCache)
+  ReduceCacheUsageInternal(kMaxItemsInCache);
+}
+
+void SoftwareImageDecodeController::ReduceCacheUsageInternal(size_t max_items) {
+  lock_.AssertAcquired();
+  size_t num_to_remove = (decoded_images_.size() > max_items)
+                             ? (decoded_images_.size() - max_items)
                              : 0;
   for (auto it = decoded_images_.rbegin();
        num_to_remove != 0 && it != decoded_images_.rend();) {
     if (it->second->is_locked()) {
       ++it;
       continue;
     }
 
     it = decoded_images_.Erase(it);
     --num_to_remove;
@@ skipping 316 matching lines @@
   current_usage_bytes_ = 0;
 }
 
 size_t SoftwareImageDecodeController::MemoryBudget::GetCurrentUsageSafe()
     const {
   return current_usage_bytes_.ValueOrDie();
 }
 
 void SoftwareImageDecodeController::OnMemoryStateChange(
     base::MemoryState state) {
+  size_t num_items_in_cache = kMaxItemsInCache;
   switch (state) {
     case base::MemoryState::NORMAL:
-      // TODO(tasak): go back to normal state.
-      break;
+      // Nothing to do here.
+      return;
     case base::MemoryState::THROTTLED:
-      // TODO(tasak): make the limits of this component's caches smaller to
-      // save memory usage.
+      num_items_in_cache = kThrottledMaxItemsInCache;

[ericrk, 2016/09/23 20:18:52]

One potential issue is that, if we continue operating in a throttled state, the
cache will build up to the previous kMaxItemsInCache again. Should we store this
somewhere so we can continue enforcing the throttled limit until we change back
to normal?

       break;
     case base::MemoryState::SUSPENDED:
-      // TODO(tasak): free this component's caches as much as possible before
-      // suspending renderer.
+      num_items_in_cache = kSuspectedMaxItemsInCache;
       break;
     case base::MemoryState::UNKNOWN:
-      // NOT_REACHED.
-      break;
+      NOTREACHED();
+      return;
   }
+  base::AutoLock hold(lock_);
+  ReduceCacheUsageInternal(num_items_in_cache);
 }
 
 }  // namespace cc