Reland text autosizing changes.

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 216 matching lines @@
 {
     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_pageNeedsAutosizing(false)
+    , m_previouslyAutosized(false)
     , m_firstBlock(0)
 #ifndef NDEBUG
-    , m_renderViewInfoPrepared(false)
     , m_blocksThatHaveBegunLayout()
 #endif
     , m_superclusters()
     , m_clusterStack()
     , m_fingerprintMapper()
 {
 }
 
 void FastTextAutosizer::record(const RenderBlock* block)
 {
@@ skipping 32 matching lines @@
 #ifndef NDEBUG
         m_blocksThatHaveBegunLayout.add(block);
 #endif
         if (Cluster* cluster = maybeCreateCluster(block))
             m_clusterStack.append(adoptPtr(cluster));
     }
 }
 
 void FastTextAutosizer::beginLayout(RenderBlock* block)
 {
-    ASSERT(enabled() && m_pageAutosizingStatus == PageNeedsAutosizing);
+    ASSERT(enabled() && m_pageNeedsAutosizing);
 #ifndef NDEBUG
     m_blocksThatHaveBegunLayout.add(block);
 #endif
 
     if (!m_firstBlock)  {
         m_firstBlock = block;
         prepareClusterStack(block->parent());
     } else if (block == currentCluster()->m_root) {
         // Ignore beginLayout on the same block twice.
         // This can happen with paginated overflow.
         return;
     }
 
     if (Cluster* cluster = maybeCreateCluster(block)) {
         m_clusterStack.append(adoptPtr(cluster));
         if (block->isTable())
             inflateTable(toRenderTable(block));
     }
 
     if (block->childrenInline() && block->firstChild())
         inflate(block);
 }
 
 void FastTextAutosizer::inflateListItem(RenderListItem* listItem, RenderListMarker* listItemMarker)
 {
-    if (!enabled() || m_pageAutosizingStatus != PageNeedsAutosizing)
+    if (!enabled() || !m_pageNeedsAutosizing)
         return;
     ASSERT(listItem && listItemMarker);
 #ifndef NDEBUG
     m_blocksThatHaveBegunLayout.add(listItem);
 #endif
     // 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());
 
@@ skipping 42 matching lines @@
                         }
                     }
                 }
             }
         }
     }
 }
 
 void FastTextAutosizer::endLayout(RenderBlock* block)
 {
-    ASSERT(enabled() && m_pageAutosizingStatus == PageNeedsAutosizing);
+    ASSERT(enabled() && m_pageNeedsAutosizing);
 
     if (block == m_firstBlock) {
         m_firstBlock = 0;
-        m_pageAutosizingStatus = PageAutosizingStatusUnknown;
         m_clusterStack.clear();
         m_superclusters.clear();
 #ifndef NDEBUG
         m_blocksThatHaveBegunLayout.clear();
 #endif
     } else if (currentCluster()->m_root == block) {
         m_clusterStack.removeLast();
     }
 }
 
@@ skipping 21 matching lines @@
 }
 
 bool FastTextAutosizer::enabled()
 {
     if (!m_document->settings() || !m_document->page() || m_document->printing())
         return false;
 
     return m_document->settings()->textAutosizingEnabled();
 }
 
