Plumb preferred raster scale for background images from Blink to cc layers.

third_party/WebKit/Source/core/paint/BoxPainter.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/paint/BoxPainter.h"
 
 #include "core/HTMLNames.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/layout/ImageQualityController.h"
@@ skipping 90 matching lines @@
 
 namespace {
 
 bool bleedAvoidanceIsClipping(BackgroundBleedAvoidance bleedAvoidance) {
   return bleedAvoidance == BackgroundBleedClipOnly ||
          bleedAvoidance == BackgroundBleedClipLayer;
 }
 
 }  // anonymous namespace
 
+// Sets a preferred composited raster scale for box with a background image,
+// if possible.
+// |srcRect| is the rect, in the space of the source image, to raster.
+// |destRect| is the rect, in the local layout space of |obj|, to raster.
+inline void updatePreferredRasterScaleFromImage(
+    const FloatRect srcRect,
+    const FloatRect& destRect,
+    const LayoutBoxModelObject& obj) {
+  if (!RuntimeEnabledFeatures::preferredImageRasterScaleEnabled())
+    return;
+  // Not yet implemented for SPv2.
+  if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
+    return;
+  if (destRect.width() == 0.0f || destRect.height() == 0.0f)
+    return;
+  float widthScale = srcRect.width() / destRect.width();
+  float heightScale = srcRect.height() / destRect.height();
+  float rasterScale = std::min(std::min(widthScale, heightScale), 10.0f);
+  if (PaintLayer* paintLayer = obj.layer()) {
+    if (paintLayer->compositingState() != PaintsIntoOwnBacking)
+      return;
+    paintLayer->graphicsLayerBacking()->setPreferredRasterScale(rasterScale);
+  }
+}
+
+inline void clearPreferredRasterScale(const LayoutBox& obj) {
+  if (PaintLayer* paintLayer = obj.layer()) {
+    if (paintLayer->compositingState() != PaintsIntoOwnBacking)
+      return;
+    paintLayer->graphicsLayerBacking()->clearPreferredRasterScale();
+  }
+}
+
 void BoxPainter::paintBoxDecorationBackgroundWithRect(
     const PaintInfo& paintInfo,
     const LayoutPoint& paintOffset,
     const LayoutRect& paintRect) {
   bool paintingOverflowContents =
       isPaintingBackgroundOfPaintContainerIntoScrollingContentsLayer(
           &m_layoutBox, paintInfo);
   const ComputedStyle& style = m_layoutBox.styleRef();
 
   Optional<DisplayItemCacheSkipper> cacheSkipper;
@@ skipping 16 matching lines @@
       paintingOverflowContents ? static_cast<const DisplayItemClient&>(
                                      *m_layoutBox.layer()
                                           ->compositedLayerMapping()
                                           ->scrollingContentsLayer())
                                : m_layoutBox;
   if (DrawingRecorder::useCachedDrawingIfPossible(
           paintInfo.context, displayItemClient,
           DisplayItem::kBoxDecorationBackground))
     return;
 
+  clearPreferredRasterScale(m_layoutBox);
+
   DrawingRecorder recorder(
       paintInfo.context, displayItemClient,
       DisplayItem::kBoxDecorationBackground,
       FloatRect(boundsForDrawingRecorder(paintInfo, paintOffset)));
   BoxDecorationData boxDecorationData(m_layoutBox);
   GraphicsContextStateSaver stateSaver(paintInfo.context, false);
 
   if (!paintingOverflowContents) {
     // FIXME: Should eventually give the theme control over whether the box
     // shadow should paint, since controls could have custom shadows of their
@@ skipping 457 matching lines @@
       Image::computeSubsetForTile(imageTile, border.rect(), intrinsicTileSize);
 
   // The shadow may have been applied with the color fill.
   const ShadowContext shadowContext(
       context, obj, info.shouldPaintShadow && !info.shouldPaintColor);
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "PaintImage",
                "data", InspectorPaintImageEvent::data(obj, *info.image));
   context.drawImageRRect(imageContext.image(), border, srcRect,
                          imageContext.compositeOp());
 
+  updatePreferredRasterScaleFromImage(srcRect, border.rect(), obj);
+
   return true;
 }
 
 }  // anonymous namespace
 
 void BoxPainter::paintFillLayer(const LayoutBoxModelObject& obj,
                                 const PaintInfo& paintInfo,
                                 const Color& color,
                                 const FillLayer& bgLayer,
                                 const LayoutRect& rect,
@@ skipping 437 matching lines @@
 bool BoxPainter::shouldForceWhiteBackgroundForPrintEconomy(
     const ComputedStyle& style,
     const Document& document) {
   return document.printing() &&
          style.getPrintColorAdjust() == PrintColorAdjustEconomy &&
          (!document.settings() ||
           !document.settings()->shouldPrintBackgrounds());
 }
 
 }  // namespace blink