client-goodbye

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 789 matching lines @@
       m_paintLayer.renderableTransform(paintingInfo.getGlobalPaintFlags()));
   IntPoint roundedDelta = roundedIntPoint(delta);
   transform.translateRight(roundedDelta.x(), roundedDelta.y());
   LayoutSize adjustedSubPixelAccumulation =
       paintingInfo.subPixelAccumulation + (delta - roundedDelta);
 
   // TODO(jbroman): Put the real transform origin here, instead of using a
   // matrix with the origin baked in.
   FloatPoint3D transformOrigin;
   Transform3DRecorder transform3DRecorder(
-      context, *m_paintLayer.layoutObject(),
-      DisplayItem::kTransform3DElementTransform, transform, transformOrigin);
+      context, DisplayItem::kTransform3DElementTransform, transform,
+      transformOrigin, m_paintLayer.layoutObject()->visualRect(),
+      m_paintLayer.layoutObject()->debugName(),
+      m_paintLayer.layoutObject()
+          ->paintedOutputOfObjectHasNoEffectRegardlessOfSize());
 
   // Now do a paint with the root layer shifted to be us.
   PaintLayerPaintingInfo transformedPaintingInfo(
       &m_paintLayer, LayoutRect(enclosingIntRect(transform.inverse().mapRect(
                          paintingInfo.paintDirtyRect))),
       paintingInfo.getGlobalPaintFlags(), adjustedSubPixelAccumulation);
   transformedPaintingInfo.ancestorHasClipPathClipping =
       paintingInfo.ancestorHasClipPathClipping;
 
   // Remove skip root background flag when we're painting with a new root.
@@ skipping 90 matching lines @@
       clipRecorder.emplace(context, *m_paintLayer.layoutObject(),
                            DisplayItem::kClipLayerOverflowControls,
                            fragment.backgroundRect, localPaintingInfo.rootLayer,
                            fragment.paginationOffset, paintFlags);
     }
 
     Optional<ScrollRecorder> scrollRecorder;
     if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled() &&
         !localPaintingInfo.scrollOffsetAccumulation.isZero()) {
       cullRect.move(localPaintingInfo.scrollOffsetAccumulation);
-      scrollRecorder.emplace(context, *m_paintLayer.layoutObject(),
-                             DisplayItem::kScrollOverflowControls,
-                             localPaintingInfo.scrollOffsetAccumulation);
+      scrollRecorder.emplace(
+          context, DisplayItem::kScrollOverflowControls,
+          localPaintingInfo.scrollOffsetAccumulation,
+          m_paintLayer.layoutObject()->visualRect(),
+          m_paintLayer.layoutObject()->debugName(),
+          m_paintLayer.layoutObject()
+              ->paintedOutputOfObjectHasNoEffectRegardlessOfSize());
     }
 
     // We pass IntPoint() as the paint offset here, because
     // ScrollableArea::paintOverflowControls just ignores it and uses the
     // offset found in a previous pass.
     CullRect snappedCullRect(pixelSnappedIntRect(cullRect));
     ScrollableAreaPainter(*scrollableArea)
         .paintOverflowControls(context, IntPoint(), snappedCullRect, true);
   }
 }
@@ skipping 58 matching lines @@
     if (!paintingInfo.scrollOffsetAccumulation.isZero()) {
       // As a descendant of the root layer, m_paintLayer's painting is not
       // controlled by the ScrollRecorders created by BlockPainter of the
       // ancestor layers up to the root layer, so we need to issue
       // ScrollRecorder for this layer seperately, with the scroll offset
       // accumulated from the root layer to the parent of this layer, to get the
       // same result as ScrollRecorder in BlockPainter.
       paintOffset += paintingInfo.scrollOffsetAccumulation;
 
       newCullRect.move(paintingInfo.scrollOffsetAccumulation);
-      scrollRecorder.emplace(context, *m_paintLayer.layoutObject(), phase,
-                             paintingInfo.scrollOffsetAccumulation);
+      scrollRecorder.emplace(
+          context, phase, paintingInfo.scrollOffsetAccumulation,
+          m_paintLayer.layoutObject()->visualRect(),
+          m_paintLayer.layoutObject()->debugName(),
+          m_paintLayer.layoutObject()
+              ->paintedOutputOfObjectHasNoEffectRegardlessOfSize());
     }
   }
   PaintInfo paintInfo(context, pixelSnappedIntRect(newCullRect), phase,
                       paintingInfo.getGlobalPaintFlags(), paintFlags,
                       paintingInfo.rootLayer->layoutObject());
 
   m_paintLayer.layoutObject()->paint(paintInfo, paintOffset);
 }
 
 void PaintLayerPainter::paintBackgroundForFragments(
@@ skipping 185 matching lines @@
           context, layoutObject, PaintPhaseClippingMask))
     return;
 
   IntRect snappedClipRect = pixelSnappedIntRect(clipRect.rect());
   LayoutObjectDrawingRecorder drawingRecorder(
       context, layoutObject, PaintPhaseClippingMask, snappedClipRect);
   context.fillRect(snappedClipRect, Color::black);
 }
 
 }  // namespace blink