Remove a bunch of fixed position dead code.

There is not change in behavior here. Just removing dead
code now that we no longer support position:fixed.

R=abarth@chromium.org

Review URL: https://codereview.chromium.org/686653002

engine/core/core.gni

@@ -1019,8 +1019,6 @@ sky_core_files = [
   "page/TouchDisambiguation.cpp",
   "page/TouchDisambiguation.h",
   "page/WindowFocusAllowedIndicator.cpp",
-  "page/scrolling/ScrollingConstraints.cpp",
-  "page/scrolling/ScrollingConstraints.h",
   "page/scrolling/ScrollingCoordinator.cpp",
   "page/scrolling/ScrollingCoordinator.h",
   "rendering/BidiRun.h",

engine/core/dom/Range.cpp

@@ -1207,16 +1207,13 @@ IntRect Range::boundingBox() const
     return result;
 }
 
-void Range::textRects(Vector<IntRect>& rects, bool useSelectionHeight, RangeInFixedPosition* inFixed) const
+void Range::textRects(Vector<IntRect>& rects, bool useSelectionHeight) const
 {
     Node* startContainer = m_start.container();
     ASSERT(startContainer);
     Node* endContainer = m_end.container();
     ASSERT(endContainer);
 
-    bool allFixed = true;
-    bool someFixed = false;
-
     Node* stopNode = pastLastNode();
     for (Node* node = firstNode(); node != stopNode; node = NodeTraversal::next(*node)) {
         RenderObject* r = node->renderer();
@@ -1225,26 +1222,17 @@ void Range::textRects(Vector<IntRect>& rects, bool useSelectionHeight, RangeInFi
         RenderText* renderText = toRenderText(r);
         int startOffset = node == startContainer ? m_start.offset() : 0;
         int endOffset = node == endContainer ? m_end.offset() : std::numeric_limits<int>::max();
-        bool isFixed = false;
-        renderText->absoluteRectsForRange(rects, startOffset, endOffset, useSelectionHeight, &isFixed);
-        allFixed &= isFixed;
-        someFixed |= isFixed;
+        renderText->absoluteRectsForRange(rects, startOffset, endOffset, useSelectionHeight);
     }
-
-    if (inFixed)
-        *inFixed = allFixed ? EntirelyFixedPosition : (someFixed ? PartiallyFixedPosition : NotFixedPosition);
 }
 
-void Range::textQuads(Vector<FloatQuad>& quads, bool useSelectionHeight, RangeInFixedPosition* inFixed) const
+void Range::textQuads(Vector<FloatQuad>& quads, bool useSelectionHeight) const
 {
     Node* startContainer = m_start.container();
     ASSERT(startContainer);
     Node* endContainer = m_end.container();
     ASSERT(endContainer);
 
-    bool allFixed = true;
-    bool someFixed = false;
-
     Node* stopNode = pastLastNode();
     for (Node* node = firstNode(); node != stopNode; node = NodeTraversal::next(*node)) {
         RenderObject* r = node->renderer();
@@ -1253,14 +1241,8 @@ void Range::textQuads(Vector<FloatQuad>& quads, bool useSelectionHeight, RangeIn
         RenderText* renderText = toRenderText(r);
         int startOffset = node == startContainer ? m_start.offset() : 0;
         int endOffset = node == endContainer ? m_end.offset() : std::numeric_limits<int>::max();
-        bool isFixed = false;
-        renderText->absoluteQuadsForRange(quads, startOffset, endOffset, useSelectionHeight, &isFixed);
-        allFixed &= isFixed;
-        someFixed |= isFixed;
+        renderText->absoluteQuadsForRange(quads, startOffset, endOffset, useSelectionHeight);
     }
-
-    if (inFixed)
-        *inFixed = allFixed ? EntirelyFixedPosition : (someFixed ? PartiallyFixedPosition : NotFixedPosition);
 }
 
 #ifndef NDEBUG

engine/core/dom/Range.h

@@ -108,18 +108,12 @@ public:
 
     ShadowRoot* shadowRoot() const;
 
-    enum RangeInFixedPosition {
-        NotFixedPosition,
-        PartiallyFixedPosition,
-        EntirelyFixedPosition
-    };
-
     // Not transform-friendly
-    void textRects(Vector<IntRect>&, bool useSelectionHeight = false, RangeInFixedPosition* = 0) const;
+    void textRects(Vector<IntRect>&, bool useSelectionHeight = false) const;
     IntRect boundingBox() const;
 
     // Transform-friendly
-    void textQuads(Vector<FloatQuad>&, bool useSelectionHeight = false, RangeInFixedPosition* = 0) const;
+    void textQuads(Vector<FloatQuad>&, bool useSelectionHeight = false) const;
     void getBorderAndTextQuads(Vector<FloatQuad>&) const;
     FloatRect boundingRect() const;
 

engine/core/page/scrolling/ScrollingConstraints.cpp

-/*
- * Copyright (C) 2012 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
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
- * THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "config.h"
-#include "core/page/scrolling/ScrollingConstraints.h"
-
-namespace blink {
-
-FloatPoint FixedPositionViewportConstraints::layerPositionForViewportRect(const FloatRect& viewportRect) const
-{
-    FloatSize offset;
-
-    if (hasAnchorEdge(AnchorEdgeLeft))
-        offset.setWidth(viewportRect.x() - m_viewportRectAtLastLayout.x());
-    else if (hasAnchorEdge(AnchorEdgeRight))
-        offset.setWidth(viewportRect.maxX() - m_viewportRectAtLastLayout.maxX());
-
-    if (hasAnchorEdge(AnchorEdgeTop))
-        offset.setHeight(viewportRect.y() - m_viewportRectAtLastLayout.y());
-    else if (hasAnchorEdge(AnchorEdgeBottom))
-        offset.setHeight(viewportRect.maxY() - m_viewportRectAtLastLayout.maxY());
-
-    return m_layerPositionAtLastLayout + offset;
-}
-
-} // namespace blink

engine/core/page/scrolling/ScrollingConstraints.h

-/*
- * Copyright (C) 2012 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
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
- * THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef ScrollingConstraints_h
-#define ScrollingConstraints_h
-
-#include "platform/geometry/FloatRect.h"
-
-namespace blink {
-
-// ViewportConstraints classes encapsulate data and logic required to reposition elements whose layout
-// depends on the viewport rect (i.e., position fixed), when scrolling and zooming.
-class ViewportConstraints {
-public:
-    // FIXME: Simplify this code now that position: sticky doesn't exist.
-    enum ConstraintType {
-        FixedPositionConstaint,
-    };
-
-    enum AnchorEdgeFlags {
-        AnchorEdgeLeft = 1 << 0,
-        AnchorEdgeRight = 1 << 1,
-        AnchorEdgeTop = 1 << 2,
-        AnchorEdgeBottom = 1 << 3
-    };
-    typedef unsigned AnchorEdges;
-
-    ViewportConstraints(const ViewportConstraints& other)
-        : m_alignmentOffset(other.m_alignmentOffset)
-        , m_anchorEdges(other.m_anchorEdges)
-    { }
-
-    virtual ~ViewportConstraints() { }
-
-    virtual ConstraintType constraintType() const = 0;
-
-    AnchorEdges anchorEdges() const { return m_anchorEdges; }
-    bool hasAnchorEdge(AnchorEdgeFlags flag) const { return m_anchorEdges & flag; }
-    void addAnchorEdge(AnchorEdgeFlags edgeFlag) { m_anchorEdges |= edgeFlag; }
-    void setAnchorEdges(AnchorEdges edges) { m_anchorEdges = edges; }
-
-    FloatSize alignmentOffset() const { return m_alignmentOffset; }
-    void setAlignmentOffset(const FloatSize& offset) { m_alignmentOffset = offset; }
-
-protected:
-    ViewportConstraints()
-        : m_anchorEdges(0)
-    { }
-
-    FloatSize m_alignmentOffset;
-    AnchorEdges m_anchorEdges;
-};
-
-class FixedPositionViewportConstraints final : public ViewportConstraints {
-public:
-    FixedPositionViewportConstraints()
-        : ViewportConstraints()
-    { }
-
-    FixedPositionViewportConstraints(const FixedPositionViewportConstraints& other)
-        : ViewportConstraints(other)
-        , m_viewportRectAtLastLayout(other.m_viewportRectAtLastLayout)
-        , m_layerPositionAtLastLayout(other.m_layerPositionAtLastLayout)
-    { }
-
-    FloatPoint layerPositionForViewportRect(const FloatRect& viewportRect) const;
-
-    const FloatRect& viewportRectAtLastLayout() const { return m_viewportRectAtLastLayout; }
-    void setViewportRectAtLastLayout(const FloatRect& rect) { m_viewportRectAtLastLayout = rect; }
-
-    const FloatPoint& layerPositionAtLastLayout() const { return m_layerPositionAtLastLayout; }
-    void setLayerPositionAtLastLayout(const FloatPoint& point) { m_layerPositionAtLastLayout = point; }
-
-    bool operator==(const FixedPositionViewportConstraints& other) const
-    {
-        return m_alignmentOffset == other.m_alignmentOffset
-            && m_anchorEdges == other.m_anchorEdges
-            && m_viewportRectAtLastLayout == other.m_viewportRectAtLastLayout
-            && m_layerPositionAtLastLayout == other.m_layerPositionAtLastLayout;
-    }
-
-    bool operator!=(const FixedPositionViewportConstraints& other) const { return !(*this == other); }
-
-private:
-    virtual ConstraintType constraintType() const override { return FixedPositionConstaint; }
-
-    FloatRect m_viewportRectAtLastLayout;
-    FloatPoint m_layerPositionAtLastLayout;
-};
-
-} // namespace blink
-
-#endif // ScrollingConstraints_h

engine/core/page/scrolling/ScrollingCoordinator.cpp

@@ -54,7 +54,6 @@
 #include "platform/scroll/Scrollbar.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
-#include "public/platform/WebLayerPositionConstraint.h"
 #include "public/platform/WebScrollbarLayer.h"
 #include "public/platform/WebScrollbarThemeGeometry.h"
 #include "public/platform/WebScrollbarThemePainter.h"
@@ -161,33 +160,6 @@ void ScrollingCoordinator::setLayerIsContainerForFixedPositionLayers(GraphicsLay
         scrollableLayer->setIsContainerForFixedPositionLayers(enable);
 }
 
-static void clearPositionConstraintExceptForLayer(GraphicsLayer* layer, GraphicsLayer* except)
-{
-    if (layer && layer != except && toWebLayer(layer))
-        toWebLayer(layer)->setPositionConstraint(WebLayerPositionConstraint());
-}
-
-static WebLayerPositionConstraint computePositionConstraint(const RenderLayer* layer)
-{
-    // FIXME(sky): Remove
-    return WebLayerPositionConstraint();
-}
-
-void ScrollingCoordinator::updateLayerPositionConstraint(RenderLayer* layer)
-{
-    ASSERT(layer->hasCompositedLayerMapping());
-    CompositedLayerMapping* compositedLayerMapping = layer->compositedLayerMapping();
-    GraphicsLayer* mainLayer = compositedLayerMapping->childForSuperlayers();
-
-    // Avoid unnecessary commits
-    clearPositionConstraintExceptForLayer(compositedLayerMapping->squashingContainmentLayer(), mainLayer);
-    clearPositionConstraintExceptForLayer(compositedLayerMapping->ancestorClippingLayer(), mainLayer);
-    clearPositionConstraintExceptForLayer(compositedLayerMapping->mainGraphicsLayer(), mainLayer);
-
-    if (WebLayer* scrollableLayer = toWebLayer(mainLayer))
-        scrollableLayer->setPositionConstraint(computePositionConstraint(layer));
-}
-
 void ScrollingCoordinator::willDestroyScrollableArea(ScrollableArea* scrollableArea)
 {
     removeWebScrollbarLayer(scrollableArea, HorizontalScrollbar);

engine/core/page/scrolling/ScrollingCoordinator.h

@@ -29,7 +29,6 @@
 #include "core/rendering/RenderObject.h"
 #include "platform/PlatformWheelEvent.h"
 #include "platform/geometry/IntRect.h"
-#include "platform/scroll/ScrollTypes.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
@@ -48,7 +47,6 @@ class GraphicsLayer;
 class Page;
 class Region;
 class ScrollableArea;
-class ViewportConstraints;
 
 class ScrollingCoordinator {
 public:
@@ -99,7 +97,6 @@ public:
     bool scrollableAreaScrollLayerDidChange(ScrollableArea*);
     void scrollableAreaScrollbarLayerDidChange(ScrollableArea*, ScrollbarOrientation);
     void setLayerIsContainerForFixedPositionLayers(GraphicsLayer*, bool);
-    void updateLayerPositionConstraint(RenderLayer*);
     void touchEventTargetRectsDidChange();
     void willDestroyRenderLayer(RenderLayer*);
 

engine/core/rendering/RenderBlock.cpp

@@ -2890,7 +2890,7 @@ void RenderBlock::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accum
         rects.append(pixelSnappedIntRect(accumulatedOffset, size()));
 }
 
-void RenderBlock::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed) const
+void RenderBlock::absoluteQuads(Vector<FloatQuad>& quads) const
 {
     // For blocks inside inlines, we go ahead and include margins so that we run right up to the
     // inline boxes above and below us (thus getting merged with them to form a single irregular
@@ -2900,10 +2900,10 @@ void RenderBlock::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed) const
         // https://bugs.webkit.org/show_bug.cgi?id=46781
         FloatRect localRect(0, -collapsedMarginBefore().toFloat(),
             width().toFloat(), (height() + collapsedMarginBefore() + collapsedMarginAfter()).toFloat());
-        quads.append(localToAbsoluteQuad(localRect, 0 /* mode */, wasFixed));
-        continuation()->absoluteQuads(quads, wasFixed);
+        quads.append(localToAbsoluteQuad(localRect, 0 /* mode */));
+        continuation()->absoluteQuads(quads);
     } else {
-        quads.append(RenderBox::localToAbsoluteQuad(FloatRect(0, 0, width().toFloat(), height().toFloat()), 0 /* mode */, wasFixed));
+        quads.append(RenderBox::localToAbsoluteQuad(FloatRect(0, 0, width().toFloat(), height().toFloat()), 0 /* mode */));
     }
 }
 

