cc/tiles/checker_image_tracker.h

   1 // Copyright 2017 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CC_TILES_CHECKER_IMAGE_TRACKER_H_
   6 #define CC_TILES_CHECKER_IMAGE_TRACKER_H_
   7
   8 #include <unordered_map>
   9 #include <vector>
  10
  11 #include "base/optional.h"
  12 #include "cc/cc_export.h"
  13 #include "cc/paint/image_id.h"
  14 #include "cc/tiles/image_controller.h"
  15 #include "third_party/skia/include/core/SkImage.h"
  16
  17 namespace cc {
  18
  19 class CC_EXPORT CheckerImageTrackerClient {
  20  public:
  21   virtual ~CheckerImageTrackerClient() = default;
  22
  23   virtual void NeedsInvalidationForCheckerImagedTiles() = 0;
  24 };
  25
  26 // CheckerImageTracker is used to track the set of images in a frame which are
  27 // decoded asynchronously, using the ImageDecodeService, from the rasterization
  28 // of tiles which depend on them. Once decoded, these images are stored for
  29 // invalidation on the next sync tree. TakeImagesToInvalidateOnSyncTree will
  30 // return this set and maintain a copy to keeps these images locked until the
  31 // sync tree is activated.
  32 // Note: It is illegal to call TakeImagesToInvalidateOnSyncTree for the next
  33 // sync tree until the previous tree is activated.
  34 class CC_EXPORT CheckerImageTracker {
  35  public:
  36   // The priority type for a decode. Note we use int to specify a decreasing
  37   // order of priority with higher values.
  38   enum DecodeType : int {
  39     // Priority for images on tiles being rasterized (visible or pre-paint).
  40     kRaster = 0,
  41     // Lowest priority for images on tiles in pre-decode region. These are tiles
  42     // which are beyond the pre-paint region, but have their images decoded.
  43     kPreDecode = 1,
  44
  45     kLast = kPreDecode
  46   };
  47
  48   struct CC_EXPORT ImageDecodeRequest {
  49     ImageDecodeRequest(PaintImage paint_image, DecodeType type);
  50     PaintImage paint_image;
  51     DecodeType type;
  52   };
  53
  54   CheckerImageTracker(ImageController* image_controller,
  55                       CheckerImageTrackerClient* client,
  56                       bool enable_checker_imaging,
  57                       size_t min_image_bytes_to_checker);
  58   CheckerImageTracker(const CheckerImageTracker&) = delete;
  59   ~CheckerImageTracker();
  60
  61   CheckerImageTracker& operator=(const CheckerImageTracker&) = delete;
  62
  63   // Returns true if the decode for |image| will be deferred to the image decode
  64   // service and it should be be skipped during raster.
  65   bool ShouldCheckerImage(const DrawImage& image, WhichTree tree);
  66
  67   // Provides a prioritized queue of images to decode.
  68   using ImageDecodeQueue = std::vector<ImageDecodeRequest>;
  69   void ScheduleImageDecodeQueue(ImageDecodeQueue image_decode_queue);
  70
  71   // Disables scheduling any decode work by the tracker.
  72   void SetNoDecodesAllowed();
  73
  74   // The max decode priority type that is allowed to run.
  75   void SetMaxDecodePriorityAllowed(DecodeType decode_type);
  76
  77   // Returns the set of images to invalidate on the sync tree.
  78   const PaintImageIdFlatSet& TakeImagesToInvalidateOnSyncTree();
  79
  80   // Called when the sync tree is activated. Each call to
  81   // TakeImagesToInvalidateOnSyncTree() must be followed by this when the
  82   // invalidated sync tree is activated.
  83   void DidActivateSyncTree();
  84
  85   // Called to reset the tracker state on navigation. This will release all
  86   // cached images. Setting |can_clear_decode_policy_tracking| will also result
  87   // in re-checkering any images already decoded by the tracker.
  88   void ClearTracker(bool can_clear_decode_policy_tracking);
  89
  90   // Informs the tracker to not checker the given image. This can be used to opt
  91   // out of the checkering behavior for certain images, such as ones that were
  92   // decoded using the img.decode api.
  93   // Note that if the image is already being checkered, then it will continue to
  94   // do so. This call is meant to be issued prior to the image appearing during
  95   // raster.
  96   void DisallowCheckeringForImage(const PaintImage& image);
  97
  98   void set_force_disabled(bool force_disabled) {
  99     force_disabled_ = force_disabled;
 100   }
 101
 102   void UpdateImageDecodingHints(
 103       base::flat_map<PaintImage::Id, PaintImage::DecodingMode>
 104           decoding_mode_map);
 105
 106   bool has_locked_decodes_for_testing() const {
 107     return !image_id_to_decode_.empty();
 108   }
 109
 110   int decode_priority_allowed_for_testing() const {
 111     return decode_priority_allowed_;
 112   }
 113   bool no_decodes_allowed_for_testing() const {
 114     return decode_priority_allowed_ == kNoDecodeAllowedPriority;
 115   }
 116   PaintImage::DecodingMode get_decoding_mode_hint_for_testing(
 117       PaintImage::Id id) {
 118     CHECK(decoding_mode_map_.find(id) != decoding_mode_map_.end());
 119     return decoding_mode_map_[id];
 120   }
 121
 122  private:
 123   static const int kNoDecodeAllowedPriority;
 124
 125   enum class DecodePolicy {
 126     // The image can be decoded asynchronously from raster. When set, the image
 127     // is always skipped during rasterization of content that includes this
 128     // image until it has been decoded using the decode service.
 129     ASYNC,
 130     // The image has been decoded asynchronously once and should now be
 131     // synchronously rasterized with the content or the image has been
 132     // permanently vetoed from being decoded async.
 133     SYNC
 134   };
 135
 136   // Contains the information to construct a DrawImage from PaintImage when
 137   // queuing the image decode.
 138   struct DecodeState {
 139     DecodePolicy policy = DecodePolicy::SYNC;
 140     SkFilterQuality filter_quality = kNone_SkFilterQuality;
 141     SkSize scale = SkSize::MakeEmpty();
 142     gfx::ColorSpace color_space;
 143     size_t frame_index = PaintImage::kDefaultFrameIndex;
 144   };
 145
 146   // Wrapper to unlock an image decode requested from the ImageController on
 147   // destruction.
 148   class ScopedDecodeHolder {
 149    public:
 150     ScopedDecodeHolder(ImageController* controller,
 151                        ImageController::ImageDecodeRequestId request_id)
 152         : controller_(controller), request_id_(request_id) {}
 153     ScopedDecodeHolder(const ScopedDecodeHolder&) = delete;
 154     ~ScopedDecodeHolder() { controller_->UnlockImageDecode(request_id_); }
 155
 156     ScopedDecodeHolder& operator=(const ScopedDecodeHolder&) = delete;
 157
 158    private:
 159     ImageController* controller_;
 160     ImageController::ImageDecodeRequestId request_id_;
 161   };
 162
 163   void DidFinishImageDecode(PaintImage::Id image_id,
 164                             ImageController::ImageDecodeRequestId request_id,
 165                             ImageController::ImageDecodeResult result);
 166
 167   // Called when the next request in the |image_decode_queue_| should be
 168   // scheduled with the image decode service.
 169   void ScheduleNextImageDecode();
 170   void UpdateDecodeState(const DrawImage& draw_image,
 171                          PaintImage::Id paint_image_id,
 172                          DecodeState* decode_state);
 173
 174   ImageController* image_controller_;
 175   CheckerImageTrackerClient* client_;
 176   const bool enable_checker_imaging_;
 177   const size_t min_image_bytes_to_checker_;
 178
 179   // Disables checkering of all images if set. As opposed to
 180   // |enable_checker_imaging_|, this setting can be toggled.
 181   bool force_disabled_ = false;
 182
 183   // A set of images which have been decoded and are pending invalidation for
 184   // raster on the checkered tiles.
 185   PaintImageIdFlatSet images_pending_invalidation_;
 186
 187   // A set of images which were invalidated on the current sync tree.
 188   PaintImageIdFlatSet invalidated_images_on_current_sync_tree_;
 189
 190   // The queue of images pending decode. We maintain a queue to ensure that the
 191   // order in which images are decoded is aligned with the priority of the tiles
 192   // dependent on these images.
 193   ImageDecodeQueue image_decode_queue_;
 194
 195   // The max decode type that is allowed to run, if decodes are allowed to run.
 196   int decode_priority_allowed_ = kNoDecodeAllowedPriority;
 197
 198   // The currently outstanding image decode that has been scheduled with the
 199   // decode service. There can be only one outstanding decode at a time.
 200   base::Optional<PaintImage> outstanding_image_decode_;
 201
 202   // A map of ImageId to its DecodePolicy.
 203   std::unordered_map<PaintImage::Id, DecodeState> image_async_decode_state_;
 204
 205   // A map of image id to image decode request id for images to be unlocked.
 206   std::unordered_map<PaintImage::Id, std::unique_ptr<ScopedDecodeHolder>>
 207       image_id_to_decode_;
 208
 209   base::flat_map<PaintImage::Id, PaintImage::DecodingMode> decoding_mode_map_;
 210
 211   base::WeakPtrFactory<CheckerImageTracker> weak_factory_{this};
 212 };
 213
 214 }  // namespace cc
 215
 216 #endif  // CC_TILES_CHECKER_IMAGE_TRACKER_H_