Remove a bunch of dead code from RenderLayer

sky/engine/core/rendering/RenderLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 112 matching lines @@
 RenderLayer::~RenderLayer()
 {
     removeFilterInfoIfNeeded();
 }
 
 String RenderLayer::debugName() const
 {
     return renderer()->debugName();
 }
 
-void RenderLayer::contentChanged(ContentChangeType changeType)
-{
-    // FIXME(sky): Remove
-}
-
 bool RenderLayer::paintsWithFilters() const
 {
     // FIXME(sky): Remove
     return renderer()->hasFilter();
 }
 
 bool RenderLayer::requiresFullLayerImageForFilters() const
 {
     if (!paintsWithFilters())
         return false;
@@ skipping 40 matching lines @@
         layer->m_hasSelfPaintingLayerDescendantDirty = true;
         // If we have reached a self-painting layer, we know our parent should have a self-painting descendant
         // in this case, there is no need to dirty our ancestors further.
         if (layer->isSelfPaintingLayer()) {
             ASSERT(!parent() || parent()->m_hasSelfPaintingLayerDescendantDirty || parent()->m_hasSelfPaintingLayerDescendant);
             break;
         }
     }
 }
 
-bool RenderLayer::scrollsWithViewport() const
-{
-    // FIXME(sky): Remove
-    return false;
-}
-
 bool RenderLayer::scrollsWithRespectTo(const RenderLayer* other) const
 {
-    if (scrollsWithViewport() != other->scrollsWithViewport())
-        return true;
     return ancestorScrollingLayer() != other->ancestorScrollingLayer();
 }
 
 void RenderLayer::updateTransformationMatrix()
 {
     if (m_transform) {
         RenderBox* box = renderBox();
         ASSERT(box);
         m_transform->makeIdentity();
         box->style()->applyTransform(*m_transform, box->pixelSnappedBorderBoxRect().size(), RenderStyle::IncludeTransformOrigin);
@@ skipping 92 matching lines @@
     }
     return 0;
 }
 
 LayoutPoint RenderLayer::positionFromPaintInvalidationContainer(const RenderObject* renderObject, const RenderLayerModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState)
 {
     // FIXME(sky): Remove
     return renderObject->positionFromPaintInvalidationContainer(paintInvalidationContainer, paintInvalidationState);
 }
 
