Refactor SoftwareImageDecodeController

cc/tiles/software_image_decode_controller.h

 // Copyright 2016 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_SOFTWARE_IMAGE_DECODE_CONTROLLER_H_
 #define CC_TILES_SOFTWARE_IMAGE_DECODE_CONTROLLER_H_
 
 #include <stdint.h>
 
 #include <unordered_map>
@@ skipping 20 matching lines @@
 // 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 {
     // 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_ &&

[ericrk, 2016/03/24 20:01:21]

I may have missed something here, was mainly looking at uses in the cc - with
the can_use_original_decode_ check here, we will return true for operator== for
two keys, one with kNone filter quality and one with kLow filter quality. With
the new logic, KNone and kLow won't match...

Maybe it is better to leave this in for readability here?

[cblume, 2016/03/24 20:59:50]

I think I agree.

There is a special case to shortcut if the qualities don't match (low/none) but
they both use the original decode.

Without it, this would have to be aware of if the qualities happen to use the
original decode and then would have to make a special case for "Well, unless
they happen to only differ by qualities which use the original decode."

We could make it not *too* messy but it would still have to be aware of what the
quality is doing, which I don't like.

So yeah, I think maybe it might make sense to leave the can_use_original_decode_
in.

            (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);
   }
 
@@ skipping 126 matching lines @@
   // 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);
 
+  struct DecodedImageResult {
+    DecodedImageResult(SkPixmap decoded_pixmap,
+                       DrawImage original_size_draw_image,
+                       DecodedDrawImage decoded_draw_image);
+
+    SkPixmap decoded_pixmap_;
+    DrawImage original_size_draw_image_;
+    DecodedDrawImage decoded_draw_image_;
+  };
+
+  scoped_ptr<DecodedImage> DecodeImageNoneLowQuality(const ImageKey& key,
+                                                     const SkImage& image);

[ericrk, 2016/03/24 16:06:59]

nit: This function is not defined or used.

[cblume, 2016/03/24 18:45:10]

Done.

+  scoped_ptr<DecodedImage> DecodeImageMediumQuality(const ImageKey& key,
+                                                    const SkImage& image);
+  scoped_ptr<DecodedImage> DecodeImageHighQuality(const ImageKey& key,
+                                                  const SkImage& image);
+
+  scoped_ptr<DecodedImage> GetOriginalImageDecode(const ImageKey& key,
+                                                  const SkImage& image);
+
+  DecodedImageResult DecodeImageOrUseCache(const ImageKey& key,
+                                           const SkImage& image);
+
+  scoped_ptr<DecodedImage> ScaleImage(
+      const ImageKey& key,
+      const DecodedImageResult& decoded_image_result);
+
   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 24 matching lines @@
   // 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_;
 
   ResourceFormat format_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_SOFTWARE_IMAGE_DECODE_CONTROLLER_H_