Display anonymous regions in DRT

Source/core/rendering/RenderTreeAsText.cpp

 /*
  * Copyright (C) 2004, 2006, 2007 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 458 matching lines @@
     ts << "\n";
 
     if (o.isText() && !o.isBR()) {
         const RenderText& text = *toRenderText(&o);
         for (InlineTextBox* box = text.firstTextBox(); box; box = box->nextTextBox()) {
             writeIndent(ts, indent + 1);
             writeTextRun(ts, text, *box);
         }
     }
 
     // FIXME: temporary hack to avoid rebase of regions tests

[Julien - ping for review, 2013/11/22 01:23:34]

Shouldn't this FIXME be removed? If not, it should be amended to be actionable
as I have no idea what should be done to fix it.

-    if (!o.isRenderNamedFlowFragmentContainer()) {
-        for (RenderObject* child = o.firstChild(); child; child = child->nextSibling()) {
-            if (child->hasLayer())
-                continue;
-            write(ts, *child, indent + 1, behavior);
-        }
+    for (RenderObject* child = o.firstChild(); child; child = child->nextSibling()) {
+        if (child->hasLayer())
+            continue;
+        write(ts, *child, indent + 1, behavior);
     }
 
     if (o.isWidget()) {
         Widget* widget = toRenderWidget(&o)->widget();
         if (widget && widget->isFrameView()) {
             FrameView* view = toFrameView(widget);
             RenderView* root = view->frame().contentRenderer();
             if (root) {
                 view->layout();
                 RenderLayer* l = root->layer();
@@ skipping 67 matching lines @@
 
     ts << "\n";
 
     if (paintPhase != LayerPaintPhaseBackground)
         write(ts, *l.renderer(), indent + 1, behavior);
 }
 
 static void writeRenderRegionList(const RenderRegionList& flowThreadRegionList, TextStream& ts, int indent)
 {
     for (RenderRegionList::const_iterator itRR = flowThreadRegionList.begin(); itRR != flowThreadRegionList.end(); ++itRR) {
         RenderRegion* renderRegion = *itRR;

[Julien - ping for review, 2013/11/22 01:23:34]

Any reason |renderRegion| is non-const?

-        writeIndent(ts, indent + 2);
-        ts << "RenderRegion";
+
+        writeIndent(ts, indent);
+        ts << static_cast<const RenderObject*>(renderRegion)->renderName();

[Julien - ping for review, 2013/11/22 01:23:34]

That's just gross and unneeded, RenderRegion is already a RenderObject.

+
         Node* generatingNodeForRegion = renderRegion->generatingNodeForRegion();
         if (generatingNodeForRegion) {
-            String tagName = getTagName(generatingNodeForRegion);
-            if (!tagName.isEmpty())
-                ts << " {" << tagName << "}";
+            if (renderRegion->hasCustomRegionStyle())
+                ts << " region style: 1";
+            if (renderRegion->hasAutoLogicalHeight())
+                ts << " hasAutoLogicalHeight";
+
+            bool isRenderNamedFlowFragment = renderRegion->isRenderNamedFlowFragment();
+            if (isRenderNamedFlowFragment)
+                ts << " (anonymous child of";
+
+            StringBuilder tagName;
+            tagName.append(generatingNodeForRegion->nodeName());
+
+            Node* nodeForRegion = renderRegion->nodeForRegion();
+            if (nodeForRegion->isPseudoElement()) {
+                if (nodeForRegion->isBeforePseudoElement())
+                    tagName.append("::before");
+                else if (nodeForRegion->isAfterPseudoElement())
+                    tagName.append("::after");
+            }
+
+            ts << " {" << tagName.toString() << "}";
+
             if (generatingNodeForRegion->isElementNode() && generatingNodeForRegion->hasID()) {
                 Element* element = toElement(generatingNodeForRegion);
                 ts << " #" << element->idForStyleResolution();
             }
-            if (renderRegion->hasCustomRegionStyle())
-                ts << " region style: 1";
-            if (renderRegion->hasAutoLogicalHeight())
-                ts << " hasAutoLogicalHeight";
+
+            if (isRenderNamedFlowFragment)
+                ts << ")";
         }
-        if (!renderRegion->isValid())
-            ts << " invalid";

[Julien - ping for review, 2013/11/22 01:23:34]

Why are we removing this information? (it seems useful to know if a region is
invalid for debugging)

+
         ts << "\n";
     }
 }
 
 static void writeRenderNamedFlowThreads(TextStream& ts, RenderView* renderView, const RenderLayer* rootLayer,
                         const LayoutRect& paintRect, int indent, RenderAsTextBehavior behavior)
 {
     if (!renderView->hasRenderNamedFlowThreads())
         return;
 
     const RenderNamedFlowThreadList* list = renderView->flowThreadController()->renderNamedFlowThreadList();
 
     writeIndent(ts, indent);
-    ts << "Flow Threads\n";
+    ts << "Named flows\n";
 
     for (RenderNamedFlowThreadList::const_iterator iter = list->begin(); iter != list->end(); ++iter) {
         const RenderNamedFlowThread* renderFlowThread = *iter;
 
         writeIndent(ts, indent + 1);
-        ts << "Thread with flow-name '" << renderFlowThread->flowThreadName() << "'\n";
+        ts << "Named flow '" << renderFlowThread->flowThreadName() << "'\n";
 
         RenderLayer* layer = renderFlowThread->layer();
         RenderTreeAsText::writeLayers(ts, rootLayer, layer, paintRect, indent + 2, behavior);
 
         // Display the valid and invalid render regions attached to this flow thread.
         const RenderRegionList& validRegionsList = renderFlowThread->renderRegionList();
+        if (!validRegionsList.isEmpty()) {
+            writeIndent(ts, indent + 2);
+            ts << "Regions for named flow '" << renderFlowThread->flowThreadName() << "'\n";
+            writeRenderRegionList(validRegionsList, ts, indent + 3);
+        }
+
         const RenderRegionList& invalidRegionsList = renderFlowThread->invalidRenderRegionList();
-        if (!validRegionsList.isEmpty() || !invalidRegionsList.isEmpty()) {
-            writeIndent(ts, indent + 1);
-            ts << "Regions for flow '"<< renderFlowThread->flowThreadName() << "'\n";
-            writeRenderRegionList(validRegionsList, ts, indent);
-            writeRenderRegionList(invalidRegionsList, ts, indent);
+        if (!invalidRegionsList.isEmpty()) {
+            writeIndent(ts, indent + 2);
+            ts << "Invalid regions for named flow '" << renderFlowThread->flowThreadName() << "'\n";
+            writeRenderRegionList(invalidRegionsList, ts, indent + 3);
         }
     }
 }
 
 void RenderTreeAsText::writeLayers(TextStream& ts, const RenderLayer* rootLayer, RenderLayer* layer,
                         const LayoutRect& paintRect, int indent, RenderAsTextBehavior behavior)
 {
     // FIXME: Apply overflow to the root layer to not break every test.  Complete hack.  Sigh.
     LayoutRect paintDirtyRect(paintRect);
     if (rootLayer == layer) {
@@ skipping 194 matching lines @@
     element->document().updateLayout();
 
     RenderObject* renderer = element->renderer();
     if (!renderer || !renderer->isListItem())
         return String();
 
     return toRenderListItem(renderer)->markerText();
 }
 
 } // namespace WebCore