Always paint background and shadow separately

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 174 matching lines @@
       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
     // own.
-    if (!m_layoutBox.boxShadowShouldBeAppliedToBackground(
-            boxDecorationData.bleedAvoidance)) {
-      paintBoxShadow(paintInfo, paintRect, style, Normal);
-    }
+    paintBoxShadow(paintInfo, paintRect, style, Normal);
 
     if (bleedAvoidanceIsClipping(boxDecorationData.bleedAvoidance)) {
       stateSaver.save();
       FloatRoundedRect border = style.getRoundedBorderFor(paintRect);
       paintInfo.context.clipRoundedRect(border);
 
       if (boxDecorationData.bleedAvoidance == BackgroundBleedClipLayer)
         paintInfo.context.beginLayer();
     }
   }
@@ skipping 85 matching lines @@
   return isNonAssociative;
 }
 
 void BoxPainter::paintFillLayers(const PaintInfo& paintInfo,
                                  const Color& c,
                                  const FillLayer& fillLayer,
                                  const LayoutRect& rect,
                                  BackgroundBleedAvoidance bleedAvoidance,
                                  SkBlendMode op,
                                  const LayoutObject* backgroundObject) {
-  // TODO(trchen): Box shadow optimization and background color are concepts
-  // that only apply to background layers. Ideally we should refactor those out
-  // of paintFillLayer.
   FillLayerOcclusionOutputList reversedPaintList;
-  bool shouldDrawBackgroundInSeparateBuffer = false;
-  if (!m_layoutBox.boxShadowShouldBeAppliedToBackground(bleedAvoidance)) {
-    shouldDrawBackgroundInSeparateBuffer =
-        calculateFillLayerOcclusionCulling(reversedPaintList, fillLayer);
-  } else {
-    // If we are responsible for painting box shadow, don't perform fill layer
-    // culling.
-    // TODO(trchen): In theory we only need to make sure the last layer has
-    // border box clipping and make it paint the box shadow. Investigate
-    // optimization opportunity later.
-    for (auto currentLayer = &fillLayer; currentLayer;
-         currentLayer = currentLayer->next()) {
-      reversedPaintList.append(currentLayer);
-      if (currentLayer->composite() != CompositeSourceOver ||
-          currentLayer->blendMode() != WebBlendModeNormal)
-        shouldDrawBackgroundInSeparateBuffer = true;
-    }
-  }
+  bool shouldDrawBackgroundInSeparateBuffer =
+      calculateFillLayerOcclusionCulling(reversedPaintList, fillLayer);
 
   // TODO(trchen): We can optimize out isolation group if we have a
   // non-transparent background color and the bottom layer encloses all other
   // layers.
 
   GraphicsContext& context = paintInfo.context;
 
   if (shouldDrawBackgroundInSeparateBuffer)
     context.beginLayer();
 
   for (auto it = reversedPaintList.rbegin(); it != reversedPaintList.rend();
        ++it)
     paintFillLayer(m_layoutBox, paintInfo, c, **it, rect, bleedAvoidance, 0,
                    LayoutSize(), op, backgroundObject);
 
   if (shouldDrawBackgroundInSeparateBuffer)
     context.endLayer();
 }
 
 namespace {
 
-// RAII shadow helper.
-class ShadowContext {
-  STACK_ALLOCATED();
-
- public:
-  ShadowContext(GraphicsContext& context,
-                const LayoutObject& obj,
-                bool applyShadow)
-      : m_saver(context, applyShadow) {
-    if (!applyShadow)
-      return;
-
-    const ShadowList* shadowList = obj.style()->boxShadow();
-    DCHECK(shadowList);
-    for (size_t i = shadowList->shadows().size(); i--;) {
-      const ShadowData& boxShadow = shadowList->shadows()[i];
-      if (boxShadow.style() != Normal)
-        continue;
-      FloatSize shadowOffset(boxShadow.x(), boxShadow.y());
-      context.setShadow(
-          shadowOffset, boxShadow.blur(),
-          boxShadow.color().resolve(obj.resolveColor(CSSPropertyColor)),
-          DrawLooperBuilder::ShadowRespectsTransforms,
-          DrawLooperBuilder::ShadowIgnoresAlpha);
-      break;
-    }
-  }
-
- private:
-  GraphicsContextStateSaver m_saver;
-};
-
 FloatRoundedRect getBackgroundRoundedRect(const LayoutObject& obj,
                                           const LayoutRect& borderRect,
                                           const InlineFlowBox* box,
                                           LayoutUnit inlineBoxWidth,
                                           LayoutUnit inlineBoxHeight,
                                           bool includeLogicalLeftEdge,
                                           bool includeLogicalRightEdge) {
   FloatRoundedRect border = obj.style()->getRoundedBorderFor(
       borderRect, includeLogicalLeftEdge, includeLogicalRightEdge);
   if (box && (box->nextLineBox() || box->prevLineBox())) {
@@ skipping 94 matching lines @@
         obj.style()->hasBorderRadius() && (includeLeftEdge || includeRightEdge);
     // BorderFillBox radius clipping is taken care of by
     // BackgroundBleedClip{Only,Layer}
     isRoundedFill = hasRoundedBorder &&
                     !(isBorderFill && bleedAvoidanceIsClipping(bleedAvoidance));
 
     shouldPaintImage = image && image->canRender();
     shouldPaintColor =
         isBottomLayer && color.alpha() &&
         (!shouldPaintImage || !layer.imageOccludesNextLayers(obj));
-    shouldPaintShadow =
-        shouldPaintColor &&
-        obj.boxShadowShouldBeAppliedToBackground(bleedAvoidance, box);
   }
 
   // FillLayerInfo is a temporary, stack-allocated container which cannot
   // outlive the StyleImage.  This would normally be a raw pointer, if not for
   // the Oilpan tooling complaints.
   Member<StyleImage> image;
   Color color;
 
   bool includeLeftEdge;
   bool includeRightEdge;
   bool isBottomLayer;
   bool isBorderFill;
   bool isClippedWithLocalScrolling;
   bool isRoundedFill;
 
   bool shouldPaintImage;
   bool shouldPaintColor;
-  bool shouldPaintShadow;
 };
 
 // RAII image paint helper.
 class ImagePaintContext {
   STACK_ALLOCATED();
 
  public:
   ImagePaintContext(const LayoutBoxModelObject& obj,
                     GraphicsContext& context,
                     const FillLayer& layer,
@@ skipping 97 matching lines @@
 
   Optional<RoundedInnerRectClipper> clipper;
   if (info.isRoundedFill && !border.isRenderable()) {
     // When the rrect is not renderable, we resort to clipping.
     // RoundedInnerRectClipper handles this case via discrete, corner-wise
     // clipping.
     clipper.emplace(obj, paintInfo, rect, border, ApplyToContext);
     border.setRadii(FloatRoundedRect::Radii());
   }
 
-  // Paint the color + shadow if needed.
-  if (info.shouldPaintColor) {
-    const ShadowContext shadowContext(context, obj, info.shouldPaintShadow);
+  // Paint the color if needed.
+  if (info.shouldPaintColor)
     context.fillRoundedRect(border, info.color);
-  }
 
-  // Paint the image + shadow if needed.
+  // Paint the image if needed.
   if (!info.shouldPaintImage || imageTile.isEmpty())
     return true;
 
   const ImagePaintContext imageContext(obj, context, layer, *info.image, op,
                                        backgroundObject, geometry->tileSize());
   if (!imageContext.image())
     return true;
 
   const FloatSize intrinsicTileSize =
       imageContext.image()->hasRelativeSize()
           ? imageTile.size()
           : FloatSize(imageContext.image()->size());
   const FloatRect srcRect =
       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());
 
   updatePreferredRasterBoundsFromImage(srcRect, border.rect(), obj);
 
   return true;
 }
 
@@ skipping 122 matching lines @@
     default:
       ASSERT_NOT_REACHED();
       break;
   }
 
   // Paint the color first underneath all images, culled if background image
   // occludes it.
   // TODO(trchen): In the !bgLayer.hasRepeatXY() case, we could improve the
   // culling test by verifying whether the background image covers the entire
   // painting area.
-  if (info.isBottomLayer && info.color.alpha()) {
+  if (info.isBottomLayer && info.color.alpha() && info.shouldPaintColor) {
     IntRect backgroundRect(pixelSnappedIntRect(scrolledPaintRect));
-    if (info.shouldPaintColor || info.shouldPaintShadow) {
-      const ShadowContext shadowContext(context, obj, info.shouldPaintShadow);
-      context.fillRect(backgroundRect, info.color);
-    }
+    context.fillRect(backgroundRect, info.color);
   }
 
   // no progressive loading of the background image
   if (info.shouldPaintImage) {
     if (!geometry) {
       geometry.emplace();
       geometry->calculate(obj, paintInfo.paintContainer(),
                           paintInfo.getGlobalPaintFlags(), bgLayer,
                           scrolledPaintRect);
     } else {
@@ skipping 296 matching lines @@
 bool BoxPainter::shouldForceWhiteBackgroundForPrintEconomy(
     const ComputedStyle& style,
     const Document& document) {
   return document.printing() &&
          style.getPrintColorAdjust() == PrintColorAdjustEconomy &&
          (!document.settings() ||
           !document.settings()->shouldPrintBackgrounds());
 }
 
 }  // namespace blink