Autosize list markers.

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 79 matching lines @@
     if (block->isRenderView())
         prepareRenderViewInfo(toRenderView(block));
 
     if (Cluster* cluster = maybeGetOrCreateCluster(block))
         m_clusterStack.append(cluster);
 
     if (block->childrenInline())
         inflate(block);
 }
 
+void FastTextAutosizer::inflateListItem(RenderBlock* listItem, RenderObject* listItemMarker)
+{
+    ASSERT(listItem->isListItem());
+    ASSERT(listItemMarker->isListMarker());
+
+    if (!enabled())
+        return;
+

[pdr., 2014/01/28 04:50:47]

currentCluster() can be null here. Probably want to check for that and return.

[skobes, 2014/01/29 00:13:29]

Done, with FIXME to investigate further.

+    // Force the LI to be inside the DBCAT when computing the multiplier.
+    // This guarantees that the DBCAT has entered layout, so we can ask for its width.
+    // It also makes sense because the list marker is autosized like a text node.
+    float multiplier = clusterMultiplier(currentCluster(), listItem);

[pdr., 2014/01/28 04:50:47]

I like the idea here except for passing listItem in to clusterMultiplier because
it complicates the code quite a bit.

Instead, can you change findTextLeaf to look like:
const RenderObject* FastTextAutosizer::findTextLeaf(const RenderObject* parent,
size_t& depth, TextLeafSearch firstOrLast)
{
    if (parent->isEmpty())
        return parent->isText() || parent->isListItem() ? parent : 0;
...

This should have the same effect but with much less code. I verified that all
tests pass with this change.

[skobes, 2014/01/29 00:13:29]

Fixed.

+
+    applyMultiplier(listItem, multiplier);
+    applyMultiplier(listItemMarker, multiplier);
+}
+
 void FastTextAutosizer::endLayout(RenderBlock* block)
 {
     if (!enabled())
         return;
 #ifndef NDEBUG
     m_blocksThatHaveBegunLayout.remove(block);
 #endif
 
     Cluster* cluster = currentCluster();
     if (cluster && cluster->m_root == block)
@@ skipping 160 matching lines @@
             ancestors.add(block);
             // The first ancestor that has all of the blocks as children wins.
             if (ancestors.count(block) == blocks.size())
                 return block;
         }
     }
     ASSERT_NOT_REACHED();
     return 0;
 }
 
-float FastTextAutosizer::clusterMultiplier(Cluster* cluster)
+float FastTextAutosizer::clusterMultiplier(Cluster* cluster, const RenderBlock* forceInclude)
 {
 #ifndef NDEBUG
     ASSERT(m_renderViewInfoPrepared);
 #endif
     if (!cluster->m_multiplier) {
         if (TextAutosizer::isIndependentDescendant(cluster->m_root)) {
-            if (clusterHasEnoughTextToAutosize(cluster)) {
-                const RenderBlock* deepestBlockContainingAllText = findDeepestBlockContainingAllText(cluster->m_root);
+            bool enoughText = clusterHasEnoughTextToAutosize(cluster);
+            if (enoughText) {
+                const RenderBlock* deepestBlockContainingAllText = findDeepestBlockContainingAllText(cluster->m_root, forceInclude);
 #ifndef NDEBUG
                 // This ensures the deepest block containing all text has a valid contentLogicalWidth.
                 ASSERT(m_blocksThatHaveBegunLayout.contains(deepestBlockContainingAllText));
 #endif
                 // Block width, in CSS pixels.
                 float textBlockWidth = deepestBlockContainingAllText->contentLogicalWidth();
                 float multiplier = min(textBlockWidth, static_cast<float>(m_layoutWidth)) / m_frameWidth;
                 cluster->m_multiplier = max(m_baseMultiplier * multiplier, 1.0f);
             } else {
                 cluster->m_multiplier = 1.0f;
             }
         } else {
             cluster->m_multiplier = cluster->m_parent ? clusterMultiplier(cluster->m_parent) : 1.0f;
         }
     }
+    ASSERT(cluster->m_multiplier);
     return cluster->m_multiplier;
 }
 
 // FIXME: Refactor this to look more like FastTextAutosizer::deepestCommonAncestor. This is copied
 //        from TextAutosizer::findDeepestBlockContainingAllText.
-const RenderBlock* FastTextAutosizer::findDeepestBlockContainingAllText(const RenderBlock* root)
+const RenderBlock* FastTextAutosizer::findDeepestBlockContainingAllText(const RenderBlock* root, const RenderBlock* forceInclude)
 {
     size_t firstDepth = 0;
     const RenderObject* firstTextLeaf = findTextLeaf(root, firstDepth, First);
     if (!firstTextLeaf)
         return root;
 
     size_t lastDepth = 0;
     const RenderObject* lastTextLeaf = findTextLeaf(root, lastDepth, Last);
     ASSERT(lastTextLeaf);
 
@@ skipping 18 matching lines @@
     if (firstNode->isRenderBlock())
         return toRenderBlock(firstNode);
 
     // containingBlock() should never leave the cluster, since it only skips ancestors when finding
     // the container of position:absolute/fixed blocks, and those cannot exist between a cluster and
     // its text node's lowest common ancestor as isAutosizingCluster would have made them into their
     // own independent cluster.
     const RenderBlock* containingBlock = firstNode->containingBlock();
     ASSERT(containingBlock->isDescendantOf(root));
 
+    if (forceInclude && !forceInclude->isDescendantOf(containingBlock)) {
+        ASSERT(forceInclude->isDescendantOf(root));
+
+        BlockSet blockSet;
+        blockSet.add(containingBlock);
+        blockSet.add(forceInclude);
+        return deepestCommonAncestor(blockSet);
+    }
+
     return containingBlock;
 }
 
 const RenderObject* FastTextAutosizer::findTextLeaf(const RenderObject* parent, size_t& depth, TextLeafSearch firstOrLast)
 {
     if (parent->isEmpty())
         return parent->isText() ? parent : 0;
 
     ++depth;
     const RenderObject* child = (firstOrLast == First) ? parent->firstChild() : parent->lastChild();
@@ skipping 63 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