Fix the bug that negative outline-offset is covered up by composited

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 541 matching lines @@
 
   if (updateClippingLayers(needsAncestorClip, needsDescendantsClippingLayer))
     layerConfigChanged = true;
 
   bool scrollingConfigChanged = false;
   if (updateScrollingLayers(m_owningLayer.needsCompositedScrolling())) {
     layerConfigChanged = true;
     scrollingConfigChanged = true;
   }
 
+  // The decoration layer is currently used for painting outline with certain
+  // offset that would be covered up by the composited scrolling contents layer
+  // and scrollbars.

[flackr, 2016/10/25 21:26:30]

Suggested wording:
If the outline needs to draw over the composited scrolling contents layer
or scrollbar layers it needs to be drawn into a separate layer.

[yigu, 2016/10/27 20:21:26]

Done.

+  int minBorderWidth =
+      std::min(layoutObject->style()->borderTopWidth(),
+               std::min(layoutObject->style()->borderLeftWidth(),
+                        std::min(layoutObject->style()->borderRightWidth(),
+                                 layoutObject->style()->borderBottomWidth())));
+  bool needsDecorationLayer =
+      m_owningLayer.getScrollableArea() &&
+      m_owningLayer.getScrollableArea()->usesCompositedScrolling() &&
+      layoutObject->style()->hasOutline() &&
+      layoutObject->style()->outlineOffset() < -minBorderWidth;
+
+  if (updateDecorationLayer(needsDecorationLayer))
+    layerConfigChanged = true;
+
   if (updateOverflowControlsLayers(
           requiresHorizontalScrollbarLayer(), requiresVerticalScrollbarLayer(),
           requiresScrollCornerLayer(), needsAncestorClip))
     layerConfigChanged = true;
 
   bool hasPerspective = style.hasPerspective();
   bool needsChildTransformLayer = hasPerspective && layoutObject->isBox();
   if (updateChildTransformLayer(needsChildTransformLayer))
     layerConfigChanged = true;
 
@@ skipping 365 matching lines @@
     clippingBox = clipBox(toLayoutBox(layoutObject()));
 
   updateChildTransformLayerGeometry();
   updateChildContainmentLayerGeometry(clippingBox, localCompositingBounds);
 
   updateMaskLayerGeometry();
   updateTransformGeometry(snappedOffsetFromCompositedAncestor,
                           relativeCompositingBounds);
   updateForegroundLayerGeometry(contentsSize, clippingBox);
   updateBackgroundLayerGeometry(contentsSize);
+  // TODO(yigu): Currently the decoration layer uses the same contentSize
+  // as background layer and foreground layer. There are scenarios that
+  // the sizes could be different.
+  // The actual size of the decoration layer should be calculated separately.

[flackr, 2016/10/25 21:26:30]

nit: The size of the background layer should be different as well. We need to
check whether we are painting the decoration layer into the background and then
ignore or consider the outline when determining the contentsSize.

[yigu, 2016/10/27 20:21:26]

Added.

+  updateDecorationLayerGeometry(contentsSize);
   updateScrollingLayerGeometry(localCompositingBounds);
   updateChildClippingMaskLayerGeometry();
 
   if (m_owningLayer.getScrollableArea() &&
       m_owningLayer.getScrollableArea()->scrollsOverflow())
     m_owningLayer.getScrollableArea()->positionOverflowControls();
 
   updateLayerBlendMode(layoutObject()->styleRef());
   updateIsRootForIsolatedGroup();
   updateContentsRect();
@@ skipping 407 matching lines @@
   }
   m_backgroundLayer->setPosition(FloatPoint());
   if (backgroundSize != m_backgroundLayer->size()) {
     m_backgroundLayer->setSize(backgroundSize);
     m_backgroundLayer->setNeedsDisplay();
   }
   m_backgroundLayer->setOffsetFromLayoutObject(
       m_graphicsLayer->offsetFromLayoutObject());
 }
 
