cc: Move more traces to be disabled-by-default around tile management.

cc/tiles/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/image_decode_controller.h"
 
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "base/memory/discardable_memory.h"
@@ skipping 90 matching lines @@
     uint64_t prepare_tiles_id,
     scoped_refptr<ImageDecodeTask>* task) {
   // If the image already exists or if we're going to create a task for it, then
   // we'll likely need to ref this image (the exception is if we're prerolling
   // the image only). That means the image is or will be in the cache. When the
   // ref goes to 0, it will be unpinned but will remain in the cache. If the
   // image does not fit into the budget, then we don't ref this image, since it
   // will be decoded at raster time which is when it will be temporarily put in
   // the cache.
   ImageKey key = ImageKey::FromDrawImage(image);
-  TRACE_EVENT1("cc", "ImageDecodeController::GetTaskForImageAndRef", "key",
+  TRACE_EVENT1("disabled-by-default-cc.debug",
+               "ImageDecodeController::GetTaskForImageAndRef", "key",
                key.ToString());
   // If we're not going to do a scale, we will just create a task to preroll the
   // image the first time we see it. This doesn't need to account for memory.
   // TODO(vmpstr): We can also lock the original sized image, in which case it
   // does require memory bookkeeping.
   if (!CanHandleImage(key, image)) {
     base::AutoLock lock(lock_);
     if (prerolled_images_.count(key.image_id()) == 0) {
       scoped_refptr<ImageDecodeTask>& existing_task = pending_image_tasks_[key];
       if (!existing_task) {
@@ skipping 52 matching lines @@
   // ref.
   RefImage(key);
   existing_task = make_scoped_refptr(
       new ImageDecodeTaskImpl(this, key, image, prepare_tiles_id));
   *task = existing_task;
   SanityCheckState(__LINE__, true);
   return true;
 }
 
 void ImageDecodeController::RefImage(const ImageKey& key) {
-  TRACE_EVENT1("cc", "ImageDecodeController::RefImage", "key", key.ToString());
+  TRACE_EVENT1("disabled-by-default-cc.debug",
+               "ImageDecodeController::RefImage", "key", key.ToString());
   lock_.AssertAcquired();
   int ref = ++decoded_images_ref_counts_[key];
   if (ref == 1) {
     DCHECK_GE(locked_images_budget_.AvailableMemoryBytes(), key.target_bytes());
     locked_images_budget_.AddUsage(key.target_bytes());
   }
 }
 
 void ImageDecodeController::UnrefImage(const DrawImage& image) {
   // When we unref the image, there are several situations we need to consider:
   // 1. The ref did not reach 0, which means we have to keep the image locked.
   // 2. The ref reached 0, we should unlock it.
   //   2a. The image isn't in the locked cache because we didn't get to decode
   //       it yet.
   //   2b. Unlock the image but keep it in list.
   const ImageKey& key = ImageKey::FromDrawImage(image);
   DCHECK(CanHandleImage(key, image));
-  TRACE_EVENT1("cc", "ImageDecodeController::UnrefImage", "key",
-               key.ToString());
+  TRACE_EVENT1("disabled-by-default-cc.debug",
+               "ImageDecodeController::UnrefImage", "key", key.ToString());
 
   base::AutoLock lock(lock_);
   auto ref_count_it = decoded_images_ref_counts_.find(key);
   DCHECK(ref_count_it != decoded_images_ref_counts_.end());
 
   --ref_count_it->second;
   if (ref_count_it->second == 0) {
     decoded_images_ref_counts_.erase(ref_count_it);
     locked_images_budget_.SubtractUsage(key.target_bytes());
 
@@ skipping 70 matching lines @@
     }
     decoded_images_.erase(image_it);
   }
   decoded_images_.push_back(AnnotatedDecodedImage(key, decoded_image));
   SanityCheckState(__LINE__, true);
 }
 
 scoped_refptr<ImageDecodeController::DecodedImage>
 ImageDecodeController::DecodeImageInternal(const ImageKey& key,
                                            const SkImage* image) {
-  TRACE_EVENT1("cc", "ImageDecodeController::DecodeImageInternal", "key",
+  TRACE_EVENT1("disabled-by-default-cc.debug",
+               "ImageDecodeController::DecodeImageInternal", "key",
                key.ToString());
 
   // Get the decoded image first (at the original scale).
   SkImageInfo decoded_info = SkImageInfo::MakeN32Premul(
       key.src_rect().width(), key.src_rect().height());
   scoped_ptr<uint8_t[]> decoded_pixels;
   {
     TRACE_EVENT0(
-        "cc",
+        "disabled-by-default-cc.debug",
         "ImageDecodeController::DecodeImageInternal - allocate decoded pixels");
     decoded_pixels.reset(
         new uint8_t[decoded_info.minRowBytes() * decoded_info.height()]);
   }
   {
-    TRACE_EVENT0("cc",
+    TRACE_EVENT0("disabled-by-default-cc.debug",
                  "ImageDecodeController::DecodeImageInternal - read pixels");
     bool result = image->readPixels(
         decoded_info, decoded_pixels.get(), decoded_info.minRowBytes(),
         key.src_rect().x(), key.src_rect().y(), SkImage::kAllow_CachingHint);
     DCHECK(result);
   }
 
   SkPixmap decoded_pixmap(decoded_info, decoded_pixels.get(),
                           decoded_info.minRowBytes());
 
   // Now scale the pixels into the destination size.
   SkImageInfo scaled_info = SkImageInfo::MakeN32Premul(
       key.target_size().width(), key.target_size().height());
   scoped_ptr<base::DiscardableMemory> scaled_pixels;
   {
     TRACE_EVENT0(
-        "cc",
+        "disabled-by-default-cc.debug",
         "ImageDecodeController::DecodeImageInternal - allocate scaled pixels");
     scaled_pixels = base::DiscardableMemoryAllocator::GetInstance()
                         ->AllocateLockedDiscardableMemory(
                             scaled_info.minRowBytes() * scaled_info.height());
   }
   SkPixmap scaled_pixmap(scaled_info, scaled_pixels->data(),
                          scaled_info.minRowBytes());
   // TODO(vmpstr): Start handling more than just high filter quality.
   DCHECK_EQ(kHigh_SkFilterQuality, key.filter_quality());
   {
-    TRACE_EVENT0("cc",
+    TRACE_EVENT0("disabled-by-default-cc.debug",
                  "ImageDecodeController::DecodeImageInternal - scale pixels");
     bool result =
         decoded_pixmap.scalePixels(scaled_pixmap, kHigh_SkFilterQuality);
     DCHECK(result);
   }
   return make_scoped_refptr(
       new DecodedImage(scaled_info, std::move(scaled_pixels),
                        SkSize::Make(-key.src_rect().x(), -key.src_rect().y())));
 }
 
 DecodedDrawImage ImageDecodeController::GetDecodedImageForDraw(
     const DrawImage& draw_image) {
   ImageKey key = ImageKey::FromDrawImage(draw_image);
-  TRACE_EVENT1("cc", "ImageDecodeController::GetDecodedImageAndRef", "key",
+  TRACE_EVENT1("disabled-by-default-cc.debug",
+               "ImageDecodeController::GetDecodedImageAndRef", "key",
                key.ToString());
   if (!CanHandleImage(key, draw_image))
     return DecodedDrawImage(draw_image.image(), draw_image.filter_quality());
 
   base::AutoLock lock(lock_);
   auto decoded_images_it = FindImage(&decoded_images_, key);
   // If we found the image and it's locked, then return it. If it's not locked,
   // erase it from the cache since it might be put into the at-raster cache.
   scoped_refptr<DecodedImage> decoded_image;
   if (decoded_images_it != decoded_images_.end()) {
@@ skipping 67 matching lines @@
   auto decoded_draw_image =
       DecodedDrawImage(decoded_image->image(), decoded_image->src_rect_offset(),
                        GetScaleAdjustment(key), kLow_SkFilterQuality);
   decoded_draw_image.set_at_raster_decode(true);
   return decoded_draw_image;
 }
 
 void ImageDecodeController::DrawWithImageFinished(
     const DrawImage& image,
     const DecodedDrawImage& decoded_image) {
-  TRACE_EVENT1("cc", "ImageDecodeController::DrawWithImageFinished", "key",
+  TRACE_EVENT1("disabled-by-default-cc.debug",
+               "ImageDecodeController::DrawWithImageFinished", "key",
                ImageKey::FromDrawImage(image).ToString());
   ImageKey key = ImageKey::FromDrawImage(image);
   if (!CanHandleImage(key, image))
     return;
 
   if (decoded_image.is_at_raster_decode())
     UnrefAtRasterImage(key);
   else
     UnrefImage(image);
   SanityCheckState(__LINE__, false);
 }
 
 void ImageDecodeController::RefAtRasterImage(const ImageKey& key) {
-  TRACE_EVENT1("cc", "ImageDecodeController::RefAtRasterImage", "key",
+  TRACE_EVENT1("disabled-by-default-cc.debug",
+               "ImageDecodeController::RefAtRasterImage", "key",
                key.ToString());
   DCHECK(FindImage(&at_raster_decoded_images_, key) !=
          at_raster_decoded_images_.end());
   ++at_raster_decoded_images_ref_counts_[key];
 }
 
 void ImageDecodeController::UnrefAtRasterImage(const ImageKey& key) {
-  TRACE_EVENT1("cc", "ImageDecodeController::UnrefAtRasterImage", "key",
+  TRACE_EVENT1("disabled-by-default-cc.debug",
+               "ImageDecodeController::UnrefAtRasterImage", "key",
                key.ToString());
   base::AutoLock lock(lock_);
 
   auto ref_it = at_raster_decoded_images_ref_counts_.find(key);
   DCHECK(ref_it != at_raster_decoded_images_ref_counts_.end());
   --ref_it->second;
   if (ref_it->second == 0) {
     at_raster_decoded_images_ref_counts_.erase(ref_it);
     auto at_raster_image_it = FindImage(&at_raster_decoded_images_, key);
     DCHECK(at_raster_image_it != at_raster_decoded_images_.end());
@@ skipping 257 matching lines @@
 
 void ImageDecodeController::MemoryBudget::ResetUsage() {
   current_usage_bytes_ = 0;
 }
 
 size_t ImageDecodeController::MemoryBudget::GetCurrentUsageSafe() const {
   return current_usage_bytes_.ValueOrDie();
 }
 
 }  // namespace cc