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..7d507ba808d1b620346081af51d7222d8a6feee4
--- /dev/null
+++ b/cc/tiles/checker_image_tracker.cc
@@ -0,0 +1,150 @@
+// 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;

[vmpstr, 2017/02/13 22:49:30]

From my understanding this is roughly a 362x362 image. Should we maybe start
with larger sizes? Maybe 1mb?

[Khushal, 2017/02/14 05:10:22]

I tried this on a few pages and then manually used this value for cases where
the pending tree would end up getting blocked for multiple frames, so any guess
like that wouldn't be great.

May be we should decide what things to UMA to better fine tune this decision.

+}  // 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());
+
+  for (std::vector<DrawImage>::iterator it = images->begin();
+       it != images->end();) {
+    const sk_sp<const SkImage>& image = it->image();
+    DCHECK(image->isLazyGenerated());
+    if (ShouldCheckerImage(image, tree)) {
+      ScheduleImageDecodeIfNecessary(image);
+      checkered_images->insert(image->uniqueID());
+      it = images->erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
+const std::unordered_set<ImageId>&
+CheckerImageTracker::TakeImagesToInvalidateOnSyncTree() {
+  DCHECK(invalidated_images_on_current_sync_tree_.empty())
+      << "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);

[vmpstr, 2017/02/13 22:49:30]

nit: lower case u

[Khushal, 2017/02/14 05:10:22]

Done.

+  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;
+  }
+
+  base::CheckedNumeric<size_t> checked_size = 4;
+  checked_size *= image->width();
+  checked_size *= image->height();
+  size_t image_size =
+      checked_size.ValueOrDefault(std::numeric_limits<size_t>::max());
+
+  return image_size >= kMinImageSizeToCheckerBytes;
+}
+
+void CheckerImageTracker::ScheduleImageDecodeIfNecessary(
+    const sk_sp<const SkImage> image) {

[vmpstr, 2017/02/13 22:49:31]

&.

Can you actually further split this into two functions?

if (ShouldScheduleImageDecode(image_id))
  ScheduleImageDecode(image);

where ScheduleImageDecode takes sk_sp<const SkImage> and moves it into
QueueImageDecode

[Khushal, 2017/02/14 05:10:22]

Done.
Though do we need a different function now? No additional ref-churn if this
function takes a const&.

+  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