Adds DevTools commands for forced viewport override.

third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp

 /*
  * Copyright (C) 2009, 2010, 2011 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 2267 matching lines @@
     if (!scrollbar)
         return;
 
     const IntRect& scrollbarRect = scrollbar->frameRect();
     TransformRecorder transformRecorder(context, *scrollbar, AffineTransform::translation(-scrollbarRect.x(), -scrollbarRect.y()));
     IntRect transformedClip = clip;
     transformedClip.moveBy(scrollbarRect.location());
     scrollbar->paint(context, CullRect(transformedClip));
 }
 
+// TODO(eseckler): Make recording distance configurable, e.g. for use in
+// headless, where we would like to record an exact area (distance = 0).
 static const int kPixelDistanceToRecord = 4000;
 
 IntRect CompositedLayerMapping::recomputeInterestRect(const GraphicsLayer* graphicsLayer) const
 {
     FloatRect graphicsLayerBounds(FloatPoint(), graphicsLayer->size());
 
     IntSize offsetFromAnchorLayoutObject;
     const LayoutBoxModelObject* anchorLayoutObject;
     if (graphicsLayer == m_squashingLayer.get()) {
         // TODO(chrishtr): this is a speculative fix for crbug.com/561306. However, it should never be the case that
         // m_squashingLayer exists yet m_squashedLayers.size() == 0. There must be a bug elsewhere.
         if (m_squashedLayers.size() == 0)
             return IntRect();
         // All squashed layers have the same clip and transform space, so we can use the first squashed layer's
         // layoutObject to map the squashing layer's bounds into viewport space, with offsetFromAnchorLayoutObject
         // to translate squashing layer's bounds into the first squashed layer's space.
         anchorLayoutObject = m_squashedLayers[0].paintLayer->layoutObject();
         offsetFromAnchorLayoutObject = m_squashedLayers[0].offsetFromLayoutObject;
     } else {
         ASSERT(graphicsLayer == m_graphicsLayer.get() || graphicsLayer == m_scrollingContentsLayer.get());
         anchorLayoutObject = m_owningLayer.layoutObject();
         offsetFromAnchorLayoutObject = graphicsLayer->offsetFromLayoutObject();
         adjustForCompositedScrolling(graphicsLayer, offsetFromAnchorLayoutObject);
     }
 
     // Start with the bounds of the graphics layer in the space of the anchor LayoutObject.
     FloatRect graphicsLayerBoundsInObjectSpace(graphicsLayerBounds);
     graphicsLayerBoundsInObjectSpace.move(offsetFromAnchorLayoutObject);
 
-    // Now map the bounds to its visible content rect in screen space, including applying clips along the way.
-    LayoutRect visibleContentRect(graphicsLayerBoundsInObjectSpace);
+    // Now map the bounds to its visible content rect in root view space, including applying clips along the way.
+    LayoutRect graphicsLayerBoundsInRootViewSpace(graphicsLayerBoundsInObjectSpace);
     LayoutView* rootView = anchorLayoutObject->view();
     while (rootView->frame()->ownerLayoutObject())
         rootView = rootView->frame()->ownerLayoutObject()->view();
-    anchorLayoutObject->mapToVisualRectInAncestorSpace(rootView, visibleContentRect);
-    visibleContentRect.intersect(LayoutRect(rootView->frameView()->visibleContentRect()));
+    anchorLayoutObject->mapToVisualRectInAncestorSpace(rootView, graphicsLayerBoundsInRootViewSpace);
+    FloatRect visibleContentRect(graphicsLayerBoundsInRootViewSpace);
+    rootView->frameView()->clipPaintRect(&visibleContentRect);
 
     IntRect enclosingGraphicsLayerBounds(enclosingIntRect(graphicsLayerBounds));
 
-    // Map the visible content rect from screen space to local graphics layer space.
+    // Map the visible content rect from root view space to local graphics layer space.
     IntRect localInterestRect;
     // If the visible content rect is empty, then it makes no sense to map it back since there is nothing to map.
     if (!visibleContentRect.isEmpty()) {
-        localInterestRect = anchorLayoutObject->absoluteToLocalQuad(FloatRect(visibleContentRect), UseTransforms | TraverseDocumentBoundaries).enclosingBoundingBox();
+        localInterestRect = anchorLayoutObject->absoluteToLocalQuad(visibleContentRect, UseTransforms | TraverseDocumentBoundaries).enclosingBoundingBox();
         localInterestRect.move(-offsetFromAnchorLayoutObject);
         // TODO(chrishtr): the code below is a heuristic, instead we should detect and return whether the mapping failed.
         // In some cases, absoluteToLocalQuad can fail to map back to the local space, due to passing through
         // non-invertible transforms or floating-point accuracy issues. Examples include rotation near 90 degrees
         // or perspective. In such cases, fall back to painting the first kPixelDistanceToRecord pixels in each direction.
         localInterestRect.intersect(enclosingGraphicsLayerBounds);
     }
     // Expand by interest rect padding amount.
     localInterestRect.inflate(kPixelDistanceToRecord);
     localInterestRect.intersect(enclosingGraphicsLayerBounds);
@@ skipping 31 matching lines @@
     if (newInterestRect.maxY() == layerSize.height() && previousInterestRect.maxY() != layerSize.height())
         return true;
 
     return false;
 }
 
 IntRect CompositedLayerMapping::computeInterestRect(const GraphicsLayer* graphicsLayer, const IntRect& previousInterestRect) const
 {
     // Use the previous interest rect if it covers the whole layer.
     IntRect wholeLayerRect = IntRect(IntPoint(), expandedIntSize(graphicsLayer->size()));
     if (!needsRepaint(*graphicsLayer) && previousInterestRect == wholeLayerRect)

[dgozman, 2016/08/29 20:45:36]

I'm curios what happens if you forceViewport to cover the whole rect (e.g.
trying to make a screenshot of everything), then resetViewport and stumble upon
this early return.

[Eric Seckler, 2016/09/12 13:58:00]

I think you're right, the logic for replacing old interest rects doesn't yet
account for the rect shrinking - it's assuming that it "moves" via scrolling. I
don't think it's a problem in this early return (this only seems to happen when
no repaint is needed anyway), but more so in
interestRectChangedEnoughToRepaint(), which doesn't update the rect if it
shrinks. So if we use forceViewport to set it to e.g. the whole page, it'd stick
to the full layers forever.

Two thoughts on this: First, this shouldn't break functionality, so keeping it
as-is would be fine except for potential performance implications (particularly
for headless this is unlikely to become an issue). Second, is this also an issue
for zooming out and then back into a page? It seems to me that this would also
extend the interest rect on zoom-out and later not shrink it on zoom-in.

I'd be happy to file a bug against this and postpone it until later. One
possible work-around would be to always update the interest rect if the layer
already needs repainting. That is, change the if statement below to:

if (needsRepaint(*graphicsLayer) ||
interestRectChangedEnoughToRepaint(previousInterestRect, newInterestRect,
expandedIntSize(graphicsLayer->size())))
    return newInterestRect;

However, this breaks a test which tries to ensure that this exact thing doesn't
happen (CompositedLayerMappingTest,
InterestRectShouldNotChangeOnPaintInvalidation). I'm not familiar with the
rationale behind this. (To me, it'd make sense to use the new interest rect when
you need to paint the layer anyway.)

Chris, Xianzhu, can you shed some light on this?

[chrishtr, 2016/09/13 00:49:18]

https://codereview.chromium.org/1441973003 is what changed the code to the
current behavior. It notes inconsistent behavior would
occur otherwise, but I think that is not possibly any more because of cleanup on
the cc side that happened since then. I can't think
of a reason right now why we would need the current behavior when an
invalidation or repaint is needed. Xianzhu can you think of
one?

[Xianzhu, 2016/09/13 01:20:11]

The behavior is mainly for performance. See
https://bugs.chromium.org/p/chromium/issues/detail?id=563496#c25. When the page
is nearly idle (visual update is scheduled for some reason, but no real visual
changes), we avoid the cost of recomputeInterestRect() to save battery.

I think we can force recomputeInterestRect() when switching between
forceViewport and non-forceViewport mode.

         return previousInterestRect;
 
-    // Paint the whole layer if "mainFrameClipsContent" is false, meaning that WebPreferences::record_whole_document is true.
-    bool shouldPaintWholePage = !m_owningLayer.layoutObject()->document().settings()->mainFrameClipsContent();
-    if (shouldPaintWholePage
-        || (graphicsLayer != m_graphicsLayer.get() && graphicsLayer != m_squashingLayer.get() && graphicsLayer != m_scrollingContentsLayer.get()))
+    if (graphicsLayer != m_graphicsLayer.get() && graphicsLayer != m_squashingLayer.get() && graphicsLayer != m_scrollingContentsLayer.get())
         return wholeLayerRect;
 
     IntRect newInterestRect = recomputeInterestRect(graphicsLayer);
     if (interestRectChangedEnoughToRepaint(previousInterestRect, newInterestRect, expandedIntSize(graphicsLayer->size())))
         return newInterestRect;
     return previousInterestRect;
 }
 
 LayoutSize CompositedLayerMapping::subpixelAccumulation() const
 {
@@ skipping 294 matching lines @@
     } else if (graphicsLayer == m_scrollingContentsLayer.get()) {
         name = "Scrolling Contents Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink