Adds DevTools commands for forced viewport override.

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

Index: third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp
diff --git a/third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp b/third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp
index 967e1b6b84d2aac716cdb7108eaeb273df829ec8..fd69d671d12e2cb1fbed2c9d03a5d35304743b4e 100644
--- a/third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp
+++ b/third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp
@@ -2285,6 +2285,8 @@ static void paintScrollbar(const Scrollbar* scrollbar, GraphicsContext& context,
     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
@@ -2314,21 +2316,22 @@ IntRect CompositedLayerMapping::recomputeInterestRect(const GraphicsLayer* graph
     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
@@ -2383,10 +2386,7 @@ IntRect CompositedLayerMapping::computeInterestRect(const GraphicsLayer* graphic
     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);