Implement merging non-composited paint property nodes in the PACompositor.

third_party/WebKit/Source/platform/graphics/paint/PropertyTreeState.cpp

Index: third_party/WebKit/Source/platform/graphics/paint/PropertyTreeState.cpp
diff --git a/third_party/WebKit/Source/platform/graphics/paint/PropertyTreeState.cpp b/third_party/WebKit/Source/platform/graphics/paint/PropertyTreeState.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e8f93e3067a50d6f7457c6536c65958e6178f561
--- /dev/null
+++ b/third_party/WebKit/Source/platform/graphics/paint/PropertyTreeState.cpp
@@ -0,0 +1,75 @@
+// Copyright 2016 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 "platform/graphics/paint/PropertyTreeState.h"
+
+#include "platform/graphics/paint/GeometryMapper.h"
+
+namespace blink {
+
+bool PropertyTreeState::hasDirectCompositingReasons() const {
+  switch (innermostNode()) {
+    case Transform:
+      return transform()->hasDirectCompositingReasons();
+    case Clip:
+      return clip()->hasDirectCompositingReasons();
+    case Effect:
+      return effect()->hasDirectCompositingReasons();
+    default:
+      return false;
+  }
+}
+
+template <typename PropertyNode>
+bool isAncestorOf(const PropertyNode* ancestor, const PropertyNode* child) {
+  while (child && child != ancestor) {
+    child = child->parent();
+  }
+  return child == ancestor;
+}
+
+PropertyTreeState::InnermostNode PropertyTreeState::innermostNode() const {

[pdr., 2016/12/22 19:46:26]

Please document this.

[chrishtr, 2016/12/22 19:53:54]

Done.

+  // TODO(chrishtr): this is very inefficient when innermostNode() is called
+  // repeatedly.
+  bool clipTransformStrictAncestorOfTransform =
+      m_clip->localTransformSpace() != m_transform.get() &&
+      isAncestorOf<TransformPaintPropertyNode>(m_clip->localTransformSpace(),
+                                               m_transform.get());
+  bool effectTransformStrictAncestorOfTransform =
+      m_effect->localTransformSpace() != m_transform.get() &&
+      isAncestorOf<TransformPaintPropertyNode>(m_effect->localTransformSpace(),
+                                               m_transform.get());
+
+  if (!m_transform->isRoot() && clipTransformStrictAncestorOfTransform &&
+      effectTransformStrictAncestorOfTransform)
+    return Transform;
+
+  bool clipAncestorOfEffect =
+      isAncestorOf<ClipPaintPropertyNode>(m_clip.get(), m_effect->outputClip());
+
+  if (!m_effect->isRoot() && clipAncestorOfEffect) {
+    return Effect;
+  }
+  if (!m_clip->isRoot())
+    return Clip;
+  return None;
+}
+
+const PropertyTreeState* PropertyTreeStateIterator::next() {
+  switch (m_properties.innermostNode()) {
+    case PropertyTreeState::Transform:
+      m_properties.setTransform(m_properties.transform()->parent());
+      return &m_properties;
+    case PropertyTreeState::Clip:
+      m_properties.setClip(m_properties.clip()->parent());
+      return &m_properties;
+    case PropertyTreeState::Effect:
+      m_properties.setEffect(m_properties.effect()->parent());
+      return &m_properties;
+    case PropertyTreeState::None:
+      return nullptr;
+  }
+}
+
+}  // namespace blink