cc: fix oop-r double image decode

While investigating power usage on Android, it turned out that images
were being double decoded.  This is because DrawImageRect was not
including the scale of src->dst rects when serializing images and
requesting them from the decode cache.

Bug: 850362
Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: Iff305092de5b23e2cdb327ecc53bb575ae2fc141
Reviewed-on: https://chromium-review.googlesource.com/1102102Reviewed-by: enne <enne@chromium.org>
Reviewed-by: Khushal <khushalsagar@chromium.org>
Commit-Queue: enne <enne@chromium.org>
Cr-Commit-Position: refs/heads/master@{#567750}

cc/paint/paint_op_buffer.cc

@@ -461,11 +461,14 @@ size_t DrawImageRectOp::Serialize(const PaintOp* base_op,
     serialized_flags = &op->flags;
   helper.Write(*serialized_flags);
 
+  // This adjustment mirrors DiscardableImageMap::GatherDiscardableImage logic.
+  SkMatrix matrix = options.canvas->getTotalMatrix();
+  matrix.postConcat(
+      SkMatrix::MakeRectToRect(op->src, op->dst, SkMatrix::kFill_ScaleToFit));
   // Note that we don't request subsets here since the GpuImageCache has no
   // optimizations for using subsets.
   SkSize scale_adjustment = SkSize::Make(1.f, 1.f);
-  helper.Write(CreateDrawImage(op->image, serialized_flags,
-                               options.canvas->getTotalMatrix()),
+  helper.Write(CreateDrawImage(op->image, serialized_flags, matrix),
                &scale_adjustment);
   helper.AlignMemory(alignof(SkScalar));
   helper.Write(scale_adjustment.width());

cc/paint/paint_op_buffer_unittest.cc

@@ -3130,6 +3130,39 @@ TEST(PaintOpBufferTest, SecurityConstrainedImageSerialization) {
   EXPECT_TRUE(*filter == *out_filter);
 }
 
+TEST(PaintOpBufferTest, DrawImageRectSerializeScaledImages) {
+  auto buffer = sk_make_sp<PaintOpBuffer>();
+  buffer->push<ScaleOp>(0.5f, 2.0f);
+
+  // scales: x dimension = x0.25, y dimension = x5
+  // translations here are arbitrary
+  SkRect src = SkRect::MakeXYWH(3, 4, 20, 6);
+  SkRect dst = SkRect::MakeXYWH(20, 38, 5, 30);
+  buffer->push<DrawImageRectOp>(
+      CreateDiscardablePaintImage(gfx::Size(32, 16)), src, dst, nullptr,
+      PaintCanvas::SrcRectConstraint::kStrict_SrcRectConstraint);
+
+  std::unique_ptr<char, base::AlignedFreeDeleter> memory(
+      static_cast<char*>(base::AlignedAlloc(PaintOpBuffer::kInitialBufferSize,
+                                            PaintOpBuffer::PaintOpAlign)));
+  TestOptionsProvider options_provider;
+  SimpleBufferSerializer serializer(
+      memory.get(), PaintOpBuffer::kInitialBufferSize,
+      options_provider.image_provider(),
+      options_provider.transfer_cache_helper(),
+      options_provider.strike_server(), options_provider.color_space(),
+      options_provider.can_use_lcd_text(),
+      options_provider.context_supports_distance_field_text(),
+      options_provider.max_texture_size(),
+      options_provider.max_texture_bytes());
+  serializer.Serialize(buffer.get());
+
+  ASSERT_EQ(options_provider.decoded_images().size(), 1u);
+  auto scale = options_provider.decoded_images().at(0).scale();
+  EXPECT_EQ(scale.width(), 0.5f * 0.25f);
+  EXPECT_EQ(scale.height(), 2.0f * 5.0f);
+}
+
 TEST(PaintOpBufferTest, RecordShadersSerializeScaledImages) {
   auto record_buffer = sk_make_sp<PaintOpBuffer>();
   record_buffer->push<DrawImageOp>(