Update svg's root paint offset property during paint

third_party/WebKit/Source/core/paint/LayoutObjectDrawingRecorder.h

 // 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.
 
 #ifndef LayoutObjectDrawingRecorder_h
 #define LayoutObjectDrawingRecorder_h
 
 #include "core/layout/LayoutObject.h"
+#include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/PaintPhase.h"
 #include "platform/geometry/LayoutPoint.h"
 #include "platform/geometry/LayoutRect.h"
 #include "platform/graphics/paint/DisplayItemCacheSkipper.h"
 #include "platform/graphics/paint/DrawingRecorder.h"
+#include "platform/graphics/paint/ScopedPaintChunkProperties.h"
 #include "wtf/Allocator.h"
 #include "wtf/Optional.h"
 
 namespace blink {
 
 class GraphicsContext;
 
 // Convenience wrapper of DrawingRecorder for LayoutObject painters.
 class LayoutObjectDrawingRecorder final {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 public:
     static bool useCachedDrawingIfPossible(GraphicsContext& context, const LayoutObject& layoutObject, DisplayItem::Type displayItemType, const LayoutPoint& paintOffset)
     {
         if (RuntimeEnabledFeatures::slimmingPaintOffsetCachingEnabled() && layoutObject.paintOffsetChanged(paintOffset))
             return false;
         if (layoutObject.fullPaintInvalidationReason() == PaintInvalidationDelayedFull)
             return false;
+
+        Optional<ScopedPaintChunkProperties> propertyScope;

[jbroman, 2016/02/01 16:44:20]

I'm not convinced LayoutObjectDrawingRecorder is the right home, nor would I
expect a boolean-returning method called "use cached drawing if possible" to
have this effect. I'd rather the callers which expect this set paint chunk
properties outside this, especially since it would be reasonable for it to span
multiple drawings.

A helper may be useful if this logic is common to multiple callers, but this
looks odd to me.

+        if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
+            // TODO(pdr): Refactor this so it is not called twice (again in useCachedDrawingIfPossible).
+            bool willUseCachedDrawing = !context.paintController().clientCacheIsValid(layoutObject);
+            if (willUseCachedDrawing)
+                updatePropertyScope(propertyScope, context, layoutObject);
+        }
+
         return DrawingRecorder::useCachedDrawingIfPossible(context, layoutObject, displayItemType);
     }
 
     static bool useCachedDrawingIfPossible(GraphicsContext& context, const LayoutObject& layoutObject, PaintPhase phase, const LayoutPoint& paintOffset)
     {
         return useCachedDrawingIfPossible(context, layoutObject, DisplayItem::paintPhaseToDrawingType(phase), paintOffset);
     }
 
     LayoutObjectDrawingRecorder(GraphicsContext& context, const LayoutObject& layoutObject, DisplayItem::Type displayItemType, const FloatRect& clip, const LayoutPoint& paintOffset)
     {
+        updatePropertyScope(m_propertyScope, context, layoutObject);
         updatePaintOffsetIfNeeded(context.paintController(), layoutObject, paintOffset);
         // We may paint a delayed-invalidation object before it's actually invalidated.
         if (layoutObject.fullPaintInvalidationReason() == PaintInvalidationDelayedFull)
             m_cacheSkipper.emplace(context);
         m_drawingRecorder.emplace(context, layoutObject, displayItemType, clip);
     }
 
     LayoutObjectDrawingRecorder(GraphicsContext& context, const LayoutObject& layoutObject, DisplayItem::Type displayItemType, const LayoutRect& clip, const LayoutPoint& paintOffset)
         : LayoutObjectDrawingRecorder(context, layoutObject, displayItemType, FloatRect(clip), paintOffset) { }
 
     LayoutObjectDrawingRecorder(GraphicsContext& context, const LayoutObject& layoutObject, PaintPhase phase, const FloatRect& clip, const LayoutPoint& paintOffset)
         : LayoutObjectDrawingRecorder(context, layoutObject, DisplayItem::paintPhaseToDrawingType(phase), clip, paintOffset) { }
 
     LayoutObjectDrawingRecorder(GraphicsContext& context, const LayoutObject& layoutObject, PaintPhase phase, const LayoutRect& clip, const LayoutPoint& paintOffset)
         : LayoutObjectDrawingRecorder(context, layoutObject, DisplayItem::paintPhaseToDrawingType(phase), FloatRect(clip), paintOffset) { }
 
     LayoutObjectDrawingRecorder(GraphicsContext& context, const LayoutObject& layoutObject, PaintPhase phase, const IntRect& clip, const LayoutPoint& paintOffset)
         : LayoutObjectDrawingRecorder(context, layoutObject, DisplayItem::paintPhaseToDrawingType(phase), FloatRect(clip), paintOffset) { }
 
     void setKnownToBeOpaque() { ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled()); m_drawingRecorder->setKnownToBeOpaque(); }
 
 #if ENABLE(ASSERT)
     void setUnderInvalidationCheckingMode(DrawingDisplayItem::UnderInvalidationCheckingMode mode) { m_drawingRecorder->setUnderInvalidationCheckingMode(mode); }
 #endif
 
