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

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 "base/memory/discardable_memory_allocator.h"
 #include "base/memory/ptr_util.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/output/context_provider.h"
 #include "cc/raster/tile_task.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu_image_decode_controller.h"
 #include "skia/ext/texture_handle.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #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 kMaxGpuImageBytes = 1024 * 1024 * 96;
 static const int kMaxDiscardableItems = 2000;
 
 // 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()) <
@@ skipping 105 matching lines @@
 
 GpuImageDecodeController::UploadedImageData::~UploadedImageData() = default;
 
 GpuImageDecodeController::ImageData::ImageData(DecodedDataMode mode,
                                                size_t size)
     : mode(mode), size(size), is_at_raster(false) {}
 
 GpuImageDecodeController::ImageData::~ImageData() = default;
 
 GpuImageDecodeController::GpuImageDecodeController(ContextProvider* context,
-                                                   ResourceFormat decode_format)
+                                                   ResourceFormat decode_format,
+                                                   size_t max_gpu_image_bytes)
     : format_(decode_format),
       context_(context),
       image_data_(ImageDataMRUCache::NO_AUTO_EVICT),
       cached_items_limit_(kMaxDiscardableItems),
-      cached_bytes_limit_(kMaxGpuImageBytes),
-      bytes_used_(0) {
+      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).
   // Don't register a dump provider in these cases.
@@ skipping 183 matching lines @@
     // 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;
     EnsureCapacity(0);
 
     // We are holding the context lock, so finish cleaning up deleted images
     // now.
     DeletePendingImages();
   } else {
     base::AutoLock lock(lock_);
-    cached_bytes_limit_ = kMaxGpuImageBytes;
+    cached_bytes_limit_ = max_gpu_image_bytes_;
   }
 }
 
 bool GpuImageDecodeController::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   for (const auto& image_pair : image_data_) {
     const ImageData* image_data = image_pair.second.get();
     const uint32_t image_id = image_pair.first;
 
@@ skipping 480 matching lines @@
 bool GpuImageDecodeController::DiscardableIsLockedForTesting(
     const DrawImage& image) {
   base::AutoLock lock(lock_);
   auto found = image_data_.Peek(image.image()->uniqueID());
   DCHECK(found != image_data_.end());
   ImageData* image_data = found->second.get();
   return image_data->decode.is_locked;
 }
 
 }  // namespace cc