cc: Add checker-imaging support to TileManager.

cc/tiles/checker_image_tracker.cc

Index: cc/tiles/checker_image_tracker.cc
diff --git a/cc/tiles/checker_image_tracker.cc b/cc/tiles/checker_image_tracker.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c081132e6ece23c5e9569af2dc37968d9e69e5cb
--- /dev/null
+++ b/cc/tiles/checker_image_tracker.cc
@@ -0,0 +1,152 @@
+// 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 {
+namespace {
+// The minimum size of an image that we should consider checkering.
+size_t kMinImageSizeToCheckerBytes = 512 * 1024;
+
+size_t SafeSizeOfImage(const SkImage* image) {
+  base::CheckedNumeric<size_t> checked_size = 4;
+  checked_size *= image->width();
+  checked_size *= image->height();
+  return checked_size.ValueOrDefault(std::numeric_limits<size_t>::max());
+}
+
+}  // namespace
+
+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() {
+  // 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());
+}
+
+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) {
+  TRACE_EVENT_ASYNC_END0("cc", "CheckerImageTracker::DeferImageDecode",
+                         image_id);
+
+  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();
+}
+
+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();
+
+  // 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