static String externalRepresentation(RenderBox* renderer, RenderAsTextBehavior behavior)
{
TextStream ts;
if (!renderer->hasLayer())
return ts.release();
RenderLayer* layer = renderer->layer();
RenderTreeAsText::writeLayers(ts, layer, layer, layer->rect(), 0, behavior);
return ts.release();
}
String GraphicsLayer::layerTreeAsText(LayerTreeAsTextBehavior behavior) const
{
TextStream ts;
dumpLayer(ts, 0, behavior);
return ts.release();
}
static String absoluteBlockHtmlForLink(int x, int y, int width, int height, const char* url, const char* children = nullptr)
{
TextStream ts;
ts << "<a style='position: absolute; left: " << x << "px; top: " << y << "px; width: " << width << "px; height: " << height
<< "px' href='" << url << "'>" << (children ? children : url) << "</a>";
return ts.release();
}
CString ViewportConfiguration::description() const
{
TextStream ts;
ts.startGroup();
ts << "viewport-configuration " << (void*)this;
{
TextStream::GroupScope scope(ts);
ts << "viewport arguments";
ts << m_viewportArguments;
}
{
TextStream::GroupScope scope(ts);
ts << "configuration";
ts << m_configuration;
}
{
TextStream::GroupScope scope(ts);
ts << "default configuration";
ts << m_defaultConfiguration;
}
ts.dumpProperty("contentSize", m_contentSize);
ts.dumpProperty("minimumLayoutSize", m_minimumLayoutSize);
ts.dumpProperty("computed initial scale", initialScale());
ts.dumpProperty("computed minimum scale", minimumScale());
ts.dumpProperty("computed layout size", layoutSize());
ts.dumpProperty("ignoring horizontal scaling constraints", shouldIgnoreHorizontalScalingConstraints() ? "true" : "false");
ts.dumpProperty("ignoring vertical scaling constraints", shouldIgnoreVerticalScalingConstraints() ? "true" : "false");
ts.endGroup();
return ts.release().utf8();
}
String ScrollingStateNode::scrollingStateTreeAsText() const
{
TextStream ts;
dump(ts, 0);
return ts.release();
}
void printSimpleLineLayoutBlockList()
{
HashSet<const RenderBlockFlow*> leafRenderers;
collectNonEmptyLeafRenderBlockFlowsForCurrentPage(leafRenderers);
if (!leafRenderers.size()) {
WTFLogAlways("No text found in this document\n");
return;
}
TextStream stream;
stream << "---------------------------------------------------\n";
for (const auto* flow : leafRenderers) {
auto reason = canUseForWithReason(*flow, FallThrough::Yes);
if (reason == NoReason)
continue;
unsigned printedLength = 30;
stream << "\"";
printTextForSubtree(*flow, printedLength, stream);
for (;printedLength > 0; --printedLength)
stream << " ";
stream << "\"(" << textLengthForSubtree(*flow) << "):";
printReasons(reason, stream);
stream << "\n";
}
stream << "---------------------------------------------------\n";
WTFLogAlways("%s", stream.release().utf8().data());
}
String ScrollingStateNode::scrollingStateTreeAsText() const
{
TextStream ts;
dump(ts, 0, ScrollingStateTreeAsTextBehaviorNormal);
return ts.release();
}
String GraphicsLayer::layerTreeAsText(LayerTreeFlags flags) const
{
TextStream ts;
RenderingContextMap renderingContextMap;
dumpLayer(ts, 0, flags, renderingContextMap);
return ts.release();
}
String LayerRendererChromium::layerTreeAsText() const
{
TextStream ts;
if (rootLayer()) {
ts << rootLayer()->layerTreeAsText();
ts << "RenderSurfaces:\n";
dumpRenderSurfaces(ts, 1, rootLayer());
}
return ts.release();
}
String counterValueForElement(Element* element)
{
// Make sure the element is not freed during the layout.
RefPtr<Element> elementRef(element);
element->document()->updateLayout();
TextStream stream;
bool isFirstCounter = true;
// The counter renderers should be children of :before or :after pseudo-elements.
if (RenderObject* before = element->pseudoElementRenderer(BEFORE))
writeCounterValuesFromChildren(stream, before, isFirstCounter);
if (RenderObject* after = element->pseudoElementRenderer(AFTER))
writeCounterValuesFromChildren(stream, after, isFirstCounter);
return stream.release();
}
CString ViewportConfiguration::description() const
{
TextStream ts;
ts << "(viewport-configuration " << (void*)this;
ts << "\n";
ts.increaseIndent();
ts.writeIndent();
ts << "(viewport arguments";
ts << m_viewportArguments;
ts << ")";
ts.decreaseIndent();
ts << "\n";
ts.increaseIndent();
ts.writeIndent();
ts << "(configuration";
ts << m_configuration;
ts << ")";
ts.decreaseIndent();
ts << "\n";
ts.increaseIndent();
ts.writeIndent();
ts << "(default configuration";
ts << m_defaultConfiguration;
ts << ")";
ts.decreaseIndent();
ts.dumpProperty("contentSize", m_contentSize);
ts.dumpProperty("minimumLayoutSize", m_minimumLayoutSize);
ts << "\n";
ts.increaseIndent();
ts.writeIndent();
ts << "(computed initial scale " << initialScale() << ")\n";
ts.writeIndent();
ts << "(computed minimum scale " << minimumScale() << ")\n";
ts.writeIndent();
ts << "(computed layout size " << layoutSize() << ")\n";
ts.writeIndent();
ts << "(ignoring horizontal scaling constraints " << (shouldIgnoreHorizontalScalingConstraints() ? "true" : "false") << ")\n";
ts.writeIndent();
ts << "(ignoring vertical scaling constraints " << (shouldIgnoreVerticalScalingConstraints() ? "true" : "false") << ")";
ts.decreaseIndent();
ts << ")\n";
return ts.release().utf8();
}
String counterValueForElement(Element* element)
{
// Make sure the element is not freed during the layout.
RefPtr<Element> elementRef(element);
element->document()->updateLayout();
TextStream stream;
bool isFirstCounter = true;
// The counter renderers should be children of anonymous children
// (i.e., :before or :after pseudo-elements).
if (RenderObject* renderer = element->renderer()) {
for (RenderObject* child = renderer->firstChild(); child; child = child->nextSibling()) {
if (child->isAnonymous())
writeCounterValuesFromChildren(stream, child, isFirstCounter);
}
}
return stream.release();
}
String externalRepresentation(RenderObject* o)
{
if (!o)
return String();
TextStream ts;
#if ENABLE(SVG)
writeRenderResources(ts, o->document());
#endif
if (o->view()->frameView())
o->view()->frameView()->layout();
RenderLayer* l = o->layer();
if (l) {
writeLayers(ts, l, l, IntRect(l->xPos(), l->yPos(), l->width(), l->height()));
writeSelection(ts, o);
}
return ts.release();
}
String externalRepresentation(Frame* frame, RenderAsTextBehavior behavior)
{
frame->document()->updateLayout();
RenderObject* o = frame->contentRenderer();
if (!o)
return String();
TextStream ts;
#if ENABLE(SVG)
writeRenderResources(ts, o->document());
#endif
if (o->hasLayer()) {
RenderLayer* l = toRenderBox(o)->layer();
writeLayers(ts, l, l, IntRect(l->x(), l->y(), l->width(), l->height()), 0, behavior);
writeSelection(ts, o);
}
return ts.release();
}
String LocalFrame::layerTreeAsText(LayerTreeFlags flags) const
{
TextStream textStream;
textStream << localLayerTreeAsText(flags);
for (Frame* child = tree().firstChild(); child; child = child->tree().traverseNext(this)) {
if (!child->isLocalFrame())
continue;
String childLayerTree = toLocalFrame(child)->localLayerTreeAsText(flags);
if (!childLayerTree.length())
continue;
textStream << "\n\n--------\nFrame: '";
textStream << child->tree().uniqueName();
textStream << "'\n--------\n";
textStream << childLayerTree;
}
return textStream.release();
}
void printSimpleLineLayoutCoverage()
{
HashSet<const RenderBlockFlow*> leafRenderers;
collectNonEmptyLeafRenderBlockFlowsForCurrentPage(leafRenderers);
if (!leafRenderers.size()) {
WTFLogAlways("No text found in this document\n");
return;
}
TextStream stream;
HashMap<AvoidanceReason, unsigned> flowStatistics;
unsigned textLength = 0;
unsigned unsupportedTextLength = 0;
unsigned numberOfUnsupportedLeafBlocks = 0;
for (const auto* flow : leafRenderers) {
auto flowLength = textLengthForSubtree(*flow);
textLength += flowLength;
auto reasons = canUseForWithReason(*flow, FallThrough::Yes);
if (reasons == NoReason)
continue;
++numberOfUnsupportedLeafBlocks;
unsupportedTextLength += flowLength;
for (auto reasonItem = EndOfReasons >> 1; reasonItem != NoReason; reasonItem >>= 1) {
if (!(reasons & reasonItem))
continue;
auto result = flowStatistics.add(reasonItem, flowLength);
if (!result.isNewEntry)
result.iterator->value += flowLength;
}
}
stream << "---------------------------------------------------\n";
stream << "Number of text blocks: total(" << leafRenderers.size() << ") non-simple(" << numberOfUnsupportedLeafBlocks << ")\nText length: total(" <<
textLength << ") non-simple(" << unsupportedTextLength << ")\n";
for (const auto reasonEntry : flowStatistics) {
printReason(reasonEntry.key, stream);
stream << ": " << (float)reasonEntry.value / (float)textLength * 100 << "%\n";
}
stream << "simple line layout coverage: " << (float)(textLength - unsupportedTextLength) / (float)textLength * 100 << "%\n";
stream << "---------------------------------------------------\n";
WTFLogAlways("%s", stream.release().utf8().data());
}
String externalRepresentation(Frame* frame, RenderAsTextBehavior behavior)
{
PrintContext printContext(frame);
if (behavior & RenderAsTextPrintingMode) {
if (!frame->contentRenderer())
return String();
printContext.begin(frame->contentRenderer()->width());
}
frame->document()->updateLayout();
RenderObject* o = frame->contentRenderer();
if (!o)
return String();
TextStream ts;
if (o->hasLayer()) {
RenderLayer* l = toRenderBox(o)->layer();
writeLayers(ts, l, l, IntRect(l->x(), l->y(), l->width(), l->height()), 0, behavior);
writeSelection(ts, o);
}
return ts.release();
}
String CCSchedulerStateMachine::toString()
{
TextStream ts;
ts << "m_commitState = " << m_commitState << "; ";
ts << "m_currentFrameNumber = " << m_currentFrameNumber << "; ";
ts << "m_lastFrameNumberWhereDrawWasCalled = " << m_lastFrameNumberWhereDrawWasCalled << "; ";
ts << "m_consecutiveFailedDraws = " << m_consecutiveFailedDraws << "; ";
ts << "m_maximumNumberOfFailedDrawsBeforeDrawIsForced = " << m_maximumNumberOfFailedDrawsBeforeDrawIsForced << "; ";
ts << "m_needsRedraw = " << m_needsRedraw << "; ";
ts << "m_needsForcedRedraw = " << m_needsForcedRedraw << "; ";
ts << "m_needsForcedRedrawAfterNextCommit = " << m_needsForcedRedrawAfterNextCommit << "; ";
ts << "m_needsCommit = " << m_needsCommit << "; ";
ts << "m_needsForcedCommit = " << m_needsForcedCommit << "; ";
ts << "m_mainThreadNeedsLayerTextures = " << m_mainThreadNeedsLayerTextures << "; ";
ts << "m_updateMoreResourcesPending = " << m_updateMoreResourcesPending << "; ";
ts << "m_insideVSync = " << m_insideVSync << "; ";
ts << "m_visible = " << m_visible << "; ";
ts << "m_canBeginFrame = " << m_canBeginFrame << "; ";
ts << "m_canDraw = " << m_canDraw << "; ";
ts << "m_drawIfPossibleFailed = " << m_drawIfPossibleFailed << "; ";
ts << "m_textureState = " << m_textureState << "; ";
ts << "m_contextState = " << m_contextState << "; ";
return ts.release();
}
String composedTreeAsText(ContainerNode& root, ComposedTreeAsTextMode mode)
{
TextStream stream;
auto descendants = composedTreeDescendants(root);
for (auto it = descendants.begin(), end = descendants.end(); it != end; ++it) {
writeIndent(stream, it.depth());
if (is<Text>(*it)) {
stream << "#text";
if (mode == ComposedTreeAsTextMode::WithPointers)
stream << " " << &*it;
stream << "\n";
continue;
}
auto& element = downcast<Element>(*it);
stream << element.localName();
if (element.shadowRoot())
stream << " (shadow root)";
if (mode == ComposedTreeAsTextMode::WithPointers)
stream << " " << &*it;
stream << "\n";
}
return stream.release();
}
void GraphicsLayer::dumpProperties(TextStream& ts, int indent, LayerTreeAsTextBehavior behavior) const
{
if (m_position != FloatPoint()) {
writeIndent(ts, indent + 1);
ts << "(position " << m_position.x() << " " << m_position.y() << ")\n";
}
if (m_boundsOrigin != FloatPoint()) {
writeIndent(ts, indent + 1);
ts << "(bounds origin " << m_boundsOrigin.x() << " " << m_boundsOrigin.y() << ")\n";
}
if (m_anchorPoint != FloatPoint3D(0.5f, 0.5f, 0)) {
writeIndent(ts, indent + 1);
ts << "(anchor " << m_anchorPoint.x() << " " << m_anchorPoint.y() << ")\n";
}
if (m_size != IntSize()) {
writeIndent(ts, indent + 1);
ts << "(bounds " << m_size.width() << " " << m_size.height() << ")\n";
}
if (m_opacity != 1) {
writeIndent(ts, indent + 1);
ts << "(opacity " << m_opacity << ")\n";
}
#if ENABLE(CSS_COMPOSITING)
if (m_blendMode != BlendModeNormal) {
writeIndent(ts, indent + 1);
ts << "(blendMode " << compositeOperatorName(CompositeSourceOver, m_blendMode) << ")\n";
}
#endif
if (m_usingTiledBacking) {
writeIndent(ts, indent + 1);
ts << "(usingTiledLayer " << m_usingTiledBacking << ")\n";
}
bool needsIOSDumpRenderTreeMainFrameRenderViewLayerIsAlwaysOpaqueHack = m_client.needsIOSDumpRenderTreeMainFrameRenderViewLayerIsAlwaysOpaqueHack(*this);
if (m_contentsOpaque || needsIOSDumpRenderTreeMainFrameRenderViewLayerIsAlwaysOpaqueHack) {
writeIndent(ts, indent + 1);
ts << "(contentsOpaque " << (m_contentsOpaque || needsIOSDumpRenderTreeMainFrameRenderViewLayerIsAlwaysOpaqueHack) << ")\n";
}
if (m_preserves3D) {
writeIndent(ts, indent + 1);
ts << "(preserves3D " << m_preserves3D << ")\n";
}
if (m_drawsContent && m_client.shouldDumpPropertyForLayer(this, "drawsContent")) {
writeIndent(ts, indent + 1);
ts << "(drawsContent " << m_drawsContent << ")\n";
}
if (!m_contentsVisible) {
writeIndent(ts, indent + 1);
ts << "(contentsVisible " << m_contentsVisible << ")\n";
}
if (!m_backfaceVisibility) {
writeIndent(ts, indent + 1);
ts << "(backfaceVisibility " << (m_backfaceVisibility ? "visible" : "hidden") << ")\n";
}
if (behavior & LayerTreeAsTextDebug) {
writeIndent(ts, indent + 1);
ts << "(primary-layer-id " << primaryLayerID() << ")\n";
writeIndent(ts, indent + 1);
ts << "(client " << static_cast<void*>(&m_client) << ")\n";
}
if (m_backgroundColor.isValid() && m_client.shouldDumpPropertyForLayer(this, "backgroundColor")) {
writeIndent(ts, indent + 1);
ts << "(backgroundColor " << m_backgroundColor.nameForRenderTreeAsText() << ")\n";
}
if (!m_transform.isIdentity()) {
writeIndent(ts, indent + 1);
ts << "(transform ";
ts << "[" << m_transform.m11() << " " << m_transform.m12() << " " << m_transform.m13() << " " << m_transform.m14() << "] ";
ts << "[" << m_transform.m21() << " " << m_transform.m22() << " " << m_transform.m23() << " " << m_transform.m24() << "] ";
ts << "[" << m_transform.m31() << " " << m_transform.m32() << " " << m_transform.m33() << " " << m_transform.m34() << "] ";
ts << "[" << m_transform.m41() << " " << m_transform.m42() << " " << m_transform.m43() << " " << m_transform.m44() << "])\n";
}
// Avoid dumping the sublayer transform on the root layer, because it's used for geometry flipping, whose behavior
// differs between platforms.
if (parent() && !m_childrenTransform.isIdentity()) {
writeIndent(ts, indent + 1);
ts << "(childrenTransform ";
ts << "[" << m_childrenTransform.m11() << " " << m_childrenTransform.m12() << " " << m_childrenTransform.m13() << " " << m_childrenTransform.m14() << "] ";
ts << "[" << m_childrenTransform.m21() << " " << m_childrenTransform.m22() << " " << m_childrenTransform.m23() << " " << m_childrenTransform.m24() << "] ";
ts << "[" << m_childrenTransform.m31() << " " << m_childrenTransform.m32() << " " << m_childrenTransform.m33() << " " << m_childrenTransform.m34() << "] ";
ts << "[" << m_childrenTransform.m41() << " " << m_childrenTransform.m42() << " " << m_childrenTransform.m43() << " " << m_childrenTransform.m44() << "])\n";
}
if (m_replicaLayer) {
writeIndent(ts, indent + 1);
ts << "(replica layer";
if (behavior & LayerTreeAsTextDebug)
ts << " " << m_replicaLayer;
ts << ")\n";
m_replicaLayer->dumpLayer(ts, indent + 2, behavior);
}
if (m_replicatedLayer) {
writeIndent(ts, indent + 1);
ts << "(replicated layer";
if (behavior & LayerTreeAsTextDebug)
ts << " " << m_replicatedLayer;
ts << ")\n";
}
if (behavior & LayerTreeAsTextIncludeRepaintRects && repaintRectMap().contains(this) && !repaintRectMap().get(this).isEmpty() && m_client.shouldDumpPropertyForLayer(this, "repaintRects")) {
writeIndent(ts, indent + 1);
ts << "(repaint rects\n";
for (size_t i = 0; i < repaintRectMap().get(this).size(); ++i) {
if (repaintRectMap().get(this)[i].isEmpty())
continue;
writeIndent(ts, indent + 2);
ts << "(rect ";
ts << repaintRectMap().get(this)[i].x() << " ";
ts << repaintRectMap().get(this)[i].y() << " ";
ts << repaintRectMap().get(this)[i].width() << " ";
ts << repaintRectMap().get(this)[i].height();
ts << ")\n";
}
writeIndent(ts, indent + 1);
ts << ")\n";
}
if (behavior & LayerTreeAsTextIncludePaintingPhases && paintingPhase()) {
writeIndent(ts, indent + 1);
ts << "(paintingPhases\n";
if (paintingPhase() & GraphicsLayerPaintBackground) {
writeIndent(ts, indent + 2);
ts << "GraphicsLayerPaintBackground\n";
}
if (paintingPhase() & GraphicsLayerPaintForeground) {
writeIndent(ts, indent + 2);
ts << "GraphicsLayerPaintForeground\n";
}
if (paintingPhase() & GraphicsLayerPaintMask) {
writeIndent(ts, indent + 2);
ts << "GraphicsLayerPaintMask\n";
}
if (paintingPhase() & GraphicsLayerPaintChildClippingMask) {
writeIndent(ts, indent + 2);
ts << "GraphicsLayerPaintChildClippingMask\n";
}
if (paintingPhase() & GraphicsLayerPaintOverflowContents) {
writeIndent(ts, indent + 2);
ts << "GraphicsLayerPaintOverflowContents\n";
}
if (paintingPhase() & GraphicsLayerPaintCompositedScroll) {
writeIndent(ts, indent + 2);
ts << "GraphicsLayerPaintCompositedScroll\n";
}
writeIndent(ts, indent + 1);
ts << ")\n";
}
dumpAdditionalProperties(ts, indent, behavior);
if (m_children.size()) {
TextStream childrenStream;
unsigned totalChildCount = 0;
dumpChildren(childrenStream, m_children, totalChildCount, indent, behavior);
writeIndent(childrenStream, indent + 1);
childrenStream << ")\n";
if (totalChildCount) {
writeIndent(ts, indent + 1);
ts << "(children " << totalChildCount << "\n";
ts << childrenStream.release();
}
}
}
WTF::CString Item::description() const
{
TextStream ts;
ts << *this;
return ts.release().utf8();
}
void Path::dump() const
{
TextStream stream;
stream << *this;
WTFLogAlways("%s", stream.release().utf8().data());
}
void GraphicsLayer::dumpProperties(TextStream& ts, int indent, LayerTreeAsTextBehavior behavior) const
{
if (m_position != FloatPoint()) {
writeIndent(ts, indent + 1);
ts << "(position " << m_position.x() << " " << m_position.y() << ")\n";
}
if (m_boundsOrigin != FloatPoint()) {
writeIndent(ts, indent + 1);
ts << "(bounds origin " << m_boundsOrigin.x() << " " << m_boundsOrigin.y() << ")\n";
}
if (m_anchorPoint != FloatPoint3D(0.5f, 0.5f, 0)) {
writeIndent(ts, indent + 1);
ts << "(anchor " << m_anchorPoint.x() << " " << m_anchorPoint.y() << ")\n";
}
if (m_size != IntSize()) {
writeIndent(ts, indent + 1);
ts << "(bounds " << m_size.width() << " " << m_size.height() << ")\n";
}
if (m_opacity != 1) {
writeIndent(ts, indent + 1);
ts << "(opacity " << m_opacity << ")\n";
}
if (m_usingTiledBacking) {
writeIndent(ts, indent + 1);
ts << "(usingTiledLayer " << m_usingTiledBacking << ")\n";
}
if (m_contentsOpaque) {
writeIndent(ts, indent + 1);
ts << "(contentsOpaque " << m_contentsOpaque << ")\n";
}
if (m_preserves3D) {
writeIndent(ts, indent + 1);
ts << "(preserves3D " << m_preserves3D << ")\n";
}
if (m_drawsContent && m_client->shouldDumpPropertyForLayer(this, "drawsContent")) {
writeIndent(ts, indent + 1);
ts << "(drawsContent " << m_drawsContent << ")\n";
}
if (!m_contentsVisible) {
writeIndent(ts, indent + 1);
ts << "(contentsVisible " << m_contentsVisible << ")\n";
}
if (!m_backfaceVisibility) {
writeIndent(ts, indent + 1);
ts << "(backfaceVisibility " << (m_backfaceVisibility ? "visible" : "hidden") << ")\n";
}
if (behavior & LayerTreeAsTextDebug) {
writeIndent(ts, indent + 1);
ts << "(";
if (m_client)
ts << "client " << static_cast<void*>(m_client);
else
ts << "no client";
ts << ")\n";
}
if (m_backgroundColor.isValid() && m_client->shouldDumpPropertyForLayer(this, "backgroundColor")) {
writeIndent(ts, indent + 1);
ts << "(backgroundColor " << m_backgroundColor.nameForRenderTreeAsText() << ")\n";
}
if (!m_transform.isIdentity()) {
writeIndent(ts, indent + 1);
ts << "(transform ";
ts << "[" << m_transform.m11() << " " << m_transform.m12() << " " << m_transform.m13() << " " << m_transform.m14() << "] ";
ts << "[" << m_transform.m21() << " " << m_transform.m22() << " " << m_transform.m23() << " " << m_transform.m24() << "] ";
ts << "[" << m_transform.m31() << " " << m_transform.m32() << " " << m_transform.m33() << " " << m_transform.m34() << "] ";
ts << "[" << m_transform.m41() << " " << m_transform.m42() << " " << m_transform.m43() << " " << m_transform.m44() << "])\n";
}
// Avoid dumping the sublayer transform on the root layer, because it's used for geometry flipping, whose behavior
// differs between platforms.
if (parent() && !m_childrenTransform.isIdentity()) {
writeIndent(ts, indent + 1);
ts << "(childrenTransform ";
ts << "[" << m_childrenTransform.m11() << " " << m_childrenTransform.m12() << " " << m_childrenTransform.m13() << " " << m_childrenTransform.m14() << "] ";
ts << "[" << m_childrenTransform.m21() << " " << m_childrenTransform.m22() << " " << m_childrenTransform.m23() << " " << m_childrenTransform.m24() << "] ";
ts << "[" << m_childrenTransform.m31() << " " << m_childrenTransform.m32() << " " << m_childrenTransform.m33() << " " << m_childrenTransform.m34() << "] ";
ts << "[" << m_childrenTransform.m41() << " " << m_childrenTransform.m42() << " " << m_childrenTransform.m43() << " " << m_childrenTransform.m44() << "])\n";
}
if (m_replicaLayer) {
writeIndent(ts, indent + 1);
ts << "(replica layer";
if (behavior & LayerTreeAsTextDebug)
ts << " " << m_replicaLayer;
ts << ")\n";
m_replicaLayer->dumpLayer(ts, indent + 2, behavior);
}
if (m_replicatedLayer) {
writeIndent(ts, indent + 1);
ts << "(replicated layer";
if (behavior & LayerTreeAsTextDebug)
ts << " " << m_replicatedLayer;
ts << ")\n";
}
if (behavior & LayerTreeAsTextIncludeRepaintRects && repaintRectMap().contains(this) && !repaintRectMap().get(this).isEmpty() && m_client->shouldDumpPropertyForLayer(this, "repaintRects")) {
writeIndent(ts, indent + 1);
ts << "(repaint rects\n";
for (size_t i = 0; i < repaintRectMap().get(this).size(); ++i) {
if (repaintRectMap().get(this)[i].isEmpty())
continue;
writeIndent(ts, indent + 2);
ts << "(rect ";
ts << repaintRectMap().get(this)[i].x() << " ";
ts << repaintRectMap().get(this)[i].y() << " ";
ts << repaintRectMap().get(this)[i].width() << " ";
ts << repaintRectMap().get(this)[i].height();
ts << ")\n";
}
writeIndent(ts, indent + 1);
ts << ")\n";
}
if (behavior & LayerTreeAsTextIncludePaintingPhases && paintingPhase()) {
writeIndent(ts, indent + 1);
ts << "(paintingPhases\n";
if (paintingPhase() & GraphicsLayerPaintBackground) {
writeIndent(ts, indent + 2);
ts << "GraphicsLayerPaintBackground\n";
}
if (paintingPhase() & GraphicsLayerPaintForeground) {
writeIndent(ts, indent + 2);
ts << "GraphicsLayerPaintForeground\n";
}
if (paintingPhase() & GraphicsLayerPaintMask) {
writeIndent(ts, indent + 2);
ts << "GraphicsLayerPaintMask\n";
}
if (paintingPhase() & GraphicsLayerPaintOverflowContents) {
writeIndent(ts, indent + 2);
ts << "GraphicsLayerPaintOverflowContents\n";
}
if (paintingPhase() & GraphicsLayerPaintCompositedScroll) {
writeIndent(ts, indent + 2);
ts << "GraphicsLayerPaintCompositedScroll\n";
}
writeIndent(ts, indent + 1);
ts << ")\n";
}
dumpAdditionalProperties(ts, indent, behavior);
if (m_children.size()) {
TextStream childrenStream;
unsigned totalChildCount = m_children.size();
for (size_t childIndex = 0; childIndex < m_children.size(); childIndex++) {
GraphicsLayer* child = m_children[childIndex];
if (!m_client->shouldSkipLayerInDump(child)) {
child->dumpLayer(childrenStream, indent + 2, behavior);
continue;
}
const Vector<GraphicsLayer*>& grandChildren = child->children();
totalChildCount += grandChildren.size() - 1;
for (size_t grandChildIndex = 0; grandChildIndex < grandChildren.size(); grandChildIndex++)
grandChildren[grandChildIndex]->dumpLayer(childrenStream, indent + 2, behavior);
}
writeIndent(childrenStream, indent + 1);
childrenStream << ")\n";
if (totalChildCount) {
writeIndent(ts, indent + 1);
ts << "(children " << totalChildCount << "\n";
ts << childrenStream.release();
}
}
}
static String inlineHtmlForLink(const char* url, const char* children = nullptr)
{
TextStream ts;
ts << "<a href='" << url << "'>" << (children ? children : url) << "</a>";
return ts.release();
}
String CCLayerImpl::layerTreeAsText() const
{
TextStream ts;
dumpLayer(ts, 0);
return ts.release();
}
static String pointerAsString(const void* ptr)
{
TextStream ts;
ts << ptr;
return ts.release();
}
String LayerChromium::layerTreeAsText() const
{
TextStream ts;
dumpLayer(ts, 0);
return ts.release();
}
static String htmlForAnchor(int x, int y, const char* name)
{
TextStream ts;
ts << "<a name='" << name << "' style='position: absolute; left: " << x << "px; top: " << y << "px'>" << name << "</a>";
return ts.release();
}