engine/core/rendering/RenderBlock.h

@@ -368,7 +368,7 @@ private:
     virtual void clipOutFloatingObjects(RenderBlock*, const PaintInfo*, const LayoutPoint&, const LayoutSize&) { };
 
     virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const override;
-    virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const override;
+    virtual void absoluteQuads(Vector<FloatQuad>&) const override;
 
     void paintContinuationOutlines(PaintInfo&, const LayoutPoint&);
 

engine/core/rendering/RenderBox.cpp

@@ -421,9 +421,9 @@ void RenderBox::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumul
     rects.append(pixelSnappedIntRect(accumulatedOffset, size()));
 }
 
-void RenderBox::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed) const
+void RenderBox::absoluteQuads(Vector<FloatQuad>& quads) const
 {
-    quads.append(localToAbsoluteQuad(FloatRect(0, 0, width().toFloat(), height().toFloat()), 0 /* mode */, wasFixed));
+    quads.append(localToAbsoluteQuad(FloatRect(0, 0, width().toFloat(), height().toFloat()), 0 /* mode */));
 }
 
 void RenderBox::updateLayerTransformAfterLayout()
@@ -1538,7 +1538,7 @@ LayoutUnit RenderBox::perpendicularContainingBlockLogicalHeight() const
     return cb->adjustContentBoxLogicalHeightForBoxSizing(logicalHeightLength.value());
 }
 
