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 17 matching lines @@
       client_(client),
       enable_checker_imaging_(enable_checker_imaging),
       weak_factory_(this) {}
 
 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) {
-  DCHECK(checkered_images->empty());
-
-  auto images_to_checker = std::remove_if(
-      images->begin(), images->end(),
-      [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;
-      });
-  images->erase(images_to_checker, images->end());
+void CheckerImageTracker::SetImageDecodeQueue(
+    ImageDecodeQueue image_decode_queue) {
+  image_decode_queue_ = std::move(image_decode_queue);
+  next_image_to_decode_ = 0;
+  ScheduleNextImageDecode();
 }
 
 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::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);
-  pending_image_decodes_.erase(image_id);
-
+  DCHECK_NE(ImageController::ImageDecodeResult::DECODE_NOT_REQUIRED, result);
+  DCHECK_EQ(outstanding_image_decode_->uniqueID(), image_id);
+  outstanding_image_decode_ = nullptr;
   images_decoded_once_.insert(image_id);
   images_pending_invalidation_.insert(image_id);
+
+  ScheduleNextImageDecode();
   client_->NeedsInvalidationForCheckerImagedTiles();
 }
 
 bool CheckerImageTracker::ShouldCheckerImage(const sk_sp<const SkImage>& image,
                                              WhichTree tree) const {
   TRACE_EVENT1("cc", "CheckerImageTracker::ShouldCheckerImage", "image_id",
                image->uniqueID());
 
   if (!enable_checker_imaging_)
     return false;
 
   // If the image was invalidated on the current sync tree and the tile is
   // for the active tree, continue checkering it on the active tree to ensure
   // the image update is atomic for the frame.
   if (invalidated_images_on_current_sync_tree_.count(image->uniqueID()) != 0 &&
       tree == WhichTree::ACTIVE_TREE) {
     return true;
   }
 
-  // If a decode request is pending for this image, continue checkering it.
-  if (pending_image_decodes_.find(image->uniqueID()) !=
-      pending_image_decodes_.end()) {
-    return true;
-  }
-
   // If the image is pending invalidation, continue checkering it. All tiles
   // for these images will be invalidated on the next pending tree.
   if (images_pending_invalidation_.find(image->uniqueID()) !=
       images_pending_invalidation_.end()) {
     return true;
   }
 
   // If the image has been decoded once before, don't checker it again.
   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) {
-  ImageId image_id = image->uniqueID();
+void CheckerImageTracker::ScheduleNextImageDecode() {
+  if (image_decode_queue_.empty())
+    return;
 
-  // 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) {
+  if (outstanding_image_decode_)

[vmpstr, 2017/03/17 18:32:13]

Leave a comment here explaining that if we have something scheduled then wait
until that completes first.

[Khushal, 2017/03/27 13:57:32]

Done.

     return;
+
+  DCHECK_GE(next_image_to_decode_, 0u);
+  DCHECK_LT(next_image_to_decode_, image_decode_queue_.size());
+  while (next_image_to_decode_ != image_decode_queue_.size()) {
+    outstanding_image_decode_ =
+        std::move(image_decode_queue_[next_image_to_decode_++]);
+
+    // The image may have already been decoded. Proceed to the next image in the

[vmpstr, 2017/03/17 18:32:13]

Can you rephrase this comment to match the code? That is, "if this image hasn't
been decoded yet, then use it. Otherwise try the next image"

[Khushal, 2017/03/27 13:57:32]

Done.

+    // queue in that case.
+    ImageId image_id = outstanding_image_decode_->uniqueID();
+    if (images_decoded_once_.count(image_id) == 0)
+      break;
+    outstanding_image_decode_ = nullptr;
   }
 
+  if (next_image_to_decode_ == image_decode_queue_.size()) {

[vmpstr, 2017/03/17 18:32:13]

Comment here

[Khushal, 2017/03/27 13:57:32]

Done.

+    next_image_to_decode_ = 0;
+    image_decode_queue_.clear();
+  }
+
+  if (!outstanding_image_decode_)
+    return;
+
+  ImageId image_id = outstanding_image_decode_->uniqueID();
+  DCHECK_EQ(image_id_to_decode_request_id_.count(image_id), 0u);
   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);
+          outstanding_image_decode_,
+          base::Bind(&CheckerImageTracker::DidFinishImageDecode,
+                     weak_factory_.GetWeakPtr(), image_id));
 }
 
 }  // namespace cc