[FastTextAutosizer] Fix the inline overlap issue.

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 784 matching lines @@
     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());
+
+    // Notify inline renderers that their width may have changed.
+    if (renderer->parent() && renderer->parent()->isRenderInline())
+        renderer->setPreferredLogicalWidthsDirty(MarkOnlyThis);

[skobes, 2014/03/31 17:19:58]

Do you know why this works?  I would have guessed MarkContainingBlockChain would
be needed here.

[pdr., 2014/04/01 06:06:43]

A good question. In looking into this I found our table layout code is very
broken. Lets look into that tomorrow (crbug.com/358510).

In standard block layout where the block contains inline children, FTA::inflate
gets called after the block's width is computed but before laying out the
children.
In normal layout the FTA flow looks like:
1) At the top of RenderBlock:Layout we do the inflation
2) During inflation we invalidate any pref widths of children
3) Later in RenderBlock::Layout we query the widths of all text nodes
(layoutInlineChildren)
4) Querying the widths with dirty pref widths will recompute them.

Because all children are walked, we can get away with MarkOnlyThis.

You may be wondering... how did my test exercise stale preferred logical widths?
It did, but only by accident. The two-pass layout caused by scrollbars caused
the pref widths to get invalidated. I've hidden the scrollbars so this test now
passes before and after my change, but I think this test is still useful to keep
around.

I've added a new test, table-inline-width, which does properly exercise the new
inline width code. It's not clear how inflateTable should work here so I've
moved the setPreferredLogicalWidthsDirty call into FTA::inflate until the table
code is more sane.

 }
 
 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 111 matching lines @@
         m_textAutosizer = 0;
 }
 
 FastTextAutosizer::LayoutScope::~LayoutScope()
 {
     if (m_textAutosizer)
         m_textAutosizer->endLayout(m_block);
 }
 
 } // namespace WebCore