-void RenderBox::mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState& transformState, MapCoordinatesFlags mode, bool* wasFixed, const PaintInvalidationState* paintInvalidationState) const
+void RenderBox::mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState& transformState, MapCoordinatesFlags mode, const PaintInvalidationState* paintInvalidationState) const
 {
     if (paintInvalidationContainer == this)
         return;
@@ -1556,15 +1556,6 @@ void RenderBox::mapLocalToContainer(const RenderLayerModelObject* paintInvalidat
     if (!o)
         return;
 
-    bool hasTransform = hasLayer() && layer()->transform();
-    // If this box has a transform, it acts as a fixed position container for fixed descendants,
-    // and may itself also be fixed position. So propagate 'fixed' up only if this box is fixed position.
-    if (hasTransform)
-        mode &= ~IsFixed;
-
-    if (wasFixed)
-        *wasFixed = mode & IsFixed;
-
     LayoutSize containerOffset = offsetFromContainer(o, roundedLayoutPoint(transformState.mappedPoint()));
 
     bool preserve3D = mode & UseTransforms && (o->style()->preserves3D() || style()->preserves3D());
@@ -1585,19 +1576,7 @@ void RenderBox::mapLocalToContainer(const RenderLayerModelObject* paintInvalidat
 
     mode &= ~ApplyContainerFlip;
 
-    o->mapLocalToContainer(paintInvalidationContainer, transformState, mode, wasFixed);
-}
-
-void RenderBox::mapAbsoluteToLocalPoint(MapCoordinatesFlags mode, TransformState& transformState) const
-{
-    bool hasTransform = hasLayer() && layer()->transform();
-    if (hasTransform) {
-        // If this box has a transform, it acts as a fixed position container for fixed descendants,
-        // and may itself also be fixed position. So propagate 'fixed' up only if this box is fixed position.
-        mode &= ~IsFixed;
-    }
-
-    RenderBoxModelObject::mapAbsoluteToLocalPoint(mode, transformState);
+    o->mapLocalToContainer(paintInvalidationContainer, transformState, mode);
 }
 
 LayoutSize RenderBox::offsetFromContainer(const RenderObject* o, const LayoutPoint& point, bool* offsetDependsOnPoint) const

engine/core/rendering/RenderBox.h

@@ -333,7 +333,7 @@ public:
     virtual LayoutUnit collapsedMarginAfter() const { return marginAfter(); }
 
     virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const override;
-    virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const override;
+    virtual void absoluteQuads(Vector<FloatQuad>&) const override;
 
     virtual void layout() override;
     virtual void paint(PaintInfo&, const LayoutPoint&) override;
@@ -645,8 +645,7 @@ protected:
 
     virtual bool shouldComputeSizeAsReplaced() const { return isReplaced() && !isInlineBlock(); }
 
-    virtual void mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState&, MapCoordinatesFlags = ApplyContainerFlip, bool* wasFixed = 0, const PaintInvalidationState* = 0) const override;
-    virtual void mapAbsoluteToLocalPoint(MapCoordinatesFlags, TransformState&) const override;
+    virtual void mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState&, MapCoordinatesFlags = ApplyContainerFlip, const PaintInvalidationState* = 0) const override;
 
     void paintRootBoxFillLayers(const PaintInfo&);
 

