Implement OnMemoryStateChange for Various CC Classes

cc/tiles/gpu_image_decode_controller.cc

 // Copyright 2016 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/gpu_image_decode_controller.h"
 
 #include <inttypes.h>
 
 #include "base/debug/alias.h"
 #include "base/memory/discardable_memory_allocator.h"
@@ skipping 17 matching lines @@
 #include "third_party/skia/include/core/SkRefCnt.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/GrTexture.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gl/trace_util.h"
 
 namespace cc {
 namespace {
 
-static const int kMaxDiscardableItems = 2000;
+// The number or entries to keep in the cache, depending on the memory state of
+// the system. This limit can be breached by in-use cache items, which cannot
+// be deleted.
+static const int kNormalMaxItemsInCache = 2000;
+static const int kThrottledMaxItemsInCache = 100;
+static const int kSuspendedMaxItemsInCache = 0;
+
+// The factor by which to reduce the GPU memory size of the cache when in the
+// THROTTLED memory state.
+static const int kThrottledCacheSizeReductionFactor = 2;
+
+// The maximum size in bytes of GPU memory in the cache while SUSPENDED or not
+// visible. This limit can be breached by in-use cache items, which cannot be
+// deleted.
+static const int kSuspendedOrInvisibleMaxGpuImageBytes = 0;
 
 // Returns true if an image would not be drawn and should therefore be
 // skipped rather than decoded.
 bool SkipImage(const DrawImage& draw_image) {
   if (!SkIRect::Intersects(draw_image.src_rect(), draw_image.image()->bounds()))
     return true;
   if (std::abs(draw_image.scale().width()) <
           std::numeric_limits<float>::epsilon() ||
       std::abs(draw_image.scale().height()) <
           std::numeric_limits<float>::epsilon()) {
@@ skipping 271 matching lines @@
   // be freed with the GL context lock held.
   DCHECK(!upload.image());
 }
 
 GpuImageDecodeController::GpuImageDecodeController(ContextProvider* context,
                                                    ResourceFormat decode_format,
                                                    size_t max_gpu_image_bytes)
     : format_(decode_format),
       context_(context),
       persistent_cache_(PersistentCache::NO_AUTO_EVICT),
-      cached_items_limit_(kMaxDiscardableItems),
-      cached_bytes_limit_(max_gpu_image_bytes),
-      bytes_used_(0),
-      max_gpu_image_bytes_(max_gpu_image_bytes) {
+      normal_max_gpu_image_bytes_(max_gpu_image_bytes) {
   // Acquire the context_lock so that we can safely retrieve the
   // GrContextThreadSafeProxy. This proxy can then be used with no lock held.
   {
     ContextProvider::ScopedContextLock context_lock(context_);
     context_threadsafe_proxy_ = sk_sp<GrContextThreadSafeProxy>(
         context->GrContext()->threadSafeProxy());
   }
 
   // In certain cases, ThreadTaskRunnerHandle isn't set (Android Webview).
   // Don't register a dump provider in these cases.
@@ skipping 171 matching lines @@
 void GpuImageDecodeController::SetShouldAggressivelyFreeResources(
     bool aggressively_free_resources) {
   TRACE_EVENT1("disabled-by-default-cc.debug",
                "GpuImageDecodeController::SetShouldAggressivelyFreeResources",
                "agressive_free_resources", aggressively_free_resources);
   if (aggressively_free_resources) {
     ContextProvider::ScopedContextLock context_lock(context_);
     base::AutoLock lock(lock_);
     // We want to keep as little in our cache as possible. Set our memory limit
     // to zero and EnsureCapacity to clean up memory.
-    cached_bytes_limit_ = 0;
+    cached_bytes_limit_ = kSuspendedOrInvisibleMaxGpuImageBytes;
     EnsureCapacity(0);
 
     // We are holding the context lock, so finish cleaning up deleted images
     // now.
     DeletePendingImages();
   } else {
     base::AutoLock lock(lock_);
-    cached_bytes_limit_ = max_gpu_image_bytes_;
+    cached_bytes_limit_ = normal_max_gpu_image_bytes_;
   }
 }
 
 bool GpuImageDecodeController::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   TRACE_EVENT0("disabled-by-default-cc.debug",
                "GpuImageDecodeController::OnMemoryDump");
   for (const auto& image_pair : persistent_cache_) {
     const ImageData* image_data = image_pair.second.get();
@@ skipping 358 matching lines @@
   }
 
   // Preferred count is only used as a guideline when triming the cache. Allow
   // new elements to be added as long as we are below our size limit.
   return CanFitSize(required_size);
 }
 
 bool GpuImageDecodeController::CanFitSize(size_t size) const {
   lock_.AssertAcquired();
 
+  size_t bytes_limit;
+  if (memory_state_ == base::MemoryState::NORMAL) {
+    bytes_limit = cached_bytes_limit_;
+  } else if (memory_state_ == base::MemoryState::THROTTLED) {
+    bytes_limit = cached_bytes_limit_ / kThrottledCacheSizeReductionFactor;
+  } else {
+    DCHECK_EQ(base::MemoryState::SUSPENDED, memory_state_);
+    bytes_limit = kSuspendedOrInvisibleMaxGpuImageBytes;
+  }
+
   base::CheckedNumeric<uint32_t> new_size(bytes_used_);
   new_size += size;
-  return new_size.IsValid() && new_size.ValueOrDie() <= cached_bytes_limit_;
+  return new_size.IsValid() && new_size.ValueOrDie() <= bytes_limit;
 }
 
 bool GpuImageDecodeController::ExceedsPreferredCount() const {
   lock_.AssertAcquired();
 
-  return persistent_cache_.size() > cached_items_limit_;
+  size_t items_limit;
+  if (memory_state_ == base::MemoryState::NORMAL) {
+    items_limit = kNormalMaxItemsInCache;
+  } else if (memory_state_ == base::MemoryState::THROTTLED) {
+    items_limit = kThrottledMaxItemsInCache;
+  } else {
+    DCHECK_EQ(base::MemoryState::SUSPENDED, memory_state_);
+    items_limit = kSuspendedMaxItemsInCache;
+  }
+
+  return persistent_cache_.size() > items_limit;
 }
 
 void GpuImageDecodeController::DecodeImageIfNecessary(
     const DrawImage& draw_image,
     ImageData* image_data) {
   lock_.AssertAcquired();
 
   DCHECK_GT(image_data->decode.ref_count, 0u);
 
   if (image_data->decode.decode_failure) {
@@ skipping 239 matching lines @@
   base::AutoLock lock(lock_);
   auto found = persistent_cache_.Peek(image.image()->uniqueID());
   DCHECK(found != persistent_cache_.end());
   ImageData* image_data = found->second.get();
   return image_data->decode.is_locked();
 }
 
 void GpuImageDecodeController::OnMemoryStateChange(base::MemoryState state) {
   switch (state) {
     case base::MemoryState::NORMAL:
-      // TODO(tasak): go back to normal state.
+      memory_state_ = state;
       break;
     case base::MemoryState::THROTTLED:
-      // TODO(tasak): make the limits of this component's caches smaller to
-      // save memory usage.
+    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::SUSPENDED:
-      // TODO(tasak): free this component's caches as much as possible before
-      // suspending renderer.
-      break;
+    }
     case base::MemoryState::UNKNOWN:
       // NOT_REACHED.
       break;
   }
 }
 
 }  // namespace cc