Move property tree debugging code to platform/graphics/paint/ (try #2)

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

 // 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.
 
 #ifndef PropertyTreeState_h
 #define PropertyTreeState_h
 
 #include "platform/graphics/paint/ClipPaintPropertyNode.h"
 #include "platform/graphics/paint/EffectPaintPropertyNode.h"
 #include "platform/graphics/paint/ScrollPaintPropertyNode.h"
 #include "platform/graphics/paint/TransformPaintPropertyNode.h"
 #include "wtf/HashFunctions.h"
 #include "wtf/HashTraits.h"
+#include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 // A complete set of paint properties including those that are inherited from
 // other objects.  RefPtrs are used to guard against use-after-free bugs and
 // DCHECKs ensure PropertyTreeState never retains the last reference to a
 // property tree node.
 class PLATFORM_EXPORT PropertyTreeState {
  public:
   PropertyTreeState(const TransformPaintPropertyNode* transform,
@@ skipping 81 matching lines @@
   //
   // The PropertyTreeStateIterator will behave like this:
   //
   // PropertyTreeStateIterator iterator(PropertyTreeState(T, C, E));
   // DCHECK(iterator.innermostNode() == Effect);
   // DCHECK(iterator.next()->innermostNode() == Clip);
   // DCHECK(iterator.next()->innermostNode() == Transform);
   // DCHECK(iterator.next()->innermostNode() == None);
   InnermostNode innermostNode() const;
 
+#if DCHECK_IS_ON()
+  // Dumps the tree from this state up to the root as a string.
+  String toTreeString() const;
+#endif
+
  private:
   RefPtr<const TransformPaintPropertyNode> m_transform;
   RefPtr<const ClipPaintPropertyNode> m_clip;
   RefPtr<const EffectPaintPropertyNode> m_effect;
   RefPtr<const ScrollPaintPropertyNode> m_scroll;
 };
 
 inline bool operator==(const PropertyTreeState& a, const PropertyTreeState& b) {
   return a.transform() == b.transform() && a.clip() == b.clip() &&
          a.effect() == b.effect() && a.scroll() == b.scroll();
 }
 
 // Iterates over the sequence transforms, clips and effects for a
 // PropertyTreeState between that state and the "root" state (all nodes equal
 // to *::Root()), in the order that they apply.
 //
 // See also PropertyTreeState::innermostNode for a more detailed example.
 class PLATFORM_EXPORT PropertyTreeStateIterator {
  public:
   PropertyTreeStateIterator(const PropertyTreeState& properties)
       : m_properties(properties) {}
   const PropertyTreeState* next();
 
  private:
   PropertyTreeState m_properties;
 };
 
+#if DCHECK_IS_ON()
+
+template <typename PropertyTreeNode>
+class PropertyTreeStatePrinter {
+ public:
+  String pathAsString(const PropertyTreeNode* lastNode) {
+    const PropertyTreeNode* node = lastNode;
+    while (!node->isRoot()) {
+      addPropertyNode(node, "");
+      node = node->parent();
+    }
+    addPropertyNode(node, "root");
+
+    StringBuilder stringBuilder;
+    addAllPropertyNodes(stringBuilder, node);
+    return stringBuilder.toString();
+  }
+
+  void addPropertyNode(const PropertyTreeNode* node, String debugInfo) {
+    m_nodeToDebugString.set(node, debugInfo);
+  }
+
+  void addAllPropertyNodes(StringBuilder& stringBuilder,
+                           const PropertyTreeNode* node,
+                           unsigned indent = 0) {
+    DCHECK(node);
+    for (unsigned i = 0; i < indent; i++)
+      stringBuilder.append(' ');
+    if (m_nodeToDebugString.contains(node))
+      stringBuilder.append(m_nodeToDebugString.get(node));
+    stringBuilder.append(String::format(" %p ", node));
+    stringBuilder.append(node->toString());
+    stringBuilder.append("\n");
+
+    for (const auto* childNode : m_nodeToDebugString.keys()) {
+      if (childNode->parent() == node)
+        addAllPropertyNodes(stringBuilder, childNode, indent + 2);
+    }
+  }
+
+  HashMap<const PropertyTreeNode*, String> m_nodeToDebugString;
+};
+
+#endif
+
 }  // namespace blink
 
 #endif  // PropertyTreeState_h