engine/core/rendering/RenderBoxModelObject.cpp

@@ -27,7 +27,6 @@
 #include "core/rendering/RenderBoxModelObject.h"
 
 #include "core/frame/Settings.h"
-#include "core/page/scrolling/ScrollingConstraints.h"
 #include "core/rendering/ImageQualityController.h"
 #include "core/rendering/RenderBlock.h"
 #include "core/rendering/RenderGeometryMap.h"

engine/core/rendering/RenderInline.cpp

@@ -674,13 +674,13 @@ private:
 
 } // unnamed namespace
 
-void RenderInline::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed) const
+void RenderInline::absoluteQuads(Vector<FloatQuad>& quads) const
 {
     AbsoluteQuadsGeneratorContext context(this, quads);
     generateLineBoxRects(context);
 
     if (continuation())
-        continuation()->absoluteQuads(quads, wasFixed);
+        continuation()->absoluteQuads(quads);
 }
 
 LayoutUnit RenderInline::offsetLeft() const
@@ -1125,7 +1125,7 @@ LayoutSize RenderInline::offsetFromContainer(const RenderObject* container, cons
     return offset;
 }
 
-void RenderInline::mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState& transformState, MapCoordinatesFlags mode, bool* wasFixed, const PaintInvalidationState* paintInvalidationState) const
+void RenderInline::mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState& transformState, MapCoordinatesFlags mode, const PaintInvalidationState* paintInvalidationState) const
 {
     if (paintInvalidationContainer == this)
         return;
@@ -1169,7 +1169,7 @@ void RenderInline::mapLocalToContainer(const RenderLayerModelObject* paintInvali
         return;
     }
 
-    o->mapLocalToContainer(paintInvalidationContainer, transformState, mode, wasFixed, paintInvalidationState);
+    o->mapLocalToContainer(paintInvalidationContainer, transformState, mode, paintInvalidationState);
 }
 
 void RenderInline::childBecameNonInline(RenderObject* child)

engine/core/rendering/RenderInline.h

@@ -58,7 +58,7 @@ public:
     virtual LayoutUnit marginEnd(const RenderStyle* otherStyle = 0) const override final;
 
     virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const override final;
-    virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const override;
+    virtual void absoluteQuads(Vector<FloatQuad>&) const override;
 
     virtual LayoutSize offsetFromContainer(const RenderObject*, const LayoutPoint&, bool* offsetDependsOnPoint = 0) const override final;
 
