cc: Add checker-imaging support to TileManager.

cc/tiles/checker_image_tracker.h

Index: cc/tiles/checker_image_tracker.h
diff --git a/cc/tiles/checker_image_tracker.h b/cc/tiles/checker_image_tracker.h
new file mode 100644
index 0000000000000000000000000000000000000000..af0bc0e86f37b8927d342fb19dfdb0f04388a047
--- /dev/null
+++ b/cc/tiles/checker_image_tracker.h
@@ -0,0 +1,100 @@
+// 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 ImageIdFlatSet& TakeImagesToInvalidateOnSyncTree();
+
+  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.
+  ImageIdFlatSet images_pending_invalidation_;
+
+  // A set of images which were invalidated on the current sync tree.
+  ImageIdFlatSet 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.
+  ImageIdFlatSet 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.
+  // TODO(khushalsagar): Plumb navigation changes here to reset this. See
+  // crbug.com/693228.
+  std::unordered_set<ImageId> 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_