Invert inline svg and svg images for dark mode

1. Invert inline-svg as if it were text.
2. Invert content in svg images instead of the entire svg image. This makes the inversion behavior of svg images similar to inline svg.

Bug: 1210613
Change-Id: I65c91ab61e49ef264cab455a2dc1f520d29bbe0b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2963312
Reviewed-by: Philip Rogers <pdr@chromium.org>
Reviewed-by: Xianzhu Wang <wangxianzhu@chromium.org>
Reviewed-by: Kai Ninomiya <kainino@chromium.org>
Reviewed-by: Fernando Serboncini <fserb@chromium.org>
Commit-Queue: Philip Rogers <pdr@chromium.org>
Cr-Commit-Position: refs/heads/master@{#907288}

third_party/blink/renderer/core/css/cssom/paint_worklet_deferred_image.cc

@@ -31,12 +31,11 @@ void PaintWorkletDeferredImage::Draw(cc::PaintCanvas* canvas,
                                      const PaintFlags& flags,
                                      const FloatRect& dest_rect,
                                      const FloatRect& src_rect,
-                                     const SkSamplingOptions& sampling,
-                                     RespectImageOrientationEnum,
+                                     const ImageDrawOptions& draw_options,
                                      ImageClampingMode clamping_mode,
                                      ImageDecodingMode) {
-  DrawInternal(canvas, dest_rect, src_rect, sampling, flags, clamping_mode,
-               image_);
+  DrawInternal(canvas, dest_rect, src_rect, draw_options.sampling_options,
+               flags, clamping_mode, image_);
 }
 
 void PaintWorkletDeferredImage::DrawTile(GraphicsContext& context,

third_party/blink/renderer/core/css/cssom/paint_worklet_deferred_image.h

@@ -35,8 +35,7 @@ class CORE_EXPORT PaintWorkletDeferredImage : public GeneratedImage {
             const cc::PaintFlags&,
             const FloatRect&,
             const FloatRect&,
-            const SkSamplingOptions&,
-            RespectImageOrientationEnum,
+            const ImageDrawOptions& draw_options,
             ImageClampingMode,
             ImageDecodingMode) override;
   void DrawTile(GraphicsContext&,

third_party/blink/renderer/core/imagebitmap/image_bitmap.cc

@@ -27,6 +27,7 @@
 #include "third_party/blink/renderer/platform/graphics/canvas_color_params.h"
 #include "third_party/blink/renderer/platform/graphics/canvas_resource_provider.h"
 #include "third_party/blink/renderer/platform/graphics/gpu/shared_gpu_context.h"
+#include "third_party/blink/renderer/platform/graphics/graphics_context.h"
 #include "third_party/blink/renderer/platform/graphics/skia/skia_utils.h"
 #include "third_party/blink/renderer/platform/graphics/unaccelerated_static_bitmap_image.h"
 #include "third_party/blink/renderer/platform/graphics/video_frame_image_util.h"
@@ -943,13 +944,14 @@ ScriptPromise ImageBitmap::CreateAsync(ImageElementBase* image,
     canvas->translate(0, draw_dst_rect.Height());
     canvas->scale(1, -1);
   }
+  ImageDrawOptions draw_options;
+  draw_options.sampling_options = SkSamplingOptions();
   SVGImageForContainer::Create(To<SVGImage>(input.get()),
                                FloatSize(input_rect.Size()), 1, NullURL())
       ->Draw(canvas, cc::PaintFlags(), FloatRect(draw_dst_rect),
-             FloatRect(draw_src_rect), SkSamplingOptions(),
+             FloatRect(draw_src_rect), draw_options,
              // The following will all be ignored.
-             kRespectImageOrientation, Image::kDoNotClampImageToSourceRect,
-             Image::kSyncDecode);
+             Image::kDoNotClampImageToSourceRect, Image::kSyncDecode);
   sk_sp<PaintRecord> paint_record = recorder.finishRecordingAsPicture();
 
   std::unique_ptr<ParsedOptions> passed_parsed_options =

third_party/blink/renderer/core/layout/shapes/shape.cc

@@ -46,6 +46,7 @@
 #include "third_party/blink/renderer/platform/geometry/float_rounded_rect.h"
 #include "third_party/blink/renderer/platform/geometry/float_size.h"
 #include "third_party/blink/renderer/platform/geometry/length_functions.h"
+#include "third_party/blink/renderer/platform/graphics/graphics_context.h"
 #include "third_party/blink/renderer/platform/graphics/graphics_types.h"
 #include "third_party/blink/renderer/platform/graphics/paint/paint_canvas.h"
 #include "third_party/blink/renderer/platform/graphics/paint/paint_flags.h"
@@ -276,9 +277,12 @@ static bool ExtractImageData(Image* image,
   IntRect image_dest_rect(IntPoint(), image_size);
   SkiaPaintCanvas canvas(surface->getCanvas());
   canvas.clear(SK_ColorTRANSPARENT);
+  ImageDrawOptions draw_options;
+  draw_options.sampling_options = SkSamplingOptions();
+  draw_options.respect_image_orientation = respect_orientation;
   image->Draw(&canvas, flags, FloatRect(image_dest_rect), image_source_rect,
-              SkSamplingOptions(), respect_orientation,
-              Image::kDoNotClampImageToSourceRect, Image::kSyncDecode);
+              draw_options, Image::kDoNotClampImageToSourceRect,
+              Image::kSyncDecode);
   return true;
 }
 

third_party/blink/renderer/core/page/drag_image_test.cc

@@ -69,8 +69,7 @@ class TestImage : public Image {
             const cc::PaintFlags&,
             const FloatRect&,
             const FloatRect&,
-            const SkSamplingOptions&,
-            RespectImageOrientationEnum,
+            const ImageDrawOptions& draw_options,
             ImageClampingMode,
             ImageDecodingMode) override {
     // Image pure virtual stub.

third_party/blink/renderer/core/svg/graphics/svg_image.cc

@@ -369,11 +369,13 @@ FloatSize SVGImage::ConcreteObjectSize(
 
 SVGImage::DrawInfo::DrawInfo(const FloatSize& container_size,
                              float zoom,
-                             const KURL& url)
+                             const KURL& url,
+                             bool is_dark_mode_enabled)
     : container_size_(container_size),
       rounded_container_size_(RoundedIntSize(container_size)),
       zoom_(zoom),
-      url_(url) {}
+      url_(url),
+      is_dark_mode_enabled_(is_dark_mode_enabled) {}
 
 FloatSize SVGImage::DrawInfo::CalculateResidualScale() const {
   return FloatSize(rounded_container_size_.Width() / container_size_.Width(),
@@ -397,7 +399,7 @@ void SVGImage::DrawForContainer(const DrawInfo& draw_info,
 }
 
 PaintImage SVGImage::PaintImageForCurrentFrame() {
-  const DrawInfo draw_info(FloatSize(intrinsic_size_), 1, NullURL());
+  const DrawInfo draw_info(FloatSize(intrinsic_size_), 1, NullURL(), false);
   auto builder = CreatePaintImageBuilder();
   PopulatePaintRecordForCurrentFrameForContainer(draw_info, builder);
   return builder.TakePaintImage();
@@ -489,7 +491,7 @@ bool SVGImage::ApplyShaderInternal(const DrawInfo& draw_info,
 }
 
 bool SVGImage::ApplyShader(PaintFlags& flags, const SkMatrix& local_matrix) {
-  const DrawInfo draw_info(FloatSize(intrinsic_size_), 1, NullURL());
+  const DrawInfo draw_info(FloatSize(intrinsic_size_), 1, NullURL(), false);
   return ApplyShaderInternal(draw_info, flags, local_matrix);
 }
 
@@ -509,11 +511,11 @@ void SVGImage::Draw(cc::PaintCanvas* canvas,
                     const PaintFlags& flags,
                     const FloatRect& dst_rect,
                     const FloatRect& src_rect,
-                    const SkSamplingOptions&,
-                    RespectImageOrientationEnum,
+                    const ImageDrawOptions& draw_options,
                     ImageClampingMode,
                     ImageDecodingMode) {
-  const DrawInfo draw_info(FloatSize(intrinsic_size_), 1, NullURL());
+  const DrawInfo draw_info(FloatSize(intrinsic_size_), 1, NullURL(),
+                           draw_options.apply_dark_mode);
   DrawInternal(draw_info, canvas, flags, dst_rect, src_rect);
 }
 
@@ -544,6 +546,7 @@ sk_sp<PaintRecord> SVGImage::PaintRecordForCurrentFrame(
   FlushPendingTimelineRewind();
 
   if (RuntimeEnabledFeatures::CompositeAfterPaintEnabled()) {
+    page_->GetSettings().SetForceDarkModeEnabled(draw_info.IsDarkModeEnabled());
     view->UpdateAllLifecyclePhases(DocumentUpdateReason::kSVGImage);
     return view->GetPaintRecord();
   }
@@ -555,6 +558,7 @@ sk_sp<PaintRecord> SVGImage::PaintRecordForCurrentFrame(
 
   view->UpdateAllLifecyclePhasesExceptPaint(DocumentUpdateReason::kSVGImage);
   PaintRecordBuilder builder(*paint_controller_);
+  builder.Context().SetDarkModeEnabled(draw_info.IsDarkModeEnabled());
   view->PaintOutsideOfLifecycle(builder.Context(), kGlobalPaintNormalPhase);
   return builder.EndRecording();
 }

third_party/blink/renderer/core/svg/graphics/svg_image.h

@@ -141,7 +141,10 @@ class CORE_EXPORT SVGImage final : public Image {
     STACK_ALLOCATED();
 
    public:
-    DrawInfo(const FloatSize& container_size, float zoom, const KURL& url);
+    DrawInfo(const FloatSize& container_size,
+             float zoom,
+             const KURL& url,
+             bool is_dark_mode_enabled);
 
     FloatSize CalculateResidualScale() const;
     float Zoom() const { return zoom_; }
@@ -150,20 +153,21 @@ class CORE_EXPORT SVGImage final : public Image {
       return rounded_container_size_;
     }
     const KURL& Url() const { return url_; }
+    bool IsDarkModeEnabled() const { return is_dark_mode_enabled_; }
 
    private:
     const FloatSize container_size_;
     const IntSize rounded_container_size_;
     const float zoom_;
     const KURL& url_;
+    const bool is_dark_mode_enabled_;
   };
 
   void Draw(cc::PaintCanvas*,
             const cc::PaintFlags&,
             const FloatRect& dst_rect,
             const FloatRect& src_rect,
-            const SkSamplingOptions&,
-            RespectImageOrientationEnum,
+            const ImageDrawOptions& draw_options,
             ImageClampingMode,
             ImageDecodingMode) override;
   void DrawForContainer(const DrawInfo&,

third_party/blink/renderer/core/svg/graphics/svg_image_for_container.cc

@@ -18,6 +18,7 @@
  */
 
 #include "third_party/blink/renderer/core/svg/graphics/svg_image_for_container.h"
+#include "third_party/blink/renderer/platform/graphics/graphics_context.h"
 
 namespace blink {
 
@@ -33,32 +34,33 @@ void SVGImageForContainer::Draw(cc::PaintCanvas* canvas,
                                 const cc::PaintFlags& flags,
                                 const FloatRect& dst_rect,
                                 const FloatRect& src_rect,
-                                const SkSamplingOptions&,
-                                RespectImageOrientationEnum,
+                                const ImageDrawOptions& draw_options,
                                 ImageClampingMode,
                                 ImageDecodingMode) {
-  const SVGImage::DrawInfo draw_info(container_size_, zoom_, url_);
+  const SVGImage::DrawInfo draw_info(container_size_, zoom_, url_,
+                                     draw_options.apply_dark_mode);
   image_->DrawForContainer(draw_info, canvas, flags, dst_rect, src_rect);
 }
 
 void SVGImageForContainer::DrawPattern(GraphicsContext& context,
                                        const cc::PaintFlags& flags,
                                        const FloatRect& dst_rect,
                                        const ImageTilingInfo& tiling_info,
-                                       RespectImageOrientationEnum) {
-  const SVGImage::DrawInfo draw_info(container_size_, zoom_, url_);
+                                       const ImageDrawOptions& draw_options) {
+  const SVGImage::DrawInfo draw_info(container_size_, zoom_, url_,
+                                     draw_options.apply_dark_mode);
   image_->DrawPatternForContainer(draw_info, context, flags, dst_rect,
                                   tiling_info);
 }
 
 bool SVGImageForContainer::ApplyShader(cc::PaintFlags& flags,
                                        const SkMatrix& local_matrix) {
-  const SVGImage::DrawInfo draw_info(container_size_, zoom_, url_);
+  const SVGImage::DrawInfo draw_info(container_size_, zoom_, url_, false);
   return image_->ApplyShaderForContainer(draw_info, flags, local_matrix);
 }
 
 PaintImage SVGImageForContainer::PaintImageForCurrentFrame() {
-  const SVGImage::DrawInfo draw_info(container_size_, zoom_, url_);
+  const SVGImage::DrawInfo draw_info(container_size_, zoom_, url_, false);
   auto builder = CreatePaintImageBuilder();
   image_->PopulatePaintRecordForCurrentFrameForContainer(draw_info, builder);
   return builder.TakePaintImage();

third_party/blink/renderer/core/svg/graphics/svg_image_for_container.h

@@ -80,22 +80,23 @@ class CORE_EXPORT SVGImageForContainer final : public Image {
             const cc::PaintFlags&,
             const FloatRect&,
             const FloatRect&,
-            const SkSamplingOptions&,
-            RespectImageOrientationEnum,
+            const ImageDrawOptions& draw_options,
             ImageClampingMode,
             ImageDecodingMode) override;
 
   // FIXME: Implement this to be less conservative.
   bool CurrentFrameKnownToBeOpaque() override { return false; }
 
+  bool IsSVGImageForContainer() const override { return true; }
+
   PaintImage PaintImageForCurrentFrame() override;
 
  protected:
   void DrawPattern(GraphicsContext&,
                    const cc::PaintFlags&,
                    const FloatRect& dest_rect,
                    const ImageTilingInfo&,
-                   RespectImageOrientationEnum) override;
+                   const ImageDrawOptions& draw_options) override;
 
  private:
   SVGImageForContainer(SVGImage* image,

third_party/blink/renderer/core/svg/graphics/svg_image_test.cc

@@ -60,9 +60,10 @@ class SVGImageTest : public testing::Test, private ScopedMockOverlayScrollbars {
     SkiaPaintCanvas canvas(null_canvas.get());
     PaintFlags flags;
     FloatRect dummy_rect(0, 0, 100, 100);
-    image->Draw(&canvas, flags, dummy_rect, dummy_rect, SkSamplingOptions(),
-                kRespectImageOrientation, Image::kDoNotClampImageToSourceRect,
-                Image::kSyncDecode);
+    ImageDrawOptions draw_options;
+    draw_options.sampling_options = SkSamplingOptions();
+    image->Draw(&canvas, flags, dummy_rect, dummy_rect, draw_options,
+                Image::kDoNotClampImageToSourceRect, Image::kSyncDecode);
   }
 
  private:

third_party/blink/renderer/modules/canvas/canvas2d/base_rendering_context_2d.cc

@@ -24,6 +24,7 @@
 #include "third_party/blink/renderer/modules/canvas/canvas2d/path_2d.h"
 #include "third_party/blink/renderer/platform/geometry/float_quad.h"
 #include "third_party/blink/renderer/platform/graphics/bitmap_image.h"
+#include "third_party/blink/renderer/platform/graphics/graphics_context.h"
 #include "third_party/blink/renderer/platform/graphics/skia/skia_utils.h"
 #include "third_party/blink/renderer/platform/graphics/stroke_data.h"
 #include "third_party/blink/renderer/platform/heap/heap.h"
@@ -1583,9 +1584,11 @@ void BaseRenderingContext2D::DrawImageInternal(
           image->SizeAsFloat(kRespectImageOrientation), src_rect);
     }
     image_flags.setAntiAlias(ShouldDrawImageAntialiased(dst_rect));
-    image->Draw(c, image_flags, dst_rect, corrected_src_rect, sampling,
-                respect_orientation, Image::kDoNotClampImageToSourceRect,
-                Image::kSyncDecode);
+    ImageDrawOptions draw_options;
+    draw_options.sampling_options = sampling;
+    draw_options.respect_image_orientation = respect_orientation;
+    image->Draw(c, image_flags, dst_rect, corrected_src_rect, draw_options,
+                Image::kDoNotClampImageToSourceRect, Image::kSyncDecode);
   } else {
     c->save();
     c->clipRect(dst_rect);

third_party/blink/renderer/modules/webgl/webgl_rendering_context_base.cc

@@ -1730,10 +1730,11 @@ bool WebGLRenderingContextBase::CopyRenderingResultsFromDrawingBuffer(
   flags.setBlendMode(SkBlendMode::kSrc);
   // We use this draw helper as we need to take into account the
   // ImageOrientation of the UnacceleratedStaticBitmapImage.
+  ImageDrawOptions draw_options;
+  draw_options.sampling_options = SkSamplingOptions();
   image->Draw(resource_provider->Canvas(), flags, FloatRect(dest_rect),
-              FloatRect(src_rect), SkSamplingOptions(),
-              kRespectImageOrientation, Image::kDoNotClampImageToSourceRect,
-              Image::kSyncDecode);
+              FloatRect(src_rect), draw_options,
+              Image::kDoNotClampImageToSourceRect, Image::kSyncDecode);
   return true;
 }
 
@@ -5138,10 +5139,11 @@ scoped_refptr<Image> WebGLRenderingContextBase::DrawImageIntoBuffer(
   PaintFlags flags;
   // TODO(ccameron): WebGL should produce sRGB images.
   // https://crbug.com/672299
+  ImageDrawOptions draw_options;
+  draw_options.sampling_options = SkSamplingOptions();
   image->Draw(resource_provider->Canvas(), flags, FloatRect(dest_rect),
-              FloatRect(src_rect), SkSamplingOptions(),
-              kRespectImageOrientation, Image::kDoNotClampImageToSourceRect,
-              Image::kSyncDecode);
+              FloatRect(src_rect), draw_options,
+              Image::kDoNotClampImageToSourceRect, Image::kSyncDecode);
   return resource_provider->Snapshot();
 }
 

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

@@ -18,6 +18,7 @@
 #include "third_party/blink/public/platform/web_graphics_context_3d_provider.h"
 #include "third_party/blink/renderer/platform/graphics/canvas_resource_provider.h"
 #include "third_party/blink/renderer/platform/graphics/gpu/shared_gpu_context.h"
+#include "third_party/blink/renderer/platform/graphics/graphics_context.h"
 #include "third_party/blink/renderer/platform/graphics/mailbox_ref.h"
 #include "third_party/blink/renderer/platform/graphics/mailbox_texture_backing.h"
 #include "third_party/blink/renderer/platform/graphics/skia/skia_utils.h"
@@ -205,15 +206,13 @@ PaintImage AcceleratedStaticBitmapImage::PaintImageForCurrentFrame() {
       .TakePaintImage();
 }
 
-void AcceleratedStaticBitmapImage::Draw(
-    cc::PaintCanvas* canvas,
-    const cc::PaintFlags& flags,
-    const FloatRect& dst_rect,
-    const FloatRect& src_rect,
-    const SkSamplingOptions& sampling,
-    RespectImageOrientationEnum should_respect_image_orientation,
-    ImageClampingMode image_clamping_mode,
-    ImageDecodingMode decode_mode) {
+void AcceleratedStaticBitmapImage::Draw(cc::PaintCanvas* canvas,
+                                        const cc::PaintFlags& flags,
+                                        const FloatRect& dst_rect,
+                                        const FloatRect& src_rect,
+                                        const ImageDrawOptions& draw_options,
+                                        ImageClampingMode image_clamping_mode,
+                                        ImageDecodingMode decode_mode) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   auto paint_image = PaintImageForCurrentFrame();
   if (!paint_image)
@@ -224,9 +223,9 @@ void AcceleratedStaticBitmapImage::Draw(
                       .set_decoding_mode(paint_image_decoding_mode)
                       .TakePaintImage();
   }
-  StaticBitmapImage::DrawHelper(canvas, flags, dst_rect, src_rect, sampling,
-                                image_clamping_mode,
-                                should_respect_image_orientation, paint_image);
+  StaticBitmapImage::DrawHelper(
+      canvas, flags, dst_rect, src_rect, draw_options.sampling_options,
+      image_clamping_mode, draw_options.respect_image_orientation, paint_image);
 }
 
 bool AcceleratedStaticBitmapImage::IsValid() const {

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

@@ -75,8 +75,7 @@ class PLATFORM_EXPORT AcceleratedStaticBitmapImage final
             const cc::PaintFlags&,
             const FloatRect& dst_rect,
             const FloatRect& src_rect,
-            const SkSamplingOptions&,
-            RespectImageOrientationEnum,
+            const ImageDrawOptions& draw_options,
             ImageClampingMode,
             ImageDecodingMode) override;