@@ -148,7 +148,7 @@ private:
     virtual LayoutRect rectWithOutlineForPaintInvalidation(const RenderLayerModelObject* paintInvalidationContainer, LayoutUnit outlineWidth, const PaintInvalidationState* = 0) const override final;
     virtual void mapRectToPaintInvalidationBacking(const RenderLayerModelObject* paintInvalidationContainer, LayoutRect&, const PaintInvalidationState*) const override final;
 
-    virtual void mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState&, MapCoordinatesFlags = ApplyContainerFlip, bool* wasFixed = 0, const PaintInvalidationState* = 0) const override;
+    virtual void mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState&, MapCoordinatesFlags = ApplyContainerFlip, const PaintInvalidationState* = 0) const override;
 
     virtual PositionWithAffinity positionForPoint(const LayoutPoint&) override final;
 

engine/core/rendering/RenderObject.cpp

@@ -1144,7 +1144,7 @@ LayoutPoint RenderObject::positionFromPaintInvalidationContainer(const RenderLay
     if (paintInvalidationContainer == this)
         return LayoutPoint();
 
-    return LayoutPoint(localToContainerPoint(LayoutPoint(), paintInvalidationContainer, 0, 0, paintInvalidationState));
+    return LayoutPoint(localToContainerPoint(LayoutPoint(), paintInvalidationContainer, 0, paintInvalidationState));
 }
 
 IntRect RenderObject::absoluteBoundingBoxRect() const
@@ -2019,7 +2019,7 @@ FloatQuad RenderObject::absoluteToLocalQuad(const FloatQuad& quad, MapCoordinate
     return transformState.lastPlanarQuad();
 }
 
-void RenderObject::mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState& transformState, MapCoordinatesFlags mode, bool* wasFixed, const PaintInvalidationState* paintInvalidationState) const
+void RenderObject::mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState& transformState, MapCoordinatesFlags mode, const PaintInvalidationState* paintInvalidationState) const
 {
     if (paintInvalidationContainer == this)
         return;
@@ -2039,7 +2039,7 @@ void RenderObject::mapLocalToContainer(const RenderLayerModelObject* paintInvali
     if (o->hasOverflowClip())
         transformState.move(-toRenderBox(o)->scrolledContentOffset());
 
-    o->mapLocalToContainer(paintInvalidationContainer, transformState, mode, wasFixed, paintInvalidationState);
+    o->mapLocalToContainer(paintInvalidationContainer, transformState, mode, paintInvalidationState);
 }
 
 const RenderObject* RenderObject::pushMappingToContainer(const RenderLayerModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
@@ -2099,21 +2099,21 @@ void RenderObject::getTransformFromContainer(const RenderObject* containerObject
     }
 }
 
-FloatQuad RenderObject::localToContainerQuad(const FloatQuad& localQuad, const RenderLayerModelObject* paintInvalidationContainer, MapCoordinatesFlags mode, bool* wasFixed) const
+FloatQuad RenderObject::localToContainerQuad(const FloatQuad& localQuad, const RenderLayerModelObject* paintInvalidationContainer, MapCoordinatesFlags mode) const
 {
     // Track the point at the center of the quad's bounding box. As mapLocalToContainer() calls offsetFromContainer(),
     // it will use that point as the reference point to decide which column's transform to apply in multiple-column blocks.
     TransformState transformState(TransformState::ApplyTransformDirection, localQuad.boundingBox().center(), localQuad);
-    mapLocalToContainer(paintInvalidationContainer, transformState, mode | ApplyContainerFlip | UseTransforms, wasFixed);
+    mapLocalToContainer(paintInvalidationContainer, transformState, mode | ApplyContainerFlip | UseTransforms);
     transformState.flatten();
 
     return transformState.lastPlanarQuad();
 }
 
-FloatPoint RenderObject::localToContainerPoint(const FloatPoint& localPoint, const RenderLayerModelObject* paintInvalidationContainer, MapCoordinatesFlags mode, bool* wasFixed, const PaintInvalidationState* paintInvalidationState) const
+FloatPoint RenderObject::localToContainerPoint(const FloatPoint& localPoint, const RenderLayerModelObject* paintInvalidationContainer, MapCoordinatesFlags mode, const PaintInvalidationState* paintInvalidationState) const
 {
     TransformState transformState(TransformState::ApplyTransformDirection, localPoint);
-    mapLocalToContainer(paintInvalidationContainer, transformState, mode | ApplyContainerFlip | UseTransforms, wasFixed, paintInvalidationState);
+    mapLocalToContainer(paintInvalidationContainer, transformState, mode | ApplyContainerFlip | UseTransforms, paintInvalidationState);
     transformState.flatten();
 
     return transformState.lastPlanarPoint();

engine/core/rendering/RenderObject.h

@@ -102,10 +102,11 @@ enum MarkingBehavior {
 };
 
 enum MapCoordinatesMode {
-    IsFixed = 1 << 0,
-    UseTransforms = 1 << 1,
-    ApplyContainerFlip = 1 << 2,
-    TraverseDocumentBoundaries = 1 << 3,
+    UseTransforms = 1 << 0,
+    // FIXME(sky): What is this for? Do we need it?
+    ApplyContainerFlip = 1 << 1,
+    // FIXME(sky): Remove
+    TraverseDocumentBoundaries = 1 << 2,
 };
 typedef unsigned MapCoordinatesFlags;
 
@@ -631,16 +632,16 @@ public:
     FloatPoint absoluteToLocal(const FloatPoint&, MapCoordinatesFlags = 0) const;
 
     // Convert a local quad to absolute coordinates, taking transforms into account.
-    FloatQuad localToAbsoluteQuad(const FloatQuad& quad, MapCoordinatesFlags mode = 0, bool* wasFixed = 0) const
+    FloatQuad localToAbsoluteQuad(const FloatQuad& quad, MapCoordinatesFlags mode = 0) const
     {
-        return localToContainerQuad(quad, 0, mode, wasFixed);
+        return localToContainerQuad(quad, 0, mode);
     }
     // Convert an absolute quad to local coordinates.
     FloatQuad absoluteToLocalQuad(const FloatQuad&, MapCoordinatesFlags mode = 0) const;
 
     // Convert a local quad into the coordinate system of container, taking transforms into account.
-    FloatQuad localToContainerQuad(const FloatQuad&, const RenderLayerModelObject* paintInvalidatinoContainer, MapCoordinatesFlags = 0, bool* wasFixed = 0) const;
-    FloatPoint localToContainerPoint(const FloatPoint&, const RenderLayerModelObject* paintInvalidationContainer, MapCoordinatesFlags = 0, bool* wasFixed = 0, const PaintInvalidationState* = 0) const;
+    FloatQuad localToContainerQuad(const FloatQuad&, const RenderLayerModelObject* paintInvalidatinoContainer, MapCoordinatesFlags = 0) const;
+    FloatPoint localToContainerPoint(const FloatPoint&, const RenderLayerModelObject* paintInvalidationContainer, MapCoordinatesFlags = 0, const PaintInvalidationState* = 0) const;
 
     // Return the offset from the container() renderer (excluding transforms). In multi-column layout,
     // different offsets apply at different points, so return the offset that applies to the given point.
@@ -658,7 +659,7 @@ public:
     IntRect absoluteBoundingBoxRectIgnoringTransforms() const;
 
     // Build an array of quads in absolute coords for line boxes
-    virtual void absoluteQuads(Vector<FloatQuad>&, bool* /*wasFixed*/ = 0) const { }
+    virtual void absoluteQuads(Vector<FloatQuad>&) const { }
 
     virtual void absoluteFocusRingQuads(Vector<FloatQuad>&);
 
@@ -832,7 +833,7 @@ public:
 
     // Map points and quads through elements, potentially via 3d transforms. You should never need to call these directly; use
     // localToAbsolute/absoluteToLocal methods instead.
-    virtual void mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState&, MapCoordinatesFlags = ApplyContainerFlip, bool* wasFixed = 0, const PaintInvalidationState* = 0) const;
+    virtual void mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState&, MapCoordinatesFlags = ApplyContainerFlip, const PaintInvalidationState* = 0) const;
     virtual void mapAbsoluteToLocalPoint(MapCoordinatesFlags, TransformState&) const;
 
     // Pushes state onto RenderGeometryMap about how to map coordinates from this renderer to its container, or ancestorToStopAt (whichever is encountered first).

