Move purging from OnMemoryState to OnPurgeMemory() in cc/

cc/tiles/gpu_image_decode_cache.cc

Index: cc/tiles/gpu_image_decode_cache.cc
diff --git a/cc/tiles/gpu_image_decode_cache.cc b/cc/tiles/gpu_image_decode_cache.cc
index 93cdd29158fe5a0c356f3f1782ef576a57e75254..1dcc40c471acd9fa494c86e0e73732d035fc2e35 100644
--- a/cc/tiles/gpu_image_decode_cache.cc
+++ b/cc/tiles/gpu_image_decode_cache.cc
@@ -6,6 +6,7 @@
 
 #include <inttypes.h>
 
+#include "base/auto_reset.h"
 #include "base/debug/alias.h"
 #include "base/memory/discardable_memory_allocator.h"
 #include "base/memory/memory_coordinator_client_registry.h"
@@ -1268,24 +1269,15 @@ bool GpuImageDecodeCache::IsInInUseCacheForTesting(
 }
 
 void GpuImageDecodeCache::OnMemoryStateChange(base::MemoryState state) {
-  switch (state) {
-    case base::MemoryState::NORMAL:
-      memory_state_ = state;
-      break;
-    case base::MemoryState::THROTTLED:
-    case base::MemoryState::SUSPENDED: {
-      memory_state_ = state;
-
-      // We've just changed our memory state to a (potentially) more
-      // restrictive one. Re-enforce cache limits.
-      base::AutoLock lock(lock_);
-      EnsureCapacity(0);
-      break;
-    }
-    case base::MemoryState::UNKNOWN:
-      // NOT_REACHED.
-      break;
-  }
+  memory_state_ = state;
+}
+
+void GpuImageDecodeCache::OnPurgeMemory() {
+  base::AutoLock lock(lock_);
+  // Temporary changes |memory_state_| to free up cache as much as possible.
+  base::AutoReset<base::MemoryState> reset(&memory_state_,
+                                           base::MemoryState::SUSPENDED);
+  EnsureCapacity(0);

[bashi, 2017/02/07 00:58:59]

It seems EnsureCapacity() changes its behavior based on |memory_state_|. Should
we change EnsureCapacity() instead of temporary changing |memory_state_|? Or
should we add a method that clears |perspstent_cache_|?

[ericrk, 2017/02/07 19:20:14]

Does the coordinator call OnMemoryStateChange(SUSPENDED) before or after calling
Purge? If before, it seems like this is unnecessary. If after, it seems possible
to race where we Purge, the cache allocates new memory, then we set to suspended
and that memory is never freed?

[bashi, 2017/02/09 00:46:18]

Thanks. I wasn't aware of the race. Current order is OnPurgeMemory() ->
OnMemoryStateChange(). I'll change the order.

That said our current plan is that OnPurgeMemory() should free up memory
regardless of memory state. We would call OnPurgeMemory() even in NORMAL state
to avoid the OS starting page swapping. Maybe I should modify EnsureCapacity()
to make it state independent but I'm not sure it's a right way. Probably revisit
later?

[ericrk, 2017/02/09 18:36:30]

I'm good re-visitng later - once we get to enabling THROTTLED, we'll need some
tweaks anyway.

 }
 
 }  // namespace cc