Consistently autosize markers in <ul> and <ol> lists.

Source/core/rendering/TextAutosizer.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  * Copyright (C) 2012 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 72 matching lines @@
 
 static RenderListItem* getAncestorListItem(const RenderObject* renderer)
 {
     RenderObject* ancestor = renderer->parent();
     while (ancestor && (ancestor->isRenderInline() || ancestor->isAnonymousBlock()))
         ancestor = ancestor->parent();
 
     return (ancestor && ancestor->isListItem()) ? toRenderListItem(ancestor) : 0;
 }
 
+static RenderObject* getAncestorList(const RenderObject* renderer)
+{
+    // FIXME: Add support for <menu> elements as a possible ancestor of an <li> element,
+    // see http://www.whatwg.org/specs/web-apps/current-work/multipage/grouping-content.html#the-li-element
+    for (RenderObject* ancestor = renderer->parent(); ancestor; ancestor = ancestor->parent()) {
+        Node* parentNode = ancestor->generatingNode();
+        if (parentNode && (parentNode->hasTagName(olTag) || parentNode->hasTagName(ulTag)))
+            return ancestor;
+    }
+    return 0;
+}
+
 TextAutosizer::TextAutosizer(Document* document)
     : m_document(document)
 {
 }
 
 TextAutosizer::~TextAutosizer()
 {
 }
 
 void TextAutosizer::recalculateMultipliers()
@@ skipping 106 matching lines @@
     ASSERT(isAutosizingContainer(container));
 
     float localMultiplier = containerShouldBeAutosized(container) ? multiplier: 1;
 
     RenderObject* descendant = nextInPreOrderSkippingDescendantsOfContainers(subtreeRoot, subtreeRoot);
     while (descendant) {
         if (descendant->isText()) {
             if (localMultiplier != 1 && descendant->style()->textAutosizingMultiplier() == 1) {
                 setMultiplier(descendant, localMultiplier);
                 setMultiplier(descendant->parent(), localMultiplier); // Parent does line spacing.
+
                 if (RenderListItem* listItemAncestor = getAncestorListItem(descendant)) {
-                    if (listItemAncestor->style()->textAutosizingMultiplier() == 1)
-                        setMultiplier(listItemAncestor, localMultiplier);
+                    if (RenderObject* list = getAncestorList(listItemAncestor)) {
+                        if (list->style()->textAutosizingMultiplier() == 1)
+                            setMultiplierForList(list, localMultiplier);
+                    }
                 }
             }
         } else if (isAutosizingContainer(descendant)) {
             RenderBlock* descendantBlock = toRenderBlock(descendant);
             TextAutosizingClusterInfo descendantClusterInfo(descendantBlock);
             if (isWiderDescendant(descendantBlock, clusterInfo) || isIndependentDescendant(descendantBlock))
                 processCluster(descendantClusterInfo, descendantBlock, descendantBlock, windowInfo);
             else if (isNarrowDescendant(descendantBlock, clusterInfo)) {
                 // Narrow descendants are processed together later to be able to apply the same multiplier
                 // to each of them if necessary.
                 clusterInfo.narrowDescendants.append(descendantClusterInfo);
             } else
                 processContainer(multiplier, descendantBlock, clusterInfo, descendantBlock, windowInfo);
         }
         descendant = nextInPreOrderSkippingDescendantsOfContainers(descendant, subtreeRoot);
     }
 }
 
 void TextAutosizer::setMultiplier(RenderObject* renderer, float multiplier)
 {
+    // FIXME: Investigate if a clone() is needed and whether it does the right thing w.r.t. style sharing.
     RefPtr<RenderStyle> newStyle = RenderStyle::clone(renderer->style());
     newStyle->setTextAutosizingMultiplier(multiplier);
     renderer->setStyle(newStyle.release());
 }
 
+void TextAutosizer::setMultiplierForList(RenderObject* renderer, float multiplier)
+{
+#ifndef NDEBUG
+    Node* parentNode = renderer->generatingNode();
+    ASSERT(parentNode);
+    ASSERT(parentNode->hasTagName(olTag) || parentNode->hasTagName(ulTag));
+#endif
+    setMultiplier(renderer, multiplier);
+
+    // Make sure all list items are autosized consistently.
+    for (RenderObject* child = renderer->firstChild(); child; child = child->nextSibling()) {
+        if (child->isListItem() && child->style()->textAutosizingMultiplier() == 1)
+            setMultiplier(child, multiplier);
+    }
+}
+
 float TextAutosizer::computeAutosizedFontSize(float specifiedSize, float multiplier)
 {
     // Somewhat arbitrary "pleasant" font size.
     const float pleasantSize = 16;
 
     // Multiply fonts that the page author has specified to be larger than
     // pleasantSize by less and less, until huge fonts are not increased at all.
     // For specifiedSize between 0 and pleasantSize we directly apply the
     // multiplier; hence for specifiedSize == pleasantSize, computedSize will be
     // multiplier * pleasantSize. For greater specifiedSizes we want to
@@ skipping 369 matching lines @@
         if (i + 1 < clusterInfos.size()) {
             float currentWidth = clusterInfos[i].root->contentLogicalWidth();
             float nextWidth = clusterInfos[i + 1].root->contentLogicalWidth();
             if (currentWidth - nextWidth > maxWidthDifferenceWithinGroup)
                 groups.grow(groups.size() + 1);
         }
     }
 }
 
 } // namespace WebCore