cc: Add more traces to checker imaging / image hijack code paths.

cc/tiles/checker_image_tracker.cc

 // Copyright 2017 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/checker_image_tracker.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "base/trace_event/trace_event.h"
 
@@ skipping 22 matching lines @@
 CheckerImageTracker::~CheckerImageTracker() {
   // Unlock all images pending decode requests.
   for (auto it : image_id_to_decode_request_id_)
     image_controller_->UnlockImageDecode(it.second);
 }
 
 void CheckerImageTracker::FilterImagesForCheckeringForTile(
     std::vector<DrawImage>* images,
     ImageIdFlatSet* checkered_images,
     WhichTree tree) {
+  TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
+               "CheckerImageTracker::FilterImagesForCheckeringForTile", "tree",
+               tree);
   DCHECK(checkered_images->empty());
 
   base::EraseIf(*images,
                 [this, tree, &checkered_images](const DrawImage& draw_image) {
                   const sk_sp<const SkImage>& image = draw_image.image();
                   DCHECK(image->isLazyGenerated());
                   if (ShouldCheckerImage(image, tree)) {
                     ScheduleImageDecodeIfNecessary(image);
                     checkered_images->insert(image->uniqueID());
                     return true;
                   }
                   return false;
                 });
 }
 
 const ImageIdFlatSet& CheckerImageTracker::TakeImagesToInvalidateOnSyncTree() {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
+               "CheckerImageTracker::TakeImagesToInvalidateOnSyncTree");
   DCHECK_EQ(invalidated_images_on_current_sync_tree_.size(), 0u)
       << "Sync tree can not be invalidated more than once";
 
   invalidated_images_on_current_sync_tree_.swap(images_pending_invalidation_);
   images_pending_invalidation_.clear();
   return invalidated_images_on_current_sync_tree_;
 }
 
 void CheckerImageTracker::DidActivateSyncTree() {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
+               "CheckerImageTracker::DidActivateSyncTree");
   for (auto image_id : invalidated_images_on_current_sync_tree_) {
     auto it = image_id_to_decode_request_id_.find(image_id);
     image_controller_->UnlockImageDecode(it->second);
     image_id_to_decode_request_id_.erase(it);
   }
 
   invalidated_images_on_current_sync_tree_.clear();
 }
 
 void CheckerImageTracker::DidFinishImageDecode(
     ImageId image_id,
     ImageController::ImageDecodeRequestId request_id,
     ImageController::ImageDecodeResult result) {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
+               "CheckerImageTracker::DidFinishImageDecode");
   TRACE_EVENT_ASYNC_END0("cc", "CheckerImageTracker::DeferImageDecode",
                          image_id);
 
   DCHECK_NE(result, ImageController::ImageDecodeResult::DECODE_NOT_REQUIRED);
   DCHECK_NE(pending_image_decodes_.count(image_id), 0u);
   pending_image_decodes_.erase(image_id);
 
   images_decoded_once_.insert(image_id);
   images_pending_invalidation_.insert(image_id);
   client_->NeedsInvalidationForCheckerImagedTiles();
@@ skipping 32 matching lines @@
   if (images_decoded_once_.find(image->uniqueID()) !=
       images_decoded_once_.end()) {
     return false;
   }
 
   return SafeSizeOfImage(image.get()) >= kMinImageSizeToCheckerBytes;
 }
 
 void CheckerImageTracker::ScheduleImageDecodeIfNecessary(
     const sk_sp<const SkImage>& image) {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
+               "CheckerImageTracker::ScheduleImageDecodeIfNecessary");
   ImageId image_id = image->uniqueID();
 
   // If the image has already been decoded, or a decode request is pending, we
   // don't need to schedule another decode.
   if (images_decoded_once_.count(image_id) != 0 ||
       pending_image_decodes_.count(image_id) != 0) {
     return;
   }
 
   TRACE_EVENT_ASYNC_BEGIN0("cc", "CheckerImageTracker::DeferImageDecode",
                            image_id);
   DCHECK_EQ(image_id_to_decode_request_id_.count(image_id), 0U);
 
   image_id_to_decode_request_id_[image_id] =
       image_controller_->QueueImageDecode(
           image, base::Bind(&CheckerImageTracker::DidFinishImageDecode,
                             weak_factory_.GetWeakPtr(), image_id));
   pending_image_decodes_.insert(image_id);
 }
 
 }  // namespace cc