Implement interest rects for synchronized paint.

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 2092 matching lines @@
     FontCachePurgePreventer fontCachePurgePreventer;
 
     IntSize offset = paintInfo.offsetFromLayoutObject;
     AffineTransform translation;
     translation.translate(-offset.width(), -offset.height());
     TransformRecorder transformRecorder(*context, *this, translation);
 
     // The dirtyRect is in the coords of the painting root.
     IntRect dirtyRect(clip);
     dirtyRect.move(offset);
-
     if (!(paintLayerFlags & PaintLayerPaintingOverflowContents)) {
         LayoutRect bounds = paintInfo.compositedBounds;
         bounds.move(paintInfo.paintLayer->subpixelAccumulation());
         dirtyRect.intersect(pixelSnappedIntRect(bounds));
     } else {
         dirtyRect.move(roundedIntSize(paintInfo.paintLayer->subpixelAccumulation()));
     }
 
 #if ENABLE(ASSERT)
     paintInfo.paintLayer->layoutObject()->assertSubtreeIsLaidOut();
@@ skipping 35 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, transformedClip);
 }
 
-// Up-call from compositing layer drawing callback.
-void CompositedLayerMapping::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& context, GraphicsLayerPaintingPhase graphicsLayerPaintingPhase, const IntRect& clip) const
+static const int kPixelDistanceToRecord = 4000;
+
+IntRect CompositedLayerMapping::computeInterestRect(const GraphicsLayer* graphicsLayer, LayoutObject* owningLayoutObject)
+{
+    FloatRect graphicsLayerBounds(FloatPoint(), graphicsLayer->size());
+
+    // Start with the bounds of the graphics layer in the space of the owning LayoutObject.
+    FloatRect graphicsLayerBoundsInObjectSpace(graphicsLayerBounds);
+    graphicsLayerBoundsInObjectSpace.move(graphicsLayer->offsetFromLayoutObject());
+
+    // Now map the bounds to its visible content rect in screen space, including applying clips along the way.
+    LayoutRect visibleContentRect(graphicsLayerBoundsInObjectSpace);
+    LayoutView* rootView = owningLayoutObject->view();
+    while (rootView->frame()->ownerLayoutObject())
+        rootView = rootView->frame()->ownerLayoutObject()->view();
+    owningLayoutObject->mapRectToPaintInvalidationBacking(rootView, visibleContentRect, 0);
+    visibleContentRect.intersect(LayoutRect(rootView->frameView()->visibleContentRect()));
+
+    // Map the visible content rect from screen 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 = owningLayoutObject->absoluteToLocalQuad(FloatRect(visibleContentRect), UseTransforms).enclosingBoundingBox();
+        localInterestRect.move(-graphicsLayer->offsetFromLayoutObject());
+    }
+    // Expand by interest rect padding amount.
+    localInterestRect.expand(IntRectOutsets(kPixelDistanceToRecord, kPixelDistanceToRecord, kPixelDistanceToRecord, kPixelDistanceToRecord));
+    localInterestRect.intersect(enclosingIntRect(graphicsLayerBounds));
+    return localInterestRect;
+}
+
+void CompositedLayerMapping::paintContentsIfNeeded(const GraphicsLayer* graphicsLayer, GraphicsContext& context, GraphicsLayerPaintingPhase graphicsLayerPaintingPhase) const
+{
+    // TODO(chrishtr): paint if needsDisplay is true *or* the interest rect has changed sufficiently.
+    if (!graphicsLayer->needsDisplay())
+        return;
+
+    IntRect interestRect;
+    if (graphicsLayer == m_graphicsLayer || graphicsLayer == m_squashingLayer)
+        interestRect = computeInterestRect(graphicsLayer, m_owningLayer.layoutObject());
+    else
+        interestRect = enclosingIntRect(FloatRect(FloatPoint(), graphicsLayer->size()));
+
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled());
+    paintContents(graphicsLayer, context, graphicsLayerPaintingPhase, interestRect);
+}
+
+void CompositedLayerMapping::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& context, GraphicsLayerPaintingPhase graphicsLayerPaintingPhase, const IntRect& interestRect) const
 {
     // https://code.google.com/p/chromium/issues/detail?id=343772
     DisableCompositingQueryAsserts disabler;
 #if ENABLE(ASSERT)
     // FIXME: once the state machine is ready, this can be removed and we can refer to that instead.
     if (Page* page = layoutObject()->frame()->page())
         page->setIsPainting(true);
 #endif
-    TRACE_EVENT1("devtools.timeline", "Paint", "data", InspectorPaintEvent::data(m_owningLayer.layoutObject(), LayoutRect(clip), graphicsLayer));
+
+    TRACE_EVENT1("devtools.timeline", "Paint", "data", InspectorPaintEvent::data(m_owningLayer.layoutObject(), LayoutRect(interestRect), graphicsLayer));
 
     PaintLayerFlags paintLayerFlags = 0;
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintBackground)
         paintLayerFlags |= PaintLayerPaintingCompositingBackgroundPhase;
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintForeground)
         paintLayerFlags |= PaintLayerPaintingCompositingForegroundPhase;
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintMask)
         paintLayerFlags |= PaintLayerPaintingCompositingMaskPhase;
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintChildClippingMask)
         paintLayerFlags |= PaintLayerPaintingChildClippingMaskPhase;
