cc: Optimize decode scheduling for checker-images.

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/trace_event/trace_event.h"
 
 namespace cc {
@@ skipping 47 matching lines @@
 
 const ImageIdFlatSet& 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::ResetImageDecodeQueue() {
+  if (image_decode_request_queue_.empty())
+    return;
+  DCHECK(enable_checker_imaging_);
+
+  sk_sp<const SkImage> pending_image_decode =
+      image_decode_request_queue_.front();
+  image_decode_request_queue_.clear();
+  pending_image_decodes_.clear();
+
+  pending_image_decodes_.insert(pending_image_decode->uniqueID());

[vmpstr, 2017/03/07 19:25:08]

I guess my confusion comes from the implementation of this function:

1. Why are we clearing pending_image_decodes_? Aren't those already in the image
controller's queue?
2. Is the work you're doing with image_decode_request_queue_ equivalent to
erase(begin() + 1, end())? If so, that's what it should say instead.

[Khushal, 2017/03/13 20:35:08]

Removed the function. I think instead of having a reset and then re-building the
queue internally in FilterImagesForCheckering, its much cleaner if the
TileManager just builds the queue and sets it.

+  image_decode_request_queue_.push_back(std::move(pending_image_decode));
+}
+
 void 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_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);
+  DCHECK_EQ(image_id, image_decode_request_queue_.front()->uniqueID());
+
   pending_image_decodes_.erase(image_id);
+  image_decode_request_queue_.erase(image_decode_request_queue_.begin());

[vmpstr, 2017/03/07 19:25:08]

"pop_front"? Unless the type doesn't have it

[Khushal, 2017/03/13 20:35:08]

Not needed anymore.

+  ScheduleNextImageDecode();
 
   images_decoded_once_.insert(image_id);
   images_pending_invalidation_.insert(image_id);
   client_->NeedsInvalidationForCheckerImagedTiles();
 }
 
 bool CheckerImageTracker::ShouldCheckerImage(const sk_sp<const SkImage>& image,
                                              WhichTree tree) const {
   TRACE_EVENT1("cc", "CheckerImageTracker::ShouldCheckerImage", "image_id",
                image->uniqueID());
@@ skipping 39 matching lines @@
   // 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);
 
+  pending_image_decodes_.insert(image_id);
+  image_decode_request_queue_.push_back(image);
+  if (image_decode_request_queue_.size() == 1u)
+    ScheduleNextImageDecode();
+}
+
+void CheckerImageTracker::ScheduleNextImageDecode() {
+  if (image_decode_request_queue_.empty())
+    return;
+
+  sk_sp<const SkImage>& image = image_decode_request_queue_.front();
+  ImageId image_id = image->uniqueID();
+  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