Move purging from OnMemoryState to OnPurgeMemory() in cc/

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 765 matching lines @@
       DCHECK(decoded_images_ref_counts_.find(key) ==
              decoded_images_ref_counts_.end());
       at_raster_image_it->second->Unlock();
       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 SoftwareImageDecodeCache::ReduceCacheUsage() {
+void SoftwareImageDecodeCache::ReduceCacheUsageUntilWithinLimit(size_t limit) {
   TRACE_EVENT0("cc", "SoftwareImageDecodeCache::ReduceCacheUsage");
-  base::AutoLock lock(lock_);
-  size_t num_to_remove = (decoded_images_.size() > max_items_in_cache_)
-                             ? (decoded_images_.size() - max_items_in_cache_)
-                             : 0;
+  size_t num_to_remove =
+      (decoded_images_.size() > limit) ? (decoded_images_.size() - limit) : 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;
   }
 }
 
+void SoftwareImageDecodeCache::ReduceCacheUsage() {
+  base::AutoLock lock(lock_);
+  ReduceCacheUsageUntilWithinLimit(max_items_in_cache_);
+}
+
 void SoftwareImageDecodeCache::RemovePendingTask(const ImageKey& key,
                                                  DecodeTaskType task_type) {
   base::AutoLock lock(lock_);
   switch (task_type) {
     case DecodeTaskType::USE_IN_RASTER_TASKS:
       pending_in_raster_image_tasks_.erase(key);
       break;
     case DecodeTaskType::USE_OUT_OF_RASTER_TASKS:
       pending_out_of_raster_image_tasks_.erase(key);
       break;
@@ skipping 339 matching lines @@
         max_items_in_cache_ = kThrottledMaxItemsInCache;
         break;
       case base::MemoryState::SUSPENDED:
         max_items_in_cache_ = kSuspendedMaxItemsInCache;
         break;
       case base::MemoryState::UNKNOWN:
         NOTREACHED();
         return;
     }
   }
-  ReduceCacheUsage();
+  // TODO(bashi): We are going to separate purging from state changes and we
+  // shouldn't purge memory here (crbug.com/684287). Tentatively call
+  // OnPurgeMemory() so that we don't break existing experiments.
+  // (i.e. purge+suspend experiment)
+  if (state == base::MemoryState::SUSPENDED)
+    OnPurgeMemory();

[ericrk, 2017/01/30 15:58:56]

This also removes the ability to handle THROTTLED state, is this intentional? I
think we just want "ReduceCacheUsage" here.

[bashi, 2017/01/31 19:30:56]

Yes, it's intentional. I'm going to move ReduceCacheUsage() call from
OnStateChange() to OnPurgeMemory(). We need to keep purging memory here because
currently purge+suspend experiment depends on this behavior. When I complete
updating all clients (this CL is the first one), and purge+suspend experiment
I'll remove this lines.

+}
+
+void SoftwareImageDecodeCache::OnPurgeMemory() {
+  base::AutoLock lock(lock_);
+  ReduceCacheUsageUntilWithinLimit(0);
 }
 
 }  // namespace cc