Put transform tree building in DisplayItemPropertyTreeBuilder.

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/graphics/paint/DisplayItem.h"
+#include "platform/graphics/paint/DisplayItemClipTree.h"
+#include "platform/graphics/paint/DisplayItemTransformTree.h"
+#include "platform/graphics/paint/Transform3DDisplayItem.h"
+
+namespace blink {
+
+DisplayItemPropertyTreeBuilder::DisplayItemPropertyTreeBuilder()
+    : m_transformTree(adoptPtr(new DisplayItemTransformTree))
+    , m_clipTree(adoptPtr(new DisplayItemClipTree))
+    , m_rangeBeginIndex(0)
+    , m_currentIndex(0)
+{
+    m_stateStack.append(State());
+}
+
+DisplayItemPropertyTreeBuilder::~DisplayItemPropertyTreeBuilder()
+{
+}
+
+PassOwnPtr<DisplayItemTransformTree> DisplayItemPropertyTreeBuilder::releaseTransformTree()
+{
+    ASSERT(m_stateStack.size() == 1);
+    ASSERT(currentState().ignoredBeginCount == 0);
+    finishRange();
+    return m_transformTree.release();
+}
+
+PassOwnPtr<DisplayItemClipTree> DisplayItemPropertyTreeBuilder::releaseClipTree()
+{
+    ASSERT(m_stateStack.size() == 1);
+    ASSERT(currentState().ignoredBeginCount == 0);
+    finishRange();
+    return m_clipTree.release();
+}
+
+Vector<DisplayItemPropertyTreeBuilder::RangeRecord> DisplayItemPropertyTreeBuilder::releaseRangeRecords()
+{
+    Vector<RangeRecord> output;
+    output.swap(m_rangeRecords);
+    return output;
+}
+
+void DisplayItemPropertyTreeBuilder::processDisplayItem(const DisplayItem& displayItem)
+{
+    if (displayItem.isBegin())
+        processBeginItem(displayItem);
+    else if (displayItem.isEnd())
+        processEndItem(displayItem);
+    m_currentIndex++;
+}
+
+namespace {
+
+enum TransformKind { NotATransform = 0, Only2DTranslation, RequiresTransformNode };
+enum ClipKind { NotAClip = 0, RequiresClipNode };
+
+struct BeginDisplayItemClassification {

[pdr., 2015/08/17 22:25:07]

This seems overabstracted.

WDYT about just adding light classification such as
requiresTransformNode(BeginTransform3DDisplayItem&) that returns
NeedsNode/DoesNotNeedNode? Instead of this intermediate classification, we'd
just copy out the matrix in processBeginItem(...).

[jbroman, 2015/08/17 23:57:19]

Then the "copying out the matrix" bit will require the same logic as the
classification, as well. Transform3D is the only case here now, but it isn't the
only one -- scroll and TransformDisplayItem are missing, at least. If I'm
already going to go to the effort of figuring out what kind of display item I
have here, why write that again?

Similarly there is more than one kind of clip. ClipDisplayItem requires
intersecting an int rect with several float rects, FloatClipDisplayItem requires
something else, etc.

[pdr., 2015/08/18 04:31:42]

I still don't follow but I may be missing something simple. Is there a case
where we'd have a single display item be both a transform kind and a clip kind?

If so, I like your approach as-is.

If not, the classification and independent switch statements seem tightly
coupled. Why not something like the following?

void DisplayItemPropertyTreeBuilder::processBeginItem(const DisplayItem&
displayItem)
{
  if (isTransform3DType(displayItem.type()) &&
addTransformNodeIfNeeded(displayItem))
    return;
  if (isClipType(displayItem.type()) && addClipNodeIfNeeded(displayItem))
    return;
  currentState().ignoredBeginCount++;
}

bool addTransformNodeIfNeeded(const DisplayItem& displayItem)
{
  if ( ... is identity or translation ... ) {
    State& nextState = finishAndPushNextState();
    nextState.offset += translation;
    return true;
  }
  if ( ... is 3d ... ) {
    State& nextState = finishAndPushNextState();
    ...
    return true;
  }
  return false;
}

bool addClipNodeIfNeeded(const DisplayItem& displayItem)
{
  // compute some clip properties.

  if ( ... no clip needed ... )
    return false;
  if ( ... float clip needed ... ) {
    State& nextState = finishAndPushNextState();
    ...
    return true;
  }
  return false;
}

[jbroman, 2015/08/18 14:18:16]

Yes, I do expect that display items may create nodes in multiple property trees.
A scroll display item creates both a transform node and a scroll node. A clip
node (with a rounded rect) creates both a clip node and an effect node. And so
on.

+    TransformKind transformKind = NotATransform;
+    TransformationMatrix matrix;
+    ClipKind clipKind = NotAClip;
+    FloatRect clipRect;
+};
+
+// 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;
+    }
+    return result;
+}
+
+} // namespace
+
+void DisplayItemPropertyTreeBuilder::processBeginItem(const DisplayItem& displayItem)
+{
+    BeginDisplayItemClassification classification = classifyBeginItem(displayItem);
+
+    if (!classification.transformKind && !classification.clipKind) {
+        currentState().ignoredBeginCount++;
+        return;
+    }
+
+    finishRange();
+    State newState(currentState());
+    newState.ignoredBeginCount = 0;
+
+    switch (classification.transformKind) {
+    case NotATransform:
+        break;
+    case Only2DTranslation:
+        // Adjust the offset associated with the current transform node.
+        newState.offset += classification.matrix.to2DTranslation();
+        break;
+    case RequiresTransformNode:
+        // Emit a transform node.
+        newState.transformNode = m_transformTree->createNewNode(
+            newState.transformNode, classification.matrix);
+        newState.offset = FloatSize();
+        break;
+    }
+
+    switch (classification.clipKind) {
+    case NotAClip:
+        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;
+    }
+
+    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::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