@@ skipping 14 matching lines @@
         || graphicsLayer == m_childClippingMaskLayer.get()
         || graphicsLayer == m_scrollingContentsLayer.get()
         || graphicsLayer == m_scrollingBlockSelectionLayer.get()) {
 
         GraphicsLayerPaintInfo paintInfo;
         paintInfo.paintLayer = &m_owningLayer;
         paintInfo.compositedBounds = compositedBounds();
         paintInfo.offsetFromLayoutObject = graphicsLayer->offsetFromLayoutObject();
 
         // We have to use the same root as for hit testing, because both methods can compute and cache clipRects.
-        doPaintTask(paintInfo, paintLayerFlags, &context, clip);
+        doPaintTask(paintInfo, paintLayerFlags, &context, interestRect);
     } else if (graphicsLayer == m_squashingLayer.get()) {
         for (size_t i = 0; i < m_squashedLayers.size(); ++i)
-            doPaintTask(m_squashedLayers[i], paintLayerFlags, &context, clip);
+            doPaintTask(m_squashedLayers[i], paintLayerFlags, &context, interestRect);
     } else if (graphicsLayer == layerForHorizontalScrollbar()) {
-        paintScrollbar(m_owningLayer.scrollableArea()->horizontalScrollbar(), context, clip);
+        paintScrollbar(m_owningLayer.scrollableArea()->horizontalScrollbar(), context, interestRect);
     } else if (graphicsLayer == layerForVerticalScrollbar()) {
-        paintScrollbar(m_owningLayer.scrollableArea()->verticalScrollbar(), context, clip);
+        paintScrollbar(m_owningLayer.scrollableArea()->verticalScrollbar(), context, interestRect);
     } else if (graphicsLayer == layerForScrollCorner()) {
         IntPoint scrollCornerAndResizerLocation = m_owningLayer.scrollableArea()->scrollCornerAndResizerRect().location();
-        ScrollableAreaPainter(*m_owningLayer.scrollableArea()).paintScrollCorner(&context, -scrollCornerAndResizerLocation, clip);
-        ScrollableAreaPainter(*m_owningLayer.scrollableArea()).paintResizer(&context, -scrollCornerAndResizerLocation, clip);
+        ScrollableAreaPainter(*m_owningLayer.scrollableArea()).paintScrollCorner(&context, -scrollCornerAndResizerLocation, interestRect);
+        ScrollableAreaPainter(*m_owningLayer.scrollableArea()).paintResizer(&context, -scrollCornerAndResizerLocation, interestRect);
     }
-    InspectorInstrumentation::didPaint(m_owningLayer.layoutObject(), graphicsLayer, &context, LayoutRect(clip));
+    InspectorInstrumentation::didPaint(m_owningLayer.layoutObject(), graphicsLayer, &context, LayoutRect(interestRect));
 #if ENABLE(ASSERT)
     if (Page* page = layoutObject()->frame()->page())
         page->setIsPainting(false);
 #endif
 }
 
 bool CompositedLayerMapping::isTrackingPaintInvalidations() const
 {
     GraphicsLayerClient* client = compositor();
     return client ? client->isTrackingPaintInvalidations() : false;
@@ skipping 152 matching lines @@
     } else if (graphicsLayer == m_scrollingBlockSelectionLayer.get()) {
         name = "Scrolling Block Selection Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink