Generate scroll/clip display item hierarchy for SPv2

Source/platform/graphics/paint/DisplayItemPropertyTreeBuilder.cpp

 // Copyright 2015 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 "config.h"
 #include "platform/graphics/paint/DisplayItemPropertyTreeBuilder.h"
 
+#include "platform/RuntimeEnabledFeatures.h"
 #include "platform/graphics/paint/DisplayItem.h"
 #include "platform/graphics/paint/DisplayItemClipTree.h"
 #include "platform/graphics/paint/DisplayItemTransformTree.h"
+#include "platform/graphics/paint/FixedPositionDisplayItem.h"
 #include "platform/graphics/paint/ScrollDisplayItem.h"
 #include "platform/graphics/paint/Transform3DDisplayItem.h"
 #include "platform/graphics/paint/TransformDisplayItem.h"
 
 namespace blink {
 
 DisplayItemPropertyTreeBuilder::DisplayItemPropertyTreeBuilder()
     : m_transformTree(adoptPtr(new DisplayItemTransformTree))
     , m_clipTree(adoptPtr(new DisplayItemClipTree))
     , m_rangeBeginIndex(0)
@@ skipping 28 matching lines @@
     output.swap(m_rangeRecords);
     return output;
 }
 
 void DisplayItemPropertyTreeBuilder::processDisplayItem(const DisplayItem& displayItem)
 {
     if (displayItem.isBegin())
         processBeginItem(displayItem);
     else if (displayItem.isEnd())
         processEndItem(displayItem);
+    else if (displayItem.type() == DisplayItem::FixedPositionContainer)
+        processAnchorItem(displayItem);
     m_currentIndex++;
 }
 
 namespace {
 
 enum TransformKind { NotATransform = 0, Only2DTranslation, RequiresTransformNode };
 enum ClipKind { NotAClip = 0, RequiresClipNode };
+enum SpecialKind { NotSpecial = 0, IsFixedPosition };
 
 struct BeginDisplayItemClassification {
     TransformKind transformKind = NotATransform;
     TransformationMatrix matrix;
     ClipKind clipKind = NotAClip;
     FloatRect clipRect;
+    SpecialKind specialKind = NotSpecial;
+    DisplayItemClient anchorKey;
 };
 
 // Classifies a begin display item based on how it affects the property trees.
 static BeginDisplayItemClassification classifyBeginItem(const DisplayItem& beginDisplayItem)
 {
     ASSERT(beginDisplayItem.isBegin());
 
     BeginDisplayItemClassification result;
     DisplayItem::Type type = beginDisplayItem.type();
     if (DisplayItem::isTransform3DType(type)) {
         const auto& begin3D = static_cast<const BeginTransform3DDisplayItem&>(beginDisplayItem);
         result.matrix = begin3D.transform();
         result.transformKind = result.matrix.isIdentityOr2DTranslation() ? Only2DTranslation : RequiresTransformNode;
     } else if (type == DisplayItem::BeginTransform) {
         const auto& begin2D = static_cast<const BeginTransformDisplayItem&>(beginDisplayItem);
         result.matrix = begin2D.transform();
         result.transformKind = begin2D.transform().isIdentityOrTranslation() ? Only2DTranslation : RequiresTransformNode;
     } else if (DisplayItem::isScrollType(type)) {
         const auto& beginScroll = static_cast<const BeginScrollDisplayItem&>(beginDisplayItem);
         const IntSize& offset = beginScroll.currentOffset();
         result.matrix.translate(-offset.width(), -offset.height());
         result.transformKind = Only2DTranslation;
+    } else if (type == DisplayItem::BeginFixedPosition) {
+        result.specialKind = IsFixedPosition;
+        result.anchorKey = static_cast<const BeginFixedPositionDisplayItem&>(beginDisplayItem).anchor();
     }
     return result;
 }
 
 } // namespace
 
 void DisplayItemPropertyTreeBuilder::processBeginItem(const DisplayItem& displayItem)
 {
     BeginDisplayItemClassification classification = classifyBeginItem(displayItem);
 
-    if (!classification.transformKind && !classification.clipKind) {
+    if (!classification.transformKind && !classification.clipKind && !classification.specialKind) {
         currentState().ignoredBeginCount++;
         return;
     }
 
     finishRange();
     BuilderState newState(currentState());
     newState.ignoredBeginCount = 0;
 
     switch (classification.transformKind) {
     case NotATransform:
@@ skipping 15 matching lines @@
         break;
     case RequiresClipNode:
         // Emit a clip node.
         FloatRect adjustedClipRect = classification.clipRect;
         adjustedClipRect.move(newState.offset);
         newState.clipNode = m_clipTree->createNewNode(
             newState.clipNode, newState.transformNode, adjustedClipRect);
         break;
     }
 
+    switch (classification.specialKind) {
+    case NotSpecial:
+        break;
+    case IsFixedPosition:
+        BuilderState referredState(m_anchors.get(classification.anchorKey));
+        newState.transformNode = referredState.transformNode;
+        newState.offset = referredState.offset;
+        newState.clipNode = referredState.clipNode;
+        {
+            // Note: This is only temporarily workaround before we implement true
+            // transform-tree-based rasterization.
+            ASSERT(currentState().transformNode == newState.transformNode);
+            static_cast<const BeginFixedPositionDisplayItem&>(displayItem).setCounterScroll(newState.offset - currentState().offset);
+        }
+        break;
+    }
+
     m_stateStack.append(newState);
 }
 
 void DisplayItemPropertyTreeBuilder::processEndItem(const DisplayItem& displayItem)
 {
     if (currentState().ignoredBeginCount) {
         // Ignored this end display item.
         currentState().ignoredBeginCount--;
     } else {
         // We've closed the scope of some property.
         finishRange();
         m_stateStack.removeLast();
         ASSERT(!m_stateStack.isEmpty());
     }
 }
 
+void DisplayItemPropertyTreeBuilder::processAnchorItem(const DisplayItem& displayItem)
+{
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+    // Anchors can duplicate when we have reflection or fragments.
+    // We can't assert uniqueness here. However we may assume the most recent one is valid.
+    m_anchors.set(displayItem.client(), currentState());
+}
+
 void DisplayItemPropertyTreeBuilder::finishRange()
 {
     // Don't emit an empty range record.
     if (m_rangeBeginIndex < m_currentIndex) {
         const auto& current = currentState();
         RangeRecord rangeRecord;
         rangeRecord.displayListBeginIndex = m_rangeBeginIndex;
         rangeRecord.displayListEndIndex = m_currentIndex;
         rangeRecord.transformNodeIndex = current.transformNode;
         rangeRecord.offset = current.offset;
         rangeRecord.clipNodeIndex = current.clipNode;
         m_rangeRecords.append(rangeRecord);
     }
 
     // The current display item is a boundary.
     // The earliest the next range could begin is the next one.
     m_rangeBeginIndex = m_currentIndex + 1;
 }
 
 } // namespace blink