-void RenderLayer::mapRectToPaintBackingCoordinates(const RenderLayerModelObject* paintInvalidationContainer, LayoutRect& rect)
-{
-    // FIXME(sky): Remove
-    ASSERT_NOT_REACHED();
-}
-
 void RenderLayer::mapRectToPaintInvalidationBacking(const RenderObject* renderObject, const RenderLayerModelObject* paintInvalidationContainer, LayoutRect& rect, const PaintInvalidationState* paintInvalidationState)
 {
     // FIXME(sky): Remove
     renderObject->mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, paintInvalidationState);
 }
 
 LayoutRect RenderLayer::computePaintInvalidationRect(const RenderObject* renderObject, const RenderLayer* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState)
 {
     // FIXME(sky): Remove
     return renderObject->computePaintInvalidationRect(paintInvalidationContainer->renderer(), paintInvalidationState);
@@ skipping 186 matching lines @@
 
 const RenderLayer* RenderLayer::compositingContainer() const
 {
     if (stackingNode()->isNormalFlowOnly())
         return parent();
     if (RenderLayerStackingNode* ancestorStackingNode = stackingNode()->ancestorStackingContextNode())
         return ancestorStackingNode->layer();
     return 0;
 }
 
-bool RenderLayer::isPaintInvalidationContainer() const
-{
-    // FIXME(sky): Remove
-    return false;
-}
-
-// Note: enclosingCompositingLayer does not include squashed layers. Compositing stacking children of squashed layers
-// receive graphics layers that are parented to the compositing ancestor of the squashed layer.
-RenderLayer* RenderLayer::enclosingLayerWithCompositedLayerMapping(IncludeSelfOrNot includeSelf) const
-{
-    // FIXME(sky): Remove
-    return 0;
-}
-
-// Return the enclosingCompositedLayerForPaintInvalidation for the given RenderLayer
-// including crossing frame boundaries.
-RenderLayer* RenderLayer::enclosingLayerForPaintInvalidationCrossingFrameBoundaries() const
-{
-    // FIXME(sky): remove
-    return enclosingLayerForPaintInvalidation();
-}
-
-RenderLayer* RenderLayer::enclosingLayerForPaintInvalidation() const
-{
-    if (isPaintInvalidationContainer())
-        return const_cast<RenderLayer*>(this);
-
-    for (const RenderLayer* curr = parent(); curr; curr = curr->parent()) {
-        if (curr->isPaintInvalidationContainer())
-            return const_cast<RenderLayer*>(curr);
-    }
-
-    return 0;
-}
-
 RenderLayer* RenderLayer::enclosingFilterLayer(IncludeSelfOrNot includeSelf) const
 {
     const RenderLayer* curr = (includeSelf == IncludeSelf) ? this : parent();
     for (; curr; curr = curr->parent()) {
         if (curr->requiresFullLayerImageForFilters())
             return const_cast<RenderLayer*>(curr);
     }
 
     return 0;
 }
 
-void RenderLayer::setNeedsCompositingInputsUpdate()
-{
-    // FIXME(sky): Remove
-}
-
 void RenderLayer::updateAncestorDependentCompositingInputs(const AncestorDependentCompositingInputs& compositingInputs)
 {
     m_ancestorDependentCompositingInputs = compositingInputs;
     m_needsAncestorDependentCompositingInputsUpdate = false;
 }
 
 void RenderLayer::updateDescendantDependentCompositingInputs(const DescendantDependentCompositingInputs& compositingInputs)
 {
     m_descendantDependentCompositingInputs = compositingInputs;
     m_needsDescendantDependentCompositingInputsUpdate = false;
@@ skipping 145 matching lines @@
 
     if (beforeChild) {
         beforeChild->setPreviousSibling(child);
         child->setNextSibling(beforeChild);
         ASSERT(beforeChild != child);
     } else
         setLastChild(child);
 
     child->m_parent = this;
 
-    setNeedsCompositingInputsUpdate();
-
     if (child->stackingNode()->isNormalFlowOnly())
         m_stackingNode->dirtyNormalFlowList();
 
     if (!child->stackingNode()->isNormalFlowOnly() || child->firstChild()) {
         // Dirty the z-order list in which we are contained. The ancestorStackingContextNode() can be null in the
         // case where we're building up generated content layers. This is ok, since the lists will start
         // off dirty in that case anyway.
         child->stackingNode()->dirtyStackingContextZOrderLists();
     }
 
@@ skipping 1137 matching lines @@
             if (!result.isRectBasedTest())
                 result = tempResult;
             if (!depthSortDescendants)
                 break;
         }
     }
 
     return resultLayer;
 }
 
-void RenderLayer::blockSelectionGapsBoundsChanged()
-{
-    setNeedsCompositingInputsUpdate();
-}
-
 void RenderLayer::addBlockSelectionGapsBounds(const LayoutRect& bounds)
 {
     m_blockSelectionGapsBounds.unite(enclosingIntRect(bounds));
-    blockSelectionGapsBoundsChanged();
 }
 
 void RenderLayer::clearBlockSelectionGapsBounds()
 {
     m_blockSelectionGapsBounds = IntRect();
     for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
         child->clearBlockSelectionGapsBounds();
-    blockSelectionGapsBoundsChanged();
 }
 
 void RenderLayer::invalidatePaintForBlockSelectionGaps()
 {
     for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
         child->invalidatePaintForBlockSelectionGaps();
 
     if (m_blockSelectionGapsBounds.isEmpty())
         return;
 
@@ skipping 146 matching lines @@
 
     if (shouldIncludeTransform)
         result = transform()->mapRect(result);
 
     LayoutPoint delta;
     convertToLayerCoords(ancestorLayer, delta);
     result.moveBy(delta);
     return result;
 }
 
