[Do Not Submit] Fingerprint and Supercluster debugging logic

Source/core/rendering/FastTextAutosizer.cpp

 /*
  * Copyright (C) 2013 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 56 matching lines @@
 #ifndef NDEBUG
     , m_renderViewInfoPrepared(false)
     , m_blocksThatHaveBegunLayout()
 #endif
     , m_superclusters()
     , m_clusterStack()
     , m_fingerprintMapper()
 {
 }
 
+static void printFingerprintAndSuperclusterStats(FastTextAutosizer::SuperclusterMap& superclusters, FastTextAutosizer::FingerprintMapper& fingerprintMapper)
+{
+    fprintf(stderr, "fingerprint and supercluster stats\n");
+    fprintf(stderr, "==================================\n");
+    fprintf(stderr, "Superclusters:\n");
+    int superclusterNumber = 0;
+    for (FastTextAutosizer::SuperclusterMap::iterator superIter = superclusters.begin(); superIter != superclusters.end(); ++superIter) {
+        superclusterNumber++;
+        fprintf(stderr, " #%d) supercluster fingerprint %u and blocks: ", superclusterNumber, superIter->key);
+        const FastTextAutosizer::BlockSet* roots = superIter->value->m_roots;
+        bool isFirst = true;
+        for (FastTextAutosizer::BlockSet::iterator blockIter = roots->begin(); blockIter != roots->end(); ++blockIter) {
+            const RenderBlock* block = (*blockIter);
+            if (!isFirst)
+                fprintf(stderr, ", ");
+            fprintf(stderr, "%p/%s", block, block->node() ? block->node()->nodeName().utf8().data() : "unknown");
+            isFirst = false;
+        }
+        fprintf(stderr, "\n");
+    }
+    fprintf(stderr, "Fingerprints for blocks:\n");
+    int blockNumber = 0;
+    for (FastTextAutosizer::FingerprintMapper::FingerprintMap::iterator fingerIter = fingerprintMapper.m_fingerprints.begin(); fingerIter != fingerprintMapper.m_fingerprints.end(); ++fingerIter) {
+        blockNumber++;
+        const RenderObject* block = fingerIter->key;
+        fprintf(stderr, " #%d) block %p/%s has fingerprint %u\n", blockNumber, block, block->node() ? block->node()->nodeName().utf8().data() : "unknown", fingerIter->value);
+    }
+    fprintf(stderr, "Blocks for fingerprints:\n");
+    int fingerprintNumber = 0;
+    for (FastTextAutosizer::FingerprintMapper::ReverseFingerprintMap::iterator blocksIter = fingerprintMapper.m_blocksForFingerprint.begin(); blocksIter != fingerprintMapper.m_blocksForFingerprint.end(); ++blocksIter) {
+        fingerprintNumber++;
+        fprintf(stderr, " #%d) fingerprint %u and blocks: ", fingerprintNumber, blocksIter->key);
+        FastTextAutosizer::BlockSet* blocks = blocksIter->value.get();
+        bool isFirst = true;
+        for (FastTextAutosizer::BlockSet::iterator blockIter = blocks->begin(); blockIter != blocks->end(); ++blockIter) {
+            const RenderBlock* block = (*blockIter);
+            if (!isFirst)
+                fprintf(stderr, ", ");
+            fprintf(stderr, "%p/%s", block, block->node() ? block->node()->nodeName().utf8().data() : "unknown");
+            isFirst = false;
+        }
+        fprintf(stderr, "\n");
+    }
+}
+
 void FastTextAutosizer::record(const RenderBlock* block)
 {
     if (!enabled())
         return;
 
     ASSERT(!m_blocksThatHaveBegunLayout.contains(block));
 
     if (!isFingerprintingCandidate(block))
         return;
 
     if (Fingerprint fingerprint = computeFingerprint(block))
         m_fingerprintMapper.addTentativeClusterRoot(block, fingerprint);
+    fprintf(stderr, "after record(%p)\n", block);
+    printFingerprintAndSuperclusterStats(m_superclusters, m_fingerprintMapper);
 }
 
 void FastTextAutosizer::destroy(const RenderBlock* block)
 {
     if (!enabled())
         return;
     ASSERT(!m_blocksThatHaveBegunLayout.contains(block));
 
     m_fingerprintMapper.remove(block);
+    fprintf(stderr, "after destroy(%p)\n", block);
+    printFingerprintAndSuperclusterStats(m_superclusters, m_fingerprintMapper);
 }
 
 void FastTextAutosizer::prepareClusterStack(const RenderObject* renderer)
 {
     if (!renderer)
         return;
     prepareClusterStack(renderer->parent());
 
     if (renderer->isRenderBlock()) {
         const RenderBlock* block = toRenderBlock(renderer);
 #ifndef NDEBUG
         m_blocksThatHaveBegunLayout.add(block);
 #endif
         if (Cluster* cluster = maybeCreateCluster(block))
             m_clusterStack.append(adoptPtr(cluster));
     }
 }
 
 void FastTextAutosizer::beginLayout(RenderBlock* block)
 {
+    fprintf(stderr, "beginLayout(%p)\n", block);
+    printFingerprintAndSuperclusterStats(m_superclusters, m_fingerprintMapper);
+
     ASSERT(enabled());
 #ifndef NDEBUG
     m_blocksThatHaveBegunLayout.add(block);
 #endif
 
     if (!m_firstBlock)  {
         prepareRenderViewInfo();
         prepareClusterStack(block->parent());
         m_firstBlock = block;
     } else if (block == currentCluster()->m_root) {
@@ skipping 332 matching lines @@
             cluster->m_multiplier = cluster->m_parent ? clusterMultiplier(cluster->m_parent) : 1.0f;
         }
     }
     ASSERT(cluster->m_multiplier);
     return cluster->m_multiplier;
 }
 
 float FastTextAutosizer::superclusterMultiplier(Supercluster* supercluster)
 {
     if (!supercluster->m_multiplier) {
+        fprintf(stderr, "superclusterMultiplier\n");
+        printFingerprintAndSuperclusterStats(m_superclusters, m_fingerprintMapper);
         const BlockSet* roots = supercluster->m_roots;
         BlockSet widthProviders;
         for (BlockSet::iterator it = roots->begin(); it != roots->end(); ++it)
             widthProviders.add(clusterWidthProvider(*it));
         const RenderBlock* widthProvider = deepestCommonAncestor(widthProviders);
 
         bool anyClusterHasEnoughTextToAutosize = false;
         for (BlockSet::iterator it = roots->begin(); it != roots->end(); ++it) {
             if (clusterWouldHaveEnoughTextToAutosize(*it, widthProvider)) {
                 anyClusterHasEnoughTextToAutosize = true;
                 break;
             }
         }
 
         supercluster->m_multiplier = anyClusterHasEnoughTextToAutosize ? multiplierFromBlock(widthProvider) : 1.0f;
     }
     ASSERT(supercluster->m_multiplier);
     return supercluster->m_multiplier;
 }
 
 const RenderBlock* FastTextAutosizer::clusterWidthProvider(const RenderBlock* root)
 {
+    fprintf(stderr, "clusterWidthProvider(%p)\n", root);
     if (root->isTableCell())
         return toRenderTableCell(root)->table();
     if (root->isTable())
         return toRenderTable(root);
 
     return deepestBlockContainingAllText(root);
 }
 
 float FastTextAutosizer::widthFromBlock(const RenderBlock* block)
 {
@@ skipping 195 matching lines @@
 }
 
 RenderObject* FastTextAutosizer::nextChildSkippingChildrenOfBlocks(const RenderObject* current, const RenderObject* stayWithin)
 {
     if (current == stayWithin || !current->isRenderBlock())
         return current->nextInPreOrder(stayWithin);
     return current->nextInPreOrderAfterChildren(stayWithin);
 }
 
 } // namespace WebCore