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 21 matching lines @@
   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 << "]"
       << " is_multipart[" << is_multipart << "]";
   return str.str();
 }
 
 }  // namespace
 
+// static
+const int CheckerImageTracker::kNoDecodeAllowedPriority = -1;
+
+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::SetNoDecodesAllowed() {
+  decode_priority_allowed_ = kNoDecodeAllowedPriority;
+}
+
+void CheckerImageTracker::SetMaxDecodePriorityAllowed(DecodeType decode_type) {
+  DCHECK_GT(decode_type, kNoDecodeAllowedPriority);
+  DCHECK_GE(decode_type, decode_priority_allowed_);
+  DCHECK_LE(decode_type, DecodeType::kLast);
+
+  if (decode_priority_allowed_ == decode_type)
+    return;
+  decode_priority_allowed_ = decode_type;
+
+  // This will start the next decode if applicable.
+  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_);
 
+#if DCHECK_IS_ON()
+  // The decodes in the queue should be prioritized correctly.
+  DecodeType type = DecodeType::kRaster;
+  for (const auto& image_request : image_decode_queue) {
+    DCHECK_GE(image_request.type, type);
+    type = image_request.type;
+  }
+#endif
+
   image_decode_queue_ = std::move(image_decode_queue);
   ScheduleNextImageDecode();
 }
 
 const PaintImageIdFlatSet&
 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";
@@ skipping 172 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 (image_decode_queue_.empty())
+    return;
+
+  // If scheduling decodes for this priority is not allowed right now, don't
+  // schedule them. We will come back here when the allowed priority changes.
+  if (image_decode_queue_.front().type > decode_priority_allowed_)
+    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