cc/images: Add more disabled-by-default traces to GPU image controller.

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/memory/discardable_memory_allocator.h"
 #include "base/memory/ptr_util.h"
@@ skipping 346 matching lines @@
 
   // It is safe to unregister, even if we didn't register in the constructor.
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
 }
 
 bool GpuImageDecodeController::GetTaskForImageAndRef(
     const DrawImage& draw_image,
     const TracingInfo& tracing_info,
     scoped_refptr<TileTask>* task) {
+  TRACE_EVENT0("disabled-by-default-cc.debug",
+               "GpuImageDecodeController::GetTaskForImageAndRef");
   if (SkipImage(draw_image)) {
     *task = nullptr;
     return false;
   }
 
   base::AutoLock lock(lock_);
   const auto image_id = draw_image.image()->uniqueID();
   ImageData* image_data = GetImageDataForDrawImage(draw_image);
   scoped_refptr<ImageData> new_data;
   if (!image_data) {
@@ skipping 40 matching lines @@
       tracing_info));
   image_data->upload.task = *task;
 
   // Ref the image again - this ref is owned by the caller, and it is their
   // responsibility to release it by calling UnrefImage.
   RefImage(draw_image);
   return true;
 }
 
 void GpuImageDecodeController::UnrefImage(const DrawImage& draw_image) {
+  TRACE_EVENT0("disabled-by-default-cc.debug",
+               "GpuImageDecodeController::UnrefImage");
   base::AutoLock lock(lock_);
   UnrefImageInternal(draw_image);
 }
 
 DecodedDrawImage GpuImageDecodeController::GetDecodedImageForDraw(
     const DrawImage& draw_image) {
   TRACE_EVENT0("cc", "GpuImageDecodeController::GetDecodedImageForDraw");
 
   // We are being called during raster. The context lock must already be
   // acquired by the caller.
@@ skipping 56 matching lines @@
   base::AutoLock lock(lock_);
   UnrefImageInternal(draw_image);
 
   // We are mid-draw and holding the context lock, ensure we clean up any
   // textures (especially at-raster), which may have just been marked for
   // deletion by UnrefImage.
   DeletePendingImages();
 }
 
 void GpuImageDecodeController::ReduceCacheUsage() {
+  TRACE_EVENT0("disabled-by-default-cc.debug",
+               "GpuImageDecodeController::ReduceCacheUsage");
   base::AutoLock lock(lock_);
   EnsureCapacity(0);
 }
 
 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;
     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_;
   }
 }
 
 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();
     const uint32_t image_id = image_pair.first;
 
     // If we have discardable decoded data, dump this here.
     if (image_data->decode.data()) {
       std::string discardable_dump_name = base::StringPrintf(
           "cc/image_memory/controller_0x%" PRIXPTR "/discardable/image_%d",
           reinterpret_cast<uintptr_t>(this), image_id);
       base::trace_event::MemoryAllocatorDump* dump =
@@ skipping 38 matching lines @@
       const int kImportance = 3;
       pmd->CreateSharedGlobalAllocatorDump(guid);
       pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
     }
   }
 
   return true;
 }
 
 void GpuImageDecodeController::DecodeImage(const DrawImage& draw_image) {
+  TRACE_EVENT0("disabled-by-default-cc.debug",
+               "GpuImageDecodeController::DecodeImage");
   base::AutoLock lock(lock_);
   ImageData* image_data = GetImageDataForDrawImage(draw_image);
   DCHECK(image_data);
   DCHECK(!image_data->is_at_raster);
   DecodeImageIfNecessary(draw_image, image_data);
 }
 
 void GpuImageDecodeController::UploadImage(const DrawImage& draw_image) {
+  TRACE_EVENT0("disabled-by-default-cc.debug",
+               "GpuImageDecodeController::UploadImage");
   ContextProvider::ScopedContextLock context_lock(context_);
   base::AutoLock lock(lock_);
   ImageData* image_data = GetImageDataForDrawImage(draw_image);
   DCHECK(image_data);
   DCHECK(!image_data->is_at_raster);
   UploadImageIfNecessary(draw_image, image_data);
 }
 
 void GpuImageDecodeController::OnImageDecodeTaskCompleted(
     const DrawImage& draw_image) {
+  TRACE_EVENT0("disabled-by-default-cc.debug",
+               "GpuImageDecodeController::OnImageDecodeTaskCompleted");
   base::AutoLock lock(lock_);
   // Decode task is complete, remove our reference to it.
   ImageData* image_data = GetImageDataForDrawImage(draw_image);
   DCHECK(image_data);
   DCHECK(image_data->decode.task);
   image_data->decode.task = nullptr;
 
   // While the decode task is active, we keep a ref on the decoded data.
   // Release that ref now.
   UnrefImageDecode(draw_image);
 }
 
 void GpuImageDecodeController::OnImageUploadTaskCompleted(
     const DrawImage& draw_image) {
+  TRACE_EVENT0("disabled-by-default-cc.debug",
+               "GpuImageDecodeController::OnImageUploadTaskCompleted");
   base::AutoLock lock(lock_);
   // Upload task is complete, remove our reference to it.
   ImageData* image_data = GetImageDataForDrawImage(draw_image);
   DCHECK(image_data);
   DCHECK(image_data->upload.task);
   image_data->upload.task = nullptr;
 
   // While the upload task is active, we keep a ref on both the image it will be
   // populating, as well as the decode it needs to populate it. Release these
   // refs now.
   UnrefImageDecode(draw_image);
   UnrefImageInternal(draw_image);
 }
 
 // Checks if an existing image decode exists. If not, returns a task to produce
 // the requested decode.
 scoped_refptr<TileTask> GpuImageDecodeController::GetImageDecodeTaskAndRef(
     const DrawImage& draw_image,
     const TracingInfo& tracing_info) {
+  TRACE_EVENT0("disabled-by-default-cc.debug",
+               "GpuImageDecodeController::GetImageDecodeTaskAndRef");
   lock_.AssertAcquired();
 
   // This ref is kept alive while an upload task may need this decode. We
   // release this ref in UploadTaskCompleted.
   RefImageDecode(draw_image);
 
   ImageData* image_data = GetImageDataForDrawImage(draw_image);
   DCHECK(image_data);
   if (image_data->decode.is_locked()) {
     // We should never be creating a decode task for an at raster image.
     DCHECK(!image_data->is_at_raster);
     // We should never be creating a decode for an already-uploaded image.
     DCHECK(!image_data->upload.image());
     return nullptr;
   }
 
   // We didn't have an existing locked image, create a task to lock or decode.
   scoped_refptr<TileTask>& existing_task = image_data->decode.task;
   if (!existing_task) {
     // Ref image decode and create a decode task. This ref will be released in
     // DecodeTaskCompleted.
     RefImageDecode(draw_image);
     existing_task = make_scoped_refptr(
         new ImageDecodeTaskImpl(this, draw_image, tracing_info));
   }
   return existing_task;
 }
 
 void GpuImageDecodeController::RefImageDecode(const DrawImage& draw_image) {
+  TRACE_EVENT0("disabled-by-default-cc.debug",
+               "GpuImageDecodeController::RefImageDecode");
   lock_.AssertAcquired();
   auto found = in_use_cache_.find(GenerateInUseCacheKey(draw_image));
   DCHECK(found != in_use_cache_.end());
   ++found->second.ref_count;
   ++found->second.image_data->decode.ref_count;
   OwnershipChanged(found->second.image_data.get());
 }
 
 void GpuImageDecodeController::UnrefImageDecode(const DrawImage& draw_image) {
+  TRACE_EVENT0("disabled-by-default-cc.debug",
+               "GpuImageDecodeController::UnrefImageDecode");
   lock_.AssertAcquired();
   auto found = in_use_cache_.find(GenerateInUseCacheKey(draw_image));
   DCHECK(found != in_use_cache_.end());
   DCHECK_GT(found->second.image_data->decode.ref_count, 0u);
   DCHECK_GT(found->second.ref_count, 0u);
   --found->second.ref_count;
   --found->second.image_data->decode.ref_count;
   OwnershipChanged(found->second.image_data.get());
   if (found->second.ref_count == 0u) {
     in_use_cache_.erase(found);
   }
 }
 
 void GpuImageDecodeController::RefImage(const DrawImage& draw_image) {
+  TRACE_EVENT0("disabled-by-default-cc.debug",
+               "GpuImageDecodeController::RefImage");
   lock_.AssertAcquired();
   InUseCacheKey key = GenerateInUseCacheKey(draw_image);
   auto found = in_use_cache_.find(key);
 
   // If no secondary cache entry was found for the given |draw_image|, then
   // the draw_image only exists in the |persistent_cache_|. Create an in-use
   // cache entry now.
   if (found == in_use_cache_.end()) {
     auto found_image = persistent_cache_.Peek(draw_image.image()->uniqueID());
     DCHECK(found_image != persistent_cache_.end());
     DCHECK(found_image->second->upload_scale_mip_level <=
            CalculateUploadScaleMipLevel(draw_image));
     found = in_use_cache_
                 .insert(InUseCache::value_type(
                     key, InUseCacheEntry(found_image->second)))
                 .first;
   }
 
   DCHECK(found != in_use_cache_.end());
   ++found->second.ref_count;
   ++found->second.image_data->upload.ref_count;
   OwnershipChanged(found->second.image_data.get());
 }
 
 void GpuImageDecodeController::UnrefImageInternal(const DrawImage& draw_image) {
+  TRACE_EVENT0("disabled-by-default-cc.debug",
+               "GpuImageDecodeController::UnrefImageInternal");
   lock_.AssertAcquired();
   auto found = in_use_cache_.find(GenerateInUseCacheKey(draw_image));
   DCHECK(found != in_use_cache_.end());
   DCHECK_GT(found->second.image_data->upload.ref_count, 0u);
   DCHECK_GT(found->second.ref_count, 0u);
   --found->second.ref_count;
   --found->second.image_data->upload.ref_count;
   OwnershipChanged(found->second.image_data.get());
   if (found->second.ref_count == 0u) {
     in_use_cache_.erase(found);
   }
 }
 
 // Called any time an image or decode ref count changes. Takes care of any
 // necessary memory budget book-keeping and cleanup.
 void GpuImageDecodeController::OwnershipChanged(ImageData* image_data) {
+  TRACE_EVENT0("disabled-by-default-cc.debug",
+               "GpuImageDecodeController::OwnershipChanged");
   lock_.AssertAcquired();
 
   bool has_any_refs =
       image_data->upload.ref_count > 0 || image_data->decode.ref_count > 0;
 
   // Don't keep around orphaned images.
   if (image_data->is_orphaned && !has_any_refs) {
     images_pending_deletion_.push_back(std::move(image_data->upload.image()));
     image_data->upload.SetImage(nullptr);
   }
@@ skipping 66 matching lines @@
   } else {
     DCHECK(!image_data->upload.budgeted || image_data->upload.ref_count > 0);
   }
 #endif
 }
 
 // Ensures that we can fit a new image of size |required_size| in our cache. In
 // doing so, this function will free unreferenced image data as necessary to
 // create rooom.
 bool GpuImageDecodeController::EnsureCapacity(size_t required_size) {
+  TRACE_EVENT0("disabled-by-default-cc.debug",
+               "GpuImageDecodeController::EnsureCapacity");
   lock_.AssertAcquired();
 
   if (CanFitSize(required_size) && !ExceedsPreferredCount())
     return true;
 
   // While we are over memory or preferred item capacity, we iterate through
   // our set of cached image data in LRU order. For each image, we can do two
   // things: 1) We can free the uploaded image, reducing the memory usage of
   // the cache and 2) we can remove the entry entirely, reducing the count of
   // elements in the cache.
@@ skipping 31 matching lines @@
     if (CanFitSize(required_size) && !ExceedsPreferredCount())
       return true;
   }
 
   // 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 {