+void CompositedLayerMapping::updateDecorationLayerGeometry(
+    const FloatSize& relativeCompositingBoundsSize) {
+  if (!m_decorationLayer)
+    return;
+  FloatSize decorationSize = relativeCompositingBoundsSize;
+  m_decorationLayer->setPosition(FloatPoint());
+  if (decorationSize != m_decorationLayer->size()) {
+    m_decorationLayer->setSize(decorationSize);
+    m_decorationLayer->setNeedsDisplay();
+  }
+  m_decorationLayer->setOffsetFromLayoutObject(
+      m_graphicsLayer->offsetFromLayoutObject());
+}
+
 void CompositedLayerMapping::registerScrollingLayers() {
   // Register fixed position layers and their containers with the scrolling
   // coordinator.
   ScrollingCoordinator* scrollingCoordinator =
       scrollingCoordinatorFromLayer(m_owningLayer);
   if (!scrollingCoordinator)
     return;
 
   scrollingCoordinator->updateLayerPositionConstraint(&m_owningLayer);
 
@@ skipping 47 matching lines @@
                       .containerLayer();
   updateBottomLayer(m_overflowControlsAncestorClippingLayer.get());
   updateBottomLayer(m_overflowControlsHostLayer.get());
   if (m_layerForHorizontalScrollbar)
     m_overflowControlsHostLayer->addChild(m_layerForHorizontalScrollbar.get());
   if (m_layerForVerticalScrollbar)
     m_overflowControlsHostLayer->addChild(m_layerForVerticalScrollbar.get());
   if (m_layerForScrollCorner)
     m_overflowControlsHostLayer->addChild(m_layerForScrollCorner.get());
 
+  // Now add the DecorationLayer as a subtree to GraphicsLayer
+  bottomLayer = m_graphicsLayer.get();
+  updateBottomLayer(m_decorationLayer.get());
+
   // The squashing containment layer, if it exists, becomes a no-op parent.
   if (m_squashingLayer) {
     ASSERT((m_ancestorClippingLayer && !m_squashingContainmentLayer) ||
            (!m_ancestorClippingLayer && m_squashingContainmentLayer));
 
     if (m_squashingContainmentLayer) {
       m_squashingContainmentLayer->removeAllChildren();
       m_squashingContainmentLayer->addChild(m_graphicsLayer.get());
       m_squashingContainmentLayer->addChild(m_squashingLayer.get());
     } else {
@@ skipping 111 matching lines @@
       }
       contentLayer->setBackgroundColor(bgColor.rgb());
     }
   }
 
   // FIXME: we could refine this to only allocate backings for one of these
   // layers if possible.
   if (m_foregroundLayer)
     m_foregroundLayer->setDrawsContent(hasPaintedContent);
 
+  // TODO(yigu): The background should no longer setDrawsContent(true) if we
+  // only have an outline (i.e. if there is nothing actually drawn into the

[flackr, 2016/10/25 21:26:30]

nit: "if we only have an outline and we're drawing the outline into the
decoration layer"

[yigu, 2016/10/27 20:21:26]

Added.

+  // background anymore.)
+  // "hasPaintedContent" should be calculated in a way that does not take the
+  // outline into consideration.
   if (m_backgroundLayer)
     m_backgroundLayer->setDrawsContent(hasPaintedContent);
 
