cc: Move pre-decodes to background worker.

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/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 19 matching lines @@
   std::ostringstream str;
   str << "paint_image_id[" << paint_image_id << "] sk_image_id[" << sk_image_id
       << "] complete[" << complete << "] static[" << static_image
       << "], fits_size_constraints[" << fits_size_constraints << "], size["
       << size << "]";
   return str.str();
 }
 
 }  // namespace
 
+CheckerImageTracker::ImageDecodeRequest::ImageDecodeRequest(
+    PaintImage paint_image,
+    DecodeType type)
+    : paint_image(std::move(paint_image)), type(type) {}
+
 CheckerImageTracker::CheckerImageTracker(ImageController* image_controller,
                                          CheckerImageTrackerClient* client,
                                          bool enable_checker_imaging)
     : image_controller_(image_controller),
       client_(client),
       enable_checker_imaging_(enable_checker_imaging),
       weak_factory_(this) {}
 
 CheckerImageTracker::~CheckerImageTracker() = default;
 
+void CheckerImageTracker::SetCanSchedulePredecodeImages(
+    bool can_schedule_predecode_images) {
+  if (can_schedule_predecode_images_ == can_schedule_predecode_images)
+    return;
+  can_schedule_predecode_images_ = can_schedule_predecode_images;
+
+  // If scheduling for the pre-decode queue was disabled, then we will stop
+  // queueing more work once a decode currently in flight is completed. If it
+  // was enabled, then kick off the next decode task.
+  if (can_schedule_predecode_images_)
+    ScheduleNextImageDecode();
+}
+
 void CheckerImageTracker::ScheduleImageDecodeQueue(
     ImageDecodeQueue image_decode_queue) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "CheckerImageTracker::ScheduleImageDecodeQueue");
   // Only checker-imaged (async updated) images are decoded using the image
   // decode service. If |enable_checker_imaging_| is false, no image should
   // be checkered.
   DCHECK(image_decode_queue.empty() || enable_checker_imaging_);
 
   image_decode_queue_ = std::move(image_decode_queue);
@@ skipping 168 matching lines @@
 }
 
 void CheckerImageTracker::ScheduleNextImageDecode() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "CheckerImageTracker::ScheduleNextImageDecode");
   // We can have only one outstanding decode pending completion with the decode
   // service. We'll come back here when it is completed.
   if (outstanding_image_decode_.has_value())
     return;
 
+  // If scheduling pre-decodes was disabled and we have reached the pre-decode
+  // images in the queue, don't run them now. We will come back here when
+  // these decodes are enabled.
+  if (!image_decode_queue_.empty() &&

[vmpstr, 2017/06/12 21:45:30]

Can you break this up a bit. Like, check if empty and return early. Then the
rest of the function can assume not empty.

What's guarding the ordering here? Are we guaranteed to get Raster tasks before
PreDecode ones?

[Khushal, 2017/06/14 00:29:19]

Done.
I added a DCHECK in ScheduleImageDecodeQueue to ensure that the images are
prioritized in the correct order.

+      image_decode_queue_.front().type == DecodeType::kPreDecode &&
+      !can_schedule_predecode_images_) {
+    return;
+  }
+
   DrawImage draw_image;
   while (!image_decode_queue_.empty()) {
-    auto candidate = std::move(image_decode_queue_.front());
+    auto candidate = std::move(image_decode_queue_.front().paint_image);
     image_decode_queue_.erase(image_decode_queue_.begin());
 
     // Once an image has been decoded, it can still be present in the decode
     // queue (duplicate entries), or while an image is still being skipped on
     // the active tree. Check if the image is still ASYNC to see if a decode is
     // needed.
     PaintImage::Id image_id = candidate.stable_id();
     auto it = image_async_decode_state_.find(image_id);
     DCHECK(it != image_async_decode_state_.end());
     if (it->second.policy != DecodePolicy::ASYNC)
@@ skipping 22 matching lines @@
   ImageController::ImageDecodeRequestId request_id =
       image_controller_->QueueImageDecode(
           draw_image, base::Bind(&CheckerImageTracker::DidFinishImageDecode,
                                  weak_factory_.GetWeakPtr(), image_id));
 
   image_id_to_decode_.emplace(image_id, base::MakeUnique<ScopedDecodeHolder>(
                                             image_controller_, request_id));
 }
 
 }  // namespace cc