cc: ImageDecodes: Remove ref counting from SIDC::DecodedImage.

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 100 matching lines @@
 
   // Decode the given image and store it in the cache. This is only called by an
   // image decode task from a worker thread.
   void DecodeImage(const ImageKey& key, const DrawImage& image);
 
   void RemovePendingTask(const ImageKey& key);
 
  private:
   // DecodedImage is a convenience storage for discardable memory. It can also
   // construct an image out of SkImageInfo and stored discardable memory.
-  // TODO(vmpstr): Make this scoped_ptr.
-  class DecodedImage : public base::RefCounted<DecodedImage> {
+  class DecodedImage {
    public:
     DecodedImage(const SkImageInfo& info,
                  scoped_ptr<base::DiscardableMemory> memory,
                  const SkSize& src_rect_offset);
+    ~DecodedImage();
 
     SkImage* image() const {
       DCHECK(locked_);
       return image_.get();
     }
 
     const SkSize& src_rect_offset() const { return src_rect_offset_; }
 
     bool is_locked() const { return locked_; }
     bool Lock();
     void Unlock();
 
    private:
-    friend class base::RefCounted<DecodedImage>;
-
-    ~DecodedImage();
-
     bool locked_;
     SkImageInfo image_info_;
     scoped_ptr<base::DiscardableMemory> memory_;
     skia::RefPtr<SkImage> image_;
     SkSize src_rect_offset_;
   };
 
   // MemoryBudget is a convenience class for memory bookkeeping and ensuring
   // that we don't go over the limit when pre-decoding.
   // TODO(vmpstr): Add memory infra to keep track of memory usage of this class.
@@ skipping 14 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 DrawImage& draw_image);
+  scoped_ptr<DecodedImage> DecodeImageInternal(const ImageKey& key,
+                                               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);
@@ skipping 10 matching lines @@
   // more of them.
   bool CanHandleImage(const ImageKey& key);
 
   std::unordered_map<ImageKey, scoped_refptr<ImageDecodeTask>, ImageKeyHash>
       pending_image_tasks_;
 
   // The members below this comment can only be accessed if the lock is held to
   // ensure that they are safe to access on multiple threads.
   base::Lock lock_;
 
-  using ImageMRUCache = base::HashingMRUCache<ImageKey,
-                                              scoped_refptr<DecodedImage>,
-                                              ImageKeyHash>;
+  using ImageMRUCache =
+      base::HashingMRUCache<ImageKey, scoped_ptr<DecodedImage>, ImageKeyHash>;
 
   // Decoded images and ref counts (predecode path).
   ImageMRUCache decoded_images_;
   std::unordered_map<ImageKey, int, ImageKeyHash> decoded_images_ref_counts_;
 
   // Decoded image and ref counts (at-raster decode path).
   ImageMRUCache at_raster_decoded_images_;
   std::unordered_map<ImageKey, int, ImageKeyHash>
       at_raster_decoded_images_ref_counts_;
 
   MemoryBudget locked_images_budget_;
 
   // 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_SOFTWARE_IMAGE_DECODE_CONTROLLER_H_