Add YUV constructor and implementations for FakePaintImageGenerator.

This change provides overrides for GetYUVA8Planes and QueryYUVA8 so that
the generator can be used as a fake for YUV decoding within unit tests.
It also CHECKs that RGB-only methods are not called within the |is_yuv_|
mode and vice versa, while providing |expect_fallback_to_rgb_| for
future tests/code paths. This is because there does not yet exist
software rendering for YUV, so software fallback goes to RGB.

Bug: 900672
Change-Id: I76bfb744d1beec72939ddb016b0a7abedbde33e7
Reviewed-on: https://chromium-review.googlesource.com/c/1458600
Commit-Queue: Madeleine Barowsky <mbarowsky@chromium.org>
Reviewed-by: Khushal <khushalsagar@chromium.org>
Auto-Submit: Madeleine Barowsky <mbarowsky@chromium.org>
Cr-Commit-Position: refs/heads/master@{#630625}

cc/test/fake_paint_image_generator.cc

@@ -4,6 +4,8 @@
 
 #include <cc/test/fake_paint_image_generator.h>
 
+#include <utility>
+
 namespace cc {
 
 FakePaintImageGenerator::FakePaintImageGenerator(
@@ -18,6 +20,20 @@ FakePaintImageGenerator::FakePaintImageGenerator(
       image_pixmap_(info, image_backing_memory_.data(), info.minRowBytes()),
       supported_sizes_(std::move(supported_sizes)) {}
 
+FakePaintImageGenerator::FakePaintImageGenerator(
+    const SkImageInfo& info,
+    const SkYUVASizeInfo& yuva_size_info,
+    std::vector<FrameMetadata> frames,
+    bool allocate_discardable_memory,
+    std::vector<SkISize> supported_sizes)
+    : PaintImageGenerator(info, std::move(frames)),
+      image_backing_memory_(
+          allocate_discardable_memory ? yuva_size_info.computeTotalBytes() : 0,
+          0),
+      supported_sizes_(std::move(supported_sizes)),
+      is_yuv_(true),
+      yuva_size_info_(yuva_size_info) {}
+
 FakePaintImageGenerator::~FakePaintImageGenerator() = default;
 
 sk_sp<SkData> FakePaintImageGenerator::GetEncodedData() const {
@@ -30,8 +46,14 @@ bool FakePaintImageGenerator::GetPixels(const SkImageInfo& info,
                                         size_t frame_index,
                                         PaintImage::GeneratorClientId client_id,
                                         uint32_t lazy_pixel_ref) {
+  CHECK(!is_yuv_ || expect_fallback_to_rgb_);
   if (image_backing_memory_.empty())
     return false;
+  if (expect_fallback_to_rgb_) {
+    image_backing_memory_.resize(info.computeMinByteSize(), 0);
+    image_pixmap_ =
+        SkPixmap(info, image_backing_memory_.data(), info.minRowBytes());
+  }
   if (frames_decoded_count_.find(frame_index) == frames_decoded_count_.end())
     frames_decoded_count_[frame_index] = 1;
   else
@@ -42,19 +64,38 @@ bool FakePaintImageGenerator::GetPixels(const SkImageInfo& info,
   return true;
 }
 
-bool FakePaintImageGenerator::QueryYUVA8(SkYUVASizeInfo* info,
+bool FakePaintImageGenerator::QueryYUVA8(SkYUVASizeInfo* yuv_info,
                                          SkYUVAIndex indices[],
                                          SkYUVColorSpace* color_space) const {
-  return false;
+  if (!is_yuv_)
+    return false;
+  *yuv_info = yuva_size_info_;
+  return true;
 }
 
-bool FakePaintImageGenerator::GetYUVA8Planes(const SkYUVASizeInfo& info,
+bool FakePaintImageGenerator::GetYUVA8Planes(const SkYUVASizeInfo& yuv_info,
                                              const SkYUVAIndex indices[],
                                              void* planes[4],
                                              size_t frame_index,
                                              uint32_t lazy_pixel_ref) {
-  NOTREACHED();
-  return false;
+  CHECK(is_yuv_);
+  CHECK(!expect_fallback_to_rgb_);
+  if (image_backing_memory_.empty())
+    return false;
+  int numPlanes = SkYUVASizeInfo::kMaxCount;
+  void* src_planes[numPlanes];
+  yuv_info.computePlanes(image_backing_memory_.data(), src_planes);
+  for (int i = 0; i < numPlanes; ++i) {
+    size_t bytes_for_plane_i =
+        yuv_info.fWidthBytes[i] *
+        base::checked_cast<size_t>(yuv_info.fSizes[i].height());
+    memcpy(planes[i], src_planes[i], bytes_for_plane_i);
+  }
+  if (frames_decoded_count_.find(frame_index) == frames_decoded_count_.end())
+    frames_decoded_count_[frame_index] = 1;
+  else
+    frames_decoded_count_[frame_index]++;
+  return true;
 }
 
 SkISize FakePaintImageGenerator::GetSupportedDecodeSize(

cc/test/fake_paint_image_generator.h

@@ -5,20 +5,32 @@
 #ifndef CC_TEST_FAKE_PAINT_IMAGE_GENERATOR_H_
 #define CC_TEST_FAKE_PAINT_IMAGE_GENERATOR_H_
 
+#include <vector>
+
 #include "base/containers/flat_map.h"
+#include "base/macros.h"  // For DISALLOW_COPY_AND_ASSIGN
 #include "cc/paint/paint_image_generator.h"
 
 namespace cc {
 
 class FakePaintImageGenerator : public PaintImageGenerator {
  public:
+  // RGB decoding mode constructor.
+  explicit FakePaintImageGenerator(
+      const SkImageInfo& info,
+      std::vector<FrameMetadata> frames = {FrameMetadata()},
+      bool allocate_discardable_memory = true,
+      std::vector<SkISize> supported_sizes = {});
+  // YUV decoding mode constructor.
   explicit FakePaintImageGenerator(
       const SkImageInfo& info,
+      const SkYUVASizeInfo& yuva_size_info,
       std::vector<FrameMetadata> frames = {FrameMetadata()},
       bool allocate_discardable_memory = true,
       std::vector<SkISize> supported_sizes = {});
   ~FakePaintImageGenerator() override;
 
+  // PaintImageGenerator implementation.
   sk_sp<SkData> GetEncodedData() const override;
   bool GetPixels(const SkImageInfo& info,
                  void* pixels,
@@ -39,8 +51,12 @@ class FakePaintImageGenerator : public PaintImageGenerator {
   const base::flat_map<size_t, int>& frames_decoded() const {
     return frames_decoded_count_;
   }
-  const std::vector<SkImageInfo>& decode_infos() const { return decode_infos_; }
+  const std::vector<SkImageInfo>& decode_infos() const {
+    CHECK(!is_yuv_);
+    return decode_infos_;
+  }
   void reset_frames_decoded() { frames_decoded_count_.clear(); }
+  void SetExpectFallbackToRGB() { expect_fallback_to_rgb_ = true; }
 
  private:
   std::vector<uint8_t> image_backing_memory_;
@@ -48,6 +64,14 @@ class FakePaintImageGenerator : public PaintImageGenerator {
   base::flat_map<size_t, int> frames_decoded_count_;
   std::vector<SkISize> supported_sizes_;
   std::vector<SkImageInfo> decode_infos_;
+  bool is_yuv_ = false;
+  SkYUVASizeInfo yuva_size_info_;
+  // TODO(skbug.com/8564): After Skia supports rendering from software YUV
+  // planes and after Chrome implements it, we should no longer expect RGB
+  // fallback.
+  bool expect_fallback_to_rgb_ = false;
+
+  DISALLOW_COPY_AND_ASSIGN(FakePaintImageGenerator);
 };
 
 }  // namespace cc