engine/core/rendering/RenderText.cpp

@@ -252,7 +252,7 @@ static FloatRect localQuadForTextBox(InlineTextBox* box, unsigned start, unsigne
     return FloatRect();
 }
 
-void RenderText::absoluteRectsForRange(Vector<IntRect>& rects, unsigned start, unsigned end, bool useSelectionHeight, bool* wasFixed)
+void RenderText::absoluteRectsForRange(Vector<IntRect>& rects, unsigned start, unsigned end, bool useSelectionHeight)
 {
     // Work around signed/unsigned issues. This function takes unsigneds, and is often passed UINT_MAX
     // to mean "all the way to the end". InlineTextBox coordinates are unsigneds, so changing this
@@ -278,12 +278,12 @@ void RenderText::absoluteRectsForRange(Vector<IntRect>& rects, unsigned start, u
                     r.setX(selectionRect.x().toFloat());
                 }
             }
-            rects.append(localToAbsoluteQuad(r, 0, wasFixed).enclosingBoundingBox());
+            rects.append(localToAbsoluteQuad(r, 0).enclosingBoundingBox());
         } else {
             // FIXME: This code is wrong. It's converting local to absolute twice. http://webkit.org/b/65722
             FloatRect rect = localQuadForTextBox(box, start, end, useSelectionHeight);
             if (!rect.isZero())
-                rects.append(localToAbsoluteQuad(rect, 0, wasFixed).enclosingBoundingBox());
+                rects.append(localToAbsoluteQuad(rect, 0).enclosingBoundingBox());
         }
     }
 }
@@ -312,7 +312,7 @@ static IntRect ellipsisRectForBox(InlineTextBox* box, unsigned startPos, unsigne
     return IntRect();
 }
 
-void RenderText::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed, ClippingOption option) const
+void RenderText::absoluteQuads(Vector<FloatQuad>& quads, ClippingOption option) const
 {
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
         FloatRect boundaries = box->calculateBoundaries();
@@ -326,16 +326,16 @@ void RenderText::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed, Clippin
             else
                 boundaries.setHeight(ellipsisRect.maxY() - boundaries.y());
         }
-        quads.append(localToAbsoluteQuad(boundaries, 0, wasFixed));
+        quads.append(localToAbsoluteQuad(boundaries, 0));
     }
 }
 
