cc: Disallow img.decode images from being checker imaged.

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 40 matching lines @@
   // Called when the sync tree is activated. Each call to
   // TakeImagesToInvalidateOnSyncTree() must be followed by this when the
   // invalidated sync tree is activated.
   void DidActivateSyncTree();
 
   // Called to reset the tracker state on navigation. This will release all
   // cached images. Setting |can_clear_decode_policy_tracking| will also result
   // in re-checkering any images already decoded by the tracker.
   void ClearTracker(bool can_clear_decode_policy_tracking);
 
+  // Informs the tracker to not checker the given image. This can be used to opt
+  // out of the checkering behavior for certain images, such as ones that were
+  // decoded using the img.decode api.
+  // Note that if the image is already being checkered, then it will continue to
+  // do so. This call is meant to be issued prior to the image appearing during
+  // raster.
+  void DisallowCheckeringForImage(const PaintImage& image);
+
  private:
   enum class DecodePolicy {
     // The image can be decoded asynchronously from raster. When set, the image
     // is always skipped during rasterization of content that includes this
     // image until it has been decoded using the decode service.
     ASYNC,
     // The image has been decoded asynchronously once and should now be
-    // synchronously rasterized with the content.
-    SYNC_DECODED_ONCE,
-    // The image has been permanently vetoed from being decoded async.
-    SYNC_PERMANENT,
+    // synchronously rasterized with the content or the image has been
+    // permanently vetoed from being decoded async.
+    SYNC
   };
 
   // Wrapper to unlock an image decode requested from the ImageController on
   // destruction.
   class ScopedDecodeHolder {
    public:
     ScopedDecodeHolder(ImageController* controller,
                        ImageController::ImageDecodeRequestId request_id)
         : controller_(controller), request_id_(request_id) {}
     ~ScopedDecodeHolder() { controller_->UnlockImageDecode(request_id_); }
@@ skipping 34 matching lines @@
   base::Optional<PaintImage> outstanding_image_decode_;
 
   // A map of ImageId to its DecodePolicy.
   std::unordered_map<PaintImage::Id, DecodePolicy> image_async_decode_state_;
 
   // A map of image id to image decode request id for images to be unlocked.
   std::unordered_map<PaintImage::Id, std::unique_ptr<ScopedDecodeHolder>>
       image_id_to_decode_;
 
   base::WeakPtrFactory<CheckerImageTracker> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(CheckerImageTracker);
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_CHECKER_IMAGE_TRACKER_H_