cc: Plumb gpu/sw image decode limits as layer tree settings.

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 <stdint.h>
 
 #include <algorithm>
 #include <functional>
 
 #include "base/format_macros.h"
 #include "base/macros.h"
 #include "base/memory/discardable_memory.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/raster/tile_task.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkPixmap.h"
 #include "ui/gfx/skia_util.h"
 
 namespace cc {
 namespace {
 
-// The amount of memory we can lock ahead of time (128MB). This limit is only
-// used to inform the caller of the amount of space available in the cache. The
-// caller can still request tasks which can cause this limit to be breached.
-const size_t kLockedMemoryLimitBytes = 128 * 1024 * 1024;
-
 // 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.
 const size_t kMaxItemsInCache = 1000;
 
 class AutoRemoveKeyFromTaskMap {
  public:
@@ skipping 133 matching lines @@
                             success);
     case TilePriority::EVENTUALLY:
       UMA_HISTOGRAM_BOOLEAN(
           "Renderer4.LockExistingCachedImage.Software.EVENTUALLY", success);
   }
 }
 
 }  // namespace
 
 SoftwareImageDecodeController::SoftwareImageDecodeController(
-    ResourceFormat format)
+    ResourceFormat format,
+    size_t locked_memory_limit_bytes)
     : decoded_images_(ImageMRUCache::NO_AUTO_EVICT),
       at_raster_decoded_images_(ImageMRUCache::NO_AUTO_EVICT),
-      locked_images_budget_(kLockedMemoryLimitBytes),
+      locked_images_budget_(locked_memory_limit_bytes),
       format_(format) {
   // In certain cases, ThreadTaskRunnerHandle isn't set (Android Webview).
   // Don't register a dump provider in these cases.
   if (base::ThreadTaskRunnerHandle::IsSet()) {
     base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
         this, "cc::SoftwareImageDecodeController",
         base::ThreadTaskRunnerHandle::Get());
   }
 }
 
-SoftwareImageDecodeController::SoftwareImageDecodeController()
-    : SoftwareImageDecodeController(RGBA_8888) {}
-
 SoftwareImageDecodeController::~SoftwareImageDecodeController() {
   DCHECK_EQ(0u, decoded_images_ref_counts_.size());
   DCHECK_EQ(0u, at_raster_decoded_images_ref_counts_.size());
 
   // It is safe to unregister, even if we didn't register in the constructor.
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
 }
 
 bool SoftwareImageDecodeController::GetTaskForImageAndRef(
@@ skipping 553 matching lines @@
 
 void SoftwareImageDecodeController::SanityCheckState(int line,
                                                      bool lock_acquired) {
 #if DCHECK_IS_ON()
   if (!lock_acquired) {
     base::AutoLock lock(lock_);
     SanityCheckState(line, true);
     return;
   }
 
-  MemoryBudget budget(kLockedMemoryLimitBytes);
+  MemoryBudget budget(locked_images_budget_.total_limit_bytes());
   for (const auto& image_pair : decoded_images_) {
     const auto& key = image_pair.first;
     const auto& image = image_pair.second;
 
     auto ref_it = decoded_images_ref_counts_.find(key);
     if (image->is_locked()) {
       budget.AddUsage(key.locked_bytes());
       DCHECK(ref_it != decoded_images_ref_counts_.end()) << line;
     } else {
       DCHECK(ref_it == decoded_images_ref_counts_.end() ||
@@ skipping 182 matching lines @@
 void SoftwareImageDecodeController::MemoryBudget::ResetUsage() {
   current_usage_bytes_ = 0;
 }
 
 size_t SoftwareImageDecodeController::MemoryBudget::GetCurrentUsageSafe()
     const {
   return current_usage_bytes_.ValueOrDie();
 }
 
 }  // namespace cc