-void RenderText::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed) const
+void RenderText::absoluteQuads(Vector<FloatQuad>& quads) const
 {
-    absoluteQuads(quads, wasFixed, NoClipping);
+    absoluteQuads(quads, NoClipping);
 }
 
-void RenderText::absoluteQuadsForRange(Vector<FloatQuad>& quads, unsigned start, unsigned end, bool useSelectionHeight, bool* wasFixed)
+void RenderText::absoluteQuadsForRange(Vector<FloatQuad>& quads, unsigned start, unsigned end, bool useSelectionHeight)
 {
     // Work around signed/unsigned issues. This function takes unsigneds, and is often passed UINT_MAX
     // to mean "all the way to the end". InlineTextBox coordinates are unsigneds, so changing this
@@ -361,11 +361,11 @@ void RenderText::absoluteQuadsForRange(Vector<FloatQuad>& quads, unsigned start,
                     r.setX(selectionRect.x().toFloat());
                 }
             }
-            quads.append(localToAbsoluteQuad(r, 0, wasFixed));
+            quads.append(localToAbsoluteQuad(r, 0));
         } else {
             FloatRect rect = localQuadForTextBox(box, start, end, useSelectionHeight);
             if (!rect.isZero())
-                quads.append(localToAbsoluteQuad(rect, 0, wasFixed));
+                quads.append(localToAbsoluteQuad(rect, 0));
         }
     }
 }

engine/core/rendering/RenderText.h

@@ -60,13 +60,13 @@ public:
     void dirtyLineBoxes(bool fullLayout);
 
     virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const override final;
-    void absoluteRectsForRange(Vector<IntRect>&, unsigned startOffset = 0, unsigned endOffset = INT_MAX, bool useSelectionHeight = false, bool* wasFixed = 0);
+    void absoluteRectsForRange(Vector<IntRect>&, unsigned startOffset = 0, unsigned endOffset = INT_MAX, bool useSelectionHeight = false);
 
-    virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const override final;
-    void absoluteQuadsForRange(Vector<FloatQuad>&, unsigned startOffset = 0, unsigned endOffset = INT_MAX, bool useSelectionHeight = false, bool* wasFixed = 0);
+    virtual void absoluteQuads(Vector<FloatQuad>&) const override final;
+    void absoluteQuadsForRange(Vector<FloatQuad>&, unsigned startOffset = 0, unsigned endOffset = INT_MAX, bool useSelectionHeight = false);
 
     enum ClippingOption { NoClipping, ClipToEllipsis };
-    void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed = 0, ClippingOption = NoClipping) const;
+    void absoluteQuads(Vector<FloatQuad>&, ClippingOption = NoClipping) const;
 
     virtual PositionWithAffinity positionForPoint(const LayoutPoint&) override;
 

engine/core/rendering/RenderView.cpp

@@ -191,10 +191,8 @@ void RenderView::layout()
     clearNeedsLayout();
 }
 
-void RenderView::mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState& transformState, MapCoordinatesFlags mode, bool* wasFixed, const PaintInvalidationState* paintInvalidationState) const
+void RenderView::mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState& transformState, MapCoordinatesFlags mode, const PaintInvalidationState* paintInvalidationState) const
 {
-    ASSERT_UNUSED(wasFixed, !wasFixed || *wasFixed == static_cast<bool>(mode & IsFixed));
-
     if (!paintInvalidationContainer && mode & UseTransforms && shouldUseTransformFromContainer(0)) {
         TransformationMatrix t;
         getTransformFromContainer(0, LayoutSize(), t);
@@ -369,10 +367,8 @@ void RenderView::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumu
     rects.append(pixelSnappedIntRect(accumulatedOffset, layer()->size()));
 }
 
-void RenderView::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed) const
+void RenderView::absoluteQuads(Vector<FloatQuad>& quads) const
 {
-    if (wasFixed)
-        *wasFixed = false;
     quads.append(FloatRect(FloatPoint(), layer()->size()));
 }
 

engine/core/rendering/RenderView.h

@@ -98,7 +98,7 @@ public:
     void invalidatePaintForSelection() const;
 
     virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const override;
-    virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const override;
+    virtual void absoluteQuads(Vector<FloatQuad>&) const override;
 
     virtual LayoutRect viewRect() const override;
 
@@ -135,7 +135,7 @@ public:
     virtual void invalidateTreeIfNeeded(const PaintInvalidationState&) override final;
 
 private:
-    virtual void mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState&, MapCoordinatesFlags = ApplyContainerFlip, bool* wasFixed = 0, const PaintInvalidationState* = 0) const override;
+    virtual void mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState&, MapCoordinatesFlags = ApplyContainerFlip, const PaintInvalidationState* = 0) const override;
     virtual const RenderObject* pushMappingToContainer(const RenderLayerModelObject* ancestorToStopAt, RenderGeometryMap&) const override;
     virtual void mapAbsoluteToLocalPoint(MapCoordinatesFlags, TransformState&) const override;
     virtual void computeSelfHitTestRects(Vector<LayoutRect>&, const LayoutPoint& layerOffset) const override;

engine/core/rendering/compositing/CompositedLayerMapping.cpp