+    static void updatePropertyScope(Optional<ScopedPaintChunkProperties>& scopedPaintChunkProperties, GraphicsContext& context, const LayoutObject& layoutObject)
+    {
+        if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled())
+            return;
+
+        // Only objects with properties and no layer need to update paint
+        // properties, as PaintLayerPainter will handle all other cases.

[trchen, 2016/02/02 01:34:48]

This statement is not true. For example, a PaintLayer needs to apply itself with
all overflow clip/scroll imposed by its positional ancestors, but not overflow
clip from itself. Its normal flow contents still need to apply overflow clip
during paint walk. See: https://codereview.chromium.org/1652313003/

I haven't looked at all cases, but we probably can't apply all properties
blindly at a single place. For example, some display items are subject to
overflow clip, but not being scrolled.

+        // (see: PaintLayerPainter::paintLayerContents).
+        if (!layoutObject.objectPaintProperties() || layoutObject.hasLayer())
+            return;
+
+        const ObjectPaintProperties& objectProperties = *layoutObject.objectPaintProperties();
+        PaintChunkProperties properties(context.paintController().currentPaintChunkProperties());
+        if (TransformPaintPropertyNode* transform = objectProperties.paintOffsetTranslation())
+            properties.transform = transform;
+        if (TransformPaintPropertyNode* transform = objectProperties.transform())
+            properties.transform = transform;
+        if (TransformPaintPropertyNode* transform = objectProperties.perspective())
+            properties.transform = transform;
+        if (TransformPaintPropertyNode* transform = objectProperties.scrollTranslation())
+            properties.transform = transform;
+        if (EffectPaintPropertyNode* effect = objectProperties.effect())
+            properties.effect = effect;
+        scopedPaintChunkProperties.emplace(context.paintController(), properties);
+    }
 private:
     static void updatePaintOffsetIfNeeded(PaintController& paintController, const LayoutObject& layoutObject, const LayoutPoint& paintOffset)
     {
         if (!RuntimeEnabledFeatures::slimmingPaintOffsetCachingEnabled() || paintController.skippingCache())
             return;
 
         if (layoutObject.paintOffsetChanged(paintOffset))
             paintController.invalidatePaintOffset(layoutObject);
         else
             ASSERT(!paintController.paintOffsetWasInvalidated(layoutObject) || !paintController.clientCacheIsValid(layoutObject));
 
         layoutObject.mutableForPainting().setPreviousPaintOffset(paintOffset);
     }
 
+    Optional<ScopedPaintChunkProperties> m_propertyScope;
     Optional<DisplayItemCacheSkipper> m_cacheSkipper;
     Optional<DrawingRecorder> m_drawingRecorder;
 };
 
 } // namespace blink
 
 #endif // LayoutObjectDrawingRecorder_h