OpacityFilterCanvas should calculate the alpha according to the origin.

The opacity filter canvas should calculate the alpha with opacity
according to the origin paint's alpha.

Bug: 1044493

Change-Id: I8f1ba00ffd75a7d455b925ed841a14ae92419a63
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2012360
Reviewed-by: Florin Malita <fmalita@chromium.org>
Reviewed-by: Jonathan Backer <backer@chromium.org>
Commit-Queue: Jonathan Backer <backer@chromium.org>
Cr-Commit-Position: refs/heads/master@{#734182}

components/viz/service/display/renderer_pixeltest.cc

@@ -3609,6 +3609,67 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadOpacity) {
       cc::FuzzyPixelOffByOneComparator(true)));
 }
 
+TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadOpacityWithAlpha) {
+  gfx::Rect viewport(this->device_viewport_size_);
+  bool needs_blending = true;
+  ResourceFormat texture_format = RGBA_8888;
+  bool nearest_neighbor = false;
+
+  int id = 1;
+  gfx::Transform transform_to_root;
+  std::unique_ptr<RenderPass> pass =
+      CreateTestRenderPass(id, viewport, transform_to_root);
+
+  // One viewport-filling 0.5-opacity transparent quad.
+  std::unique_ptr<cc::FakeRecordingSource> transparent_recording =
+      cc::FakeRecordingSource::CreateFilledRecordingSource(viewport.size());
+  cc::PaintFlags transparent_flags;
+  transparent_flags.setColor(SK_ColorTRANSPARENT);
+  transparent_recording->add_draw_rect_with_flags(viewport, transparent_flags);
+  transparent_recording->Rerecord();
+  scoped_refptr<cc::RasterSource> transparent_raster_source =
+      transparent_recording->CreateRasterSource();
+
+  gfx::Transform transparent_quad_to_target_transform;
+  SharedQuadState* transparent_shared_state =
+      CreateTestSharedQuadState(transparent_quad_to_target_transform, viewport,
+                                pass.get(), gfx::RRectF());
+  transparent_shared_state->opacity = 0.5f;
+
+  auto* transparent_quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
+  transparent_quad->SetNew(
+      transparent_shared_state, viewport, viewport, needs_blending,
+      gfx::RectF(0, 0, 1, 1), viewport.size(), nearest_neighbor, texture_format,
+      viewport, 1.f, {}, transparent_raster_source->GetDisplayItemList());
+
+  // One viewport-filling white quad.
+  std::unique_ptr<cc::FakeRecordingSource> white_recording =
+      cc::FakeRecordingSource::CreateFilledRecordingSource(viewport.size());
+  cc::PaintFlags white_flags;
+  white_flags.setColor(SK_ColorWHITE);
+  white_recording->add_draw_rect_with_flags(viewport, white_flags);
+  white_recording->Rerecord();
+  scoped_refptr<cc::RasterSource> white_raster_source =
+      white_recording->CreateRasterSource();
+
+  gfx::Transform white_quad_to_target_transform;
+  SharedQuadState* white_shared_state = CreateTestSharedQuadState(
+      white_quad_to_target_transform, viewport, pass.get(), gfx::RRectF());
+
+  auto* white_quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
+  white_quad->SetNew(white_shared_state, viewport, viewport, needs_blending,
+                     gfx::RectF(0, 0, 1, 1), viewport.size(), nearest_neighbor,
+                     texture_format, viewport, 1.f, {},
+                     white_raster_source->GetDisplayItemList());
+
+  RenderPassList pass_list;
+  pass_list.push_back(std::move(pass));
+
+  EXPECT_TRUE(this->RunPixelTest(&pass_list,
+                                 base::FilePath(FILE_PATH_LITERAL("white.png")),
+                                 cc::FuzzyPixelOffByOneComparator(true)));
+}
+
 template <typename TypeParam>
 bool IsSoftwareRenderer() {
   return false;

skia/ext/opacity_filter_canvas.cc

@@ -11,12 +11,12 @@ OpacityFilterCanvas::OpacityFilterCanvas(SkCanvas* canvas,
                                          float opacity,
                                          bool disable_image_filtering)
     : INHERITED(canvas),
-      alpha_(SkScalarRoundToInt(opacity * 255)),
-      disable_image_filtering_(disable_image_filtering) { }
+      opacity_(opacity),
+      disable_image_filtering_(disable_image_filtering) {}
 
 bool OpacityFilterCanvas::onFilter(SkPaint& paint) const {
-  if (alpha_ < 255)
-    paint.setAlpha(alpha_);
+  if (opacity_ < 1.f)
+    paint.setAlphaf(paint.getAlphaf() * opacity_);
 
   if (disable_image_filtering_)
     paint.setFilterQuality(kNone_SkFilterQuality);

skia/ext/opacity_filter_canvas.h

@@ -29,7 +29,7 @@ class SK_API OpacityFilterCanvas : public SkPaintFilterCanvas {
  private:
   typedef SkPaintFilterCanvas INHERITED;
 
-  int alpha_;
+  float opacity_;
   bool disable_image_filtering_;
 };