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;
+static const int kMaxCacheItems = 2000;
+static const int kMaxCacheItemsThrottled = 100;
 
 // 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) {
   // 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).
@@ skipping 559 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_ / 2;
+  } else {
+    DCHECK_EQ(base::MemoryState::SUSPENDED, memory_state_);
+    bytes_limit = 0;
+  }
+
   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 = kMaxCacheItems;
+  } else if (memory_state_ == base::MemoryState::THROTTLED) {
+    items_limit = kMaxCacheItemsThrottled;
+  } else {
+    DCHECK_EQ(base::MemoryState::SUSPENDED, memory_state_);
+    items_limit = 0;
+  }
+
+  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