Avoid layout/full-repaint on view height change if possible

Source/core/rendering/RenderView.cpp

Index: Source/core/rendering/RenderView.cpp
diff --git a/Source/core/rendering/RenderView.cpp b/Source/core/rendering/RenderView.cpp
index 05955691af573fc99f2d0102d0b46c6a62b72e2f..8ffd652405448c4ee3b09a4286fdd5016152e979 100644
--- a/Source/core/rendering/RenderView.cpp
+++ b/Source/core/rendering/RenderView.cpp
@@ -1235,6 +1235,56 @@ LayoutUnit RenderView::viewportPercentageMax(float percentage) const
         * percentage / 100.f;
 }
 
+void RenderView::viewResized()
+{
+    if (!RuntimeEnabledFeatures::optimizedLayoutOnViewHeightChangeEnabled() || width() != viewWidth() || needsLayoutOnHeightChange()) {

[ojan, 2013/12/18 00:48:20]

I don't think we need to add a RuntimeEnabledFeatures flag for this. All the
functionality is in this patch, no? Usually flags are for cases where we expect
the feature to take many patches or where we are especially worried about
needing to turn this feature off in release. Neither of those seems to apply to
this case, right?

[Xianzhu, 2013/12/18 20:22:45]

Yes. I added the flag because I was afraid of the incompleteness of
RenderView::needsLayoutOnHeightChange(). Will remove the flag.

+        setNeedsLayout();
+    } else {
+        setHeight(viewHeight());
+        if (m_overflow)
+            m_overflow->setVisualOverflow(borderBoxRect());
+        layer()->updateLayerPositionsAfterLayout(layer(), RenderLayer::defaultFlags);
+    }
+}
+
+bool RenderView::needsLayoutOnHeightChange() const

[ojan, 2013/12/18 00:48:20]

This misses a number of cases. For example, if the documentElement is column
flexbox with flex:1 on the body of it's flex items. Similarly, if the
documentElement or body are position: absolute with top and bottom set.

Also, I think we want a function like this that we can use in other places in
the rendering code. So, I think it should be a method on RenderBox. You still
need the RenderView method for the styleResolver check, but then it can call the
RenderBox method for the rest.

[Xianzhu, 2013/12/18 20:22:45]

Thanks for the case. Will add them.
Thought of this when filing crbug.com/310875 (about layout of blocks on logical
height change), but found that path is more complex than the RenderView case
because of the style of the RenderBox itself. I've listed tens of the CSS
properties that may disable the optimized layout (e.g. margin, padding, clip,
shape, mask, borderRadius, ...) but I'm not sure they are complete.

Now I'm thinking of the following solution:
RenderBox:
  virtual bool selfNeedsLayoutOnHeightChange() const { return true; }  // will
implement in the future.
  virtual bool childNeedsLayoutOnHeightChange() const { common RenderBox
features of RenderView::needsLayoutOnHeightChange() in this change }

RenderView:
  virtual bool selfNeedsLayoutOnHeightChange() const OVERRIDE {
     return isPaginated || printing || ...;
  }
  virtual bool childNeedsLayoutOnHeightChange() const OVERRIDE {
     if (RenderBox::childNeedsLayoutOnHeightChange())
        return true;
     Other RenderView-specific conditions;
  }

wdyt?

+{
+    if (!style()->isHorizontalWritingMode() || hasPercentHeightDescendants() || document().paginated())
+        return true;
+
+    if (!document().styleResolver() || document().styleResolver()->affectedByViewportChange())

[ojan, 2013/12/18 00:48:20]

It's not uncommon that we destroy the styleResolver. I think this should just be
document().ensureStyleResolver()->affectedByViewportChange()

+        return true;
+
+    // Needs layout if there is no body element (e.g. there is frameset).
+    Element* body = document().body();
+    if (!body || !body->renderer() || !body->renderer()->isBody())

[ojan, 2013/12/18 00:48:20]

I don't think you need this case. We'll do a layout when we add the body element
to the render tree anyways.

[Xianzhu, 2013/12/18 20:22:45]

My intention was to exclude the frameset case which may need layout on height
change.

+        return true;
+
+    Element* documentElement = document().documentElement();
+    if (RenderObject* rootRenderer = documentElement ? documentElement->renderer() : 0) {
+        // Background image may be stretched related to the viewport size.
+        if (rootRenderer->rendererForRootBackground()->style()->hasBackgroundImage())
+            return true;
+    } else {
+        return true;
+    }
+
+    TrackedRendererListHashSet* positionedDescendants = positionedObjects();
+    if (positionedDescendants) {
+        TrackedRendererListHashSet::iterator end = positionedDescendants->end();
+        for (TrackedRendererListHashSet::iterator it = positionedDescendants->begin(); it != end; ++it) {
+            RenderStyle* style = (*it)->style();
+            // Fixed position element may change compositing state when viewport height changes.
+            if (style->position() == FixedPosition)
+                return true;
+            if (style->top().isPercent() || style->height().isPercent() || style->maxHeight().isPercent() || !style->bottom().isAuto())
+                return true;
+        }
+    }
+
+    return false;
+}
+
 FragmentationDisabler::FragmentationDisabler(RenderObject* root)
 {
     RenderView* renderView = root->view();