cc: ImageDecodes: handle low quality filters.

cc/tiles/image_decode_controller.h

 // Copyright 2015 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_IMAGE_DECODE_CONTROLLER_H_
 #define CC_TILES_IMAGE_DECODE_CONTROLLER_H_
 
 #include <stdint.h>
 
 #include <unordered_map>
@@ skipping 15 matching lines @@
 
 // ImageDecodeControllerKey is a class that gets a cache key out of a given draw
 // image. That is, this key uniquely identifies an image in the cache. Note that
 // it's insufficient to use SkImage's unique id, since the same image can appear
 // in the cache multiple times at different scales and filter qualities.
 class CC_EXPORT ImageDecodeControllerKey {
  public:
   static ImageDecodeControllerKey FromDrawImage(const DrawImage& image);
 
   bool operator==(const ImageDecodeControllerKey& other) const {
-    return image_id_ == other.image_id_ && src_rect_ == other.src_rect_ &&
-           target_size_ == other.target_size_ &&
-           filter_quality_ == other.filter_quality_;
+    // The image_id always has to be the same. However, after that all original
+    // decodes are the same, so if we can use the original decode, return true.
+    // If not, then we have to compare every field.
+    return image_id_ == other.image_id_ &&
+           can_use_original_decode_ == other.can_use_original_decode_ &&
+           (can_use_original_decode_ ||
+            (src_rect_ == other.src_rect_ &&
+             target_size_ == other.target_size_ &&
+             filter_quality_ == other.filter_quality_));
   }
 
   bool operator!=(const ImageDecodeControllerKey& other) const {
     return !(*this == other);
   }
 
   uint32_t image_id() const { return image_id_; }
   SkFilterQuality filter_quality() const { return filter_quality_; }
   gfx::Rect src_rect() const { return src_rect_; }
   gfx::Size target_size() const { return target_size_; }
 
-  // Helper to figure out how much memory this decoded and scaled image would
-  // take.
-  size_t target_bytes() const {
+  bool can_use_original_decode() const { return can_use_original_decode_; }
+  size_t get_hash() const { return hash_; }
+
+  // Helper to figure out how much memory the locked image represented by this
+  // key would take.
+  size_t locked_bytes() const {
     // TODO(vmpstr): Handle formats other than RGBA.
     base::CheckedNumeric<size_t> result = 4;
-    result *= target_size_.width();
-    result *= target_size_.height();
+    if (can_use_original_decode()) {
+      result *= original_size_.width();
+      result *= original_size_.height();
+    } else {
+      result *= target_size_.width();
+      result *= target_size_.height();
+    }
     return result.ValueOrDefault(std::numeric_limits<size_t>::max());
   }
 
   std::string ToString() const;
 
  private:
   ImageDecodeControllerKey(uint32_t image_id,
                            const gfx::Rect& src_rect,
                            const gfx::Size& size,
-                           SkFilterQuality filter_quality);
+                           SkFilterQuality filter_quality,
+                           bool can_use_original_decode,
+                           const gfx::Size& original_size);
 
   uint32_t image_id_;
   gfx::Rect src_rect_;
   gfx::Size target_size_;
   SkFilterQuality filter_quality_;
+  bool can_use_original_decode_;
+  gfx::Size original_size_;

[enne (OOO), 2016/02/11 00:06:06]

I'm not sure I follow why you need two sizes here? If you can use the original
decode, isn't target_size == original_size? (Or can it be?)

[vmpstr, 2016/02/11 00:23:46]

Hmm.. I'm going to confirm, but yeah I think I can use target_size (ie I can set
target size to be the full image rect in the case where we're using the original
decode)

+  size_t hash_;
 };
 
 // Hash function for the above ImageDecodeControllerKey.
 struct ImageDecodeControllerKeyHash {
   size_t operator()(const ImageDecodeControllerKey& key) const {
-    // TODO(vmpstr): This is a mess. Maybe it's faster to just search the vector
-    // always (forwards or backwards to account for LRU).
-    uint64_t src_rect_hash =
-        base::HashInts(static_cast<uint64_t>(base::HashInts(
-                           key.src_rect().x(), key.src_rect().y())),
-                       static_cast<uint64_t>(base::HashInts(
-                           key.src_rect().width(), key.src_rect().height())));
-
-    uint64_t target_size_hash =
-        base::HashInts(key.target_size().width(), key.target_size().height());
-
-    return base::HashInts(base::HashInts(src_rect_hash, target_size_hash),
-                          base::HashInts(key.image_id(), key.filter_quality()));
+    return key.get_hash();
   }
 };
 
 // ImageDecodeController is responsible for generating decode tasks, decoding
 // images, storing images in cache, and being able to return the decoded images
 // when requested.
 
 // ImageDecodeController is responsible for the following things:
 // 1. Given a DrawImage, it can return an ImageDecodeTask which when run will
 //    decode and cache the resulting image. If the image does not need a task to
@@ skipping 111 matching lines @@
 
   // Looks for the key in the cache and returns true if it was found and was
   // successfully locked (or if it was already locked). Note that if this
   // function returns true, then a ref count is increased for the image.
   bool LockDecodedImageIfPossibleAndRef(const ImageKey& key);
 
   // Actually decode the image. Note that this function can (and should) be
   // called with no lock acquired, since it can do a lot of work. Note that it
   // can also return nullptr to indicate the decode failed.
   scoped_refptr<DecodedImage> DecodeImageInternal(const ImageKey& key,
-                                                  const SkImage* image);
+                                                  const DrawImage& draw_image);
+
+  // Get the decoded draw image for the given key and draw_image. Note that this
+  // function has to be called with no lock acquired, since it will acquire its
+  // own locks and might call DecodeImageInternal above. Also note that this
+  // function will use the provided key, even if
+  // ImageKey::FromDrawImage(draw_image) would return a different key.
+  // Note that when used internally, we still require that
+  // DrawWithImageFinished() is called afterwards.
+  DecodedDrawImage GetDecodedImageForDrawInternal(const ImageKey& key,
+                                                  const DrawImage& draw_image);
+
   void SanityCheckState(int line, bool lock_acquired);
   void RefImage(const ImageKey& key);
   void RefAtRasterImage(const ImageKey& key);
   void UnrefAtRasterImage(const ImageKey& key);
 
   // These functions indicate whether the images can be handled and cached by
   // ImageDecodeController or whether they will fall through to Skia (with
   // exception of possibly prerolling them). Over time these should return
   // "false" in less cases, as the ImageDecodeController should start handling
   // more of them.
@@ skipping 18 matching lines @@
 
   // Note that this is used for cases where the only thing we do is preroll the
   // image the first time we see it. This mimics the previous behavior and
   // should over time change as the compositor starts to handle more cases.
   std::unordered_set<uint32_t> prerolled_images_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_IMAGE_DECODE_CONTROLLER_H_