+  if (m_decorationLayer)
+    m_decorationLayer->setDrawsContent(true);
+
   if (m_maskLayer)
     m_maskLayer->setDrawsContent(true);
 
   if (m_childClippingMaskLayer)
     m_childClippingMaskLayer->setDrawsContent(true);
 }
 
 void CompositedLayerMapping::updateChildrenTransform() {
   if (GraphicsLayer* childTransformLayer = this->childTransformLayer()) {
     childTransformLayer->setTransform(owningLayer().perspectiveTransform());
@@ skipping 179 matching lines @@
   ApplyToLayersAffectedByPreserve3D = (1 << 0),
   ApplyToSquashingLayer = (1 << 1),
   ApplyToScrollbarLayers = (1 << 2),
   ApplyToBackgroundLayer = (1 << 3),
   ApplyToMaskLayers = (1 << 4),
   ApplyToContentLayers = (1 << 5),
   ApplyToChildContainingLayers =
       (1 << 6),  // layers between m_graphicsLayer and children
   ApplyToNonScrollingContentLayers = (1 << 7),
   ApplyToScrollingContentLayers = (1 << 8),
+  ApplyToDecorationLayer = (1 << 9),
   ApplyToAllGraphicsLayers =
       (ApplyToSquashingLayer | ApplyToScrollbarLayers | ApplyToBackgroundLayer |
        ApplyToMaskLayers |
        ApplyToLayersAffectedByPreserve3D |
        ApplyToContentLayers |
-       ApplyToScrollingContentLayers)
+       ApplyToScrollingContentLayers |
+       ApplyToDecorationLayer)
 };
 typedef unsigned ApplyToGraphicsLayersMode;
 
 template <typename Func>
 static void ApplyToGraphicsLayers(const CompositedLayerMapping* mapping,
                                   const Func& f,
                                   ApplyToGraphicsLayersMode mode) {
   ASSERT(mode);
 
   if ((mode & ApplyToLayersAffectedByPreserve3D) &&
@@ skipping 42 matching lines @@
        (mode & ApplyToNonScrollingContentLayers)) &&
       mapping->backgroundLayer())
     f(mapping->backgroundLayer());
 
   if ((mode & ApplyToScrollbarLayers) && mapping->layerForHorizontalScrollbar())
     f(mapping->layerForHorizontalScrollbar());
   if ((mode & ApplyToScrollbarLayers) && mapping->layerForVerticalScrollbar())
     f(mapping->layerForVerticalScrollbar());
   if ((mode & ApplyToScrollbarLayers) && mapping->layerForScrollCorner())
     f(mapping->layerForScrollCorner());
+
+  if (((mode & ApplyToDecorationLayer) ||
+       (mode & ApplyToNonScrollingContentLayers)) &&
+      mapping->decorationLayer())
+    f(mapping->decorationLayer());
 }
 
 struct UpdateRenderingContextFunctor {
   void operator()(GraphicsLayer* layer) const {
     layer->setRenderingContext(renderingContext);
   }
   int renderingContext;
 };
 
 void CompositedLayerMapping::updateRenderingContext() {
@@ skipping 141 matching lines @@
   return layerChanged;
 }
 
 bool CompositedLayerMapping::updateBackgroundLayer(bool needsBackgroundLayer) {
   bool layerChanged = false;
   if (needsBackgroundLayer) {
     if (!m_backgroundLayer) {
       m_backgroundLayer =
           createGraphicsLayer(CompositingReasonLayerForBackground);
       m_backgroundLayer->setTransformOrigin(FloatPoint3D());
       m_backgroundLayer->setPaintingPhase(GraphicsLayerPaintBackground);

[flackr, 2016/10/25 21:26:30]

I think this function needs to know if we have a decoration layer and if not set
the painting phase to GraphicsLayerPaintBackground |
GraphicsLayerPaintDecoration otherwise it seems like we won't draw the outline
into the background when we don't create the decoration layer.

[yigu, 2016/10/27 20:21:26]

Fix it by adding phase |= GraphicsLayerPaintDecoration into
paintingPhaseForPrimaryLayer() which is called by updatePaintingPhases() which
happens whenever there is a layer change.

       layerChanged = true;
     }
   } else {
     if (m_backgroundLayer) {
       m_backgroundLayer->removeFromParent();
       m_backgroundLayer = nullptr;
       layerChanged = true;
     }
   }
 
   if (layerChanged && !m_owningLayer.layoutObject()->documentBeingDestroyed())
     compositor()->rootFixedBackgroundsChanged();
 
   return layerChanged;
 }
 
