Correct visual rects for scroll corner/resizer and non-frame composited scroll bars.

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 46 matching lines @@
 #include "core/plugins/PluginView.h"
 #include "platform/LengthFunctions.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/geometry/TransformState.h"
 #include "platform/graphics/BitmapImage.h"
 #include "platform/graphics/CompositorMutableProperties.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/paint/ClipDisplayItem.h"
 #include "platform/graphics/paint/CullRect.h"
+#include "platform/graphics/paint/DrawingRecorder.h"
 #include "platform/graphics/paint/PaintController.h"
+#include "platform/graphics/paint/SkPictureBuilder.h"
 #include "platform/graphics/paint/TransformDisplayItem.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 static IntRect clipBox(LayoutBox* layoutObject);
 
@@ skipping 2224 matching lines @@
     return previousInterestRect;
 }
 
 LayoutSize CompositedLayerMapping::subpixelAccumulation() const
 {
     return m_owningLayer.subpixelAccumulation();
 }
 
 bool CompositedLayerMapping::needsRepaint(const GraphicsLayer& graphicsLayer) const
 {
-    // TODO(wkorman): Delegate needsRepaint() for scrollbar-affiliated layers.
-    return m_owningLayer.needsRepaint();
+    return isScrollableAreaLayer(&graphicsLayer) ? true : m_owningLayer.needsRepaint();

[wkorman, 2016/04/05 19:03:04]

Since last review:

- updated this line. Is always-true reasonable? Tests pass and not clear to me
what other PaintLayer we might delegate to otherwise.
- removed not-appropriate change to PaintLayerScrollableArea.cpp where we would
end up calling box.enclosingLayer()->setNeedsRepaint() which was overkill

 }
 
-void CompositedLayerMapping::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& context, GraphicsLayerPaintingPhase graphicsLayerPaintingPhase, const IntRect& interestRect) const
+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(interestRect), graphicsLayer));
@@ skipping 27 matching lines @@
         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, *graphicsLayer, paintLayerFlags, context, interestRect);
     } else if (graphicsLayer == m_squashingLayer.get()) {
         for (size_t i = 0; i < m_squashedLayers.size(); ++i)
             doPaintTask(m_squashedLayers[i], *graphicsLayer, paintLayerFlags, context, interestRect);
-    } else if (graphicsLayer == layerForHorizontalScrollbar()) {
-        paintScrollbar(m_owningLayer.getScrollableArea()->horizontalScrollbar(), context, interestRect);
-    } else if (graphicsLayer == layerForVerticalScrollbar()) {
-        paintScrollbar(m_owningLayer.getScrollableArea()->verticalScrollbar(), context, interestRect);
-    } else if (graphicsLayer == layerForScrollCorner()) {
-        IntPoint scrollCornerAndResizerLocation = m_owningLayer.getScrollableArea()->scrollCornerAndResizerRect().location();
-        CullRect cullRect(enclosingIntRect(interestRect));
-        ScrollableAreaPainter(*m_owningLayer.getScrollableArea()).paintScrollCorner(context, -scrollCornerAndResizerLocation, cullRect);
-        ScrollableAreaPainter(*m_owningLayer.getScrollableArea()).paintResizer(context, -scrollCornerAndResizerLocation, cullRect);
+    } else if (isScrollableAreaLayer(graphicsLayer)) {
+        paintScrollableArea(graphicsLayer, context, interestRect);
     }
     InspectorInstrumentation::didPaint(m_owningLayer.layoutObject(), graphicsLayer, context, LayoutRect(interestRect));
 #if ENABLE(ASSERT)
     if (Page* page = layoutObject()->frame()->page())
         page->setIsPainting(false);
 #endif
 }
 
+void CompositedLayerMapping::paintScrollableArea(const GraphicsLayer* graphicsLayer,
+    GraphicsContext& context, const IntRect& interestRect) const
+{
+    // Note the composited scrollable area painted here is never associated with a frame. For
+    // painting frame ScrollableAreas, see PaintLayerCompositor::paintContents.
+
+    if (DrawingRecorder::useCachedDrawingIfPossible(context, *graphicsLayer, DisplayItem::ScrollbarCompositedScrollbar))
+        return;
+
+    FloatRect layerBounds(FloatPoint(), graphicsLayer->size());
+    SkPictureBuilder pictureBuilder(layerBounds, nullptr, &context);
+    PaintLayerScrollableArea* scrollableArea = m_owningLayer.getScrollableArea();
+    if (graphicsLayer == layerForHorizontalScrollbar()) {
+        paintScrollbar(scrollableArea->horizontalScrollbar(), pictureBuilder.context(), interestRect);
+    } else if (graphicsLayer == layerForVerticalScrollbar()) {
+        paintScrollbar(scrollableArea->verticalScrollbar(), pictureBuilder.context(), interestRect);
+    } else if (graphicsLayer == layerForScrollCorner()) {
+        // Note that scroll corners always paint into local space, whereas scrollbars paint in the space of their containing frame.
+        IntPoint scrollCornerAndResizerLocation = scrollableArea->scrollCornerAndResizerRect().location();
+        CullRect cullRect(enclosingIntRect(interestRect));
+        ScrollableAreaPainter(*scrollableArea).paintScrollCorner(pictureBuilder.context(), -scrollCornerAndResizerLocation, cullRect);
+        ScrollableAreaPainter(*scrollableArea).paintResizer(pictureBuilder.context(), -scrollCornerAndResizerLocation, cullRect);
+    }
+    // Replay the painted scrollbar content with the GraphicsLayer backing as the DisplayItemClient
+    // in order for the resulting DrawingDisplayItem to produce the correct visualRect (i.e., the
+    // bounds of the involved GraphicsLayer).
+    DrawingRecorder drawingRecorder(context, *graphicsLayer, DisplayItem::ScrollbarCompositedScrollbar, layerBounds);
+    pictureBuilder.endRecording()->playback(context.canvas());
+}
+
+bool CompositedLayerMapping::isScrollableAreaLayer(const GraphicsLayer* graphicsLayer) const
+{
+    return graphicsLayer == layerForHorizontalScrollbar()
+        || graphicsLayer == layerForVerticalScrollbar()
+        || graphicsLayer == layerForScrollCorner();
+}
+
 bool CompositedLayerMapping::isTrackingPaintInvalidations() const
 {
     GraphicsLayerClient* client = compositor();
     return client ? client->isTrackingPaintInvalidations() : false;
 }
 
 #if ENABLE(ASSERT)
 void CompositedLayerMapping::verifyNotPainting()
 {
     ASSERT(!layoutObject()->frame()->page() || !layoutObject()->frame()->page()->isPainting());
@@ skipping 153 matching lines @@
     } else if (graphicsLayer == m_scrollingContentsLayer.get()) {
         name = "Scrolling Contents Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink