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;
   }
 
+  // If the outline needs to draw over the composited scrolling contents layer
+  // or scrollbar layers it needs to be drawn into a separate layer.
+  int minBorderWidth =
+      std::min(layoutObject->style()->borderTopWidth(),
+               std::min(layoutObject->style()->borderLeftWidth(),
+                        std::min(layoutObject->style()->borderRightWidth(),
+                                 layoutObject->style()->borderBottomWidth())));
+  bool needsDecorationOutlineLayer =
+      m_owningLayer.getScrollableArea() &&
+      m_owningLayer.getScrollableArea()->usesCompositedScrolling() &&
+      layoutObject->style()->hasOutline() &&
+      layoutObject->style()->outlineOffset() < -minBorderWidth;
+
+  if (updateDecorationOutlineLayer(needsDecorationOutlineLayer))
+    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.
+  // 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 contentSize.
+  updateDecorationOutlineLayerGeometry(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::updateDecorationOutlineLayerGeometry(
+    const FloatSize& relativeCompositingBoundsSize) {
+  if (!m_decorationOutlineLayer)
+    return;
+  FloatSize decorationSize = relativeCompositingBoundsSize;
+  m_decorationOutlineLayer->setPosition(FloatPoint());
+  if (decorationSize != m_decorationOutlineLayer->size()) {
+    m_decorationOutlineLayer->setSize(decorationSize);
+    m_decorationOutlineLayer->setNeedsDisplay();
+  }
+  m_decorationOutlineLayer->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 DecorationOutlineLayer as a subtree to GraphicsLayer
+  if (m_decorationOutlineLayer.get())
+    m_graphicsLayer->addChild(m_decorationOutlineLayer.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 and we are drawing the outline into the decoration
+  // layer (i.e. if there is nothing actually drawn into the
+  // 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_decorationOutlineLayer)
+    m_decorationOutlineLayer->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),
+  ApplyToDecorationOutlineLayer = (1 << 9),
   ApplyToAllGraphicsLayers =
       (ApplyToSquashingLayer | ApplyToScrollbarLayers | ApplyToBackgroundLayer |
        ApplyToMaskLayers |
        ApplyToLayersAffectedByPreserve3D |
        ApplyToContentLayers |
-       ApplyToScrollingContentLayers)
+       ApplyToScrollingContentLayers |
+       ApplyToDecorationOutlineLayer)
 };
 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 & ApplyToDecorationOutlineLayer) ||
+       (mode & ApplyToNonScrollingContentLayers)) &&
+      mapping->decorationOutlineLayer())
+    f(mapping->decorationOutlineLayer());
 }
 
 struct UpdateRenderingContextFunctor {
   void operator()(GraphicsLayer* layer) const {
     layer->setRenderingContext(renderingContext);
   }
   int renderingContext;
 };
 
 void CompositedLayerMapping::updateRenderingContext() {
@@ skipping 158 matching lines @@
       layerChanged = true;
     }
   }
 
   if (layerChanged && !m_owningLayer.layoutObject()->documentBeingDestroyed())
     compositor()->rootFixedBackgroundsChanged();
 
   return layerChanged;
 }
 
+bool CompositedLayerMapping::updateDecorationOutlineLayer(
+    bool needsDecorationOutlineLayer) {
+  bool layerChanged = false;
+  if (needsDecorationOutlineLayer) {
+    if (!m_decorationOutlineLayer) {
+      m_decorationOutlineLayer =
+          createGraphicsLayer(CompositingReasonLayerForDecoration);
+      m_decorationOutlineLayer->setPaintingPhase(GraphicsLayerPaintDecoration);
+      layerChanged = true;
+    }
+  } else if (m_decorationOutlineLayer) {
+    m_decorationOutlineLayer = 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 182 matching lines @@
 
 GraphicsLayerPaintingPhase
 CompositedLayerMapping::paintingPhaseForPrimaryLayer() const {
   unsigned phase = 0;
   if (!m_backgroundLayer)
     phase |= GraphicsLayerPaintBackground;
   if (!m_foregroundLayer)
     phase |= GraphicsLayerPaintForeground;
   if (!m_maskLayer)
     phase |= GraphicsLayerPaintMask;
+  if (!m_decorationOutlineLayer)
+    phase |= GraphicsLayerPaintDecoration;
 
   if (m_scrollingContentsLayer) {
     phase &= ~GraphicsLayerPaintForeground;
     phase |= GraphicsLayerPaintCompositedScroll;
   }
 
   return static_cast<GraphicsLayerPaintingPhase>(phase);
 }
 
 float CompositedLayerMapping::compositingOpacity(
@@ skipping 718 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_decorationOutlineLayer.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_decorationOutlineLayer.get()) {
+    name = "Decoration Layer";
   } else {
     ASSERT_NOT_REACHED();
   }
 
   return name;
 }
 
 }  // namespace blink