CanvasResourceProvider: Move CanvasImageProvider to .cc file

CanvasImageProvider is an inner class of CanvasResourceProvider,
that only needs to be defined on the header for the base::Optional
use of it. This CL changes that to std::unique_ptr<> like its sister
member |canvas_|, moves its implementation to the .cc file and
inlines the 1-line methods.

Also I replaced a base::Unretained() with a WeakPtr() since
I didn't see why wouldn't it work.

No new code intended beyond that, just cleaning up what there is.

Bug: 839970
Change-Id: I8f3b299c12662a7a83c72ac7bc3eae1b8c1f27ea
Reviewed-on: https://chromium-review.googlesource.com/c/1318816
Commit-Queue: Miguel Casas <mcasas@chromium.org>
Reviewed-by: enne <enne@chromium.org>
Reviewed-by: Mohammad Reza Zakerinasab <zakerinasab@chromium.org>
Reviewed-by: Khushal <khushalsagar@chromium.org>
Cr-Commit-Position: refs/heads/master@{#605819}

third_party/blink/renderer/platform/graphics/canvas_resource_provider.cc

@@ -512,6 +512,33 @@ std::unique_ptr<CanvasResourceProvider> CanvasResourceProvider::Create(
   return nullptr;
 }
 
+class CanvasResourceProvider::CanvasImageProvider : public cc::ImageProvider {
+ public:
+  CanvasImageProvider(cc::ImageDecodeCache* cache_n32,
+                      cc::ImageDecodeCache* cache_f16,
+                      const gfx::ColorSpace& target_color_space,
+                      SkColorType target_color_type);
+  ~CanvasImageProvider() override = default;
+
+  // cc::ImageProvider implementation.
+  ScopedDecodedDrawImage GetDecodedDrawImage(const cc::DrawImage&) override;
+
+  void ReleaseLockedImages() { locked_images_.clear(); }
+
+ private:
+  void CanUnlockImage(ScopedDecodedDrawImage);
+  void CleanupLockedImages();
+
+  bool cleanup_task_pending_ = false;
+  std::vector<ScopedDecodedDrawImage> locked_images_;
+  cc::PlaybackImageProvider playback_image_provider_n32_;
+  base::Optional<cc::PlaybackImageProvider> playback_image_provider_f16_;
+
+  base::WeakPtrFactory<CanvasImageProvider> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(CanvasImageProvider);
+};
+
 CanvasResourceProvider::CanvasImageProvider::CanvasImageProvider(
     cc::ImageDecodeCache* cache_n32,
     cc::ImageDecodeCache* cache_f16,
@@ -530,8 +557,6 @@ CanvasResourceProvider::CanvasImageProvider::CanvasImageProvider(
   }
 }
 
-CanvasResourceProvider::CanvasImageProvider::~CanvasImageProvider() = default;
-
 cc::ImageProvider::ScopedDecodedDrawImage
 CanvasResourceProvider::CanvasImageProvider::GetDecodedDrawImage(
     const cc::DrawImage& draw_image) {
@@ -557,17 +582,11 @@ CanvasResourceProvider::CanvasImageProvider::GetDecodedDrawImage(
     ReleaseLockedImages();
   }
 
-  // It is safe to use base::Unretained, since decodes acquired from a provider
-  // must not exceed the provider's lifetime.
   auto decoded_draw_image = scoped_decoded_image.decoded_image();
   return ScopedDecodedDrawImage(
-      decoded_draw_image,
-      base::BindOnce(&CanvasImageProvider::CanUnlockImage,
-                     base::Unretained(this), std::move(scoped_decoded_image)));
-}
-
-void CanvasResourceProvider::CanvasImageProvider::ReleaseLockedImages() {
-  locked_images_.clear();
+      decoded_draw_image, base::BindOnce(&CanvasImageProvider::CanUnlockImage,
+                                         weak_factory_.GetWeakPtr(),
+                                         std::move(scoped_decoded_image)));
 }
 
 void CanvasResourceProvider::CanvasImageProvider::CanUnlockImage(
@@ -629,10 +648,9 @@ cc::PaintCanvas* CanvasResourceProvider::Canvas() {
     cc::ImageDecodeCache* cache_f16 = nullptr;
     if (ColorParams().PixelFormat() == kF16CanvasPixelFormat)
       cache_f16 = ImageDecodeCacheF16();
-    canvas_image_provider_.emplace(ImageDecodeCacheRGBA8(), cache_f16,
-                                   target_color_space,
-                                   color_params_.GetSkColorType());
-    cc::ImageProvider* image_provider = &*canvas_image_provider_;
+    canvas_image_provider_ = std::make_unique<CanvasImageProvider>(
+        ImageDecodeCacheRGBA8(), cache_f16, target_color_space,
+        color_params_.GetSkColorType());
 
     cc::SkiaPaintCanvas::ContextFlushes context_flushes;
     if (IsAccelerated() &&
@@ -648,10 +666,11 @@ cc::PaintCanvas* CanvasResourceProvider::Canvas() {
     if (ColorParams().NeedsSkColorSpaceXformCanvas()) {
       canvas_ = std::make_unique<cc::SkiaPaintCanvas>(
           GetSkSurface()->getCanvas(), ColorParams().GetSkColorSpace(),
-          image_provider, context_flushes);
+          canvas_image_provider_.get(), context_flushes);
     } else {
       canvas_ = std::make_unique<cc::SkiaPaintCanvas>(
-          GetSkSurface()->getCanvas(), image_provider, context_flushes);
+          GetSkSurface()->getCanvas(), canvas_image_provider_.get(),
+          context_flushes);
     }
   }
 

third_party/blink/renderer/platform/graphics/canvas_resource_provider.h

@@ -180,30 +180,7 @@ class PLATFORM_EXPORT CanvasResourceProvider
   cc::PaintImage MakeImageSnapshot();
 
  private:
-  class CanvasImageProvider : public cc::ImageProvider {
-   public:
-    CanvasImageProvider(cc::ImageDecodeCache* cache_n32,
-                        cc::ImageDecodeCache* cache_f16,
-                        const gfx::ColorSpace& target_color_space,
-                        SkColorType target_color_type);
-    ~CanvasImageProvider() override;
-
-    // cc::ImageProvider implementation.
-    ScopedDecodedDrawImage GetDecodedDrawImage(const cc::DrawImage&) override;
-
-    void ReleaseLockedImages();
-
-   private:
-    void CanUnlockImage(ScopedDecodedDrawImage);
-    void CleanupLockedImages();
-
-    bool cleanup_task_pending_ = false;
-    std::vector<ScopedDecodedDrawImage> locked_images_;
-    cc::PlaybackImageProvider playback_image_provider_n32_;
-    base::Optional<cc::PlaybackImageProvider> playback_image_provider_f16_;
-
-    base::WeakPtrFactory<CanvasImageProvider> weak_factory_;
-  };
+  class CanvasImageProvider;
 
   virtual sk_sp<SkSurface> CreateSkSurface() const = 0;
   virtual scoped_refptr<CanvasResource> CreateResource();
@@ -214,7 +191,7 @@ class PLATFORM_EXPORT CanvasResourceProvider
   base::WeakPtr<CanvasResourceDispatcher> resource_dispatcher_;
   IntSize size_;
   CanvasColorParams color_params_;
-  base::Optional<CanvasImageProvider> canvas_image_provider_;
+  std::unique_ptr<CanvasImageProvider> canvas_image_provider_;
   std::unique_ptr<cc::SkiaPaintCanvas> canvas_;
   mutable sk_sp<SkSurface> surface_;  // mutable for lazy init
   std::unique_ptr<SkCanvas> xform_canvas_;