@@ -921,13 +921,13 @@ void CompositedLayerMapping::updateBackgroundLayerGeometry(const FloatSize& rela
 
 void CompositedLayerMapping::registerScrollingLayers()
 {
+    // FIXME(sky): Remove this whole function. I think this doesn't do anything now that we don't support position:fixed.
+
     // Register fixed position layers and their containers with the scrolling coordinator.
     ScrollingCoordinator* scrollingCoordinator = scrollingCoordinatorFromLayer(m_owningLayer);
     if (!scrollingCoordinator)
         return;
 
-    scrollingCoordinator->updateLayerPositionConstraint(&m_owningLayer);
-
     // Page scale is applied as a transform on the root render view layer. Because the scroll
     // layer is further up in the hierarchy, we need to avoid marking the root render view
     // layer as a container.

engine/public/platform/WebLayer.h

@@ -189,11 +189,6 @@ public:
     virtual void setIsContainerForFixedPositionLayers(bool) = 0;
     virtual bool isContainerForFixedPositionLayers() const = 0;
 
-    // This function sets layer position constraint. The constraint will be used
-    // to adjust layer position during threaded scrolling.
-    virtual void setPositionConstraint(const WebLayerPositionConstraint&) = 0;
-    virtual WebLayerPositionConstraint positionConstraint() const = 0;
-
     // The scroll client is notified when the scroll position of the WebLayer
     // changes. Only a single scroll client can be set for a WebLayer at a time.
     // The WebLayer does not take ownership of the scroll client, and it is the

engine/public/platform/WebLayerPositionConstraint.h

-/*
- * Copyright (C) 2013 Google 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
- *     documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef WebLayerPositionConstraint_h
-#define WebLayerPositionConstraint_h
-
-namespace blink {
-
-struct WebLayerPositionConstraint {
-    bool isFixedPosition     : 1;
-    bool isFixedToRightEdge  : 1;
-    bool isFixedToBottomEdge : 1;
-
-    WebLayerPositionConstraint()
-        : isFixedPosition(false)
-        , isFixedToRightEdge(false)
-        , isFixedToBottomEdge(false)
-    {
-    }
-
-    static WebLayerPositionConstraint fixedPosition(bool fixedToRightEdge, bool fixedToBottomEdge)
-    {
-        WebLayerPositionConstraint constraint;
-        constraint.isFixedPosition = true;
-        constraint.isFixedToRightEdge = fixedToRightEdge;
-        constraint.isFixedToBottomEdge = fixedToBottomEdge;
-        return constraint;
-    }
-};
-
-} // namespace blink
-
-#endif // WebLayerPositionConstraint_h

viewer/cc/web_layer_impl.cc

@@ -23,7 +23,6 @@
 #include "sky/engine/public/platform/WebFloatRect.h"
 #include "sky/engine/public/platform/WebGraphicsLayerDebugInfo.h"
 #include "sky/engine/public/platform/WebLayerClient.h"
-#include "sky/engine/public/platform/WebLayerPositionConstraint.h"
 #include "sky/engine/public/platform/WebLayerScrollClient.h"
 #include "sky/engine/public/platform/WebSize.h"
 #include "third_party/skia/include/utils/SkMatrix44.h"
@@ -388,33 +387,6 @@ bool WebLayerImpl::isContainerForFixedPositionLayers() const {
   return layer_->IsContainerForFixedPositionLayers();
 }
 
-static blink::WebLayerPositionConstraint ToWebLayerPositionConstraint(
-    const cc::LayerPositionConstraint& constraint) {
-  blink::WebLayerPositionConstraint web_constraint;
-  web_constraint.isFixedPosition = constraint.is_fixed_position();
-  web_constraint.isFixedToRightEdge = constraint.is_fixed_to_right_edge();
-  web_constraint.isFixedToBottomEdge = constraint.is_fixed_to_bottom_edge();
-  return web_constraint;
-}
-
-static cc::LayerPositionConstraint ToLayerPositionConstraint(
-    const blink::WebLayerPositionConstraint& web_constraint) {
-  cc::LayerPositionConstraint constraint;
-  constraint.set_is_fixed_position(web_constraint.isFixedPosition);
-  constraint.set_is_fixed_to_right_edge(web_constraint.isFixedToRightEdge);
-  constraint.set_is_fixed_to_bottom_edge(web_constraint.isFixedToBottomEdge);
-  return constraint;
-}
-
-void WebLayerImpl::setPositionConstraint(
-    const blink::WebLayerPositionConstraint& constraint) {
-  layer_->SetPositionConstraint(ToLayerPositionConstraint(constraint));
-}
-
-blink::WebLayerPositionConstraint WebLayerImpl::positionConstraint() const {
-  return ToWebLayerPositionConstraint(layer_->position_constraint());
-}
-
 void WebLayerImpl::setScrollClient(blink::WebLayerScrollClient* scroll_client) {
   if (scroll_client) {
     layer_->set_did_scroll_callback(

viewer/cc/web_layer_impl.h

@@ -125,9 +125,6 @@ class WebLayerImpl : public blink::WebLayer, public cc::LayerClient {
   virtual blink::WebVector<blink::WebRect> touchEventHandlerRegion() const;
   virtual void setIsContainerForFixedPositionLayers(bool is_container);
   virtual bool isContainerForFixedPositionLayers() const;
-  virtual void setPositionConstraint(
-      const blink::WebLayerPositionConstraint& constraint);
-  virtual blink::WebLayerPositionConstraint positionConstraint() const;
   virtual void setScrollClient(blink::WebLayerScrollClient* client);
   virtual bool isOrphan() const;
   virtual void setWebLayerClient(blink::WebLayerClient* client);