Switch DrawImage to sk_sp<>

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 <memory>
 #include <unordered_map>
 #include <unordered_set>
 
 #include "base/atomic_sequence_num.h"
 #include "base/containers/mru_cache.h"
 #include "base/hash.h"
 #include "base/memory/discardable_memory_allocator.h"
 #include "base/memory/ref_counted.h"
 #include "base/numerics/safe_math.h"
 #include "base/threading/thread_checker.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "cc/base/cc_export.h"
 #include "cc/playback/decoded_draw_image.h"
 #include "cc/playback/draw_image.h"
 #include "cc/resources/resource_format.h"
 #include "cc/tiles/image_decode_controller.h"
-#include "skia/ext/refptr.h"
+#include "third_party/skia/include/core/SkRefCnt.h"
 
 namespace cc {
 
 // 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);
@@ skipping 96 matching lines @@
   // DecodedImage is a convenience storage for discardable memory. It can also
   // construct an image out of SkImageInfo and stored discardable memory.
   class DecodedImage {
    public:
     DecodedImage(const SkImageInfo& info,
                  std::unique_ptr<base::DiscardableMemory> memory,
                  const SkSize& src_rect_offset,
                  uint64_t tracing_id);
     ~DecodedImage();
 
-    SkImage* image() const {
+    const sk_sp<SkImage>& image() const {
       DCHECK(locked_);
-      return image_.get();
+      return image_;
     }
 
     const SkSize& src_rect_offset() const { return src_rect_offset_; }
 
     bool is_locked() const { return locked_; }
     bool Lock();
     void Unlock();
 
     const base::DiscardableMemory* memory() const { return memory_.get(); }
 
     // An ID which uniquely identifies this DecodedImage within the image decode
     // controller. Used in memory tracing.
     uint64_t tracing_id() const { return tracing_id_; }
 
    private:
     bool locked_;
     SkImageInfo image_info_;
     std::unique_ptr<base::DiscardableMemory> memory_;
-    skia::RefPtr<SkImage> image_;
+    sk_sp<SkImage> image_;
     SkSize src_rect_offset_;
     uint64_t tracing_id_;
   };
 
   // MemoryBudget is a convenience class for memory bookkeeping and ensuring
   // that we don't go over the limit when pre-decoding.
   class MemoryBudget {
    public:
     explicit MemoryBudget(size_t limit_bytes);
 
@@ skipping 31 matching lines @@
   // 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);
 
   // GetOriginalImageDecode is called by DecodeImageInternal when the quality
   // does not scale the image. Like DecodeImageInternal, it should be called
   // with no lock acquired and it returns nullptr if the decoding failed.
-  std::unique_ptr<DecodedImage> GetOriginalImageDecode(const ImageKey& key,
-                                                       const SkImage& image);
+  std::unique_ptr<DecodedImage> GetOriginalImageDecode(
+      const ImageKey& key,
+      sk_sp<const SkImage> image);

[danakj, 2016/04/22 20:36:04]

I think florin was against saying const for these? or i misunderstood

 
   // GetScaledImageDecode is called by DecodeImageInternal when the quality
   // requires the image be scaled. Like DecodeImageInternal, it should be
   // called with no lock acquired and it returns nullptr if the decoding or
   // scaling failed.
-  std::unique_ptr<DecodedImage> GetScaledImageDecode(const ImageKey& key,
-                                                     const SkImage& image);
+  std::unique_ptr<DecodedImage> GetScaledImageDecode(
+      const ImageKey& key,
+      sk_sp<const SkImage> 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
@@ skipping 30 matching lines @@
 
   ResourceFormat format_;
 
   // Used to uniquely identify DecodedImages for memory traces.
   base::AtomicSequenceNumber next_tracing_id_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_SOFTWARE_IMAGE_DECODE_CONTROLLER_H_