-bool RenderLayer::hasCompositedMask() const
-{
-    // FIXME(sky): Remove
-    return false;
-}
-
-bool RenderLayer::hasCompositedClippingMask() const
-{
-    // FIXME(sky): Remove
-    return false;
-}
-
-bool RenderLayer::clipsCompositingDescendantsWithBorderRadius() const
-{
-    // FIXME(sky): Remove
-    return false;
-}
-
 bool RenderLayer::paintsWithTransform(PaintBehavior paintBehavior) const
 {
     // FIXME(sky): Remove
     return transform();
 }
 
 bool RenderLayer::backgroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect) const
 {
     if (!isSelfPaintingLayer() && !hasSelfPaintingLayerDescendant())
         return false;
@@ skipping 25 matching lines @@
         return false;
 
     return childBackgroundIsKnownToBeOpaqueInRect(localRect);
 }
 
 bool RenderLayer::childBackgroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect) const
 {
     RenderLayerStackingNodeReverseIterator revertseIterator(*m_stackingNode, PositiveZOrderChildren | NormalFlowChildren | NegativeZOrderChildren);
     while (RenderLayerStackingNode* child = revertseIterator.next()) {
         const RenderLayer* childLayer = child->layer();
-        // Stop at composited paint boundaries.
-        if (childLayer->isPaintInvalidationContainer())
-            continue;
-
         if (!childLayer->canUseConvertToLayerCoords())
             continue;
 
         LayoutPoint childOffset;
         LayoutRect childLocalRect(localRect);
         childLayer->convertToLayerCoords(this, childOffset);
         childLocalRect.moveBy(-childOffset);
 
         if (childLayer->backgroundIsKnownToBeOpaqueInRect(childLocalRect))
             return true;
@@ skipping 79 matching lines @@
 
     if (m_scrollableArea)
         m_scrollableArea->updateAfterStyleChange(oldStyle);
 
     // Overlay scrollbars can make this layer self-painting so we need
     // to recompute the bit once scrollbars have been updated.
     updateSelfPaintingLayer();
 
     updateTransform(oldStyle, renderer()->style());
     updateFilters(oldStyle, renderer()->style());
-
-    setNeedsCompositingInputsUpdate();
 }
 
 bool RenderLayer::scrollsOverflow() const
 {
     if (RenderLayerScrollableArea* scrollableArea = this->scrollableArea())
         return scrollableArea->scrollsOverflow();
 
     return false;
 }
 
@@ skipping 46 matching lines @@
 
 void RenderLayer::filterNeedsPaintInvalidation()
 {
 }
 
 void RenderLayer::setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants()
 {
     renderer()->setShouldDoFullPaintInvalidation(true);
 
     for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) {
-        if (!child->isPaintInvalidationContainer())
-            child->setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
+        child->setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
     }
 }
 
 DisableCompositingQueryAsserts::DisableCompositingQueryAsserts()
     : m_disabler(gCompositingQueryMode, CompositingQueriesAreAllowed) { }
 
 } // namespace blink
 
 #ifndef NDEBUG
 void showLayerTree(const blink::RenderLayer* layer)
 {
     if (!layer)
         return;
 
     if (blink::LocalFrame* frame = layer->renderer()->frame()) {
         WTF::String output = externalRepresentation(frame, blink::RenderAsTextShowAllLayers | blink::RenderAsTextShowLayerNesting | blink::RenderAsTextShowCompositedLayers | blink::RenderAsTextShowAddresses | blink::RenderAsTextShowIDAndClass | blink::RenderAsTextDontUpdateLayout | blink::RenderAsTextShowLayoutState);
         fprintf(stderr, "%s\n", output.utf8().data());
     }
 }
 
 void showLayerTree(const blink::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif