Clean up handling of autosizing state 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_updatePageInfoDeferred(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() || m_updatePageInfoDeferred)
+        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, true /* relayout */);
+        }
+        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, bool relayout)
 {
     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());
 
-    if (renderer->isRenderBlock())
-        toRenderBlock(renderer)->invalidateLineHeight();
+    if (relayout) {
+        renderer->setStyle(style.release());

[pdr., 2014/03/25 04:23:41]

This can cause us to go back through quite a bit of extra code, including
styleDidChange and FTA::record. Is that intended?

I expected this to just setNeedsLayout or adjust the layout triggers in
RenderStyle.

[skobes, 2014/03/25 18:25:26]

There's no way for setStyleInternal to trigger a layout, it's literally just
setting a RefPtr.

We could setNeedsLayout manually but it seems safer to use setStyle when we are
touching style outside of layout.  That way RenderObject is responsible for the
logic to mark the block as needing layout.  For example, setStyle will mark the
pref widths dirty.  FTA has some issues with pref widths, but at least we can
make sure they are correct when we resetMultipliers. :)

Also note that the old autosizer does all multiplier changes with setStyle.

+    } else {
+        renderer->setStyleInternal(style.release());
+        if (renderer->isRenderBlock())
+            toRenderBlock(renderer)->invalidateLineHeight();

[pdr., 2014/03/25 04:23:41]

Is this lineheight change supposed to be part of this patch?

[skobes, 2014/03/25 18:25:26]

This patch is branched from the lineheight change.

+    }
+
+    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