cc: Add checker-imaging support to TileManager.

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 {
+namespace {
+// The minimum size of an image that we should consider checkering.
+size_t kMinImageSizeToCheckerBytes = 512 * 1024;
+}  // 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);

[enne (OOO), 2017/02/16 21:41:32]

std::vector::erase <_<

How about: swap with last element and then erase? or just null and handle null
elsewhere?

[Khushal, 2017/02/17 19:05:38]

Done. And with a suggestion from vmpstr@ on how to make it look pretty. Does it
actually look pretty? :P

+    } else {
+      ++it;
+    }
+  }
+}
+
+const std::unordered_set<ImageId>&
+CheckerImageTracker::TakeImagesToInvalidateOnSyncTree() {
+  DCHECK(invalidated_images_on_current_sync_tree_.empty())

[vmpstr, 2017/02/16 20:59:14]

nit: Can you make this DCHECK_EQ(0u, ....size()), so that upon failure we get
more information than just "it's not empty"

[Khushal, 2017/02/17 19:05:38]

Done.

+      << "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(

[vmpstr, 2017/02/16 20:59:13]

Can you add a unittest where we queue some requests, but then switch the cache
on the image decode controller? I want to make sure that each of the calls is
balanced (decode with did finish decode)

+    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;
+  }
+
+  base::CheckedNumeric<size_t> checked_size = 4;

[enne (OOO), 2017/02/16 21:41:32]

This is a very popular dance.  Maybe we need a skia/ext/
SafeSizeOfImage(SkImage) function?

[vmpstr, 2017/02/16 22:01:27]

+1000

[Khushal, 2017/02/17 19:05:38]

On popular demand. Done.

+  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) {
+  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