Do-not-commit: Count layout tree memory usage

third_party/WebKit/Source/core/frame/FrameView.cpp

 /*
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  *                     1999 Lars Knoll <knoll@kde.org>
  *                     1999 Antti Koivisto <koivisto@kde.org>
  *                     2000 Dirk Mueller <mueller@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
@@ skipping 1318 matching lines @@
     return;
 
 #if DCHECK_IS_ON()
   // Post-layout assert that nobody was re-marked as needing layout during
   // layout.
   layoutView()->assertSubtreeIsLaidOut();
 #endif
 
   frame().document()->layoutUpdated();
   checkDoesNotNeedLayout();
+
+  printLayoutTreeStats();
+}
+
+struct TreeStats {
+  int frames;
+  int layoutObjects;
+  int objectPaintProperties;
+  int layoutObjectMemory;
+  int layoutTreeApproximateHeapMemoryUsage;
+  int paintPropertiesMemoryUsage;
+  int paintPropertyTransformNodes;
+  int paintPropertyScrollNodes;
+  int paintPropertyClipNodes;
+  int paintPropertyEffectNodes;
+  int borderBoxProperties;
+  int contentsProperties;
+};
+
+void FrameView::printLayoutTreeStats() const {
+  TreeStats stats = {};
+  countLayoutTreeStats(stats, *this);
+  LOG(ERROR) << "Layout Tree Stats -------------";
+  LOG(ERROR) << "  frame count: " << stats.frames;
+  LOG(ERROR) << "  layout object count: " << stats.layoutObjects;
+  LOG(ERROR) << "  layout object memory: " << stats.layoutObjectMemory
+             << " bytes";
+  LOG(ERROR) << "  layout tree additional heap memory: "
+             << stats.layoutTreeApproximateHeapMemoryUsage << " bytes";
+  LOG(ERROR) << "  object paint properties: " << stats.objectPaintProperties;
+  LOG(ERROR) << "  paint properties memory: "
+             << stats.paintPropertiesMemoryUsage << " bytes";
+  LOG(ERROR) << "    transform nodes (" << sizeof(TransformPaintPropertyNode)
+             << " bytes): " << stats.paintPropertyTransformNodes;
+  LOG(ERROR) << "    scroll nodes (" << sizeof(ScrollPaintPropertyNode)
+             << " bytes): " << stats.paintPropertyScrollNodes;
+  LOG(ERROR) << "    clip nodes (" << sizeof(ClipPaintPropertyNode)
+             << " bytes): " << stats.paintPropertyClipNodes;
+  LOG(ERROR) << "    effect nodes (" << sizeof(EffectPaintPropertyNode)
+             << " bytes): " << stats.paintPropertyEffectNodes;
+  LOG(ERROR) << "    border box properties (" << sizeof(PropertyTreeState)
+             << " bytes): " << stats.borderBoxProperties;
+  LOG(ERROR) << "    contents properties (" << sizeof(PropertyTreeState)
+             << " bytes): " << stats.contentsProperties;
+}
+
+void FrameView::countLayoutTreeStats(TreeStats& stats,
+                                     const FrameView& frame) const {
+  stats.frames++;
+  if (frame.m_preTranslation) {
+    stats.paintPropertyTransformNodes++;
+    stats.paintPropertiesMemoryUsage += sizeof(TransformPaintPropertyNode);
+  }
+  if (frame.m_scrollTranslation) {
+    stats.paintPropertyTransformNodes++;
+    stats.paintPropertyScrollNodes++;
+    stats.paintPropertiesMemoryUsage += sizeof(TransformPaintPropertyNode);
+    stats.paintPropertiesMemoryUsage += sizeof(ScrollPaintPropertyNode);
+  }
+  if (frame.m_contentClip) {
+    stats.paintPropertyClipNodes++;
+    stats.paintPropertiesMemoryUsage += sizeof(ClipPaintPropertyNode);
+  }
+  if (frame.m_totalPropertyTreeStateForContents) {
+    stats.paintPropertiesMemoryUsage += sizeof(PropertyTreeState);
+  }
+  if (LayoutView* view = frame.layoutView())
+    countLayoutTreeStats(stats, *view);
+}
+
+void FrameView::countLayoutTreeStats(TreeStats& stats,
+                                     const LayoutObject& object) const {
+  stats.layoutObjects++;
+  stats.layoutObjectMemory += object.objectSize();
+  stats.layoutTreeApproximateHeapMemoryUsage +=
+      object.approximateHeapMemoryUsage();
+
+  if (const auto* properties = object.paintProperties()) {
+    stats.objectPaintProperties++;
+    stats.paintPropertiesMemoryUsage += sizeof(ObjectPaintProperties);
+    stats.paintPropertiesMemoryUsage += properties->heapMemoryUsage();
+
+    if (properties->paintOffsetTranslation())
+      stats.paintPropertyTransformNodes++;
+    if (properties->transform())
+      stats.paintPropertyTransformNodes++;
+    if (properties->effect())
+      stats.paintPropertyEffectNodes++;
+    if (properties->filter())
+      stats.paintPropertyEffectNodes++;
+    if (properties->mask())
+      stats.paintPropertyEffectNodes++;
+    if (properties->maskClip())
+      stats.paintPropertyClipNodes++;
+    if (properties->cssClip())
+      stats.paintPropertyClipNodes++;
+    if (properties->cssClipFixedPosition())
+      stats.paintPropertyClipNodes++;
+    if (properties->innerBorderRadiusClip())
+      stats.paintPropertyClipNodes++;
+    if (properties->overflowClip())
+      stats.paintPropertyClipNodes++;
+    if (properties->perspective())
+      stats.paintPropertyTransformNodes++;
+    if (properties->svgLocalToBorderBoxTransform())
+      stats.paintPropertyTransformNodes++;
+    if (properties->scrollTranslation()) {
+      stats.paintPropertyTransformNodes++;
+      stats.paintPropertyScrollNodes++;
+    }
+    if (properties->scrollbarPaintOffset())
+      stats.paintPropertyTransformNodes++;
+
+    if (properties->localBorderBoxProperties())
+      stats.borderBoxProperties++;
+    if (properties->hasContentsProperties())
+      stats.contentsProperties++;
+  }
+
+  for (const LayoutObject* child = object.slowFirstChild(); child;
+       child = child->nextSibling()) {
+    countLayoutTreeStats(stats, *child);
+  }
+  if (object.isLayoutPart()) {
+    const LayoutPart& layoutPart = toLayoutPart(object);
+    FrameViewBase* frameViewBase = layoutPart.frameViewBase();
+    if (frameViewBase && frameViewBase->isFrameView())
+      countLayoutTreeStats(stats, *toFrameView(frameViewBase));
+  }
 }
 
 void FrameView::invalidateTreeIfNeeded(
     const PaintInvalidationState& paintInvalidationState) {
   DCHECK(!RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled());
 
   if (shouldThrottleRendering())
     return;
 
   lifecycle().advanceTo(DocumentLifecycle::InPaintInvalidation);
@@ skipping 3911 matching lines @@
 void FrameView::setAnimationHost(
     std::unique_ptr<CompositorAnimationHost> host) {
   m_animationHost = std::move(host);
 }
 
 LayoutUnit FrameView::caretWidth() const {
   return LayoutUnit(getHostWindow()->windowToViewportScalar(1));
 }
 
 }  // namespace blink