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 20 matching lines @@
 #include "config.h"
 #include "core/rendering/FastTextAutosizer.h"
 
 #include "core/dom/Document.h"
 #include "core/frame/Frame.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/Settings.h"
 #include "core/page/Page.h"
 #include "core/rendering/InlineIterator.h"
 #include "core/rendering/RenderBlock.h"
+#include "core/rendering/RenderListItem.h"
+#include "core/rendering/RenderListMarker.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/TextAutosizer.h"
 
 using namespace std;
 
 namespace WebCore {
 
 FastTextAutosizer::FastTextAutosizer(const Document* document)
     : m_document(document)
 #ifndef NDEBUG
@@ skipping 37 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(RenderListItem* listItem, RenderListMarker* listItemMarker)
+{
+    if (!enabled())
+        return;
+#ifndef NDEBUG
+    m_blocksThatHaveBegunLayout.add(listItem);
+#endif
+
+    Cluster* cluster = currentCluster();
+    // FIXME: Why is this check needed?
+    if (!cluster)
+        return;
+
+    // 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(cluster);
+
+    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 187 matching lines @@
                 float textBlockWidth = deepestBlockWithAllText->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::deepestBlockContainingAllText(Cluster* cluster)
 {
     if (cluster->m_deepestBlockContainingAllText)
         return cluster->m_deepestBlockContainingAllText;
 
@@ skipping 32 matching lines @@
     // 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(cluster->m_root));
 
     return cluster->m_deepestBlockContainingAllText = containingBlock;
 }
 
 const RenderObject* FastTextAutosizer::findTextLeaf(const RenderObject* parent, size_t& depth, TextLeafSearch firstOrLast)
 {
+    // List items are treated as text due to the marker.
+    // The actual renderer for the marker (RenderListMarker) may not be in the tree yet since it is added during layout.
+    if (parent->isListItem())
+        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 (!TextAutosizer::isAutosizingContainer(child) || !TextAutosizer::isIndependentDescendant(toRenderBlock(child))) {
             const RenderObject* leaf = findTextLeaf(child, depth, firstOrLast);
@@ skipping 81 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