Use stream printers in showNodePath() and Node::showTreeForThisAcrossFrame() implementations.

third_party/WebKit/Source/core/dom/Node.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 1524 matching lines @@
 }
 
 #ifndef NDEBUG
 
 void Node::showNode(const char* prefix) const
 {
     std::stringstream stream;
     if (prefix)
         stream << prefix;
     stream << *this << "\n";
+    // TODO(tkent): Replace WTFLogAlways with something else.
     WTFLogAlways("%s", stream.str().c_str());
 }
 
 void Node::showTreeForThis() const
 {
     showTreeAndMark(this, "*");
 }
 
 void Node::showTreeForThisInFlatTree() const
 {
     showTreeAndMarkInFlatTree(this, "*");
 }
 
-void Node::showNodePathForThis() const
+void Node::printNodePathTo(std::ostream& stream) const
 {
     HeapVector<Member<const Node>, 16> chain;
     const Node* node = this;
     while (node->parentOrShadowHostNode()) {
         chain.append(node);
         node = node->parentOrShadowHostNode();
     }
     for (unsigned index = chain.size(); index > 0; --index) {
         const Node* node = chain[index - 1];
         if (node->isShadowRoot()) {
             int count = 0;
             for (const ShadowRoot* shadowRoot = toShadowRoot(node)->olderShadowRoot(); shadowRoot; shadowRoot = shadowRoot->olderShadowRoot())
                 ++count;
-            WTFLogAlways("/#shadow-root[%d]", count);
+            stream << "/#shadow-root[" << count << "]";
             continue;
         }
 
         switch (node->getNodeType()) {
         case kElementNode: {
-            WTFLogAlways("/%s", node->nodeName().utf8().data());
+            stream << "/" << node->nodeName().utf8().data();
 
             const Element* element = toElement(node);
             const AtomicString& idattr = element->getIdAttribute();
             bool hasIdAttr = !idattr.isNull() && !idattr.isEmpty();
             if (node->previousSibling() || node->nextSibling()) {
                 int count = 0;
                 for (const Node* previous = node->previousSibling(); previous; previous = previous->previousSibling()) {
                     if (previous->nodeName() == node->nodeName()) {
                         ++count;
                     }
                 }
                 if (hasIdAttr)
-                    WTFLogAlways("[@id=\"%s\" and position()=%d]", idattr.utf8().data(), count);
+                    stream << "[@id=\"" << idattr.utf8().data() << "\" and position()=" << count << "]";
                 else
-                    WTFLogAlways("[%d]", count);
+                    stream << "[" << count << "]";
             } else if (hasIdAttr) {
-                WTFLogAlways("[@id=\"%s\"]", idattr.utf8().data());
+                stream << "[@id=\"" << idattr.utf8().data() << "\"]";
             }
             break;
         }
         case kTextNode:
-            WTFLogAlways("/text()");
+            stream << "/text()";
             break;
         case kAttributeNode:
-            WTFLogAlways("/@%s", node->nodeName().utf8().data());
+            stream << "/@" << node->nodeName().utf8().data();
             break;
         default:
             break;
         }
     }
-    WTFLogAlways("\n");
 }
 
 static void traverseTreeAndMark(const String& baseIndent, const Node* rootNode, const Node* markedNode1, const char* markedLabel1, const Node* markedNode2, const char* markedLabel2)
 {
     for (const Node& node : NodeTraversal::inclusiveDescendantsOf(*rootNode)) {
         StringBuilder indent;
         if (node == markedNode1)
             indent.append(markedLabel1);
         if (node == markedNode2)
             indent.append(markedLabel2);
@@ skipping 67 matching lines @@
 }
 
 static ContainerNode* parentOrShadowHostOrFrameOwner(const Node* node)
 {
     ContainerNode* parent = node->parentOrShadowHostNode();
     if (!parent && node->document().frame())
         parent = node->document().frame()->deprecatedLocalOwner();
     return parent;
 }
 
-static void showSubTreeAcrossFrame(const Node* node, const Node* markedNode, const String& indent)
+static void printSubTreeAcrossFrame(const Node* node, const Node* markedNode, const String& indent, std::ostream& stream)
 {
     if (node == markedNode)
-        fputs("*", stderr);
-    fputs(indent.utf8().data(), stderr);
-    node->showNode();
+        stream << "*";
+    stream << indent.utf8().data() << *node << "\n";
     if (node->isShadowRoot()) {
         if (ShadowRoot* youngerShadowRoot = toShadowRoot(node)->youngerShadowRoot())
-            showSubTreeAcrossFrame(youngerShadowRoot, markedNode, indent + "\t");
+            printSubTreeAcrossFrame(youngerShadowRoot, markedNode, indent + "\t", stream);
     } else {
         if (node->isFrameOwnerElement())
-            showSubTreeAcrossFrame(toHTMLFrameOwnerElement(node)->contentDocument(), markedNode, indent + "\t");
+            printSubTreeAcrossFrame(toHTMLFrameOwnerElement(node)->contentDocument(), markedNode, indent + "\t", stream);
         if (ShadowRoot* oldestShadowRoot = oldestShadowRootFor(node))
-            showSubTreeAcrossFrame(oldestShadowRoot, markedNode, indent + "\t");
+            printSubTreeAcrossFrame(oldestShadowRoot, markedNode, indent + "\t", stream);
     }
     for (const Node* child = node->firstChild(); child; child = child->nextSibling())
-        showSubTreeAcrossFrame(child, markedNode, indent + "\t");
+        printSubTreeAcrossFrame(child, markedNode, indent + "\t", stream);
 }
 
 void Node::showTreeForThisAcrossFrame() const
 {
     const Node* rootNode = this;
     while (parentOrShadowHostOrFrameOwner(rootNode))
         rootNode = parentOrShadowHostOrFrameOwner(rootNode);
-    showSubTreeAcrossFrame(rootNode, this, "");
+    std::stringstream stream;
+    printSubTreeAcrossFrame(rootNode, this, "", stream);
+    // TODO(tkent): Replace WTFLogAlways with something else.
+    WTFLogAlways("%s", stream.str().c_str());
 }
 
 #endif
 
 // --------
 
 Element* Node::enclosingLinkEventParentOrSelf() const
 {
     const Node* result = nullptr;
     for (const Node* node = this; node; node = FlatTreeTraversal::parent(*node)) {
@@ skipping 654 matching lines @@
 void showTree(const blink::Node* node)
 {
     if (node)
         node->showTreeForThis();
     else
         fprintf(stderr, "Cannot showTree for (nil)\n");
 }
 
 void showNodePath(const blink::Node* node)
 {
+    std::stringstream stream;
     if (node)
-        node->showNodePathForThis();
+        node->printNodePathTo(stream);
     else
-        fprintf(stderr, "Cannot showNodePath for (nil)\n");
+        stream << "Cannot showNodePath for <null>";
+    stream << "\n";
+    // TODO(tkent): Replace WTFLogAlways with something else.
+    WTFLogAlways("%s", stream.str().c_str());
 }
 
 #endif