[FastTextAutosizer] Refactor for understandability

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 33 matching lines @@
 #include "core/rendering/RenderView.h"
 
 using namespace std;
 
 namespace WebCore {
 
 static const RenderObject* parentElementRenderer(const RenderObject* renderer)
 {
     // At style recalc, the renderer's parent may not be attached,
     // so we need to obtain this from the DOM tree.
-
     const Node* node = renderer->node();
     if (!node)
         return 0;
 
     while ((node = node->parentNode())) {
         if (node->isElementNode())
             return node->renderer();
     }
     return 0;
 }
 
-static const Vector<QualifiedName>& formInputTags()
+static bool isFormInput(const Element* element)
 {
-    // Returns the tags for the form input elements.
     DEFINE_STATIC_LOCAL(Vector<QualifiedName>, formInputTags, ());
     if (formInputTags.isEmpty()) {
         formInputTags.append(HTMLNames::inputTag);
         formInputTags.append(HTMLNames::buttonTag);
         formInputTags.append(HTMLNames::selectTag);
     }
-    return formInputTags;
+    return formInputTags.contains(element->tagQName());
 }
 
-static bool isAutosizingContainer(const RenderObject* renderer)
+static bool isPotentialClusterRoot(const RenderObject* renderer)
 {
-    // "Autosizing containers" are the smallest unit for which we can
-    // enable/disable Text Autosizing.
+    // "Potential cluster roots" are the smallest unit for which we can
+    // enable/disable text autosizing.
     // - Must not be inline, as different multipliers on one line looks terrible.
     //   Exceptions are inline-block and alike elements (inline-table, -webkit-inline-*),
     //   as they often contain entire multi-line columns of text.
     // - Must not be list items, as items in the same list should look consistent (*).
     // - Must not be normal list items, as items in the same list should look
     //   consistent, unless they are floating or position:absolute/fixed.
     Node* node = renderer->generatingNode();
-    if ((node && !node->hasChildren())
-        || !renderer->isRenderBlock()
-        || (renderer->isInline() && !renderer->style()->isDisplayReplacedType()))
+    if (node && !node->hasChildren())
+        return false;
+    if (!renderer->isRenderBlock())
+        return false;
+    if (renderer->isInline() && !renderer->style()->isDisplayReplacedType())
         return false;
     if (renderer->isListItem())
-        return renderer->isFloating() || renderer->isOutOfFlowPositioned();
+        return (renderer->isFloating() || renderer->isOutOfFlowPositioned());
     // Avoid creating containers for text within text controls, buttons, or <select> buttons.
     Node* parentNode = renderer->parent() ? renderer->parent()->generatingNode() : 0;
-    if (parentNode && parentNode->isElementNode() && formInputTags().contains(toElement(parentNode)->tagQName()))
+    if (parentNode && parentNode->isElementNode() && isFormInput(toElement(parentNode)))
         return false;
 
     return true;
 }
 
-static RenderObject* nextInPreOrderSkippingDescendantsOfContainers(const RenderObject* current, const RenderObject* stayWithin)
-{
-    if (current == stayWithin || !isAutosizingContainer(current))
-        return current->nextInPreOrder(stayWithin);
-    return current->nextInPreOrderAfterChildren(stayWithin);
-}
-
 static bool isIndependentDescendant(const RenderBlock* renderer)
 {
-    ASSERT(isAutosizingContainer(renderer));
+    ASSERT(isPotentialClusterRoot(renderer));
 
-    // "Autosizing clusters" are special autosizing containers within which we
-    // want to enforce a uniform text size multiplier, in the hopes of making
-    // the major sections of the page look internally consistent.
-    // All their descendants (including other autosizing containers) must share
-    // the same multiplier, except for subtrees which are themselves clusters,
-    // and some of their descendant containers might not be autosized at all
-    // (for example if their height is constrained).
-    // Additionally, clusterShouldBeAutosized requires each cluster to contain a
-    // minimum amount of text, without which it won't be autosized.
-    //
-    // Clusters are chosen using very similar criteria to CSS flow roots, aka
-    // block formatting contexts (http://w3.org/TR/css3-box/#flow-root), since
-    // flow roots correspond to box containers that behave somewhat
-    // independently from their parent (for example they don't overlap floats).
-    // The definition of a flow root also conveniently includes most of the
-    // ways that a box and its children can have significantly different width
-    // from the box's parent (we want to avoid having significantly different
-    // width blocks within a cluster, since the narrower blocks would end up
-    // larger than would otherwise be necessary).
     RenderBlock* containingBlock = renderer->containingBlock();
     return renderer->isRenderView()
         || renderer->isFloating()
         || renderer->isOutOfFlowPositioned()
         || renderer->isTableCell()
         || renderer->isTableCaption()
         || renderer->isFlexibleBoxIncludingDeprecated()
         || renderer->hasColumns()
         || (containingBlock && containingBlock->isHorizontalWritingMode() != renderer->isHorizontalWritingMode())
         || renderer->style()->isDisplayReplacedType()
         || renderer->isTextArea()
         || renderer->style()->userModify() != READ_ONLY;
     // FIXME: Tables need special handling to multiply all their columns by
     // the same amount even if they're different widths; so do hasColumns()
     // containers, and probably flexboxes...
 }
 
-static bool containerIsRowOfLinks(const RenderObject* container)
+static bool blockIsRowOfLinks(const RenderBlock* block)
 {
-    // A "row of links" is a container for which holds:
-    //  1. it should not contain non-link text elements longer than 3 characters
-    //  2. it should contain min. 3 inline links and all links should
-    //     have the same specified font size
-    //  3. it should not contain <br> elements
-    //  4. it should contain only inline elements unless they are containers,
+    // A "row of links" is a block for which:
+    //  1. It does not contain non-link text elements longer than 3 characters
+    //  2. It contains a minimum of 3 inline links and all links should
+    //     have the same specified font size.
+    //  3. It should not contain <br> elements.
+    //  4. It should contain only inline elements unless they are containers,
     //     children of link elements or children of sub-containers.
     int linkCount = 0;
-    RenderObject* renderer = container->nextInPreOrder(container);
+    RenderObject* renderer = block->nextInPreOrder(block);
     float matchingFontSize = -1;
 
     while (renderer) {
-        if (!isAutosizingContainer(renderer)) {
+        if (!isPotentialClusterRoot(renderer)) {
             if (renderer->isText() && toRenderText(renderer)->text().impl()->stripWhiteSpace()->length() > 3)
                 return false;
-            if (!renderer->isInline())
-                return false;
-            if (renderer->isBR())
+            if (!renderer->isInline() || renderer->isBR())
                 return false;
         }
         if (renderer->style()->isLink()) {
-            if (matchingFontSize < 0) {
+            linkCount++;
+            if (matchingFontSize < 0)
                 matchingFontSize = renderer->style()->specifiedFontSize();
-            } else {
-                if (matchingFontSize != renderer->style()->specifiedFontSize())
-                    return false;
-            }
+            else if (matchingFontSize != renderer->style()->specifiedFontSize())
+                return false;
 
-            linkCount++;
             // Skip traversing descendants of the link.
-            renderer = renderer->nextInPreOrderAfterChildren(container);
-        } else {
-            renderer = nextInPreOrderSkippingDescendantsOfContainers(renderer, container);
+            renderer = renderer->nextInPreOrderAfterChildren(block);
+            continue;
         }
+        renderer = renderer->nextInPreOrder(block);
     }
 
     return (linkCount >= 3);
 }
 
-static bool contentHeightIsConstrained(const RenderBlock* container)
+static bool blockHeightConstrained(const RenderBlock* block)
 {
     // FIXME: Propagate constrainedness down the tree, to avoid inefficiently walking back up from each box.
     // FIXME: This code needs to take into account vertical writing modes.
     // FIXME: Consider additional heuristics, such as ignoring fixed heights if the content is already overflowing before autosizing kicks in.
-    for (; container; container = container->containingBlock()) {
-        RenderStyle* style = container->style();
+    for (; block; block = block->containingBlock()) {
+        RenderStyle* style = block->style();
         if (style->overflowY() >= OSCROLL)
             return false;
-        if (style->height().isSpecified() || style->maxHeight().isSpecified() || container->isOutOfFlowPositioned()) {
+        if (style->height().isSpecified() || style->maxHeight().isSpecified() || block->isOutOfFlowPositioned()) {
             // Some sites (e.g. wikipedia) set their html and/or body elements to height:100%,
             // without intending to constrain the height of the content within them.
-            return !container->isRoot() && !container->isBody();
+            return !block->isRoot() && !block->isBody();
         }
-        if (container->isFloating())
+        if (block->isFloating())
             return false;
     }
     return false;
 }
 
-static bool containerContainsOneOfTags(const RenderBlock* container, const Vector<QualifiedName>& tags)
+static bool blockContainsFormInput(const RenderBlock* block)
 {
-    const RenderObject* renderer = container;
+    const RenderObject* renderer = block;
     while (renderer) {
-        const Node* rendererNode = renderer->node();
-        if (rendererNode && rendererNode->isElementNode()) {
-            if (tags.contains(toElement(rendererNode)->tagQName()))
-                return true;
-        }
-        renderer = nextInPreOrderSkippingDescendantsOfContainers(renderer, container);
+        const Node* node = renderer->node();
+        if (node && node->isElementNode() && isFormInput(toElement(node)))
+            return true;
+        if (renderer == block)
+            renderer = renderer->nextInPreOrder(block);
+        else
+            renderer = renderer->nextInPreOrderAfterChildren(block);
     }
 
     return false;
 }
 
-static bool containerShouldBeAutosized(const RenderBlock* container)
+// Some blocks are not autosized even if their parent cluster wants them to.
+static bool blockSuppressesAutosizing(const RenderBlock* block)
 {
-    if (containerContainsOneOfTags(container, formInputTags()))
-        return false;
+    if (blockContainsFormInput(block))
+        return true;
 
-    if (containerIsRowOfLinks(container))
-        return false;
+    if (blockIsRowOfLinks(block))
+        return true;
 
     // Don't autosize block-level text that can't wrap (as it's likely to
     // expand sideways and break the page's layout).
-    if (!container->style()->autoWrap())
-        return false;
+    if (!block->style()->autoWrap())
+        return true;
 
-    return !contentHeightIsConstrained(container);
+    if (blockHeightConstrained(block))
+        return true;
+
+    return false;
+}
+
+static bool mightBeWiderOrNarrowerDescendant(const RenderBlock* block)
+{
+    // FIXME: This heuristic may need to be expanded to other ways a block can be wider or narrower
+    //        than its parent containing block.
+    return block->style() && block->style()->width().isSpecified();
+}
+
+// Before a block enters layout we don't know for sure if it will become a cluster.
+// Note: clusters are also created for blocks that do become autosizing clusters!
+static bool blockMightBecomeAutosizingCluster(const RenderBlock* block)
+{
+    ASSERT(isPotentialClusterRoot(block));
+    return isIndependentDescendant(block) || mightBeWiderOrNarrowerDescendant(block) || block->isTable();
 }
 
 FastTextAutosizer::FastTextAutosizer(const Document* document)
     : m_document(document)
     , m_frameWidth(0)
     , m_layoutWidth(0)
     , m_baseMultiplier(0)
     , m_pageAutosizingStatus(PageAutosizingStatusUnknown)
     , m_firstBlock(0)
 #ifndef NDEBUG
     , m_renderViewInfoPrepared(false)
     , m_blocksThatHaveBegunLayout()
 #endif
     , m_superclusters()
     , m_clusterStack()
     , m_fingerprintMapper()
 {
 }
 
 void FastTextAutosizer::record(const RenderBlock* block)
 {
     if (!enabled())
         return;
 
     ASSERT(!m_blocksThatHaveBegunLayout.contains(block));
 
-    if (!isFingerprintingCandidate(block))
+    if (!isPotentialClusterRoot(block))
+        return;
+
+    if (!blockMightBecomeAutosizingCluster(block))
         return;
 
     if (Fingerprint fingerprint = computeFingerprint(block))
         m_fingerprintMapper.addTentativeClusterRoot(block, fingerprint);
 }
 
 void FastTextAutosizer::destroy(const RenderBlock* block)
 {
     if (!enabled())
         return;
@@ skipping 80 matching lines @@
             continue;
         for (RenderObject* row = section->firstChild(); row; row = row->nextSibling()) {
             if (!row->isTableRow())
                 continue;
             for (RenderObject* cell = row->firstChild(); cell; cell = cell->nextSibling()) {
                 if (!cell->isTableCell())
                     continue;
                 RenderTableCell* renderTableCell = toRenderTableCell(cell);
 
                 bool shouldAutosize;
-                if (!containerShouldBeAutosized(renderTableCell))
+                if (blockSuppressesAutosizing(renderTableCell))
                     shouldAutosize = false;
                 else if (Supercluster* supercluster = getSupercluster(renderTableCell))
                     shouldAutosize = anyClusterHasEnoughTextToAutosize(supercluster->m_roots, table);
                 else
                     shouldAutosize = clusterWouldHaveEnoughTextToAutosize(renderTableCell, table);
 
                 if (shouldAutosize) {
                     for (RenderObject* child = cell; child; child = child->nextInPreOrder(cell)) {
                         if (child->isText()) {
                             applyMultiplier(child, multiplier);
@@ skipping 20 matching lines @@
 #endif
     } else if (currentCluster()->m_root == block) {
         m_clusterStack.removeLast();
     }
 }
 
 void FastTextAutosizer::inflate(RenderBlock* block)
 {
     Cluster* cluster = currentCluster();
     float multiplier = 0;
-    for (RenderObject* descendant = nextChildSkippingChildrenOfBlocks(block, block); descendant; descendant = nextChildSkippingChildrenOfBlocks(descendant, block)) {
+    RenderObject* descendant = block->nextInPreOrder();
+    while (descendant) {
+        // Skip block descendants because they will be inflate()'d on their own.
+        if (descendant->isRenderBlock()) {
+            descendant = descendant->nextInPreOrderAfterChildren(block);
+            continue;
+        }
         if (descendant->isText()) {
             // We only calculate this multiplier on-demand to ensure the parent block of this text
             // has entered layout.
             if (!multiplier)
                 multiplier = cluster->m_autosize ? clusterMultiplier(cluster) : 1.0f;
             applyMultiplier(descendant, multiplier);
             applyMultiplier(descendant->parent(), multiplier); // Parent handles line spacing.
         }
+        descendant = descendant->nextInPreOrder(block);
     }
 }
 
 bool FastTextAutosizer::enabled()
 {
     if (!m_document->settings() || !m_document->page() || m_document->printing())
         return false;
 
     return m_document->settings()->textAutosizingEnabled();
 }
@@ skipping 22 matching lines @@
     }
 
     m_pageAutosizingStatus = m_frameWidth && (m_baseMultiplier * (static_cast<float>(m_layoutWidth) / m_frameWidth) > 1.0f)
         ? PageNeedsAutosizing : PageDoesNotNeedAutosizing;
 
 #ifndef NDEBUG
     m_renderViewInfoPrepared = true;
 #endif
 }
 
-bool FastTextAutosizer::isFingerprintingCandidate(const RenderBlock* block)
-{
-    // FIXME: move the logic out of TextAutosizer.cpp into this class.
-    return block->isRenderView()
-        || (isAutosizingContainer(block)
-            && (isIndependentDescendant(block)
-                || mightBeWiderOrNarrowerDescendant(block)));
-}
-
 bool FastTextAutosizer::clusterWouldHaveEnoughTextToAutosize(const RenderBlock* root, const RenderBlock* widthProvider)
 {
     Cluster hypotheticalCluster(root, true, 0);
     return clusterHasEnoughTextToAutosize(&hypotheticalCluster, widthProvider);
 }
 
 bool FastTextAutosizer::clusterHasEnoughTextToAutosize(Cluster* cluster, const RenderBlock* widthProvider)
 {
     if (cluster->m_hasEnoughTextToAutosize != UnknownAmountOfText)
         return cluster->m_hasEnoughTextToAutosize == HasEnoughText;
 
     const RenderBlock* root = cluster->m_root;
     if (!widthProvider)
         widthProvider = clusterWidthProvider(root);
 
     // TextAreas and user-modifiable areas get a free pass to autosize regardless of text content.
     if (root->isTextArea() || (root->style() && root->style()->userModify() != READ_ONLY)) {
         cluster->m_hasEnoughTextToAutosize = HasEnoughText;
         return true;
     }
 
-    if (!containerShouldBeAutosized(root)) {
+    if (blockSuppressesAutosizing(root)) {
         cluster->m_hasEnoughTextToAutosize = NotEnoughText;
         return false;
     }
 
     // 4 lines of text is considered enough to autosize.
     float minimumTextLengthToAutosize = widthFromBlock(widthProvider) * 4;
 
     float length = 0;
     RenderObject* descendant = root->nextInPreOrder(root);
     while (descendant) {
         if (descendant->isRenderBlock()) {
             RenderBlock* block = toRenderBlock(descendant);
-            if (isAutosizingContainer(block)) {
-                // Note: Ideally we would check isWiderOrNarrowerDescendant here but we only know that
-                //       after the block has entered layout, which may not be the case.
+
+            // Note: Ideally we would check isWiderOrNarrowerDescendant here but we only know that
+            //       after the block has entered layout, which may not be the case.
+            if (isPotentialClusterRoot(block)) {
                 bool isAutosizingClusterRoot = isIndependentDescendant(block) || block->isTable();
-                if ((isAutosizingClusterRoot && !block->isTableCell())
-                    || !containerShouldBeAutosized(block)) {
+                if ((isAutosizingClusterRoot && !block->isTableCell()) || blockSuppressesAutosizing(block)) {
                     descendant = descendant->nextInPreOrderAfterChildren(root);
                     continue;
                 }
             }
         } else if (descendant->isText()) {
             // Note: Using text().stripWhiteSpace().length() instead of renderedTextLength() because
             // the lineboxes will not be built until layout. These values can be different.
             // Note: This is an approximation assuming each character is 1em wide.
             length += toRenderText(descendant)->text().stripWhiteSpace().length() * descendant->style()->specifiedFontSize();
 
@@ skipping 55 matching lines @@
     if (renderer->isTableCell())
         data.m_column = renderer->node()->nodeIndex();
 
     return StringHasher::computeHash<UChar>(
         static_cast<const UChar*>(static_cast<const void*>(&data)),
         sizeof data / sizeof(UChar));
 }
 
 FastTextAutosizer::Cluster* FastTextAutosizer::maybeCreateCluster(const RenderBlock* block)
 {
-    if (!isAutosizingContainer(block))
+    if (!isPotentialClusterRoot(block))
         return 0;
 
     Cluster* parentCluster = m_clusterStack.isEmpty() ? 0 : currentCluster();
     ASSERT(parentCluster || block->isRenderView());
 
-    // Create clusters to suppress / unsuppress autosizing based on containerShouldBeAutosized.
-    bool containerCanAutosize = containerShouldBeAutosized(block);
-    bool parentClusterCanAutosize = parentCluster && parentCluster->m_autosize;
-    bool createClusterThatMightAutosize = block->isRenderView()
-        || mightBeWiderOrNarrowerDescendant(block)
-        || isIndependentDescendant(block)
-        || block->isTable();
+    bool mightAutosize = blockMightBecomeAutosizingCluster(block);
+    bool suppressesAutosizing = blockSuppressesAutosizing(block);
 
-    // If the container would not alter the m_autosize bit, it doesn't need to be a cluster.
-    if (!createClusterThatMightAutosize && containerCanAutosize == parentClusterCanAutosize)
+    // If the block would not alter the m_autosize bit, it doesn't need to be a cluster.
+    bool parentSuppressesAutosizing = parentCluster && !parentCluster->m_autosize;
+    if (!mightAutosize && suppressesAutosizing == parentSuppressesAutosizing)
         return 0;
 
-    return new Cluster(block, containerCanAutosize, parentCluster, getSupercluster(block));
+    return new Cluster(block, !suppressesAutosizing, parentCluster, getSupercluster(block));
 }
 
 FastTextAutosizer::Supercluster* FastTextAutosizer::getSupercluster(const RenderBlock* block)
 {
     Fingerprint fingerprint = m_fingerprintMapper.get(block);
     if (!fingerprint)
         return 0;
 
     BlockSet* roots = &m_fingerprintMapper.getTentativeClusterRoots(fingerprint);
     if (!roots || roots->size() < 2 || !roots->contains(block))
@@ skipping 177 matching lines @@
         return parent;
 
     if (parent->isEmpty())
         return parent->isText() ? parent : 0;
 
     ++depth;
     const RenderObject* child = (firstOrLast == First) ? parent->firstChild() : parent->lastChild();
     while (child) {
         // Note: At this point clusters may not have been created for these blocks so we cannot rely
         //       on m_clusters. Instead, we use a best-guess about whether the block will become a cluster.
-        if (!isAutosizingContainer(child) || !isIndependentDescendant(toRenderBlock(child))) {
+        if (!isPotentialClusterRoot(child) || !isIndependentDescendant(toRenderBlock(child))) {
             const RenderObject* leaf = findTextLeaf(child, depth, firstOrLast);
             if (leaf)
                 return leaf;
         }
         child = (firstOrLast == First) ? child->nextSibling() : child->previousSibling();
     }
     --depth;
 
     return 0;
 }
 
 void FastTextAutosizer::applyMultiplier(RenderObject* renderer, float multiplier)
 {
     ASSERT(renderer);
     RenderStyle* currentStyle = renderer->style();
     if (currentStyle->textAutosizingMultiplier() == multiplier)
         return;
 
     // We need to clone the render style to avoid breaking style sharing.
     RefPtr<RenderStyle> style = RenderStyle::clone(currentStyle);
     style->setTextAutosizingMultiplier(multiplier);
     style->setUnique();
     renderer->setStyleInternal(style.release());
 }
 
-bool FastTextAutosizer::mightBeWiderOrNarrowerDescendant(const RenderBlock* block)
-{
-    // FIXME: This heuristic may need to be expanded to other ways a block can be wider or narrower
-    //        than its parent containing block.
-    return block->style() && block->style()->width().isSpecified();
-}
-
 bool FastTextAutosizer::isWiderOrNarrowerDescendant(Cluster* cluster)
 {
     if (!cluster->m_parent || !mightBeWiderOrNarrowerDescendant(cluster->m_root))
         return true;
 
     const RenderBlock* parentDeepestBlockContainingAllText = deepestBlockContainingAllText(cluster->m_parent);
     ASSERT(m_blocksThatHaveBegunLayout.contains(cluster->m_root));
     ASSERT(m_blocksThatHaveBegunLayout.contains(parentDeepestBlockContainingAllText));
 
     float contentWidth = cluster->m_root->contentLogicalWidth().toFloat();
@@ skipping 81 matching lines @@
 FastTextAutosizer::Fingerprint FastTextAutosizer::FingerprintMapper::get(const RenderObject* renderer)
 {
     return m_fingerprints.get(renderer);
 }
 
 FastTextAutosizer::BlockSet& FastTextAutosizer::FingerprintMapper::getTentativeClusterRoots(Fingerprint fingerprint)
 {
     return *m_blocksForFingerprint.get(fingerprint);
 }
 
-RenderObject* FastTextAutosizer::nextChildSkippingChildrenOfBlocks(const RenderObject* current, const RenderObject* stayWithin)
-{
-    if (current == stayWithin || !current->isRenderBlock())
-        return current->nextInPreOrder(stayWithin);
-    return current->nextInPreOrderAfterChildren(stayWithin);
-}
-
 FastTextAutosizer::LayoutScope::LayoutScope(RenderBlock* block)
     : m_textAutosizer(block->document().fastTextAutosizer())
     , m_block(block)
 {
     if (!m_textAutosizer)
         return;
 
     if (!m_textAutosizer->enabled()) {
         m_textAutosizer = 0;
         return;
     }
 
     if (m_textAutosizer->m_pageAutosizingStatus == PageAutosizingStatusUnknown)
         m_textAutosizer->updateRenderViewInfo();
 
     if (m_textAutosizer->m_pageAutosizingStatus == PageNeedsAutosizing)
         m_textAutosizer->beginLayout(m_block);
     else
         m_textAutosizer = 0;
 }
 
 FastTextAutosizer::LayoutScope::~LayoutScope()
 {
     if (m_textAutosizer)
         m_textAutosizer->endLayout(m_block);
 }
 
 } // namespace WebCore