+bool CompositedLayerMapping::updateDecorationLayer(bool needsDecorationLayer) {
+  bool layerChanged = false;
+  if (needsDecorationLayer) {
+    if (!m_decorationLayer) {
+      m_decorationLayer =
+          createGraphicsLayer(CompositingReasonLayerForDecoration);
+      m_decorationLayer->setPaintingPhase(GraphicsLayerPaintDecoration);
+      layerChanged = true;
+    }
+  } else if (m_decorationLayer) {
+    m_decorationLayer = nullptr;
+    layerChanged = true;
+  }
+
+  return layerChanged;
+}
+
 bool CompositedLayerMapping::updateMaskLayer(bool needsMaskLayer) {
   bool layerChanged = false;
   if (needsMaskLayer) {
     if (!m_maskLayer) {
       m_maskLayer = createGraphicsLayer(CompositingReasonLayerForMask);
       m_maskLayer->setPaintingPhase(GraphicsLayerPaintMask);
       layerChanged = true;
     }
   } else if (m_maskLayer) {
     m_maskLayer = nullptr;
@@ skipping 918 matching lines @@
   if (graphicsLayerPaintingPhase & GraphicsLayerPaintForeground)
     paintLayerFlags |= PaintLayerPaintingCompositingForegroundPhase;
   if (graphicsLayerPaintingPhase & GraphicsLayerPaintMask)
     paintLayerFlags |= PaintLayerPaintingCompositingMaskPhase;
   if (graphicsLayerPaintingPhase & GraphicsLayerPaintChildClippingMask)
     paintLayerFlags |= PaintLayerPaintingChildClippingMaskPhase;
   if (graphicsLayerPaintingPhase & GraphicsLayerPaintOverflowContents)
     paintLayerFlags |= PaintLayerPaintingOverflowContents;
   if (graphicsLayerPaintingPhase & GraphicsLayerPaintCompositedScroll)
     paintLayerFlags |= PaintLayerPaintingCompositingScrollingPhase;
+  if (graphicsLayerPaintingPhase & GraphicsLayerPaintDecoration)
+    paintLayerFlags |= PaintLayerPaintingCompositingDecorationPhase;
 
   if (graphicsLayer == m_backgroundLayer.get())
     paintLayerFlags |= PaintLayerPaintingRootBackgroundOnly;
   else if (compositor()->fixedRootBackgroundLayer() &&
            m_owningLayer.isRootLayer())
     paintLayerFlags |= PaintLayerPaintingSkipRootBackground;
 
   if (graphicsLayer == m_graphicsLayer.get() ||
       graphicsLayer == m_foregroundLayer.get() ||
       graphicsLayer == m_backgroundLayer.get() ||
       graphicsLayer == m_maskLayer.get() ||
       graphicsLayer == m_childClippingMaskLayer.get() ||
-      graphicsLayer == m_scrollingContentsLayer.get()) {
+      graphicsLayer == m_scrollingContentsLayer.get() ||
+      graphicsLayer == m_decorationLayer.get()) {
     bool paintRootBackgroundOntoScrollingContentsLayer =
         m_backgroundPaintsOntoScrollingContentsLayer;
     DCHECK(!paintRootBackgroundOntoScrollingContentsLayer ||
            (!m_backgroundLayer && !m_foregroundLayer));
     if (paintRootBackgroundOntoScrollingContentsLayer) {
       if (graphicsLayer == m_scrollingContentsLayer.get())
         paintLayerFlags &= ~PaintLayerPaintingSkipRootBackground;
       else
         paintLayerFlags |= PaintLayerPaintingSkipRootBackground;
     }
@@ skipping 260 matching lines @@
   } else if (graphicsLayer == m_layerForScrollCorner.get()) {
     name = "Scroll Corner Layer";
   } else if (graphicsLayer == m_overflowControlsHostLayer.get()) {
     name = "Overflow Controls Host Layer";
   } else if (graphicsLayer == m_overflowControlsAncestorClippingLayer.get()) {
     name = "Overflow Controls Ancestor Clipping Layer";
   } else if (graphicsLayer == m_scrollingLayer.get()) {
     name = "Scrolling Layer";
   } else if (graphicsLayer == m_scrollingContentsLayer.get()) {
     name = "Scrolling Contents Layer";
+  } else if (graphicsLayer == m_decorationLayer.get()) {
+    name = "Decoration Layer";
   } else {
     ASSERT_NOT_REACHED();
   }
 
   return name;
 }
 
 }  // namespace blink