+  TRACE_EVENT0("disabled-by-default-cc.debug",
+               "GpuImageDecodeController::CanFitSize");
   lock_.AssertAcquired();
 
   base::CheckedNumeric<uint32_t> new_size(bytes_used_);
   new_size += size;
   return new_size.IsValid() && new_size.ValueOrDie() <= cached_bytes_limit_;
 }
 
 bool GpuImageDecodeController::ExceedsPreferredCount() const {
+  TRACE_EVENT0("disabled-by-default-cc.debug",
+               "GpuImageDecodeController::ExceedsPreferredCount");
   lock_.AssertAcquired();
 
   return persistent_cache_.size() > cached_items_limit_;
 }
 
 void GpuImageDecodeController::DecodeImageIfNecessary(
     const DrawImage& draw_image,
     ImageData* image_data) {
   lock_.AssertAcquired();
 
@@ skipping 125 matching lines @@
   DCHECK(uploaded_image);
 
   // At-raster may have decoded this while we were unlocked. If so, ignore our
   // result.
   if (!image_data->upload.image())
     image_data->upload.SetImage(std::move(uploaded_image));
 }
 
 scoped_refptr<GpuImageDecodeController::ImageData>
 GpuImageDecodeController::CreateImageData(const DrawImage& draw_image) {
+  TRACE_EVENT0("disabled-by-default-cc.debug",
+               "GpuImageDecodeController::CreateImageData");
   lock_.AssertAcquired();
 
   DecodedDataMode mode;
   int upload_scale_mip_level = CalculateUploadScaleMipLevel(draw_image);
   auto params = SkImage::DeferredTextureImageUsageParams(
       draw_image.matrix(), CalculateUploadScaleFilterQuality(draw_image),
       upload_scale_mip_level);
   size_t data_size = draw_image.image()->getDeferredTextureImageData(
       *context_threadsafe_proxy_.get(), &params, 1, nullptr);
 
   if (data_size == 0) {
     // Can't upload image, too large or other failure. Try to use SW fallback.
     SkImageInfo image_info =
         CreateImageInfoForDrawImage(draw_image, upload_scale_mip_level);
     data_size = image_info.getSafeSize(image_info.minRowBytes());
     mode = DecodedDataMode::CPU;
   } else {
     mode = DecodedDataMode::GPU;
   }
 
   return make_scoped_refptr(
       new ImageData(mode, data_size, upload_scale_mip_level,
                     CalculateUploadScaleFilterQuality(draw_image)));
 }
 
 void GpuImageDecodeController::DeletePendingImages() {
+  TRACE_EVENT0("disabled-by-default-cc.debug",
+               "GpuImageDecodeController::DeletePendingImages");
   context_->GetLock()->AssertAcquired();
   lock_.AssertAcquired();
   images_pending_deletion_.clear();
 }
 
 SkImageInfo GpuImageDecodeController::CreateImageInfoForDrawImage(
     const DrawImage& draw_image,
     int upload_scale_mip_level) const {
+  TRACE_EVENT0("disabled-by-default-cc.debug",
+               "GpuImageDecodeController::CreateImageInfoForDrawImage");
   gfx::Size mip_size =
       CalculateSizeForMipLevel(draw_image, upload_scale_mip_level);
   return SkImageInfo::Make(mip_size.width(), mip_size.height(),
                            ResourceFormatToClosestSkColorType(format_),
                            kPremul_SkAlphaType);
 }
 
 // Tries to find an ImageData that can be used to draw the provided
 // |draw_image|. First looks for an exact entry in our |in_use_cache_|. If one
 // cannot be found, it looks for a compatible entry in our |persistent_cache_|.
 GpuImageDecodeController::ImageData*
 GpuImageDecodeController::GetImageDataForDrawImage(
     const DrawImage& draw_image) {
+  TRACE_EVENT0("disabled-by-default-cc.debug",
+               "GpuImageDecodeController::GetImageDataForDrawImage");
   lock_.AssertAcquired();
   auto found_in_use = in_use_cache_.find(GenerateInUseCacheKey(draw_image));
   if (found_in_use != in_use_cache_.end())
     return found_in_use->second.image_data.get();
 
   auto found_persistent = persistent_cache_.Get(draw_image.image()->uniqueID());
   if (found_persistent != persistent_cache_.end()) {
     ImageData* image_data = found_persistent->second.get();
     if (IsCompatible(image_data, draw_image)) {
       return image_data;
     } else {
       found_persistent->second->is_orphaned = true;
       // Call OwnershipChanged before erasing the orphaned task from the
       // persistent cache. This ensures that if the orphaned task has 0
       // references, it is cleaned up safely before it is deleted.
       OwnershipChanged(image_data);
       persistent_cache_.Erase(found_persistent);
     }
   }
 
   return nullptr;
 }
 
 // Determines if we can draw the provided |draw_image| using the provided
 // |image_data|. This is true if the |image_data| is not scaled, or if it
 // is scaled at an equal or larger scale and equal or larger quality to
 // the provided |draw_image|.
 bool GpuImageDecodeController::IsCompatible(const ImageData* image_data,
                                             const DrawImage& draw_image) const {
+  TRACE_EVENT0("disabled-by-default-cc.debug",
+               "GpuImageDecodeController::IsCompatible");
   bool is_scaled = image_data->upload_scale_mip_level != 0;
   bool scale_is_compatible = CalculateUploadScaleMipLevel(draw_image) >=
                              image_data->upload_scale_mip_level;
   bool quality_is_compatible = CalculateUploadScaleFilterQuality(draw_image) <=
                                image_data->upload_scale_filter_quality;
   return !is_scaled || (scale_is_compatible && quality_is_compatible);
 }
 
 size_t GpuImageDecodeController::GetDrawImageSizeForTesting(
     const DrawImage& image) {
@@ skipping 14 matching lines @@
 bool GpuImageDecodeController::DiscardableIsLockedForTesting(
     const DrawImage& image) {
   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();
 }
 
 }  // namespace cc