cc: Use an enum for tracking images vetoed for async decodes.

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>
 
@@ skipping 36 matching lines @@
   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:
+  enum class AsyncDecodeVetoState {

[vmpstr, 2017/04/11 18:42:55]

s/AsyncDecodeVetoState/DecodePolicy/

[Khushal, 2017/04/12 20:31:17]

Done.

+    // The image can be decoded asynchronously from raster.
+    ASYNC,
+    // The image has been decoded asynchronously once and should now be
+    // synchronously rasterized with the content.
+    SYNC_DECODED_ONCE,

[vmpstr, 2017/04/11 18:42:55]

Is there any semantic difference between the last two values? Like is ASYNC/SYNC
enough or is there a subtle difference? If there's a difference, please comment
on it.

[Khushal, 2017/04/12 20:31:17]

Done.

+    // The image has been permanently vetoed from being decoded async.
+    SYNC_PERMANENT,
+  };
+
   void DidFinishImageDecode(ImageId image_id,
                             ImageController::ImageDecodeRequestId request_id,
                             ImageController::ImageDecodeResult result);
 
   // 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;
+  bool ShouldCheckerImage(const sk_sp<const SkImage>& image, WhichTree tree);
 
   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.
+  // A map of ImageId to its permitted AsyncDecodeVetoState.

[vmpstr, 2017/04/11 18:42:55]

nit: s/permitted //

[Khushal, 2017/04/12 20:31:17]

Done.

   // 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_;
+  std::unordered_map<ImageId, AsyncDecodeVetoState> image_async_decode_state_;
 
   // 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_