-void FastTextAutosizer::updateRenderViewInfo()
+void FastTextAutosizer::updatePageInfoInAllFrames()
 {
+    if (!enabled())
+        return;
+
+    ASSERT(m_document->frame()->isMainFrame());
+
+    for (LocalFrame* frame = m_document->frame(); frame; frame = frame->tree().traverseNext()) {
+        if (FastTextAutosizer* textAutosizer = frame->document()->fastTextAutosizer())
+            textAutosizer->updatePageInfo();
+    }
+}
+
+void FastTextAutosizer::updatePageInfo()
+{
+    if (!enabled())
+        return;
+
+    int previousFrameWidth = m_frameWidth;
+    int previousLayoutWidth = m_layoutWidth;
+    float previousBaseMultiplier = m_baseMultiplier;
+
     RenderView* renderView = toRenderView(m_document->renderer());
     bool horizontalWritingMode = isHorizontalWritingMode(renderView->style()->writingMode());
 
     LocalFrame* mainFrame = m_document->page()->mainFrame();
     IntSize frameSize = m_document->settings()->textAutosizingWindowSizeOverride();
     if (frameSize.isEmpty())
         frameSize = mainFrame->view()->unscaledVisibleContentSize(IncludeScrollbars);
     m_frameWidth = horizontalWritingMode ? frameSize.width() : frameSize.height();
 
     IntSize layoutSize = m_document->page()->mainFrame()->view()->layoutSize();
     m_layoutWidth = horizontalWritingMode ? layoutSize.width() : layoutSize.height();
 
     // Compute the base font scale multiplier based on device and accessibility settings.
     m_baseMultiplier = m_document->settings()->accessibilityFontScaleFactor();
     // If the page has a meta viewport or @viewport, don't apply the device scale adjustment.
     const ViewportDescription& viewportDescription = m_document->page()->mainFrame()->document()->viewportDescription();
     if (!viewportDescription.isSpecifiedByAuthor()) {
         float deviceScaleAdjustment = m_document->settings()->deviceScaleAdjustment();
         m_baseMultiplier *= deviceScaleAdjustment;
     }
 
-    m_pageAutosizingStatus = m_frameWidth && (m_baseMultiplier * (static_cast<float>(m_layoutWidth) / m_frameWidth) > 1.0f)
-        ? PageNeedsAutosizing : PageDoesNotNeedAutosizing;
+    m_pageNeedsAutosizing = !!m_frameWidth
+        && (m_baseMultiplier * (static_cast<float>(m_layoutWidth) / m_frameWidth) > 1.0f);
 
-#ifndef NDEBUG
-    m_renderViewInfoPrepared = true;
-#endif
+    // If we are no longer autosizing the page, we won't do anything during the next layout.
+    // Set all the multipliers back to 1 now.
+    if (!m_pageNeedsAutosizing && m_previouslyAutosized)
+        resetMultipliers();
+
+    // If page info has changed, multipliers may have changed. Force a layout to recompute them.
+    if (m_pageNeedsAutosizing
+        && (m_frameWidth != previousFrameWidth
+            || m_layoutWidth != previousLayoutWidth
+            || m_baseMultiplier != previousBaseMultiplier))
+        setAllTextNeedsLayout();
+}
+
+void FastTextAutosizer::resetMultipliers()
+{
+    RenderObject* renderer = m_document->renderer();
+    while (renderer) {
+        if (RenderStyle* style = renderer->style()) {
+            if (style->textAutosizingMultiplier() != 1)
+                applyMultiplier(renderer, 1, LayoutNeeded);
+        }
+        renderer = renderer->nextInPreOrder();
+    }
+    m_previouslyAutosized = false;
+}
+
+void FastTextAutosizer::setAllTextNeedsLayout()
+{
+    RenderObject* renderer = m_document->renderer();
+    while (renderer) {
+        if (renderer->isText())
+            renderer->setNeedsLayout();
+        renderer = renderer->nextInPreOrder();
+    }
 }
 
 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)
 {
@@ skipping 147 matching lines @@
             if (ancestors.count(block) == blocks.size())
                 return block;
         }
     }
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 float FastTextAutosizer::clusterMultiplier(Cluster* cluster)
 {
-    ASSERT(m_renderViewInfoPrepared);
     if (!cluster->m_multiplier) {
         if (cluster->m_root->isTable()
             || isIndependentDescendant(cluster->m_root)
             || isWiderOrNarrowerDescendant(cluster)) {
 
             if (cluster->m_supercluster) {
                 cluster->m_multiplier = superclusterMultiplier(cluster);
             } else if (clusterHasEnoughTextToAutosize(cluster)) {
                 cluster->m_multiplier = multiplierFromBlock(clusterWidthProvider(cluster->m_root));
                 // Do not inflate table descendants above the table's multiplier. See inflateTable(...) for details.
@@ skipping 148 matching lines @@
             if (leaf)
                 return leaf;
         }
         child = (firstOrLast == First) ? child->nextSibling() : child->previousSibling();
     }
     --depth;
 
     return 0;
 }
 
-void FastTextAutosizer::applyMultiplier(RenderObject* renderer, float multiplier)
+void FastTextAutosizer::applyMultiplier(RenderObject* renderer, float multiplier, RelayoutBehavior relayoutBehavior)
 {
     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());
+
+    switch (relayoutBehavior) {
+    case AlreadyInLayout:
+        renderer->setStyleInternal(style.release());
+        if (renderer->isRenderBlock())
+            toRenderBlock(renderer)->invalidateLineHeight();
+        break;
+
+    case LayoutNeeded:
+        renderer->setStyle(style.release());
+        break;
+    }
+
+    if (multiplier != 1)
+        m_previouslyAutosized = true;
 }
 
 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));
@@ skipping 90 matching lines @@
     return *m_blocksForFingerprint.get(fingerprint);
 }
 
 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)
+    if (m_textAutosizer->enabled() && m_textAutosizer->m_pageNeedsAutosizing)
         m_textAutosizer->beginLayout(m_block);
     else
         m_textAutosizer = 0;
 }
 
 FastTextAutosizer::LayoutScope::~LayoutScope()
 {
     if (m_textAutosizer)
         m_textAutosizer->endLayout(m_block);
 }
 
 } // namespace WebCore