Merge 142534

Source/WebCore/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 19 matching lines @@
 #include "IntSize.h"
 #include "RenderObject.h"
 #include "RenderStyle.h"
 #include "RenderText.h"
 #include "RenderView.h"
 #include "Settings.h"
 #include "StyleInheritedData.h"
 
 #include <algorithm>
 #include <wtf/StdLibExtras.h>
+#include <wtf/Vector.h>
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
 struct TextAutosizingWindowInfo {
     IntSize windowSize;
     IntSize minLayoutSize;
 };
 
+// Represents cluster related data. Instances should not persist between calls to processSubtree.
 struct TextAutosizingClusterInfo {
     explicit TextAutosizingClusterInfo(RenderBlock* root)
         : root(root)
         , blockContainingAllText(0)
         , maxAllowedDifferenceFromTextWidth(150)
     {
     }
 
     RenderBlock* root;
     const RenderBlock* blockContainingAllText;
 
     // Upper limit on the difference between the width of the cluster's block containing all
     // text and that of a narrow child before the child becomes a separate cluster.
     float maxAllowedDifferenceFromTextWidth;
+
+    // Descendants of the cluster that are narrower than the block containing all text and must be
+    // processed together.
+    Vector<TextAutosizingClusterInfo> narrowDescendants;
 };
 
 
 static const Vector<QualifiedName>& formInputTags()
 {
     // Returns the tags for the form input elements.
     DEFINE_STATIC_LOCAL(Vector<QualifiedName>, formInputTags, ());
     if (formInputTags.isEmpty()) {
         formInputTags.append(inputTag);
         formInputTags.append(buttonTag);
@@ skipping 69 matching lines @@
         int logicalLayoutWidth = clusterInfo.root->isHorizontalWritingMode() ? windowInfo.minLayoutSize.width() : windowInfo.minLayoutSize.height();
         // Ignore box width in excess of the layout width, to avoid extreme multipliers.
         float logicalClusterWidth = std::min<float>(textWidth, logicalLayoutWidth);
 
         multiplier = logicalClusterWidth / logicalWindowWidth;
         multiplier *= m_document->settings()->textAutosizingFontScaleFactor();
         multiplier = std::max(1.0f, multiplier);
     }
 
     processContainer(multiplier, container, clusterInfo, subtreeRoot, windowInfo);
+
+    Vector<TextAutosizingClusterInfo>& narrowDescendants = clusterInfo.narrowDescendants;
+    for (size_t i = 0; i < narrowDescendants.size(); ++i) {
+        TextAutosizingClusterInfo& descendantClusterInfo = narrowDescendants[i];
+        processCluster(descendantClusterInfo, descendantClusterInfo.root, descendantClusterInfo.root, windowInfo);
+    }
 }
 
 void TextAutosizer::processContainer(float multiplier, RenderBlock* container, TextAutosizingClusterInfo& clusterInfo, RenderObject* subtreeRoot, const TextAutosizingWindowInfo& windowInfo)
 {
     ASSERT(isAutosizingContainer(container));
 
     float localMultiplier = containerShouldBeAutosized(container) ? multiplier: 1;
 
     RenderObject* descendant = nextInPreOrderSkippingDescendantsOfContainers(subtreeRoot, subtreeRoot);
     while (descendant) {
         if (descendant->isText()) {
             if (localMultiplier != descendant->style()->textAutosizingMultiplier()) {
                 setMultiplier(descendant, localMultiplier);
                 setMultiplier(descendant->parent(), localMultiplier); // Parent does line spacing.
             }
             // FIXME: Increase list marker size proportionately.
         } else if (isAutosizingContainer(descendant)) {
             RenderBlock* descendantBlock = toRenderBlock(descendant);
-            if (isAutosizingCluster(descendantBlock, clusterInfo)) {
-                TextAutosizingClusterInfo descendantClusterInfo(descendantBlock);
+            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)
 {
     RefPtr<RenderStyle> newStyle = RenderStyle::clone(renderer->style());
@@ skipping 331 matching lines @@
         child = (direction == FirstToLast) ? child->nextSibling() : child->previousSibling();
     }
     --depth;
 
     return 0;
 }
 
 } // namespace WebCore
 
 #endif // ENABLE(TEXT_AUTOSIZING)