cc: Remove some spammy traces from GpuImageDecodeController

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 727 matching lines @@
                 .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 119 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 154 matching lines @@
   } 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_|.
@@ skipping 24 matching lines @@
 
   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 33 matching lines @@
       // TODO(tasak): free this component's caches as much as possible before
       // suspending renderer.
       break;
     case base::MemoryState::UNKNOWN:
       // NOT_REACHED.
       break;
   }
 }
 
 }  // namespace cc