Round the subpixel accumulation used for composited scrolling content

third_party/WebKit/Source/core/paint/PaintLayerPainter.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/paint/PaintLayerPainter.h"
 
 #include "core/frame/LocalFrame.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/ClipPathClipper.h"
 #include "core/paint/FilterPainter.h"
@@ skipping 29 matching lines @@
       !layer.IsRootLayer() && !layer.GetLayoutObject().IsDocumentElement())
     return true;
 
   return false;
 }
 
 void PaintLayerPainter::Paint(GraphicsContext& context,
                               const LayoutRect& damage_rect,
                               const GlobalPaintFlags global_paint_flags,
                               PaintLayerFlags paint_flags) {
+  DCHECK(paint_layer_.GetCompositingState() != kPaintsIntoOwnBacking ||
+         paint_layer_.SubpixelAccumulation().IsZero());
   PaintLayerPaintingInfo painting_info(
       &paint_layer_, LayoutRect(EnclosingIntRect(damage_rect)),
       global_paint_flags, LayoutSize());
   if (ShouldPaintLayerInSoftwareMode(global_paint_flags, paint_flags))
     Paint(context, painting_info, paint_flags);
 }
 
 static ShouldRespectOverflowClipType ShouldRespectOverflowClip(
     PaintLayerFlags paint_flags,
     const LayoutObject& layout_object) {
@@ skipping 262 matching lines @@
   if (paint_layer_.GetLayoutObject().View()->GetFrame() &&
       paint_layer_.GetLayoutObject()
           .View()
           ->GetFrame()
           ->ShouldThrottleRendering())
     return result;
 
   // Ensure our lists are up to date.
   paint_layer_.StackingNode()->UpdateLayerListsIfNeeded();
 
-  LayoutSize subpixel_accumulation =
-      paint_layer_.GetCompositingState() == kPaintsIntoOwnBacking
-          ? paint_layer_.SubpixelAccumulation()
-          : painting_info_arg.sub_pixel_accumulation;
   ShouldRespectOverflowClipType respect_overflow_clip =
       ShouldRespectOverflowClip(paint_flags, paint_layer_.GetLayoutObject());
 
   Optional<SubsequenceRecorder> subsequence_recorder;
   bool should_clear_empty_paint_phase_flags = false;
   if (ShouldCreateSubsequence(paint_layer_, context, painting_info_arg,
                               paint_flags)) {
     if (!ShouldRepaintSubsequence(paint_layer_, painting_info_arg,
-                                  respect_overflow_clip, subpixel_accumulation,
+                                  respect_overflow_clip,
+                                  painting_info_arg.sub_pixel_accumulation,
                                   should_clear_empty_paint_phase_flags) &&
         SubsequenceRecorder::UseCachedSubsequenceIfPossible(context,
                                                             paint_layer_))
       return result;
     DCHECK(paint_layer_.SupportsSubsequenceCaching());
     subsequence_recorder.emplace(context, paint_layer_);
   } else {
     should_clear_empty_paint_phase_flags = true;
   }
 
   if (should_clear_empty_paint_phase_flags) {
     paint_layer_.SetPreviousPaintPhaseDescendantOutlinesEmpty(false);
     paint_layer_.SetPreviousPaintPhaseFloatEmpty(false);
     paint_layer_.SetPreviousPaintPhaseDescendantBlockBackgroundsEmpty(false);
   }
 
   PaintLayerPaintingInfo painting_info = painting_info_arg;
 
   LayoutPoint offset_from_root;
   paint_layer_.ConvertToLayerCoords(painting_info.root_layer, offset_from_root);
-  offset_from_root.Move(subpixel_accumulation);
+  offset_from_root.Move(painting_info_arg.sub_pixel_accumulation);
 
   LayoutRect bounds = paint_layer_.PhysicalBoundingBox(offset_from_root);
   if (!painting_info.paint_dirty_rect.Contains(bounds))
     result = kMayBeClippedByPaintDirtyRect;
 
   // These helpers output clip and compositing operations using a RAII pattern.
   // Stack-allocated-varibles are destructed in the reverse order of
   // construction, so they are nested properly.
   Optional<ClipPathClipper> clip_path_clipper;
   // Clip-path, like border radius, must not be applied to the contents of a
@@ skipping 35 matching lines @@
         painting_info.GetGlobalPaintFlags()));
     compositing_recorder.emplace(
         context, paint_layer_.GetLayoutObject(),
         WebCoreCompositeToSkiaComposite(
             kCompositeSourceOver,
             paint_layer_.GetLayoutObject().Style()->BlendMode()),
         paint_layer_.GetLayoutObject().Opacity(), &compositing_bounds);
   }
 
   PaintLayerPaintingInfo local_painting_info(painting_info);
-  local_painting_info.sub_pixel_accumulation = subpixel_accumulation;
-
   bool should_paint_content = paint_layer_.HasVisibleContent() &&
                               is_self_painting_layer &&
                               !is_painting_overlay_scrollbars;
 
   PaintLayerFragments layer_fragments;
   if (should_paint_content || should_paint_self_outline ||
       is_painting_overlay_scrollbars) {
     // Collect the fragments. This will compute the clip rectangles and paint
     // offsets for each layer fragment.
     ClipRectsCacheSlot cache_slot = (paint_flags & kPaintLayerUncachedClipRects)
@@ skipping 801 matching lines @@
                            paint_flags, kHasNotClipped);
 }
 
 void PaintLayerPainter::PaintOverlayScrollbars(
     GraphicsContext& context,
     const LayoutRect& damage_rect,
     const GlobalPaintFlags paint_flags) {
   if (!paint_layer_.ContainsDirtyOverlayScrollbars())
     return;
 
+  DCHECK(paint_layer_.GetCompositingState() != kPaintsIntoOwnBacking ||
+         paint_layer_.SubpixelAccumulation().IsZero());
   PaintLayerPaintingInfo painting_info(
       &paint_layer_, LayoutRect(EnclosingIntRect(damage_rect)), paint_flags,
       LayoutSize());
   Paint(context, painting_info, kPaintLayerPaintingOverlayScrollbars);
 
   paint_layer_.SetContainsDirtyOverlayScrollbars(false);
 }
 
 void PaintLayerPainter::FillMaskingFragment(GraphicsContext& context,
                                             const ClipRect& clip_rect) {
   const LayoutObject& layout_object = paint_layer_.GetLayoutObject();
   if (LayoutObjectDrawingRecorder::UseCachedDrawingIfPossible(
           context, layout_object, kPaintPhaseClippingMask))
     return;
 
   IntRect snapped_clip_rect = PixelSnappedIntRect(clip_rect.Rect());
   LayoutObjectDrawingRecorder drawing_recorder(
       context, layout_object, kPaintPhaseClippingMask, snapped_clip_rect);
   context.FillRect(snapped_clip_rect, Color::kBlack);
 }
 
 }  // namespace blink