cc: Add checker-imaging support to TileManager.

cc/tiles/checker_image_tracker.h

+// 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.
+
+#ifndef CC_TILES_CHECKER_IMAGE_TRACKER_H_
+#define CC_TILES_CHECKER_IMAGE_TRACKER_H_
+
+#include <unordered_map>
+#include <vector>
+
+#include "cc/base/cc_export.h"
+#include "cc/playback/image_id.h"
+#include "cc/tiles/image_controller.h"
+#include "third_party/skia/include/core/SkImage.h"
+
+namespace cc {
+
+class CC_EXPORT CheckerImageTrackerClient {
+ public:
+  virtual ~CheckerImageTrackerClient() = default;
+
+  virtual void NeedsInvalidationForCheckerImagedTiles() = 0;
+};
+
+// CheckerImageTracker is used to track the set of images in a frame which are
+// decoded asynchronously, using the ImageDecodeService, from the rasterization
+// of tiles which depend on them. Once decoded, these images are stored for
+// invalidation on the next sync tree. TakeImagesToInvalidateOnSyncTree will
+// return this set and maintain a copy to keeps these images locked until the
+// sync tree is activated.
+// Note: It is illegal to call TakeImagesToInvalidateOnSyncTree for the next
+// sync tree until the previous tree is activated.
+class CC_EXPORT CheckerImageTracker {
+ public:
+  CheckerImageTracker(ImageController* image_controller,
+                      CheckerImageTrackerClient* client,
+                      bool enable_checker_imaging);
+  ~CheckerImageTracker();
+
+  // Given the |images| for a tile, filters the images which will be deferred
+  // asynchronously using the image decoded service, eliminating them from
+  // |images| adds them to the |checkered_images| set, so they can be skipped
+  // during the rasterization of this tile.
+  // The entries remaining in |images| are for images for which a cached decode
+  // from the image decode service is available, or which must be decoded before
+  // before this tile can be rasterized.
+  void FilterImagesForCheckeringForTile(std::vector<DrawImage>* images,
+                                        ImageIdFlatSet* checkered_images,
+                                        WhichTree tree);
+
+  // Returns the set of images to invalidate on the sync tree.
+  const std::unordered_set<ImageId>& TakeImagesToInvalidateOnSyncTree();

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

It kind of seems like this should be a flat set too? Do you expect a lot of
them?

I can maaaybe understand images_decoded_once being a map, maybe from the
perspective of a really long-lived LTH across multiple navigations.  (That said,
maybe cc needs to be informed about navigations so it can clear this and
re-checker?)  But even so, I don't know that I expect the average number of
images on a page to be >100 tbh.  Maybe this is just data structure bike
shedding, but I'd kinda say everything should be a flat set except
images_decoded_once for now.

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

Makes sense. Other than the once decoded images set, nothing else should have a
significant number of entries. I filed a bug for resetting it on navigations. I
think setting the root layer on the host only happens with navigation changes,
but may be a more obvious call on the host would be better.

[enne (OOO), 2017/02/17 19:12:51]

Yeah, it's possible.  I think we'd want to add some more comments maybe at the
LayerTreeHost or above interfaces to make it clear that SetRootLayer also
implied navigation.  Maybe we could rename the interface in Blink.

+
+  void DidActivateSyncTree();
+
+ private:
+  void DidFinishImageDecode(ImageId image_id,
+                            ImageController::ImageDecodeRequestId request_id);
+
+  // Returns true if the decode for |image| will be deferred to the image decode
+  // service and it should be be skipped during raster.
+  bool ShouldCheckerImage(const sk_sp<const SkImage>& image,
+                          WhichTree tree) const;
+
+  void ScheduleImageDecodeIfNecessary(const sk_sp<const SkImage>& image);
+
+  ImageController* image_controller_;
+  CheckerImageTrackerClient* client_;
+  const bool enable_checker_imaging_;
+
+  // A set of images which have been decoded and are pending invalidation for
+  // raster on the checkered tiles.
+  ImageIdSet images_pending_invalidation_;
+
+  // A set of images which were invalidated on the current sync tree.
+  ImageIdSet invalidated_images_on_current_sync_tree_;
+
+  // A set of images which are currently pending decode from the image decode
+  // service.
+  // TODO(khushalsagar): This should be a queue that gets re-built each time we
+  // do a PrepareTiles? See crbug.com/689184.
+  ImageIdSet pending_image_decodes_;
+
+  // A set of images which have been decoded at least once from the
+  // ImageDecodeService and should not be checkered again.
+  // TODO(khushalsagar): Limit the size of this set.
+  ImageIdSet images_decoded_once_;
+
+  // A map of image id to image decode request id for images to be unlocked.
+  std::unordered_map<ImageId, ImageController::ImageDecodeRequestId>
+      image_id_to_decode_request_id_;
+
+  base::WeakPtrFactory<CheckerImageTracker> weak_factory_;
+};
+
+}  // namespace cc
+
+#endif  // CC_TILES_CHECKER_IMAGE_TRACKER_H_