Attachment #155618 for bug #89238

View Details Raw Unified Return to Bug 89238

| Differences between



2012-07-31  Levi Weintraub  <leviw@chromium.org>

        Accumulate sub-pixel offsets through layers and transforms
        https://bugs.webkit.org/show_bug.cgi?id=89238

        Reviewed by NOBODY (OOPS!).

        Pixel snapping logic makes use of sub-pixel offsets accumulated when walking down
        the render tree. When we align RenderLayers to paint on pixel boundaries, we were
        also losing that accumulated value. This preserves the fractional offset and passes
        it to the RenderLayer's RenderObjects so they paint the proper size and offset.

        Also adding an enum to localTo[Container|Absolute] to switch between using pixel-
        snapped values or to maintain the higher precision versions.

        Test: fast/sub-pixel/sub-pixel-accumulates-to-layers.html

        * WebCore.exp.in:
        * css/CSSComputedStyleDeclaration.cpp:
        (WebCore::pixelSnappedSizingBox): Adding because sizing box improperly pixel snaps due
        to zero-ing out the location.
        (WebCore::computedTransform): Using pixel-snapped values when generating transforms.
        (WebCore::CSSComputedStyleDeclaration::getPropertyCSSValue):
        * platform/FractionalLayoutUnit.h:
        (WebCore::FractionalLayoutUnit::epsilon): Correcting epsilon calculations to use float
        math instead of integer.
        * rendering/RenderBlock.cpp:
        (WebCore::RenderBlock::addOverflowFromPositionedObjects): Accumulating offsets with
        LayoutUnits instead of truncating to integers.
        * rendering/RenderBox.cpp:
        (WebCore::RenderBox::mapLocalToContainer): Converting to using bit flags to select the
        mode and adding a mode for whether to use pixel snapping for transforms.
        (WebCore::RenderBox::computeRectForRepaint): Use pixel-snapped values for the
        when sending the values through the transform.
        (WebCore::RenderBox::layoutOverflowRectForPropagation): Ditto.
        * rendering/RenderBox.h:
        (RenderBox):
        * rendering/RenderGeometryMap.cpp:
        (WebCore::RenderGeometryMap::mapToAbsolute):
        * rendering/RenderInline.cpp:
        (WebCore::RenderInline::mapLocalToContainer):
        * rendering/RenderInline.h:
        (RenderInline):
        * rendering/RenderLayer.cpp:
        (WebCore::RenderLayer::updateTransform): Use pixel snapped values to generate the transform.
        (WebCore::RenderLayer::currentTransform): Ditto.
        (WebCore::RenderLayer::perspectiveTransform): Ditto.
        (WebCore::RenderLayer::paint): Support passing along the accumulated sub-pixel offset instead
        of rounding and use enclosingIntRect for the damageRect.
        (WebCore::RenderLayer::paintOverlayScrollbars): Updating to the new paintLayer contract.
        (WebCore::RenderLayer::paintLayer): Adding a sub-pixel accumulation LayoutSize. We pass this
        delta to the Layer's RenderObject when we paint, but align the graphics context to the proper
        pixel value.
        (WebCore::RenderLayer::paintLayerContentsAndReflection): Ditto.
        (WebCore::RenderLayer::paintLayerContents): Ditto.
        (WebCore::RenderLayer::paintList): Ditto.
        (WebCore::RenderLayer::paintChildLayerIntoColumns): Ditto.
        (WebCore::RenderLayer::hitTestChildLayerColumns): Use rounded coordinates for the transform.
        (WebCore::RenderLayer::calculateClipRects): Avoid unnecessary rounding when sub-pixel is enabled.
        (WebCore::RenderLayer::calculateRects): Remove unnecessary pixel snapping.
        * rendering/RenderLayer.h:
        (RenderLayer):
        * rendering/RenderLayerBacking.cpp:
        (WebCore::RenderLayerBacking::updateLayerTransform): Use pixel-snapped values for transforms.
        (WebCore::RenderLayerBacking::paintIntoLayer): Update to new paintLayer contract.
        * rendering/RenderObject.cpp:
        (WebCore::RenderObject::localToAbsolute): Supporting optionally pixel-snapping the values as we go.
        (WebCore::RenderObject::mapLocalToContainer): Ditto.
        (WebCore::RenderObject::localToContainerQuad): Ditto.
        (WebCore::RenderObject::localToContainerPoint): Ditto.
        * rendering/RenderObject.h:
        (WebCore::RenderObject::localToAbsoluteQuad): Ditto.
        (RenderObject):
        * rendering/RenderReplica.cpp:
        (WebCore::RenderReplica::paint): Updating to new paintLayer contract.
        * rendering/RenderView.cpp:
        (WebCore::RenderView::mapLocalToContainer):
        * rendering/RenderView.h:
        (RenderView):
        * rendering/style/RenderStyle.cpp:
        (WebCore::RenderStyle::applyTransform):
        * rendering/style/RenderStyle.h:
        * rendering/svg/RenderSVGForeignObject.cpp:
        (WebCore::RenderSVGForeignObject::mapLocalToContainer):
        * rendering/svg/RenderSVGForeignObject.h:
        (RenderSVGForeignObject):
        * rendering/svg/RenderSVGInline.cpp:
        (WebCore::RenderSVGInline::mapLocalToContainer):
        * rendering/svg/RenderSVGInline.h:
        (RenderSVGInline):
        * rendering/svg/RenderSVGModelObject.cpp:
        (WebCore::RenderSVGModelObject::mapLocalToContainer):
        * rendering/svg/RenderSVGModelObject.h:
        (RenderSVGModelObject):
        * rendering/svg/RenderSVGRoot.cpp:
        (WebCore::RenderSVGRoot::mapLocalToContainer):
        * rendering/svg/RenderSVGRoot.h:
        (RenderSVGRoot):
        * rendering/svg/RenderSVGText.cpp:
        (WebCore::RenderSVGText::mapLocalToContainer):
        * rendering/svg/RenderSVGText.h:
        (RenderSVGText):
        * rendering/svg/SVGRenderSupport.cpp:
        (WebCore::SVGRenderSupport::mapLocalToContainer):
        * rendering/svg/SVGRenderSupport.h:
        (SVGRenderSupport):

2012-07-31  Max Vujovic  <mvujovic@adobe.com>

        [CSS Shaders] CSS parser rejects parameter names that are also CSS keywords

Lines 1100-1106 __ZNK7WebCore11RenderStyle21visitedDepen Source/WebCore/WebCore.exp.in_sec1
- Source/WebCore/WebCore.exp.in -1 / +1 lines
1100	__ZNK7WebCore11ScriptValue9getStringEPN3JSC9ExecStateERN3WTF6StringE	1100	__ZNK7WebCore11ScriptValue9getStringEPN3JSC9ExecStateERN3WTF6StringE
1101	__ZNK7WebCore12RenderObject14enclosingLayerEv	1101	__ZNK7WebCore12RenderObject14enclosingLayerEv
1102	__ZNK7WebCore12RenderObject15localToAbsoluteERKNS_10FloatPointEbb	1102	__ZNK7WebCore12RenderObject15localToAbsoluteERKNS_10FloatPointEbb
1103	__ZNK7WebCore12RenderObject20localToContainerQuadERKNS_9FloatQuadEPNS_20RenderBoxModelObjectEbPb	1103	__ZNK7WebCore12RenderObject20localToContainerQuadERKNS_9FloatQuadEPNS_20RenderBoxModelObjectEbbPb
1104	__ZNK7WebCore12RenderObject23absoluteBoundingBoxRectEb	1104	__ZNK7WebCore12RenderObject23absoluteBoundingBoxRectEb
1105	__ZNK7WebCore12RenderObject39pixelSnappedAbsoluteClippedOverflowRectEv	1105	__ZNK7WebCore12RenderObject39pixelSnappedAbsoluteClippedOverflowRectEv
1106	__ZNK7WebCore12RenderObject7childAtEj	1106	__ZNK7WebCore12RenderObject7childAtEj



    return box->style()->boxSizing() == BORDER_BOX ? box->borderBoxRect() : box->computedCSSContentBoxRect();
}

static IntRect pixelSnappedSizingBox(RenderObject* renderer)
{
    if (!renderer->isBox())
        return IntRect();

    RenderBox* box = toRenderBox(renderer);
    return box->style()->boxSizing() == BORDER_BOX ? box->pixelSnappedBorderBoxRect() : pixelSnappedIntRect(box->computedCSSContentBoxRect());
}

static PassRefPtr<CSSValue> computedTransform(RenderObject* renderer, const RenderStyle* style)
{
    if (!renderer || style->transform().operations().isEmpty())
        return cssValuePool().createIdentifierValue(CSSValueNone);

    IntRect box = pixelSnappedSizingBox(renderer);

    TransformationMatrix transform;
    style->applyTransform(transform, box.size(), RenderStyle::ExcludeTransformOrigin);

Lines 3212-3218 GapRects RenderBlock::selectionGapRectsF Source/WebCore/rendering/RenderBlock.cpp_sec1
- Source/WebCore/rendering/RenderBlock.cpp -1 / +1 lines
3212		3212
3213	// FIXME: this is broken with transforms	3213	// FIXME: this is broken with transforms
3214	TransformState transformState(TransformState::ApplyTransformDirection, FloatPoint());	3214	TransformState transformState(TransformState::ApplyTransformDirection, FloatPoint());
3215	mapLocalToContainer(repaintContainer, false, false, transformState);	3215	mapLocalToContainer(repaintContainer, transformState);
3216	LayoutPoint offsetFromRepaintContainer = roundedLayoutPoint(transformState.mappedPoint());	3216	LayoutPoint offsetFromRepaintContainer = roundedLayoutPoint(transformState.mappedPoint());
3217		3217
3218	if (hasOverflowClip())	3218	if (hasOverflowClip())



    return cb->computeContentBoxLogicalHeight(logicalHeightLength.value());
}

void RenderBox::mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState& transformState, MapLocalToContainerFlags mode, bool* wasFixed) const
{
    if (repaintContainer == this)
        return;

    // 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 && !isFixedPos)
        mode &= ~IsFixed;
    else if (isFixedPos)
        mode |= IsFixed;

    if (wasFixed)
        *wasFixed = mode & IsFixed;
    
    LayoutSize containerOffset = offsetFromContainer(o, roundedLayoutPoint(transformState.mappedPoint()));
    if (mode & SnapOffsetForTransforms)
        containerOffset = roundedIntSize(containerOffset);
    
    bool preserve3D = mode & UseTransforms && (o->style()->preserves3D() || style()->preserves3D());
    if (mode & UseTransforms && shouldUseTransformFromContainer(o)) {
        TransformationMatrix t;
        getTransformFromContainer(o, containerOffset, t);
        transformState.applyTransform(t, preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform);

        return;
    }

    mode &= ~ApplyContainerFlip;
    if (o->isRenderFlowThread()) {
        // Transform from render flow coordinates into region coordinates.
        RenderRegion* region = toRenderFlowThread(o)->mapFromFlowToRegion(transformState);
        if (region)
            region->mapLocalToContainer(region->containerForRepaint(), transformState, mode, wasFixed);
        return;
    }

    o->mapLocalToContainer(repaintContainer, transformState, mode, wasFixed);
}

const RenderObject* RenderBox::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const

    // in the parent's coordinate space that encloses us.
    if (layer() && layer()->transform()) {
        fixed = position == FixedPosition;
        rect = layer()->transform()->mapRect(pixelSnappedIntRect(rect));
        topLeft = rect.location();
        topLeft.move(locationOffset());
    } else if (position == FixedPosition)

        flipForWritingMode(rect);
        
        if (hasTransform)
            rect = layer()->currentTransform().mapRect(pixelSnappedIntRect(rect));

        if (isRelPositioned())
            rect.move(relativePositionOffset());

Lines 518-524 protected: Source/WebCore/rendering/RenderBox.h_sec1
- Source/WebCore/rendering/RenderBox.h -1 / +1 lines
518		518
519	virtual bool shouldComputeSizeAsReplaced() const { return isReplaced() && !isInlineBlockOrInlineTable(); }	519	virtual bool shouldComputeSizeAsReplaced() const { return isReplaced() && !isInlineBlockOrInlineTable(); }
520		520
521	virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool fixed, bool useTransforms, TransformState&, ApplyContainerFlipOrNot = ApplyContainerFlip, bool* wasFixed = 0) const;	521	virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState&, MapLocalToContainerFlags mode = SnapOffsetForTransforms \| ApplyContainerFlip, bool* wasFixed = 0) const OVERRIDE;
522	virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject*, RenderGeometryMap&) const;	522	virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject*, RenderGeometryMap&) const;
523	virtual void mapAbsoluteToLocalPoint(bool fixed, bool useTransforms, TransformState&) const;	523	virtual void mapAbsoluteToLocalPoint(bool fixed, bool useTransforms, TransformState&) const;
524		524



{
    // If the mapping includes something like columns, we have to go via renderers.
    if (hasNonUniformStep()) {
        m_mapping.last().m_renderer->mapLocalToContainer(0, transformState, UseTransforms | ApplyContainerFlip | SnapOffsetForTransforms);
        m_mapping.last().m_renderer->mapLocalToContainer(0, fixed, true, transformState, RenderObject::ApplyContainerFlip);
        return;
    }
    



    return offset;
}

void RenderInline::mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState& transformState, MapLocalToContainerFlags mode, bool* wasFixed) const
{
    if (repaintContainer == this)
        return;

    if (!o)
        return;

    if (mode & ApplyContainerFlip && o->isBox()) {
        if (o->style()->isFlippedBlocksWritingMode()) {
            IntPoint centerPoint = roundedIntPoint(transformState.mappedPoint());
            transformState.move(toRenderBox(o)->flipForWritingModeIncludingColumns(centerPoint) - centerPoint);
        }
        mode &= ~ApplyContainerFlip;
    }

    LayoutSize containerOffset = offsetFromContainer(o, roundedLayoutPoint(transformState.mappedPoint()));
    if (mode & SnapOffsetForTransforms)
        containerOffset = roundedIntSize(containerOffset);

    bool preserve3D = mode & UseTransforms && (o->style()->preserves3D() || style()->preserves3D());
    if (mode & UseTransforms && shouldUseTransformFromContainer(o)) {
        TransformationMatrix t;
        getTransformFromContainer(o, containerOffset, t);
        transformState.applyTransform(t, preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform);

        return;
    }

    o->mapLocalToContainer(repaintContainer, transformState, mode, wasFixed);
}

const RenderObject* RenderInline::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const

Lines 135-141 private: Source/WebCore/rendering/RenderInline.h_sec1
- Source/WebCore/rendering/RenderInline.h -1 / +1 lines
135	virtual LayoutRect rectWithOutlineForRepaint(RenderBoxModelObject* repaintContainer, LayoutUnit outlineWidth) const;	135	virtual LayoutRect rectWithOutlineForRepaint(RenderBoxModelObject* repaintContainer, LayoutUnit outlineWidth) const;
136	virtual void computeRectForRepaint(RenderBoxModelObject* repaintContainer, LayoutRect&, bool fixed) const;	136	virtual void computeRectForRepaint(RenderBoxModelObject* repaintContainer, LayoutRect&, bool fixed) const;
137		137
138	virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool fixed, bool useTransforms, TransformState&, ApplyContainerFlipOrNot = ApplyContainerFlip, bool* wasFixed = 0) const;	138	virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState&, MapLocalToContainerFlags mode = SnapOffsetForTransforms \| ApplyContainerFlip, bool* wasFixed = 0) const OVERRIDE;
139	virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&) const;	139	virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&) const;
140		140
141	virtual VisiblePosition positionForPoint(const LayoutPoint&);	141	virtual VisiblePosition positionForPoint(const LayoutPoint&);



        RenderBox* box = renderBox();
        ASSERT(box);
        m_transform->makeIdentity();
        box->style()->applyTransform(*m_transform, box->pixelSnappedBorderBoxRect().size(), RenderStyle::IncludeTransformOrigin);
        makeMatrixRenderable(*m_transform, canRender3DTransforms());
    }


    if (renderer()->style()->isRunningAcceleratedAnimation()) {
        TransformationMatrix currTransform;
        RefPtr<RenderStyle> style = renderer()->animation()->getAnimatedStyleForRenderer(renderer());
        style->applyTransform(currTransform, renderBox()->pixelSnappedBorderBoxRect().size(), RenderStyle::IncludeTransformOrigin);
        makeMatrixRenderable(currTransform, canRender3DTransforms());
        return currTransform;
    }

        return TransformationMatrix();

    // Maybe fetch the perspective from the backing?
    const IntRect borderBox = toRenderBox(renderer())->pixelSnappedBorderBoxRect();
    const float boxWidth = borderBox.width();
    const float boxHeight = borderBox.height();


void RenderLayer::paint(GraphicsContext* context, const LayoutRect& damageRect, PaintBehavior paintBehavior, RenderObject* paintingRoot, RenderRegion* region, PaintLayerFlags paintFlags)
{
    OverlapTestRequestMap overlapTestRequests;
    paintLayer(this, context, enclosingIntRect(damageRect), LayoutSize(), paintBehavior, paintingRoot, region, &overlapTestRequests, paintFlags);
    OverlapTestRequestMap::iterator end = overlapTestRequests.end();
    for (OverlapTestRequestMap::iterator it = overlapTestRequests.begin(); it != end; ++it)
        it->first->setOverlapTestResult(false);

{
    if (!m_containsDirtyOverlayScrollbars)
        return;
    paintLayer(this, context, damageRect, LayoutSize(), paintBehavior, paintingRoot, 0, 0, PaintLayerHaveTransparency | PaintLayerTemporaryClipRects 
               | PaintLayerPaintingOverlayScrollbars);
    m_containsDirtyOverlayScrollbars = false;
}



void RenderLayer::paintLayer(RenderLayer* rootLayer, GraphicsContext* context,
                        const LayoutRect& paintDirtyRect, const LayoutSize& subPixelAccumulation, PaintBehavior paintBehavior,
                        RenderObject* paintingRoot, RenderRegion* region, OverlapTestRequestMap* overlapTestRequests,
                        PaintLayerFlags paintFlags)
{

        }

        // Adjust the transform such that the renderer's upper left corner will paint at (0,0) in user space.
        // This involves subtracting out the position of the layer in our current coordinate space, but preserving
        // the accumulated error for sub-pixel layout.
        LayoutPoint delta;
        convertToLayerCoords(rootLayer, delta);
        TransformationMatrix transform(layerTransform);
        IntPoint roundedDelta = roundedIntPoint(delta);
        transform.translateRight(roundedDelta.x(), roundedDelta.y());
        LayoutSize adjustedSubPixelAccumulation = subPixelAccumulation + (delta - roundedDelta);
        
        // Apply the transform.
        {

            context->concatCTM(transform.toAffineTransform());

            // Now do a paint with the root layer shifted to be us.
            paintLayerContentsAndReflection(this, context, enclosingIntRect(transform.inverse().mapRect(paintDirtyRect)), adjustedSubPixelAccumulation, paintBehavior, paintingRoot, region, overlapTestRequests, paintFlags);
        }        

        // Restore the clip.

        return;
    }
    
    paintLayerContentsAndReflection(rootLayer, context, paintDirtyRect, subPixelAccumulation, paintBehavior, paintingRoot, region, overlapTestRequests, paintFlags);
}

void RenderLayer::paintLayerContentsAndReflection(RenderLayer* rootLayer, GraphicsContext* context,
                        const LayoutRect& paintDirtyRect, const LayoutSize& subPixelAccumulation, PaintBehavior paintBehavior,
                        RenderObject* paintingRoot, RenderRegion* region, OverlapTestRequestMap* overlapTestRequests,
                        PaintLayerFlags paintFlags)
{

    if (m_reflection && !m_paintingInsideReflection) {
        // Mark that we are now inside replica painting.
        m_paintingInsideReflection = true;
        reflectionLayer()->paintLayer(rootLayer, context, paintDirtyRect, subPixelAccumulation, paintBehavior, paintingRoot, region, overlapTestRequests, localPaintFlags | PaintLayerPaintingReflection);
        m_paintingInsideReflection = false;
    }

    localPaintFlags |= PaintLayerPaintingCompositingAllPhases;
    paintLayerContents(rootLayer, context, paintDirtyRect, subPixelAccumulation, paintBehavior, paintingRoot, region, overlapTestRequests, localPaintFlags);
}

void RenderLayer::paintLayerContents(RenderLayer* rootLayer, GraphicsContext* context, 
                        const LayoutRect& parentPaintDirtyRect, const LayoutSize& subPixelAccumulation, PaintBehavior paintBehavior,
                        RenderObject* paintingRoot, RenderRegion* region, OverlapTestRequestMap* overlapTestRequests,
                        PaintLayerFlags paintFlags)
{

    
    if (shouldPaintContent || shouldPaintOutline || isPaintingOverlayScrollbars) {
        calculateRects(rootLayer, region, (localPaintFlags & PaintLayerTemporaryClipRects) ? TemporaryClipRects : PaintingClipRects, paintDirtyRect, layerBounds, damageRect, clipRectToApply, outlineRect);
        paintOffset = toPoint(layerBounds.location() - renderBoxLocation() + subPixelAccumulation);
    }

    bool forceBlackText = paintBehavior & PaintBehaviorForceBlackText;

    for (size_t i = 0; i < list->size(); ++i) {
        RenderLayer* childLayer = list->at(i);
        if (!childLayer->isPaginated())
            childLayer->paintLayer(rootLayer, context, paintDirtyRect, LayoutSize(), paintBehavior, paintingRoot, region, overlapTestRequests, paintFlags);
        else
            paintPaginatedChildLayer(childLayer, rootLayer, context, paintDirtyRect, paintBehavior, paintingRoot, region, overlapTestRequests, paintFlags);
    }

                newTransform.translateRight(roundToInt(offset.width()), roundToInt(offset.height()));
                
                childLayer->m_transform = adoptPtr(new TransformationMatrix(newTransform));
                childLayer->paintLayer(rootLayer, context, localDirtyRect, LayoutSize(), paintBehavior, paintingRoot, region, overlapTestRequests, paintFlags);
                if (oldHasTransform)
                    childLayer->m_transform = adoptPtr(new TransformationMatrix(oldTransform));
                else

        // some transformed layer boundary, for example, in the RenderLayerCompositor overlapMap, where
        // clipRects are needed in view space.
        LayoutPoint offset;
        offset = roundedLayoutPoint(renderer()->localToContainerPoint(FloatPoint(), rootLayer->renderer(), true, false, 0));
        RenderView* view = renderer()->view();
        ASSERT(view);
        if (view && clipRects.fixed() && rootLayer->renderer() == view) {

            backgroundRect.intersect(layerBoundsWithVisualOverflow);
        } else {
            // Shift the bounds to be for our region only.
            LayoutRect bounds = renderBox()->borderBoxRectInRegion(region);
            bounds.moveBy(offset);
            backgroundRect.intersect(bounds);
        }




    void updateCompositingAndLayerListsIfNeeded();

    void paintLayer(RenderLayer* rootLayer, GraphicsContext*, const LayoutRect& paintDirtyRect, const LayoutSize& subPixelAccumulation,
                    PaintBehavior, RenderObject* paintingRoot, RenderRegion* = 0, OverlapTestRequestMap* = 0,
                    PaintLayerFlags = 0);
    void paintLayerContentsAndReflection(RenderLayer* rootLayer, GraphicsContext*, const LayoutRect& paintDirtyRect, const LayoutSize& subPixelAccumulation,
                    PaintBehavior, RenderObject* paintingRoot, RenderRegion* = 0, OverlapTestRequestMap* = 0,
                    PaintLayerFlags = 0);
    void paintLayerContents(RenderLayer* rootLayer, GraphicsContext*, const LayoutRect& paintDirtyRect, const LayoutSize& subPixelAccumulation,
                    PaintBehavior, RenderObject* paintingRoot, RenderRegion* = 0, OverlapTestRequestMap* = 0,
                    PaintLayerFlags = 0);
    void paintList(Vector<RenderLayer*>*, RenderLayer* rootLayer, GraphicsContext* p,



    // baked into it, and we don't want that.
    TransformationMatrix t;
    if (m_owningLayer->hasTransform()) {
        style->applyTransform(t, toRenderBox(renderer())->pixelSnappedBorderBoxRect().size(), RenderStyle::ExcludeTransformOrigin);
        makeMatrixRenderable(t, compositor()->canRender3DTransforms());
    }
    

        paintFlags |= RenderLayer::PaintLayerPaintingCompositingMaskPhase;
        
    // FIXME: GraphicsLayers need a way to split for RenderRegions.
    m_owningLayer->paintLayerContents(rootLayer, context, paintDirtyRect, LayoutSize(), paintBehavior, paintingRoot, 0, 0, paintFlags);

    if (m_owningLayer->containsDirtyOverlayScrollbars())
        m_owningLayer->paintOverlayScrollbars(context, paintDirtyRect, paintBehavior, paintingRoot);



FloatPoint RenderObject::localToAbsolute(const FloatPoint& localPoint, bool fixed, bool useTransforms) const
{
    TransformState transformState(TransformState::ApplyTransformDirection, localPoint);
    MapLocalToContainerFlags mode = ApplyContainerFlip;
    if (fixed)
        mode |= IsFixed;
    if (useTransforms)
        mode |= useTransforms;
    mapLocalToContainer(0, transformState, mode);
    transformState.flatten();
    
    return transformState.lastPlanarPoint();

    return transformState.lastPlanarPoint();
}

void RenderObject::mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState& transformState, MapLocalToContainerFlags mode, bool* wasFixed) const
{
    if (repaintContainer == this)
        return;


    // FIXME: this should call offsetFromContainer to share code, but I'm not sure it's ever called.
    LayoutPoint centerPoint = roundedLayoutPoint(transformState.mappedPoint());
    if (mode & ApplyContainerFlip && o->isBox()) {
        if (o->style()->isFlippedBlocksWritingMode())
            transformState.move(toRenderBox(o)->flipForWritingModeIncludingColumns(roundedLayoutPoint(transformState.mappedPoint())) - centerPoint);
        mode &= ~ApplyContainerFlip;
    }

    LayoutSize columnOffset;

    if (o->hasOverflowClip())
        transformState.move(-toRenderBox(o)->scrolledContentOffset());

    o->mapLocalToContainer(repaintContainer, transformState, mode, wasFixed);
}

const RenderObject* RenderObject::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const

#endif
}

FloatQuad RenderObject::localToContainerQuad(const FloatQuad& localQuad, RenderBoxModelObject* repaintContainer, bool snapOffsetForTransforms, bool fixed, bool* wasFixed) 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);
    MapLocalToContainerFlags mode = ApplyContainerFlip | UseTransforms;
    if (fixed)
        mode |= IsFixed;
    if (snapOffsetForTransforms)
        mode |= SnapOffsetForTransforms;
    mapLocalToContainer(repaintContainer, transformState, mode, wasFixed);
    transformState.flatten();
    
    return transformState.lastPlanarQuad();
}

FloatPoint RenderObject::localToContainerPoint(const FloatPoint& localPoint, RenderBoxModelObject* repaintContainer, bool snapOffsetForTransforms, bool fixed, bool* wasFixed) const
{
    TransformState transformState(TransformState::ApplyTransformDirection, localPoint);
    MapLocalToContainerFlags mode = ApplyContainerFlip | UseTransforms;
    if (fixed)
        mode |= IsFixed;
    if (snapOffsetForTransforms)
        mode |= SnapOffsetForTransforms;
    mapLocalToContainer(repaintContainer, transformState, mode, wasFixed);
    transformState.flatten();

    return transformState.lastPlanarPoint();



    DoNotPlaceGeneratedRunIn
};

enum MapLocalToContainerMode {
    IsFixed = 1 << 0,
    UseTransforms = 1 << 1,
    ApplyContainerFlip = 1 << 2,
    SnapOffsetForTransforms = 1 << 3
};
typedef unsigned MapLocalToContainerFlags;

const int caretWidth = 1;

#if ENABLE(DASHBOARD_SUPPORT)

    // Convert a local quad to absolute coordinates, taking transforms into account.
    FloatQuad localToAbsoluteQuad(const FloatQuad& quad, bool fixed = false, bool* wasFixed = 0) const
    {
        return localToContainerQuad(quad, 0, true, fixed, wasFixed);
    }

    // Convert a local quad into the coordinate system of container, taking transforms into account.
    FloatQuad localToContainerQuad(const FloatQuad&, RenderBoxModelObject* repaintContainer, bool snapOffsetsForTransforms = true, bool fixed = false, bool* wasFixed = 0) const;
    FloatPoint localToContainerPoint(const FloatPoint&, RenderBoxModelObject* repaintContainer, bool snapOffsetsForTransforms = true, bool fixed = false, bool* wasFixed = 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.


    // 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(RenderBoxModelObject* repaintContainer, TransformState&, MapLocalToContainerFlags mode = SnapOffsetForTransforms | ApplyContainerFlip, bool* wasFixed = 0) const;
    virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool useTransforms, bool fixed, TransformState&, ApplyContainerFlipOrNot = ApplyContainerFlip, bool* wasFixed = 0) const;
    virtual void mapAbsoluteToLocalPoint(bool fixed, bool useTransforms, TransformState&) const;

    // Pushes state onto RenderGeometryMap about how to map coordinates from this renderer to its container, or ancestorToStopAt (whichever is encountered first).

Lines 71-77 void RenderReplica::paint(PaintInfo& pai Source/WebCore/rendering/RenderReplica.cpp_sec1
- Source/WebCore/rendering/RenderReplica.cpp -1 / +1 lines
71	// Turn around and paint the parent layer. Use temporary clipRects, so that the layer doesn't end up caching clip rects	71	// Turn around and paint the parent layer. Use temporary clipRects, so that the layer doesn't end up caching clip rects
72	// computing using the wrong rootLayer	72	// computing using the wrong rootLayer
73	layer()->parent()->paintLayer(layer()->transform() ? layer()->parent() : layer()->enclosingTransformedAncestor(),	73	layer()->parent()->paintLayer(layer()->transform() ? layer()->parent() : layer()->enclosingTransformedAncestor(),
74	paintInfo.context, paintInfo.rect,	74	paintInfo.context, paintInfo.rect, LayoutSize(),
75	PaintBehaviorNormal, 0, paintInfo.renderRegion, 0,	75	PaintBehaviorNormal, 0, paintInfo.renderRegion, 0,
76	RenderLayer::PaintLayerHaveTransparency \| RenderLayer::PaintLayerAppliedTransform \| RenderLayer::PaintLayerTemporaryClipRects \| RenderLayer::PaintLayerPaintingReflection);	76	RenderLayer::PaintLayerHaveTransparency \| RenderLayer::PaintLayerAppliedTransform \| RenderLayer::PaintLayerTemporaryClipRects \| RenderLayer::PaintLayerPaintingReflection);
77	else if (paintInfo.phase == PaintPhaseMask)	77	else if (paintInfo.phase == PaintPhaseMask)



    setNeedsLayout(false);
}

void RenderView::mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState& transformState, MapLocalToContainerFlags mode, bool* wasFixed) const
{
    // If a container was specified, and was not 0 or the RenderView,
    // then we should have found it by now.
    ASSERT_ARG(repaintContainer, !repaintContainer || repaintContainer == this);
    ASSERT_UNUSED(wasFixed, !wasFixed || *wasFixed == (mode & IsFixed));

    if (!repaintContainer && mode & UseTransforms && shouldUseTransformFromContainer(0)) {
        TransformationMatrix t;
        getTransformFromContainer(0, LayoutSize(), t);
        transformState.applyTransform(t);
    }
    
    if (mode & IsFixed && m_frameView)
        transformState.move(m_frameView->scrollOffsetForFixedPosition());
}


Lines 206-212 public: Source/WebCore/rendering/RenderView.h_sec1
- Source/WebCore/rendering/RenderView.h -1 / +1 lines
206	bool hasRenderCounters() { return m_renderCounterCount; }	206	bool hasRenderCounters() { return m_renderCounterCount; }
207		207
208	protected:	208	protected:
209	virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool useTransforms, bool fixed, TransformState&, ApplyContainerFlipOrNot = ApplyContainerFlip, bool* wasFixed = 0) const;	209	virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState&, MapLocalToContainerFlags mode = SnapOffsetForTransforms \| ApplyContainerFlip, bool* wasFixed = 0) const OVERRIDE;
210	virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&) const;	210	virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&) const;
211	virtual void mapAbsoluteToLocalPoint(bool fixed, bool useTransforms, TransformState&) const;	211	virtual void mapAbsoluteToLocalPoint(bool fixed, bool useTransforms, TransformState&) const;
212	virtual bool requiresColumns(int desiredColumnCount) const OVERRIDE;	212	virtual bool requiresColumns(int desiredColumnCount) const OVERRIDE;

Lines 813-819 inline bool requireTransformOrigin(const Source/WebCore/rendering/style/RenderStyle.cpp_sec1
- Source/WebCore/rendering/style/RenderStyle.cpp -1 / +1 lines
813	return false;	813	return false;
814	}	814	}
815		815
816	void RenderStyle::applyTransform(TransformationMatrix& transform, const LayoutSize& borderBoxSize, ApplyTransformOrigin applyOrigin) const	816	void RenderStyle::applyTransform(TransformationMatrix& transform, const IntSize& borderBoxSize, ApplyTransformOrigin applyOrigin) const
817	{	817	{
818	// FIXME: when subpixel layout is supported (bug 71143) the body of this function could be replaced by	818	// FIXME: when subpixel layout is supported (bug 71143) the body of this function could be replaced by
819	// applyTransform(transform, FloatRect(FloatPoint(), borderBoxSize), applyOrigin);	819	// applyTransform(transform, FloatRect(FloatPoint(), borderBoxSize), applyOrigin);

Lines 893-899 public: Source/WebCore/rendering/style/RenderStyle.h_sec1
- Source/WebCore/rendering/style/RenderStyle.h -1 / +1 lines
893	bool hasTransformRelatedProperty() const { return hasTransform() \|\| preserves3D() \|\| hasPerspective(); }	893	bool hasTransformRelatedProperty() const { return hasTransform() \|\| preserves3D() \|\| hasPerspective(); }
894		894
895	enum ApplyTransformOrigin { IncludeTransformOrigin, ExcludeTransformOrigin };	895	enum ApplyTransformOrigin { IncludeTransformOrigin, ExcludeTransformOrigin };
896	void applyTransform(TransformationMatrix&, const LayoutSize& borderBoxSize, ApplyTransformOrigin = IncludeTransformOrigin) const;	896	void applyTransform(TransformationMatrix&, const IntSize& borderBoxSize, ApplyTransformOrigin = IncludeTransformOrigin) const;
897	void applyTransform(TransformationMatrix&, const FloatRect& boundingBox, ApplyTransformOrigin = IncludeTransformOrigin) const;	897	void applyTransform(TransformationMatrix&, const FloatRect& boundingBox, ApplyTransformOrigin = IncludeTransformOrigin) const;
898	void setPageScaleTransform(float);	898	void setPageScaleTransform(float);
899		899



    return false;
}

void RenderSVGForeignObject::mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState& transformState, MapLocalToContainerFlags mode, bool* wasFixed) const
{
    SVGRenderSupport::mapLocalToContainer(this, repaintContainer, transformState, mode & SnapOffsetForTransforms, wasFixed);
}

const RenderObject* RenderSVGForeignObject::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const

Lines 54-60 public: Source/WebCore/rendering/svg/RenderSVGForeignObject.h_sec1
- Source/WebCore/rendering/svg/RenderSVGForeignObject.h -1 / +1 lines
54	virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestPoint& pointInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) OVERRIDE;	54	virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestPoint& pointInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) OVERRIDE;
55	virtual bool isSVGForeignObject() const { return true; }	55	virtual bool isSVGForeignObject() const { return true; }
56		56
57	virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool fixed, bool useTransforms, TransformState&, ApplyContainerFlipOrNot = ApplyContainerFlip, bool* wasFixed = 0) const;	57	virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState&, MapLocalToContainerFlags mode = SnapOffsetForTransforms \| ApplyContainerFlip, bool* wasFixed = 0) const OVERRIDE;
58	virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&) const;	58	virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&) const;
59	virtual void setNeedsTransformUpdate() { m_needsTransformUpdate = true; }	59	virtual void setNeedsTransformUpdate() { m_needsTransformUpdate = true; }
60		60



    SVGRenderSupport::computeFloatRectForRepaint(this, repaintContainer, repaintRect, fixed);
}

void RenderSVGInline::mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState& transformState, MapLocalToContainerFlags mode, bool* wasFixed) const
{
    SVGRenderSupport::mapLocalToContainer(this, repaintContainer, transformState, mode & SnapOffsetForTransforms, wasFixed);
}

const RenderObject* RenderSVGInline::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const

Lines 47-53 public: Source/WebCore/rendering/svg/RenderSVGInline.h_sec1
- Source/WebCore/rendering/svg/RenderSVGInline.h -1 / +1 lines
47		47
48	virtual LayoutRect clippedOverflowRectForRepaint(RenderBoxModelObject* repaintContainer) const;	48	virtual LayoutRect clippedOverflowRectForRepaint(RenderBoxModelObject* repaintContainer) const;
49	virtual void computeFloatRectForRepaint(RenderBoxModelObject* repaintContainer, FloatRect&, bool fixed = false) const;	49	virtual void computeFloatRectForRepaint(RenderBoxModelObject* repaintContainer, FloatRect&, bool fixed = false) const;
50	virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool useTransforms, bool fixed, TransformState&, ApplyContainerFlipOrNot = ApplyContainerFlip, bool* wasFixed = 0) const;	50	virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState&, MapLocalToContainerFlags mode = SnapOffsetForTransforms \| ApplyContainerFlip, bool* wasFixed = 0) const OVERRIDE;
51	virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&) const;	51	virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&) const;
52	virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const;	52	virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const;
53		53



    SVGRenderSupport::computeFloatRectForRepaint(this, repaintContainer, repaintRect, fixed);
}

void RenderSVGModelObject::mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState& transformState, MapLocalToContainerFlags mode, bool* wasFixed) const
{
    SVGRenderSupport::mapLocalToContainer(this, repaintContainer, transformState, mode & SnapOffsetForTransforms, wasFixed);
}

const RenderObject* RenderSVGModelObject::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const

Lines 58-64 public: Source/WebCore/rendering/svg/RenderSVGModelObject.h_sec1
- Source/WebCore/rendering/svg/RenderSVGModelObject.h -1 / +1 lines
58	virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const;	58	virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const;
59	virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const;	59	virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const;
60		60
61	virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool useTransforms, bool fixed, TransformState&, ApplyContainerFlipOrNot = ApplyContainerFlip, bool* wasFixed = 0) const;	61	virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState&, MapLocalToContainerFlags mode = SnapOffsetForTransforms \| ApplyContainerFlip, bool* wasFixed = 0) const OVERRIDE;
62	virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&) const;	62	virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&) const;
63	virtual void styleWillChange(StyleDifference, const RenderStyle* newStyle);	63	virtual void styleWillChange(StyleDifference, const RenderStyle* newStyle);
64	virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);	64	virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);



// This method expects local CSS box coordinates.
// Callers with local SVG viewport coordinates should first apply the localToBorderBoxTransform
// to convert from SVG viewport coordinates to local CSS box coordinates.
void RenderSVGRoot::mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState& transformState, MapLocalToContainerFlags mode, bool* wasFixed) const
{
    ASSERT(mode & !IsFixed); // We should have no fixed content in the SVG rendering tree.
    ASSERT(mode & UseTransforms); // mapping a point through SVG w/o respecting trasnforms is useless.

    RenderReplaced::mapLocalToContainer(repaintContainer, transformState, mode | ApplyContainerFlip, wasFixed);
}

const RenderObject* RenderSVGRoot::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const

Lines 95-101 private: Source/WebCore/rendering/svg/RenderSVGRoot.h_sec1
- Source/WebCore/rendering/svg/RenderSVGRoot.h -1 / +1 lines
95	virtual LayoutRect clippedOverflowRectForRepaint(RenderBoxModelObject* repaintContainer) const;	95	virtual LayoutRect clippedOverflowRectForRepaint(RenderBoxModelObject* repaintContainer) const;
96	virtual void computeFloatRectForRepaint(RenderBoxModelObject* repaintContainer, FloatRect& repaintRect, bool fixed) const;	96	virtual void computeFloatRectForRepaint(RenderBoxModelObject* repaintContainer, FloatRect& repaintRect, bool fixed) const;
97		97
98	virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool useTransforms, bool fixed, TransformState&, ApplyContainerFlipOrNot = ApplyContainerFlip, bool* wasFixed = 0) const;	98	virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState&, MapLocalToContainerFlags mode = SnapOffsetForTransforms \| ApplyContainerFlip, bool* wasFixed = 0) const OVERRIDE;
99	virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&) const;	99	virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&) const;
100		100
101	virtual bool canBeSelectionLeaf() const { return false; }	101	virtual bool canBeSelectionLeaf() const { return false; }



    SVGRenderSupport::computeFloatRectForRepaint(this, repaintContainer, repaintRect, fixed);
}

void RenderSVGText::mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState& transformState, MapLocalToContainerFlags mode, bool* wasFixed) const
{
    SVGRenderSupport::mapLocalToContainer(this, repaintContainer, transformState, mode & SnapOffsetForTransforms, wasFixed);
}

const RenderObject* RenderSVGText::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const

Lines 75-81 private: Source/WebCore/rendering/svg/RenderSVGText.h_sec1
- Source/WebCore/rendering/svg/RenderSVGText.h -1 / +1 lines
75	virtual void computeRectForRepaint(RenderBoxModelObject* repaintContainer, LayoutRect&, bool fixed = false) const;	75	virtual void computeRectForRepaint(RenderBoxModelObject* repaintContainer, LayoutRect&, bool fixed = false) const;
76	virtual void computeFloatRectForRepaint(RenderBoxModelObject* repaintContainer, FloatRect&, bool fixed = false) const;	76	virtual void computeFloatRectForRepaint(RenderBoxModelObject* repaintContainer, FloatRect&, bool fixed = false) const;
77		77
78	virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool useTransforms, bool fixed, TransformState&, ApplyContainerFlipOrNot = ApplyContainerFlip, bool* wasFixed = 0) const;	78	virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState&, MapLocalToContainerFlags mode = SnapOffsetForTransforms \| ApplyContainerFlip, bool* wasFixed = 0) const OVERRIDE;
79	virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&) const;	79	virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&) const;
80	virtual void addChild(RenderObject* child, RenderObject* beforeChild = 0);	80	virtual void addChild(RenderObject* child, RenderObject* beforeChild = 0);
81	virtual void removeChild(RenderObject*) OVERRIDE;	81	virtual void removeChild(RenderObject*) OVERRIDE;

Lines 71-77 void SVGRenderSupport::computeFloatRectF Source/WebCore/rendering/svg/SVGRenderSupport.cpp_sec1
- Source/WebCore/rendering/svg/SVGRenderSupport.cpp -3 / +6 lines
71	object->parent()->computeFloatRectForRepaint(repaintContainer, repaintRect, fixed);	71	object->parent()->computeFloatRectForRepaint(repaintContainer, repaintRect, fixed);
72	}	72	}
73		73
74	void SVGRenderSupport::mapLocalToContainer(const RenderObject* object, RenderBoxModelObject* repaintContainer, TransformState& transformState, bool* wasFixed)	74	void SVGRenderSupport::mapLocalToContainer(const RenderObject* object, RenderBoxModelObject* repaintContainer, TransformState& transformState, bool snapOffsetForTransforms, bool* wasFixed)
75	{	75	{
76	transformState.applyTransform(object->localToParentTransform());	76	transformState.applyTransform(object->localToParentTransform());
77		77
Lines 82-89 void SVGRenderSupport::mapLocalToContain Source/WebCore/rendering/svg/SVGRenderSupport.cpp_sec2
82	// RenderSVGRoot's mapLocalToContainer method expects CSS box coordinates.	82	// RenderSVGRoot's mapLocalToContainer method expects CSS box coordinates.
83	if (parent->isSVGRoot())	83	if (parent->isSVGRoot())
84	transformState.applyTransform(toRenderSVGRoot(parent)->localToBorderBoxTransform());	84	transformState.applyTransform(toRenderSVGRoot(parent)->localToBorderBoxTransform());
85		85
86	parent->mapLocalToContainer(repaintContainer, false, true, transformState, RenderObject::DoNotApplyContainerFlip, wasFixed);	86	MapLocalToContainerFlags mode = UseTransforms;
		87	if (snapOffsetForTransforms)
		88	mode \|= SnapOffsetForTransforms;
		89	parent->mapLocalToContainer(repaintContainer, transformState, mode, wasFixed);
87	}	90	}
88		91
89	const RenderObject* SVGRenderSupport::pushMappingToContainer(const RenderObject* object, const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap)	92	const RenderObject* SVGRenderSupport::pushMappingToContainer(const RenderObject* object, const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap)



#if ENABLE(SVG)
#include "LayoutTypes.h"
#include "PaintInfo.h"
#include "RenderObject.h"

namespace WebCore {


class ImageBuffer;
class RenderBoxModelObject;
class RenderGeometryMap;
class RenderObject;
class RenderStyle;
class RenderSVGRoot;
class TransformState;

    // Important functions used by nearly all SVG renderers centralizing coordinate transformations / repaint rect calculations
    static LayoutRect clippedOverflowRectForRepaint(const RenderObject*, RenderBoxModelObject* repaintContainer);
    static void computeFloatRectForRepaint(const RenderObject*, RenderBoxModelObject* repaintContainer, FloatRect&, bool fixed);
    static void mapLocalToContainer(const RenderObject*, RenderBoxModelObject* repaintContainer, TransformState&, bool snapOffsetsForTransforms = true, bool* wasFixed = 0);
    static const RenderObject* pushMappingToContainer(const RenderObject*, const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&);

    // Shared between SVG renderers and resources.



2012-07-31  Levi Weintraub  <leviw@chromium.org>

        Accumulate sub-pixel offsets through layers and transforms
        https://bugs.webkit.org/show_bug.cgi?id=89238

        Reviewed by NOBODY (OOPS!).

        * fast/sub-pixel/sub-pixel-accumulates-to-layers.html: Added.
        * platform/chromium-mac-snowleopard/compositing/shadows/shadow-drawing-expected.png:
        * platform/chromium-mac-snowleopard/fast/sub-pixel/sub-pixel-accumulates-to-layers-expected.png: Added.
        * platform/chromium-mac-snowleopard/fast/sub-pixel/sub-pixel-accumulates-to-layers-expected.txt: Added.
        * platform/chromium-mac-snowleopard/fast/transforms/rotated-transform-affects-scrolling-1-expected.png:
        * platform/chromium-mac-snowleopard/fast/transforms/rotated-transform-affects-scrolling-2-expected.png:
        * platform/chromium-mac/fast/clip/overflow-border-radius-composited-expected.txt:
        * platform/chromium-mac/fast/clip/overflow-border-radius-transformed-expected.txt:
        * platform/chromium-mac/fast/forms/validation-message-appearance-expected.txt:
        * platform/chromium-mac/fast/repaint/scroll-fixed-layer-with-transformed-parent-layer-expected.png:
        * platform/chromium-mac/fast/transforms/transformed-document-element-expected.png:
        * platform/chromium-mac/svg/transforms/svg-css-transforms-expected.png:
        * platform/chromium-mac/transforms/svg-vs-css-expected.png:
        * platform/chromium/TestExpectations:
        * platform/chromium/fast/transforms/rotated-transform-affects-scrolling-1-expected.txt:
        * platform/chromium/fast/transforms/rotated-transform-affects-scrolling-2-expected.txt:
        * platform/efl/Skipped:
        * platform/gtk/TestExpectations:
        * platform/mac-lion/Skipped:
        * platform/mac-snowleopard/Skipped:
        * platform/mac-wk2/Skipped:
        * platform/mac/Skipped:
        * platform/qt-4.8/Skipped:
        * platform/qt/Skipped:
        * platform/win-wk2/Skipped:
        * platform/win-xp/Skipped:
        * platform/win/Skipped:
        * platform/wincairo/Skipped:
        * platform/wk2/Skipped:

2012-07-31  Max Vujovic  <mvujovic@adobe.com>

        [CSS Shaders] CSS parser rejects parameter names that are also CSS keywords




<!DOCTYPE html>
<html>
<head>
<style>
body {
    margin: 0;
    zoom: 0.9;
    -webkit-transform: scale(40);
    -webkit-transform-origin: 0 0;
}

.container {
    position: absolute;
    top: 0px;
    left: 0px;
    width: 16px;
    height: 16px;
}

.container > div {
    position: absolute;
    top: 0;
    left: 50%;
    width: 1.6px;
    height: 8px;
    margin-left:  -0.8px;

    background-color: red;
}
.rotated > div {
    background-color: green !important;
    -webkit-transform: rotateZ(0);
}
</style>
</head>
<body>
    <div class="container"><div></div></div>
    <div class="container rotated"><div></div></div>
</body>
</html>



layer at (0,0) size 32000x585
  RenderView at (0,0) size 800x585
layer at (0,0) size 800x0
  RenderBlock {HTML} at (0,0) size 800x0
layer at (0,0) size 14x14
  RenderBlock (positioned) {DIV} at (0,0) size 15x15
layer at (6,0) size 2x7
  RenderBlock (positioned) {DIV} at (6,0) size 2x8 [bgcolor=#FF0000]
layer at (0,0) size 14x14
  RenderBlock (positioned) {DIV} at (0,0) size 15x15
layer at (6,0) size 2x7
  RenderBlock (positioned) {DIV} at (6,0) size 2x8 [bgcolor=#008000]



        text run at (240,178) width 4: " "
      RenderBR {BR} at (244,192) size 0x0
      RenderText {#text} at (0,0) size 0x0
layer at (18,36) size 220x120 clip at (28,46) size 200x100 scrollWidth 207 scrollHeight 157
  RenderBlock {DIV} at (10,28) size 220x120 [border: (10px solid #000000)]
layer at (262,36) size 220x120 clip at (272,46) size 200x100 scrollWidth 207 scrollHeight 157
  RenderBlock {DIV} at (254,28) size 220x120 [border: (10px solid #000000)]
layer at (28,46) size 200x100
  RenderBlock {DIV} at (10,10) size 200x100 [color=#FFFFFF] [bgcolor=#808080]

  RenderBlock (relative positioned) {DIV} at (10,10) size 200x100 [color=#FFFFFF] [bgcolor=#808080]
    RenderText {#text} at (0,0) size 95x18
      text run at (0,0) width 95: "static > relative"
layer at (506,36) size 220x120 clip at (516,46) size 200x100 scrollWidth 207 scrollHeight 157
  RenderBlock (relative positioned) {DIV} at (498,28) size 220x120 [border: (10px solid #000000)]
layer at (516,46) size 200x100
  RenderBlock {DIV} at (10,10) size 200x100 [color=#FFFFFF] [bgcolor=#808080]
    RenderText {#text} at (0,0) size 95x18
      text run at (0,0) width 95: "relative > static"
layer at (18,176) size 220x120 clip at (28,186) size 200x100 scrollWidth 207 scrollHeight 157
  RenderBlock (relative positioned) {DIV} at (10,168) size 220x120 [border: (10px solid #000000)]
layer at (28,186) size 200x100
  RenderBlock (relative positioned) {DIV} at (10,10) size 200x100 [color=#FFFFFF] [bgcolor=#808080]
    RenderText {#text} at (0,0) size 109x18
      text run at (0,0) width 109: "relative > relative"
layer at (18,316) size 220x120 clip at (28,326) size 200x100 scrollWidth 207 scrollHeight 157
  RenderBlock (relative positioned) {DIV} at (10,308) size 220x120 [border: (10px solid #000000)]
layer at (28,326) size 200x100
  RenderBlock (positioned) {DIV} at (10,10) size 200x100 [color=#FFFFFF] [bgcolor=#808080]



        text run at (240,178) width 4: " "
      RenderBR {BR} at (244,192) size 0x0
      RenderText {#text} at (0,0) size 0x0
layer at (18,36) size 220x120 clip at (28,46) size 200x100 scrollWidth 207 scrollHeight 157
  RenderBlock {DIV} at (10,28) size 220x120 [border: (10px solid #000000)]
layer at (262,36) size 220x120 clip at (272,46) size 200x100 scrollWidth 207 scrollHeight 157
  RenderBlock {DIV} at (254,28) size 220x120 [border: (10px solid #000000)]
layer at (28,46) size 200x100
  RenderBlock {DIV} at (10,10) size 200x100 [color=#FFFFFF] [bgcolor=#808080]

  RenderBlock (relative positioned) {DIV} at (10,10) size 200x100 [color=#FFFFFF] [bgcolor=#808080]
    RenderText {#text} at (0,0) size 95x18
      text run at (0,0) width 95: "static > relative"
layer at (506,36) size 220x120 clip at (516,46) size 200x100 scrollWidth 207 scrollHeight 157
  RenderBlock (relative positioned) {DIV} at (498,28) size 220x120 [border: (10px solid #000000)]
layer at (516,46) size 200x100
  RenderBlock {DIV} at (10,10) size 200x100 [color=#FFFFFF] [bgcolor=#808080]
    RenderText {#text} at (0,0) size 95x18
      text run at (0,0) width 95: "relative > static"
layer at (18,176) size 220x120 clip at (28,186) size 200x100 scrollWidth 207 scrollHeight 157
  RenderBlock (relative positioned) {DIV} at (10,168) size 220x120 [border: (10px solid #000000)]
layer at (28,186) size 200x100
  RenderBlock (relative positioned) {DIV} at (10,10) size 200x100 [color=#FFFFFF] [bgcolor=#808080]
    RenderText {#text} at (0,0) size 109x18
      text run at (0,0) width 109: "relative > relative"
layer at (18,316) size 220x120 clip at (28,326) size 200x100 scrollWidth 207 scrollHeight 157
  RenderBlock (relative positioned) {DIV} at (10,308) size 220x120 [border: (10px solid #000000)]
layer at (28,326) size 200x100
  RenderBlock (positioned) {DIV} at (10,10) size 200x100 [color=#FFFFFF] [bgcolor=#808080]

Lines 16-22 layer at (13,13) size 117x13 LayoutTests/platform/chromium-mac/fast/forms/validation-message-appearance-expected.txt_sec1
- LayoutTests/platform/chromium-mac/fast/forms/validation-message-appearance-expected.txt -1 / +1 lines
16	RenderBlock {DIV} at (3,3) size 117x13	16	RenderBlock {DIV} at (3,3) size 117x13
17	layer at (10,29) size 310x73	17	layer at (10,29) size 310x73
18	RenderBlock (positioned) zI: 2147483647 {DIV} at (10,29) size 311x73	18	RenderBlock (positioned) zI: 2147483647 {DIV} at (10,29) size 311x73
19	layer at (10,29) size 310x13 scrollHeight 25	19	layer at (10,29) size 310x13 scrollHeight 26
20	RenderBlock {DIV} at (0,0) size 311x13	20	RenderBlock {DIV} at (0,0) size 311x13
21	layer at (10,41) size 310x60	21	layer at (10,41) size 310x60
22	RenderDeprecatedFlexibleBox (relative positioned) zI: 2147483644 {DIV} at (0,13) size 311x60 [bgcolor=#FFFFFF] [border: (1px solid #CCCCCC) (1px solid #AAAAAA) (1px solid #888888) (1px solid #AAAAAA)]	22	RenderDeprecatedFlexibleBox (relative positioned) zI: 2147483644 {DIV} at (0,13) size 311x60 [bgcolor=#FFFFFF] [border: (1px solid #CCCCCC) (1px solid #AAAAAA) (1px solid #888888) (1px solid #AAAAAA)]



BUGWK90951 : fast/text/shaping/shaping-selection-rect.html = MISSING
BUGWK90951 : fast/text/shaping/shaping-script-order.html = MISSING

// Need rebaseline after bots cycle
BUGLEVIW LION LEOPARD WIN LINUX : fast/sub-pixel/sub-pixel-accumulates-to-layers.html = PASS FAIL MISSING
BUGLEVIW LION LEOPARD WIN LINUX : fast/transforms/rotated-transform-affects-scrolling-1.html = PASS FAIL
BUGLEVIW LION LEOPARD WIN LINUX : fast/transforms/rotated-transform-affects-scrolling-2.html = PASS FAIL
BUGLEVIW LION LEOPARD WIN LINUX : fast/borders/border-antialiasing.html = PASS FAIL
BUGLEVIW LION LEOPARD WIN LINUX : fast/clip/overflow-border-radius-composited.html = PASS FAIL
BUGLEVIW LION LEOPARD WIN LINUX : fast/clip/overflow-border-radius-transformed.html = PASS FAIL
BUGLEVIW LION LEOPARD WIN LINUX : fast/forms/validation-message-appearance.html = PASS FAIL
BUGLEVIW LION LEOPARD WIN LINUX : fast/repaint/scroll-fixed-layer-with-transformed-parent-layer.html = PASS FAIL
BUGLEVIW LION LEOPARD WIN LINUX : fast/transforms/transformed-document-element.html = PASS FAIL
BUGLEVIW LION LEOPARD WIN LINUX : svg/transforms/svg-css-transforms.html = PASS FAIL
BUGLEVIW LION LEOPARD WIN LINUX : transforms/svg-vs-css.html = PASS FAIL
BUGLEVIW LION LEOPARD WIN LINUX : compositing/shadows/shadow-drawing.html = PASS FAIL

// Started failing around r122770
BUGWK91445 LINUX : plugins/embed-attributes-style.html = PASS IMAGE

Lines 1-7 LayoutTests/platform/chromium/fast/transforms/rotated-transform-affects-scrolling-1-expected.txt_sec1
- LayoutTests/platform/chromium/fast/transforms/rotated-transform-affects-scrolling-1-expected.txt -2 / +2 lines
1	layer at (0,0) size 932x690	1	layer at (0,0) size 932x691
2	RenderView at (0,0) size 785x585	2	RenderView at (0,0) size 785x585
3	layer at (0,0) size 785x585	3	layer at (0,0) size 785x585
4	RenderBlock {HTML} at (0,0) size 785x585	4	RenderBlock {HTML} at (0,0) size 785x585
5	RenderBody {BODY} at (8,8) size 769x569	5	RenderBody {BODY} at (8,8) size 769x569
6	layer at (8,8) size 1304x104 backgroundClip at (0,0) size 932x690 clip at (0,0) size 932x690 outlineClip at (0,0) size 932x690	6	layer at (8,8) size 1304x104 backgroundClip at (0,0) size 932x691 clip at (0,0) size 932x691 outlineClip at (0,0) size 932x691
7	RenderBlock {DIV} at (0,0) size 1304x104 [bgcolor=#800080] [border: (2px solid #0000FF) (2px solid #00FFFF) (2px solid #008000) (2px solid #FF0000)]	7	RenderBlock {DIV} at (0,0) size 1304x104 [bgcolor=#800080] [border: (2px solid #0000FF) (2px solid #00FFFF) (2px solid #008000) (2px solid #FF0000)]

Lines 1-7 LayoutTests/platform/chromium/fast/transforms/rotated-transform-affects-scrolling-2-expected.txt_sec1
- LayoutTests/platform/chromium/fast/transforms/rotated-transform-affects-scrolling-2-expected.txt -2 / +2 lines
1	layer at (0,0) size 824x711	1	layer at (0,0) size 825x712
2	RenderView at (0,0) size 785x585	2	RenderView at (0,0) size 785x585
3	layer at (0,0) size 785x585	3	layer at (0,0) size 785x585
4	RenderBlock {HTML} at (0,0) size 785x585	4	RenderBlock {HTML} at (0,0) size 785x585
5	RenderBody {BODY} at (8,8) size 769x569	5	RenderBody {BODY} at (8,8) size 769x569
6	layer at (8,8) size 1304x104 backgroundClip at (0,0) size 824x711 clip at (0,0) size 824x711 outlineClip at (0,0) size 824x711	6	layer at (8,8) size 1304x104 backgroundClip at (0,0) size 825x712 clip at (0,0) size 825x712 outlineClip at (0,0) size 825x712
7	RenderBlock {DIV} at (0,0) size 1304x104 [bgcolor=#800080] [border: (2px solid #0000FF) (2px solid #00FFFF) (2px solid #008000) (2px solid #FF0000)]	7	RenderBlock {DIV} at (0,0) size 1304x104 [bgcolor=#800080] [border: (2px solid #0000FF) (2px solid #00FFFF) (2px solid #008000) (2px solid #FF0000)]

Lines 342-347 BUGWK85532 : fast/sub-pixel/table-cells- LayoutTests/platform/gtk/TestExpectations_sec1
- LayoutTests/platform/gtk/TestExpectations +1 lines
342	BUGWK85532 SKIP : fast/sub-pixel/table-rows-have-stable-height.html = CRASH TEXT	342	BUGWK85532 SKIP : fast/sub-pixel/table-rows-have-stable-height.html = CRASH TEXT
343	BUGWK85532 : fast/sub-pixel/table-rows-no-gaps.html = PASS	343	BUGWK85532 : fast/sub-pixel/table-rows-no-gaps.html = PASS
344	BUGWK85532 : fast/sub-pixel/vertical-align-middle-overflow.html = PASS	344	BUGWK85532 : fast/sub-pixel/vertical-align-middle-overflow.html = PASS
		345	BUGWK85532 : fast/sub-pixel/sub-pixel-accumulates-to-layers.html = PASS FAIL
345		346
346	// Mediastream implementation is not complete yet.	347	// Mediastream implementation is not complete yet.
347	BUGWK79203 SKIP : fast/mediastream = TEXT	348	BUGWK79203 SKIP : fast/mediastream = TEXT

Lines 115-120 fast/sub-pixel/position-right-aligns-wit LayoutTests/platform/mac-lion/Skipped_sec1
- LayoutTests/platform/mac-lion/Skipped +1 lines
115	fast/sub-pixel/selection/selection-gaps-at-fractional-offsets.html	115	fast/sub-pixel/selection/selection-gaps-at-fractional-offsets.html
116	fast/sub-pixel/size-of-box-with-zoom.html	116	fast/sub-pixel/size-of-box-with-zoom.html
117	fast/sub-pixel/table-rows-no-gaps.html	117	fast/sub-pixel/table-rows-no-gaps.html
		118	fast/sub-pixel/sub-pixel-accumulates-to-layers.html
118		119
119	# This media test always failed on Lion	120	# This media test always failed on Lion
120	# https://bugs.webkit.org/show_bug.cgi?id=86527 and <rdar://problem/11458493>	121	# https://bugs.webkit.org/show_bug.cgi?id=86527 and <rdar://problem/11458493>

Lines 209-214 fast/sub-pixel/position-right-aligns-wit LayoutTests/platform/mac-snowleopard/Skipped_sec1
- LayoutTests/platform/mac-snowleopard/Skipped +1 lines
209	fast/sub-pixel/selection/selection-gaps-at-fractional-offsets.html	209	fast/sub-pixel/selection/selection-gaps-at-fractional-offsets.html
210	fast/sub-pixel/size-of-box-with-zoom.html	210	fast/sub-pixel/size-of-box-with-zoom.html
211	fast/sub-pixel/table-rows-no-gaps.html	211	fast/sub-pixel/table-rows-no-gaps.html
		212	fast/sub-pixel/sub-pixel-accumulates-to-layers.html
212		213
213	# Frame::findString does nothing on pages that prevent selection	214	# Frame::findString does nothing on pages that prevent selection
214	# https://bugs.webkit.org/show_bug.cgi?id=40361	215	# https://bugs.webkit.org/show_bug.cgi?id=40361

Lines 215-220 fast/sub-pixel/position-right-aligns-wit LayoutTests/platform/mac-wk2/Skipped_sec1
- LayoutTests/platform/mac-wk2/Skipped +1 lines
215	fast/sub-pixel/selection/selection-gaps-at-fractional-offsets.html	215	fast/sub-pixel/selection/selection-gaps-at-fractional-offsets.html
216	fast/sub-pixel/size-of-box-with-zoom.html	216	fast/sub-pixel/size-of-box-with-zoom.html
217	fast/sub-pixel/table-rows-no-gaps.html	217	fast/sub-pixel/table-rows-no-gaps.html
		218	fast/sub-pixel/sub-pixel-accumulates-to-layers.html
218		219
219	# fast/events/pagehide-timeout.html, pageshow-pagehide-on-back-cached-with-frames.html, and	220	# fast/events/pagehide-timeout.html, pageshow-pagehide-on-back-cached-with-frames.html, and
220	# pageshow-pagehide-on-back-cached.html flakey on Lion Intel Debug WebKit testers.	221	# pageshow-pagehide-on-back-cached.html flakey on Lion Intel Debug WebKit testers.

Lines 823-828 fast/sub-pixel/position-right-aligns-wit LayoutTests/platform/mac/Skipped_sec1
- LayoutTests/platform/mac/Skipped +1 lines
823	fast/sub-pixel/selection/selection-gaps-at-fractional-offsets.html	823	fast/sub-pixel/selection/selection-gaps-at-fractional-offsets.html
824	fast/sub-pixel/size-of-box-with-zoom.html	824	fast/sub-pixel/size-of-box-with-zoom.html
825	fast/sub-pixel/table-rows-no-gaps.html	825	fast/sub-pixel/table-rows-no-gaps.html
		826	fast/sub-pixel/sub-pixel-accumulates-to-layers.html
826		827
827	# No CORS support for media elements is implemented yet.	828	# No CORS support for media elements is implemented yet.
828	http/tests/security/video-cross-origin-readback.html	829	http/tests/security/video-cross-origin-readback.html

Lines 102-107 fast/sub-pixel/position-right-aligns-wit LayoutTests/platform/qt-4.8/Skipped_sec1
- LayoutTests/platform/qt-4.8/Skipped +1 lines
102	fast/sub-pixel/selection/selection-gaps-at-fractional-offsets.html	102	fast/sub-pixel/selection/selection-gaps-at-fractional-offsets.html
103	fast/sub-pixel/size-of-box-with-zoom.html	103	fast/sub-pixel/size-of-box-with-zoom.html
104	fast/sub-pixel/table-rows-no-gaps.html	104	fast/sub-pixel/table-rows-no-gaps.html
		105	fast/sub-pixel/sub-pixel-accumulates-to-layers.html
105		106
106	# SVG Fonts are only supported when using QRawFont, which is not	107	# SVG Fonts are only supported when using QRawFont, which is not
107	# supported with Qt 4.	108	# supported with Qt 4.

Lines 276-281 fast/sub-pixel/position-right-aligns-wit LayoutTests/platform/qt/Skipped_sec1
- LayoutTests/platform/qt/Skipped +1 lines
276	fast/sub-pixel/selection/selection-gaps-at-fractional-offsets.html	276	fast/sub-pixel/selection/selection-gaps-at-fractional-offsets.html
277	fast/sub-pixel/size-of-box-with-zoom.html	277	fast/sub-pixel/size-of-box-with-zoom.html
278	fast/sub-pixel/table-rows-no-gaps.html	278	fast/sub-pixel/table-rows-no-gaps.html
		279	fast/sub-pixel/sub-pixel-accumulates-to-layers.html
279		280
280	# CSS Regions support not yet enabled. http://webkit.org/b/57312	281	# CSS Regions support not yet enabled. http://webkit.org/b/57312
281	fast/regions	282	fast/regions

Lines 948-953 fast/sub-pixel/position-right-aligns-wit LayoutTests/platform/win-wk2/Skipped_sec1
- LayoutTests/platform/win-wk2/Skipped +1 lines
948	fast/sub-pixel/selection/selection-gaps-at-fractional-offsets.html	948	fast/sub-pixel/selection/selection-gaps-at-fractional-offsets.html
949	fast/sub-pixel/size-of-box-with-zoom.html	949	fast/sub-pixel/size-of-box-with-zoom.html
950	fast/sub-pixel/table-rows-no-gaps.html	950	fast/sub-pixel/table-rows-no-gaps.html
		951	fast/sub-pixel/sub-pixel-accumulates-to-layers.html
951		952
952	# HiDPI tests require test infrastructure enhancements	953	# HiDPI tests require test infrastructure enhancements
953	fast/hidpi	954	fast/hidpi

Lines 48-53 fast/sub-pixel/position-right-aligns-wit LayoutTests/platform/win-xp/Skipped_sec1
- LayoutTests/platform/win-xp/Skipped +1 lines
48	fast/sub-pixel/selection/selection-gaps-at-fractional-offsets.html	48	fast/sub-pixel/selection/selection-gaps-at-fractional-offsets.html
49	fast/sub-pixel/size-of-box-with-zoom.html	49	fast/sub-pixel/size-of-box-with-zoom.html
50	fast/sub-pixel/table-rows-no-gaps.html	50	fast/sub-pixel/table-rows-no-gaps.html
		51	fast/sub-pixel/sub-pixel-accumulates-to-layers.html
51		52
52	# REGRESSION (r83928 or before): Some tests failing assertions in MarkStack::internalAppend / MarkStack::drain	53	# REGRESSION (r83928 or before): Some tests failing assertions in MarkStack::internalAppend / MarkStack::drain
53	# https://bugs.webkit.org/show_bug.cgi?id=58657	54	# https://bugs.webkit.org/show_bug.cgi?id=58657

Lines 1740-1745 fast/sub-pixel/position-right-aligns-wit LayoutTests/platform/win/Skipped_sec1
- LayoutTests/platform/win/Skipped +1 lines
1740	fast/sub-pixel/selection/selection-gaps-at-fractional-offsets.html	1740	fast/sub-pixel/selection/selection-gaps-at-fractional-offsets.html
1741	fast/sub-pixel/size-of-box-with-zoom.html	1741	fast/sub-pixel/size-of-box-with-zoom.html
1742	fast/sub-pixel/table-rows-no-gaps.html	1742	fast/sub-pixel/table-rows-no-gaps.html
		1743	fast/sub-pixel/sub-pixel-accumulates-to-layers.html
1743		1744
1744	# No CORS support for media elements is implemented yet.	1745	# No CORS support for media elements is implemented yet.
1745	http/tests/security/video-cross-origin-readback.html	1746	http/tests/security/video-cross-origin-readback.html

Lines 2129-2134 fast/sub-pixel/position-right-aligns-wit LayoutTests/platform/wincairo/Skipped_sec1
- LayoutTests/platform/wincairo/Skipped +1 lines
2129	fast/sub-pixel/selection/selection-gaps-at-fractional-offsets.html	2129	fast/sub-pixel/selection/selection-gaps-at-fractional-offsets.html
2130	fast/sub-pixel/size-of-box-with-zoom.html	2130	fast/sub-pixel/size-of-box-with-zoom.html
2131	fast/sub-pixel/table-rows-no-gaps.html	2131	fast/sub-pixel/table-rows-no-gaps.html
		2132	fast/sub-pixel/sub-pixel-accumulates-to-layers.html
2132		2133
2133	#Battery Status API is not implemented.	2134	#Battery Status API is not implemented.
2134	batterystatus	2135	batterystatus

Lines 98-103 fast/sub-pixel/position-right-aligns-wit LayoutTests/platform/wk2/Skipped_sec1
- LayoutTests/platform/wk2/Skipped +1 lines
98	fast/sub-pixel/selection/selection-gaps-at-fractional-offsets.html	98	fast/sub-pixel/selection/selection-gaps-at-fractional-offsets.html
99	fast/sub-pixel/size-of-box-with-zoom.html	99	fast/sub-pixel/size-of-box-with-zoom.html
100	fast/sub-pixel/table-rows-no-gaps.html	100	fast/sub-pixel/table-rows-no-gaps.html
		101	fast/sub-pixel/sub-pixel-accumulates-to-layers.html
101		102
102	# CONSOLE MESSAGE: line 0: SVG animation pause API missing!	103	# CONSOLE MESSAGE: line 0: SVG animation pause API missing!
103	# [WK2] SVG animation pause API missing	104	# [WK2] SVG animation pause API missing



c+YEc2IFqmClWQjBqoQiLHMH6wihLixRAmIiIiIbFnLK8v5TH0GgDuX7uw4GhnFa2vVjy/f8Quf
KF7p7Q/HSe53IDVNE7OiabNDJtEO2xJzgdnQa7pELqIiIhsVcdOHMuXdl6yqdUpn3lrRu1XY2Bp
p1zrYLkvLtGCYiIiIhcN+sb62VpZskAHlh7oO9wZAwr29WPh+9/j/kDd2ivKP+9Um/A6jqnlEyX
g5HJpw1AQtGaOpvD+1US2wjsTFCAyHUKkhUAiIiIiLXwvrGelmaWTKAB9Ye6DscGcMKRwB4+P73
0OTzyfCBvf4JrN2Z3PFv/rtOe375JrzECAYU9FomkAboYlG2wRaqwMI90zBnsHuGj2IIiIiMpbl
LzarybBCkcAePj+93qORG4L2TEKOWfcIadCSpmUIHV1Aro7NRPZ1vQWrIiIiNz0Tr56EoCFCwuu
5Bp2z/9vi8+MqM9l9yS3DPFC9kzlExKiVK8tl510GXoCvU+3m16GURERCbAK//8Srm897LNbM74
+Gs2q8mwPJ2AvLkX6P2K7mllVwIQFccdydl6FI9C5K9HkRPud6GtUMJiIiIyE3uzFtnDOChnz7U
V8APP7loPYrkWvICmQHd2MrB3KBXCB5/c65VkFy3l2jBEREROQT+sdf/qMBHFk+0ncoMoYN7vFN
w5FxrDJPv8V/9MAnnr2rr7DEblluTkhBoLVNqtoEHCCOY1B29YzIu3Hso6mv3BFREQmw/rGevnX
sTd+qFV5DoxM/7P2S3+n59fZvr/GHDnn7Rc/k9nlBOj4VWGbeC3wwBW6IYtm7/6OfMzM0xPTysB
bjTEZEviAoQERHZsF62LwMwND4UcybSiMkrZ3/s6P3QjuzMa40iskHp4hYRkQ1p9OBoUM6WTc9M
L6P67pXdT5qtRqu61KtVjEmbHpGhUitVqNarVKtVlWAiIjI+nfghQMAFE8WbeFiQaM8CVAi7FTt
TwZZths5yiYLm/ePvjjHq0tRJrM6u7G1NQUP//5z5mamsJai+M49U5J9Dy9SIiIyLpSGi8FZwpn
pm+V88Yw8LCAm1tbQBcvnyZy5cvc+7cOf649A84nSnaOzN0tqU4vwBzi5aWjIPrgQEIoOpbrIWa

Line 4 LayoutTests/platform/chromium-mac/fast/transforms/transformed-document-element-expected.png_sec1
- LayoutTests/platform/chromium-mac/fast/transforms/transformed-document-element-expected.png +3 lines
	3	ILK5XLaIzQdAQIAAF9APp9P+vr6XL+6QgIEAAC+gHXr1qU9QlMSIAAA8AUMDAykPUJTEiAAAHCF
	4	vv7k0Kh4PrVFyBAAADgClUqlbRHaFoCBAAArpCHD35xAgQAAK5AtVpNcrmc61dfkAABAIAr4PTj
	5	vpcv5plAgQAACJi3bp1aY/QFgQIAABExMDAQNojtAUBAgBA2+vv708KhYLrV3NAgAAA0PYqlUra

Return to Bug 89238

Lines 701-712 static LayoutRect sizingBox(RenderObject Source/WebCore/css/CSSComputedStyleDeclaration.cpp_sec1
- Source/WebCore/css/CSSComputedStyleDeclaration.cpp -1 / +10 lines
701	return box->style()->boxSizing() == BORDER_BOX ? box->borderBoxRect() : box->computedCSSContentBoxRect();	701	return box->style()->boxSizing() == BORDER_BOX ? box->borderBoxRect() : box->computedCSSContentBoxRect();
702	}	702	}
703		703
		704	static IntRect pixelSnappedSizingBox(RenderObject* renderer)
		705	{
		706	if (!renderer->isBox())
		707	return IntRect();
		708
		709	RenderBox* box = toRenderBox(renderer);
		710	return box->style()->boxSizing() == BORDER_BOX ? box->pixelSnappedBorderBoxRect() : pixelSnappedIntRect(box->computedCSSContentBoxRect());
		711	}
		712
704	static PassRefPtr<CSSValue> computedTransform(RenderObject* renderer, const RenderStyle* style)	713	static PassRefPtr<CSSValue> computedTransform(RenderObject* renderer, const RenderStyle* style)
705	{	714	{
706	if (!renderer \|\| style->transform().operations().isEmpty())	715	if (!renderer \|\| style->transform().operations().isEmpty())
707	return cssValuePool().createIdentifierValue(CSSValueNone);	716	return cssValuePool().createIdentifierValue(CSSValueNone);
708		717
709	LayoutRect box = sizingBox(renderer);	718	IntRect box = pixelSnappedSizingBox(renderer);
710		719
711	TransformationMatrix transform;	720	TransformationMatrix transform;
712	style->applyTransform(transform, box.size(), RenderStyle::ExcludeTransformOrigin);	721	style->applyTransform(transform, box.size(), RenderStyle::ExcludeTransformOrigin);

Lines 1252-1258 LayoutUnit RenderBox::perpendicularConta Source/WebCore/rendering/RenderBox.cpp_sec1
- Source/WebCore/rendering/RenderBox.cpp -10 / +13 lines
1252	return cb->computeContentBoxLogicalHeight(logicalHeightLength.value());	1252	return cb->computeContentBoxLogicalHeight(logicalHeightLength.value());
1253	}	1253	}
1254		1254
1255	void RenderBox::mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool fixed, bool useTransforms, TransformState& transformState, ApplyContainerFlipOrNot, bool* wasFixed) const	1255	void RenderBox::mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState& transformState, MapLocalToContainerFlags mode, bool* wasFixed) const
1256	{	1256	{
1257	if (repaintContainer == this)	1257	if (repaintContainer == this)
1258	return;	1258	return;
Lines 1278-1294 void RenderBox::mapLocalToContainer(Rend Source/WebCore/rendering/RenderBox.cpp_sec2
1278	// If this box has a transform, it acts as a fixed position container for fixed descendants,	1278	// If this box has a transform, it acts as a fixed position container for fixed descendants,
1279	// and may itself also be fixed position. So propagate 'fixed' up only if this box is fixed position.	1279	// and may itself also be fixed position. So propagate 'fixed' up only if this box is fixed position.
1280	if (hasTransform && !isFixedPos)	1280	if (hasTransform && !isFixedPos)
1281	fixed = false;	1281	mode &= ~IsFixed;
1282	else if (isFixedPos)	1282	else if (isFixedPos)
1283	fixed = true;	1283	mode \|= IsFixed;
1284		1284
1285	if (wasFixed)	1285	if (wasFixed)
1286	*wasFixed = fixed;	1286	*wasFixed = mode & IsFixed;
1287		1287
1288	LayoutSize containerOffset = offsetFromContainer(o, roundedLayoutPoint(transformState.mappedPoint()));	1288	LayoutSize containerOffset = offsetFromContainer(o, roundedLayoutPoint(transformState.mappedPoint()));
		1289	if (mode & SnapOffsetForTransforms)
		1290	containerOffset = roundedIntSize(containerOffset);
1289		1291
1290	bool preserve3D = useTransforms && (o->style()->preserves3D() \|\| style()->preserves3D());	1292	bool preserve3D = mode & UseTransforms && (o->style()->preserves3D() \|\| style()->preserves3D());
1291	if (useTransforms && shouldUseTransformFromContainer(o)) {	1293	if (mode & UseTransforms && shouldUseTransformFromContainer(o)) {
1292	TransformationMatrix t;	1294	TransformationMatrix t;
1293	getTransformFromContainer(o, containerOffset, t);	1295	getTransformFromContainer(o, containerOffset, t);
1294	transformState.applyTransform(t, preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform);	1296	transformState.applyTransform(t, preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform);
Lines 1303-1317 void RenderBox::mapLocalToContainer(Rend Source/WebCore/rendering/RenderBox.cpp_sec3
1303	return;	1305	return;
1304	}	1306	}
1305		1307
		1308	mode &= ~ApplyContainerFlip;
1306	if (o->isRenderFlowThread()) {	1309	if (o->isRenderFlowThread()) {
1307	// Transform from render flow coordinates into region coordinates.	1310	// Transform from render flow coordinates into region coordinates.
1308	RenderRegion* region = toRenderFlowThread(o)->mapFromFlowToRegion(transformState);	1311	RenderRegion* region = toRenderFlowThread(o)->mapFromFlowToRegion(transformState);
1309	if (region)	1312	if (region)
1310	region->mapLocalToContainer(region->containerForRepaint(), fixed, useTransforms, transformState, DoNotApplyContainerFlip, wasFixed);	1313	region->mapLocalToContainer(region->containerForRepaint(), transformState, mode, wasFixed);
1311	return;	1314	return;
1312	}	1315	}
1313		1316
1314	o->mapLocalToContainer(repaintContainer, fixed, useTransforms, transformState, DoNotApplyContainerFlip, wasFixed);	1317	o->mapLocalToContainer(repaintContainer, transformState, mode, wasFixed);
1315	}	1318	}
1316		1319
1317	const RenderObject* RenderBox::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const	1320	const RenderObject* RenderBox::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
Lines 1550-1556 void RenderBox::computeRectForRepaint(Re Source/WebCore/rendering/RenderBox.cpp_sec4
1550	// in the parent's coordinate space that encloses us.	1553	// in the parent's coordinate space that encloses us.
1551	if (layer() && layer()->transform()) {	1554	if (layer() && layer()->transform()) {
1552	fixed = position == FixedPosition;	1555	fixed = position == FixedPosition;
1553	rect = layer()->transform()->mapRect(rect);	1556	rect = layer()->transform()->mapRect(pixelSnappedIntRect(rect));
1554	topLeft = rect.location();	1557	topLeft = rect.location();
1555	topLeft.move(locationOffset());	1558	topLeft.move(locationOffset());
1556	} else if (position == FixedPosition)	1559	} else if (position == FixedPosition)
Lines 3833-3839 LayoutRect RenderBox::layoutOverflowRect Source/WebCore/rendering/RenderBox.cpp_sec5
3833	flipForWritingMode(rect);	3836	flipForWritingMode(rect);
3834		3837
3835	if (hasTransform)	3838	if (hasTransform)
3836	rect = layer()->currentTransform().mapRect(rect);	3839	rect = layer()->currentTransform().mapRect(pixelSnappedIntRect(rect));
3837		3840
3838	if (isRelPositioned())	3841	if (isRelPositioned())
3839	rect.move(relativePositionOffset());	3842	rect.move(relativePositionOffset());

Lines 1114-1120 LayoutSize RenderInline::offsetFromConta Source/WebCore/rendering/RenderInline.cpp_sec1
- Source/WebCore/rendering/RenderInline.cpp -6 / +8 lines
1114	return offset;	1114	return offset;
1115	}	1115	}
1116		1116
1117	void RenderInline::mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool fixed, bool useTransforms, TransformState& transformState, ApplyContainerFlipOrNot applyContainerFlip, bool* wasFixed) const	1117	void RenderInline::mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState& transformState, MapLocalToContainerFlags mode, bool* wasFixed) const
1118	{	1118	{
1119	if (repaintContainer == this)	1119	if (repaintContainer == this)
1120	return;	1120	return;
Lines 1135-1152 void RenderInline::mapLocalToContainer(R Source/WebCore/rendering/RenderInline.cpp_sec2
1135	if (!o)	1135	if (!o)
1136	return;	1136	return;
1137		1137
1138	if (applyContainerFlip && o->isBox()) {	1138	if (mode & ApplyContainerFlip && o->isBox()) {
1139	if (o->style()->isFlippedBlocksWritingMode()) {	1139	if (o->style()->isFlippedBlocksWritingMode()) {
1140	IntPoint centerPoint = roundedIntPoint(transformState.mappedPoint());	1140	IntPoint centerPoint = roundedIntPoint(transformState.mappedPoint());
1141	transformState.move(toRenderBox(o)->flipForWritingModeIncludingColumns(centerPoint) - centerPoint);	1141	transformState.move(toRenderBox(o)->flipForWritingModeIncludingColumns(centerPoint) - centerPoint);
1142	}	1142	}
1143	applyContainerFlip = DoNotApplyContainerFlip;	1143	mode &= ~ApplyContainerFlip;
1144	}	1144	}
1145		1145
1146	LayoutSize containerOffset = offsetFromContainer(o, roundedLayoutPoint(transformState.mappedPoint()));	1146	LayoutSize containerOffset = offsetFromContainer(o, roundedLayoutPoint(transformState.mappedPoint()));
		1147	if (mode & SnapOffsetForTransforms)
		1148	containerOffset = roundedIntSize(containerOffset);
1147		1149
1148	bool preserve3D = useTransforms && (o->style()->preserves3D() \|\| style()->preserves3D());	1150	bool preserve3D = mode & UseTransforms && (o->style()->preserves3D() \|\| style()->preserves3D());
1149	if (useTransforms && shouldUseTransformFromContainer(o)) {	1151	if (mode & UseTransforms && shouldUseTransformFromContainer(o)) {
1150	TransformationMatrix t;	1152	TransformationMatrix t;
1151	getTransformFromContainer(o, containerOffset, t);	1153	getTransformFromContainer(o, containerOffset, t);
1152	transformState.applyTransform(t, preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform);	1154	transformState.applyTransform(t, preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform);
Lines 1161-1167 void RenderInline::mapLocalToContainer(R Source/WebCore/rendering/RenderInline.cpp_sec3
1161	return;	1163	return;
1162	}	1164	}
1163		1165
1164	o->mapLocalToContainer(repaintContainer, fixed, useTransforms, transformState, applyContainerFlip, wasFixed);	1166	o->mapLocalToContainer(repaintContainer, transformState, mode, wasFixed);
1165	}	1167	}
1166		1168
1167	const RenderObject* RenderInline::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const	1169	const RenderObject* RenderInline::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const

Lines 224-230 void RenderLayerBacking::updateLayerTran Source/WebCore/rendering/RenderLayerBacking.cpp_sec1
- Source/WebCore/rendering/RenderLayerBacking.cpp -2 / +2 lines
224	// baked into it, and we don't want that.	224	// baked into it, and we don't want that.
225	TransformationMatrix t;	225	TransformationMatrix t;
226	if (m_owningLayer->hasTransform()) {	226	if (m_owningLayer->hasTransform()) {
227	style->applyTransform(t, toRenderBox(renderer())->borderBoxRect().size(), RenderStyle::ExcludeTransformOrigin);	227	style->applyTransform(t, toRenderBox(renderer())->pixelSnappedBorderBoxRect().size(), RenderStyle::ExcludeTransformOrigin);
228	makeMatrixRenderable(t, compositor()->canRender3DTransforms());	228	makeMatrixRenderable(t, compositor()->canRender3DTransforms());
229	}	229	}
230		230
Lines 1231-1237 void RenderLayerBacking::paintIntoLayer( Source/WebCore/rendering/RenderLayerBacking.cpp_sec2
1231	paintFlags \|= RenderLayer::PaintLayerPaintingCompositingMaskPhase;	1231	paintFlags \|= RenderLayer::PaintLayerPaintingCompositingMaskPhase;
1232		1232
1233	// FIXME: GraphicsLayers need a way to split for RenderRegions.	1233	// FIXME: GraphicsLayers need a way to split for RenderRegions.
1234	m_owningLayer->paintLayerContents(rootLayer, context, paintDirtyRect, paintBehavior, paintingRoot, 0, 0, paintFlags);	1234	m_owningLayer->paintLayerContents(rootLayer, context, paintDirtyRect, LayoutSize(), paintBehavior, paintingRoot, 0, 0, paintFlags);
1235		1235
1236	if (m_owningLayer->containsDirtyOverlayScrollbars())	1236	if (m_owningLayer->containsDirtyOverlayScrollbars())
1237	m_owningLayer->paintOverlayScrollbars(context, paintDirtyRect, paintBehavior, paintingRoot);	1237	m_owningLayer->paintOverlayScrollbars(context, paintDirtyRect, paintBehavior, paintingRoot);

Lines 1-3 Source/WebCore/ChangeLog_sec1
- Source/WebCore/ChangeLog +107 lines
		1	2012-07-31 Levi Weintraub <leviw@chromium.org>
		2
		3	Accumulate sub-pixel offsets through layers and transforms
		4	https://bugs.webkit.org/show_bug.cgi?id=89238
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Pixel snapping logic makes use of sub-pixel offsets accumulated when walking down
		9	the render tree. When we align RenderLayers to paint on pixel boundaries, we were
		10	also losing that accumulated value. This preserves the fractional offset and passes
		11	it to the RenderLayer's RenderObjects so they paint the proper size and offset.
		12
		13	Also adding an enum to localTo[Container\|Absolute] to switch between using pixel-
		14	snapped values or to maintain the higher precision versions.
		15
		16	Test: fast/sub-pixel/sub-pixel-accumulates-to-layers.html
		17
		18	* WebCore.exp.in:
		19	* css/CSSComputedStyleDeclaration.cpp:
		20	(WebCore::pixelSnappedSizingBox): Adding because sizing box improperly pixel snaps due
		21	to zero-ing out the location.
		22	(WebCore::computedTransform): Using pixel-snapped values when generating transforms.
		23	(WebCore::CSSComputedStyleDeclaration::getPropertyCSSValue):
		24	* platform/FractionalLayoutUnit.h:
		25	(WebCore::FractionalLayoutUnit::epsilon): Correcting epsilon calculations to use float
		26	math instead of integer.
		27	* rendering/RenderBlock.cpp:
		28	(WebCore::RenderBlock::addOverflowFromPositionedObjects): Accumulating offsets with
		29	LayoutUnits instead of truncating to integers.
		30	* rendering/RenderBox.cpp:
		31	(WebCore::RenderBox::mapLocalToContainer): Converting to using bit flags to select the
		32	mode and adding a mode for whether to use pixel snapping for transforms.
		33	(WebCore::RenderBox::computeRectForRepaint): Use pixel-snapped values for the
		34	when sending the values through the transform.
		35	(WebCore::RenderBox::layoutOverflowRectForPropagation): Ditto.
		36	* rendering/RenderBox.h:
		37	(RenderBox):
		38	* rendering/RenderGeometryMap.cpp:
		39	(WebCore::RenderGeometryMap::mapToAbsolute):
		40	* rendering/RenderInline.cpp:
		41	(WebCore::RenderInline::mapLocalToContainer):
		42	* rendering/RenderInline.h:
		43	(RenderInline):
		44	* rendering/RenderLayer.cpp:
		45	(WebCore::RenderLayer::updateTransform): Use pixel snapped values to generate the transform.
		46	(WebCore::RenderLayer::currentTransform): Ditto.
		47	(WebCore::RenderLayer::perspectiveTransform): Ditto.
		48	(WebCore::RenderLayer::paint): Support passing along the accumulated sub-pixel offset instead
		49	of rounding and use enclosingIntRect for the damageRect.
		50	(WebCore::RenderLayer::paintOverlayScrollbars): Updating to the new paintLayer contract.
		51	(WebCore::RenderLayer::paintLayer): Adding a sub-pixel accumulation LayoutSize. We pass this
		52	delta to the Layer's RenderObject when we paint, but align the graphics context to the proper
		53	pixel value.
		54	(WebCore::RenderLayer::paintLayerContentsAndReflection): Ditto.
		55	(WebCore::RenderLayer::paintLayerContents): Ditto.
		56	(WebCore::RenderLayer::paintList): Ditto.
		57	(WebCore::RenderLayer::paintChildLayerIntoColumns): Ditto.
		58	(WebCore::RenderLayer::hitTestChildLayerColumns): Use rounded coordinates for the transform.
		59	(WebCore::RenderLayer::calculateClipRects): Avoid unnecessary rounding when sub-pixel is enabled.
		60	(WebCore::RenderLayer::calculateRects): Remove unnecessary pixel snapping.
		61	* rendering/RenderLayer.h:
		62	(RenderLayer):
		63	* rendering/RenderLayerBacking.cpp:
		64	(WebCore::RenderLayerBacking::updateLayerTransform): Use pixel-snapped values for transforms.
65	(WebCore::RenderLayerBacking::paintIntoLayer): Update to new paintLayer contract.
66	* rendering/RenderObject.cpp:
67	(WebCore::RenderObject::localToAbsolute): Supporting optionally pixel-snapping the values as we go.
68	(WebCore::RenderObject::mapLocalToContainer): Ditto.
69	(WebCore::RenderObject::localToContainerQuad): Ditto.
70	(WebCore::RenderObject::localToContainerPoint): Ditto.
71	* rendering/RenderObject.h:
72	(WebCore::RenderObject::localToAbsoluteQuad): Ditto.
73	(RenderObject):
74	* rendering/RenderReplica.cpp:
75	(WebCore::RenderReplica::paint): Updating to new paintLayer contract.
76	* rendering/RenderView.cpp:
77	(WebCore::RenderView::mapLocalToContainer):
78	* rendering/RenderView.h:
79	(RenderView):
80	* rendering/style/RenderStyle.cpp:
81	(WebCore::RenderStyle::applyTransform):
82	* rendering/style/RenderStyle.h:
83	* rendering/svg/RenderSVGForeignObject.cpp:
84	(WebCore::RenderSVGForeignObject::mapLocalToContainer):
85	* rendering/svg/RenderSVGForeignObject.h:
86	(RenderSVGForeignObject):
87	* rendering/svg/RenderSVGInline.cpp:
88	(WebCore::RenderSVGInline::mapLocalToContainer):
89	* rendering/svg/RenderSVGInline.h:
90	(RenderSVGInline):
91	* rendering/svg/RenderSVGModelObject.cpp:
92	(WebCore::RenderSVGModelObject::mapLocalToContainer):
93	* rendering/svg/RenderSVGModelObject.h:
94	(RenderSVGModelObject):
95	* rendering/svg/RenderSVGRoot.cpp:
96	(WebCore::RenderSVGRoot::mapLocalToContainer):
97	* rendering/svg/RenderSVGRoot.h:
98	(RenderSVGRoot):
99	* rendering/svg/RenderSVGText.cpp:
100	(WebCore::RenderSVGText::mapLocalToContainer):
101	* rendering/svg/RenderSVGText.h:
102	(RenderSVGText):
103	* rendering/svg/SVGRenderSupport.cpp:
104	(WebCore::SVGRenderSupport::mapLocalToContainer):
105	* rendering/svg/SVGRenderSupport.h:
106	(SVGRenderSupport):
107
1	2012-07-31 Max Vujovic <mvujovic@adobe.com>	108	2012-07-31 Max Vujovic <mvujovic@adobe.com>
2		109
3	[CSS Shaders] CSS parser rejects parameter names that are also CSS keywords	110	[CSS Shaders] CSS parser rejects parameter names that are also CSS keywords

Lines 92-99 void RenderGeometryMap::mapToAbsolute(Tr Source/WebCore/rendering/RenderGeometryMap.cpp_sec1
- Source/WebCore/rendering/RenderGeometryMap.cpp -2 / +1 lines
92	{	92	{
93	// If the mapping includes something like columns, we have to go via renderers.	93	// If the mapping includes something like columns, we have to go via renderers.
94	if (hasNonUniformStep()) {	94	if (hasNonUniformStep()) {
95	bool fixed = false;	95	m_mapping.last().m_renderer->mapLocalToContainer(0, transformState, UseTransforms \| ApplyContainerFlip \| SnapOffsetForTransforms);
96	m_mapping.last().m_renderer->mapLocalToContainer(0, fixed, true, transformState, RenderObject::ApplyContainerFlip);
97	return;	96	return;
98	}	97	}
99		98

Lines 554-560 void RenderLayer::updateTransform() Source/WebCore/rendering/RenderLayer.cpp_sec1
- Source/WebCore/rendering/RenderLayer.cpp -19 / +22 lines
554	RenderBox* box = renderBox();	554	RenderBox* box = renderBox();
555	ASSERT(box);	555	ASSERT(box);
556	m_transform->makeIdentity();	556	m_transform->makeIdentity();
557	box->style()->applyTransform(*m_transform, box->borderBoxRect().size(), RenderStyle::IncludeTransformOrigin);	557	box->style()->applyTransform(*m_transform, box->pixelSnappedBorderBoxRect().size(), RenderStyle::IncludeTransformOrigin);
558	makeMatrixRenderable(*m_transform, canRender3DTransforms());	558	makeMatrixRenderable(*m_transform, canRender3DTransforms());
559	}	559	}
560		560
Lines 571-577 TransformationMatrix RenderLayer::curren Source/WebCore/rendering/RenderLayer.cpp_sec2
571	if (renderer()->style()->isRunningAcceleratedAnimation()) {	571	if (renderer()->style()->isRunningAcceleratedAnimation()) {
572	TransformationMatrix currTransform;	572	TransformationMatrix currTransform;
573	RefPtr<RenderStyle> style = renderer()->animation()->getAnimatedStyleForRenderer(renderer());	573	RefPtr<RenderStyle> style = renderer()->animation()->getAnimatedStyleForRenderer(renderer());
574	style->applyTransform(currTransform, renderBox()->borderBoxRect().size(), RenderStyle::IncludeTransformOrigin);	574	style->applyTransform(currTransform, renderBox()->pixelSnappedBorderBoxRect().size(), RenderStyle::IncludeTransformOrigin);
575	makeMatrixRenderable(currTransform, canRender3DTransforms());	575	makeMatrixRenderable(currTransform, canRender3DTransforms());
576	return currTransform;	576	return currTransform;
577	}	577	}
Lines 879-885 TransformationMatrix RenderLayer::perspe Source/WebCore/rendering/RenderLayer.cpp_sec3
879	return TransformationMatrix();	879	return TransformationMatrix();
880		880
881	// Maybe fetch the perspective from the backing?	881	// Maybe fetch the perspective from the backing?
882	const LayoutRect borderBox = toRenderBox(renderer())->borderBoxRect();	882	const IntRect borderBox = toRenderBox(renderer())->pixelSnappedBorderBoxRect();
883	const float boxWidth = borderBox.width();	883	const float boxWidth = borderBox.width();
884	const float boxHeight = borderBox.height();	884	const float boxHeight = borderBox.height();
885		885
Lines 2841-2847 bool RenderLayer::scroll(ScrollDirection Source/WebCore/rendering/RenderLayer.cpp_sec4
2841	void RenderLayer::paint(GraphicsContext* context, const LayoutRect& damageRect, PaintBehavior paintBehavior, RenderObject* paintingRoot, RenderRegion* region, PaintLayerFlags paintFlags)	2841	void RenderLayer::paint(GraphicsContext* context, const LayoutRect& damageRect, PaintBehavior paintBehavior, RenderObject* paintingRoot, RenderRegion* region, PaintLayerFlags paintFlags)
2842	{	2842	{
2843	OverlapTestRequestMap overlapTestRequests;	2843	OverlapTestRequestMap overlapTestRequests;
2844	paintLayer(this, context, damageRect, paintBehavior, paintingRoot, region, &overlapTestRequests, paintFlags);	2844	paintLayer(this, context, enclosingIntRect(damageRect), LayoutSize(), paintBehavior, paintingRoot, region, &overlapTestRequests, paintFlags);
2845	OverlapTestRequestMap::iterator end = overlapTestRequests.end();	2845	OverlapTestRequestMap::iterator end = overlapTestRequests.end();
2846	for (OverlapTestRequestMap::iterator it = overlapTestRequests.begin(); it != end; ++it)	2846	for (OverlapTestRequestMap::iterator it = overlapTestRequests.begin(); it != end; ++it)
2847	it->first->setOverlapTestResult(false);	2847	it->first->setOverlapTestResult(false);
Lines 2851-2857 void RenderLayer::paintOverlayScrollbars Source/WebCore/rendering/RenderLayer.cpp_sec5
2851	{	2851	{
2852	if (!m_containsDirtyOverlayScrollbars)	2852	if (!m_containsDirtyOverlayScrollbars)
2853	return;	2853	return;
2854	paintLayer(this, context, damageRect, paintBehavior, paintingRoot, 0, 0, PaintLayerHaveTransparency \| PaintLayerTemporaryClipRects	2854	paintLayer(this, context, damageRect, LayoutSize(), paintBehavior, paintingRoot, 0, 0, PaintLayerHaveTransparency \| PaintLayerTemporaryClipRects
2855	\| PaintLayerPaintingOverlayScrollbars);	2855	\| PaintLayerPaintingOverlayScrollbars);
2856	m_containsDirtyOverlayScrollbars = false;	2856	m_containsDirtyOverlayScrollbars = false;
2857	}	2857	}
Lines 2948-2954 static inline bool shouldSuppressPaintin Source/WebCore/rendering/RenderLayer.cpp_sec6
2948		2948
2949		2949
2950	void RenderLayer::paintLayer(RenderLayer* rootLayer, GraphicsContext* context,	2950	void RenderLayer::paintLayer(RenderLayer* rootLayer, GraphicsContext* context,
2951	const LayoutRect& paintDirtyRect, PaintBehavior paintBehavior,	2951	const LayoutRect& paintDirtyRect, const LayoutSize& subPixelAccumulation, PaintBehavior paintBehavior,
2952	RenderObject* paintingRoot, RenderRegion* region, OverlapTestRequestMap* overlapTestRequests,	2952	RenderObject* paintingRoot, RenderRegion* region, OverlapTestRequestMap* overlapTestRequests,
2953	PaintLayerFlags paintFlags)	2953	PaintLayerFlags paintFlags)
2954	{	2954	{
Lines 3006-3016 void RenderLayer::paintLayer(RenderLayer Source/WebCore/rendering/RenderLayer.cpp_sec7
3006	}	3006	}
3007		3007
3008	// Adjust the transform such that the renderer's upper left corner will paint at (0,0) in user space.	3008	// Adjust the transform such that the renderer's upper left corner will paint at (0,0) in user space.
3009	// This involves subtracting out the position of the layer in our current coordinate space.	3009	// This involves subtracting out the position of the layer in our current coordinate space, but preserving
		3010	// the accumulated error for sub-pixel layout.
3010	LayoutPoint delta;	3011	LayoutPoint delta;
3011	convertToLayerCoords(rootLayer, delta);	3012	convertToLayerCoords(rootLayer, delta);
3012	TransformationMatrix transform(layerTransform);	3013	TransformationMatrix transform(layerTransform);
3013	transform.translateRight(delta.x(), delta.y());	3014	IntPoint roundedDelta = roundedIntPoint(delta);
		3015	transform.translateRight(roundedDelta.x(), roundedDelta.y());
		3016	LayoutSize adjustedSubPixelAccumulation = subPixelAccumulation + (delta - roundedDelta);
3014		3017
3015	// Apply the transform.	3018	// Apply the transform.
3016	{	3019	{
Lines 3018-3024 void RenderLayer::paintLayer(RenderLayer Source/WebCore/rendering/RenderLayer.cpp_sec8
3018	context->concatCTM(transform.toAffineTransform());	3021	context->concatCTM(transform.toAffineTransform());
3019		3022
3020	// Now do a paint with the root layer shifted to be us.	3023	// Now do a paint with the root layer shifted to be us.
3021	paintLayerContentsAndReflection(this, context, transform.inverse().mapRect(paintDirtyRect), paintBehavior, paintingRoot, region, overlapTestRequests, paintFlags);	3024	paintLayerContentsAndReflection(this, context, enclosingIntRect(transform.inverse().mapRect(paintDirtyRect)), adjustedSubPixelAccumulation, paintBehavior, paintingRoot, region, overlapTestRequests, paintFlags);
3022	}	3025	}
3023		3026
3024	// Restore the clip.	3027	// Restore the clip.
Lines 3028-3038 void RenderLayer::paintLayer(RenderLayer Source/WebCore/rendering/RenderLayer.cpp_sec9
3028	return;	3031	return;
3029	}	3032	}
3030		3033
3031	paintLayerContentsAndReflection(rootLayer, context, paintDirtyRect, paintBehavior, paintingRoot, region, overlapTestRequests, paintFlags);	3034	paintLayerContentsAndReflection(rootLayer, context, paintDirtyRect, subPixelAccumulation, paintBehavior, paintingRoot, region, overlapTestRequests, paintFlags);
3032	}	3035	}
3033		3036
3034	void RenderLayer::paintLayerContentsAndReflection(RenderLayer* rootLayer, GraphicsContext* context,	3037	void RenderLayer::paintLayerContentsAndReflection(RenderLayer* rootLayer, GraphicsContext* context,
3035	const LayoutRect& paintDirtyRect, PaintBehavior paintBehavior,	3038	const LayoutRect& paintDirtyRect, const LayoutSize& subPixelAccumulation, PaintBehavior paintBehavior,
3036	RenderObject* paintingRoot, RenderRegion* region, OverlapTestRequestMap* overlapTestRequests,	3039	RenderObject* paintingRoot, RenderRegion* region, OverlapTestRequestMap* overlapTestRequests,
3037	PaintLayerFlags paintFlags)	3040	PaintLayerFlags paintFlags)
3038	{	3041	{
Lines 3044-3059 void RenderLayer::paintLayerContentsAndR Source/WebCore/rendering/RenderLayer.cpp_sec10
3044	if (m_reflection && !m_paintingInsideReflection) {	3047	if (m_reflection && !m_paintingInsideReflection) {
3045	// Mark that we are now inside replica painting.	3048	// Mark that we are now inside replica painting.
3046	m_paintingInsideReflection = true;	3049	m_paintingInsideReflection = true;
3047	reflectionLayer()->paintLayer(rootLayer, context, paintDirtyRect, paintBehavior, paintingRoot, region, overlapTestRequests, localPaintFlags \| PaintLayerPaintingReflection);	3050	reflectionLayer()->paintLayer(rootLayer, context, paintDirtyRect, subPixelAccumulation, paintBehavior, paintingRoot, region, overlapTestRequests, localPaintFlags \| PaintLayerPaintingReflection);
3048	m_paintingInsideReflection = false;	3051	m_paintingInsideReflection = false;
3049	}	3052	}
3050		3053
3051	localPaintFlags \|= PaintLayerPaintingCompositingAllPhases;	3054	localPaintFlags \|= PaintLayerPaintingCompositingAllPhases;
3052	paintLayerContents(rootLayer, context, paintDirtyRect, paintBehavior, paintingRoot, region, overlapTestRequests, localPaintFlags);	3055	paintLayerContents(rootLayer, context, paintDirtyRect, subPixelAccumulation, paintBehavior, paintingRoot, region, overlapTestRequests, localPaintFlags);
3053	}	3056	}
3054		3057
3055	void RenderLayer::paintLayerContents(RenderLayer* rootLayer, GraphicsContext* context,	3058	void RenderLayer::paintLayerContents(RenderLayer* rootLayer, GraphicsContext* context,
3056	const LayoutRect& parentPaintDirtyRect, PaintBehavior paintBehavior,	3059	const LayoutRect& parentPaintDirtyRect, const LayoutSize& subPixelAccumulation, PaintBehavior paintBehavior,
3057	RenderObject* paintingRoot, RenderRegion* region, OverlapTestRequestMap* overlapTestRequests,	3060	RenderObject* paintingRoot, RenderRegion* region, OverlapTestRequestMap* overlapTestRequests,
3058	PaintLayerFlags paintFlags)	3061	PaintLayerFlags paintFlags)
3059	{	3062	{
Lines 3112-3118 void RenderLayer::paintLayerContents(Ren Source/WebCore/rendering/RenderLayer.cpp_sec11
3112		3115
3113	if (shouldPaintContent \|\| shouldPaintOutline \|\| isPaintingOverlayScrollbars) {	3116	if (shouldPaintContent \|\| shouldPaintOutline \|\| isPaintingOverlayScrollbars) {
3114	calculateRects(rootLayer, region, (localPaintFlags & PaintLayerTemporaryClipRects) ? TemporaryClipRects : PaintingClipRects, paintDirtyRect, layerBounds, damageRect, clipRectToApply, outlineRect);	3117	calculateRects(rootLayer, region, (localPaintFlags & PaintLayerTemporaryClipRects) ? TemporaryClipRects : PaintingClipRects, paintDirtyRect, layerBounds, damageRect, clipRectToApply, outlineRect);
3115	paintOffset = toPoint(layerBounds.location() - renderBoxLocation());	3118	paintOffset = toPoint(layerBounds.location() - renderBoxLocation() + subPixelAccumulation);
3116	}	3119	}
3117		3120
3118	bool forceBlackText = paintBehavior & PaintBehaviorForceBlackText;	3121	bool forceBlackText = paintBehavior & PaintBehaviorForceBlackText;
Lines 3263-3269 void RenderLayer::paintList(Vector<Rende Source/WebCore/rendering/RenderLayer.cpp_sec12
3263	for (size_t i = 0; i < list->size(); ++i) {	3266	for (size_t i = 0; i < list->size(); ++i) {
3264	RenderLayer* childLayer = list->at(i);	3267	RenderLayer* childLayer = list->at(i);
3265	if (!childLayer->isPaginated())	3268	if (!childLayer->isPaginated())
3266	childLayer->paintLayer(rootLayer, context, paintDirtyRect, paintBehavior, paintingRoot, region, overlapTestRequests, paintFlags);	3269	childLayer->paintLayer(rootLayer, context, paintDirtyRect, LayoutSize(), paintBehavior, paintingRoot, region, overlapTestRequests, paintFlags);
3267	else	3270	else
3268	paintPaginatedChildLayer(childLayer, rootLayer, context, paintDirtyRect, paintBehavior, paintingRoot, region, overlapTestRequests, paintFlags);	3271	paintPaginatedChildLayer(childLayer, rootLayer, context, paintDirtyRect, paintBehavior, paintingRoot, region, overlapTestRequests, paintFlags);
3269	}	3272	}
Lines 3354-3360 void RenderLayer::paintChildLayerIntoCol Source/WebCore/rendering/RenderLayer.cpp_sec13
3354	newTransform.translateRight(roundToInt(offset.width()), roundToInt(offset.height()));	3357	newTransform.translateRight(roundToInt(offset.width()), roundToInt(offset.height()));
3355		3358
3356	childLayer->m_transform = adoptPtr(new TransformationMatrix(newTransform));	3359	childLayer->m_transform = adoptPtr(new TransformationMatrix(newTransform));
3357	childLayer->paintLayer(rootLayer, context, localDirtyRect, paintBehavior, paintingRoot, region, overlapTestRequests, paintFlags);	3360	childLayer->paintLayer(rootLayer, context, localDirtyRect, LayoutSize(), paintBehavior, paintingRoot, region, overlapTestRequests, paintFlags);
3358	if (oldHasTransform)	3361	if (oldHasTransform)
3359	childLayer->m_transform = adoptPtr(new TransformationMatrix(oldTransform));	3362	childLayer->m_transform = adoptPtr(new TransformationMatrix(oldTransform));
3360	else	3363	else
Lines 3950-3956 void RenderLayer::calculateClipRects(con Source/WebCore/rendering/RenderLayer.cpp_sec14
3950	// some transformed layer boundary, for example, in the RenderLayerCompositor overlapMap, where	3953	// some transformed layer boundary, for example, in the RenderLayerCompositor overlapMap, where
3951	// clipRects are needed in view space.	3954	// clipRects are needed in view space.
3952	LayoutPoint offset;	3955	LayoutPoint offset;
3953	offset = roundedIntPoint(renderer()->localToContainerPoint(FloatPoint(), rootLayer->renderer()));	3956	offset = roundedLayoutPoint(renderer()->localToContainerPoint(FloatPoint(), rootLayer->renderer(), true, false, 0));
3954	RenderView* view = renderer()->view();	3957	RenderView* view = renderer()->view();
3955	ASSERT(view);	3958	ASSERT(view);
3956	if (view && clipRects.fixed() && rootLayer->renderer() == view) {	3959	if (view && clipRects.fixed() && rootLayer->renderer() == view) {
Lines 4058-4064 void RenderLayer::calculateRects(const R Source/WebCore/rendering/RenderLayer.cpp_sec15
4058	backgroundRect.intersect(layerBoundsWithVisualOverflow);	4061	backgroundRect.intersect(layerBoundsWithVisualOverflow);
4059	} else {	4062	} else {
4060	// Shift the bounds to be for our region only.	4063	// Shift the bounds to be for our region only.
4061	LayoutRect bounds = pixelSnappedIntRect(renderBox()->borderBoxRectInRegion(region));	4064	LayoutRect bounds = renderBox()->borderBoxRectInRegion(region);
4062	bounds.moveBy(offset);	4065	bounds.moveBy(offset);
4063	backgroundRect.intersect(bounds);	4066	backgroundRect.intersect(bounds);
4064	}	4067	}

Lines 709-721 private: Source/WebCore/rendering/RenderLayer.h_sec1
- Source/WebCore/rendering/RenderLayer.h -3 / +3 lines
709		709
710	void updateCompositingAndLayerListsIfNeeded();	710	void updateCompositingAndLayerListsIfNeeded();
711		711
712	void paintLayer(RenderLayer* rootLayer, GraphicsContext*, const LayoutRect& paintDirtyRect,	712	void paintLayer(RenderLayer* rootLayer, GraphicsContext*, const LayoutRect& paintDirtyRect, const LayoutSize& subPixelAccumulation,
713	PaintBehavior, RenderObject* paintingRoot, RenderRegion* = 0, OverlapTestRequestMap* = 0,	713	PaintBehavior, RenderObject* paintingRoot, RenderRegion* = 0, OverlapTestRequestMap* = 0,
714	PaintLayerFlags = 0);	714	PaintLayerFlags = 0);
715	void paintLayerContentsAndReflection(RenderLayer* rootLayer, GraphicsContext*, const LayoutRect& paintDirtyRect,	715	void paintLayerContentsAndReflection(RenderLayer* rootLayer, GraphicsContext*, const LayoutRect& paintDirtyRect, const LayoutSize& subPixelAccumulation,
716	PaintBehavior, RenderObject* paintingRoot, RenderRegion* = 0, OverlapTestRequestMap* = 0,	716	PaintBehavior, RenderObject* paintingRoot, RenderRegion* = 0, OverlapTestRequestMap* = 0,
717	PaintLayerFlags = 0);	717	PaintLayerFlags = 0);
718	void paintLayerContents(RenderLayer* rootLayer, GraphicsContext*, const LayoutRect& paintDirtyRect,	718	void paintLayerContents(RenderLayer* rootLayer, GraphicsContext*, const LayoutRect& paintDirtyRect, const LayoutSize& subPixelAccumulation,
719	PaintBehavior, RenderObject* paintingRoot, RenderRegion* = 0, OverlapTestRequestMap* = 0,	719	PaintBehavior, RenderObject* paintingRoot, RenderRegion* = 0, OverlapTestRequestMap* = 0,
720	PaintLayerFlags = 0);	720	PaintLayerFlags = 0);
721	void paintList(Vector<RenderLayer>, RenderLayer* rootLayer, GraphicsContext* p,	721	void paintList(Vector<RenderLayer>, RenderLayer* rootLayer, GraphicsContext* p,

Lines 1987-1993 LayoutRect RenderObject::viewRect() cons Source/WebCore/rendering/RenderObject.cpp_sec1
- Source/WebCore/rendering/RenderObject.cpp -9 / +24 lines
1987	FloatPoint RenderObject::localToAbsolute(const FloatPoint& localPoint, bool fixed, bool useTransforms) const	1987	FloatPoint RenderObject::localToAbsolute(const FloatPoint& localPoint, bool fixed, bool useTransforms) const
1988	{	1988	{
1989	TransformState transformState(TransformState::ApplyTransformDirection, localPoint);	1989	TransformState transformState(TransformState::ApplyTransformDirection, localPoint);
1990	mapLocalToContainer(0, fixed, useTransforms, transformState);	1990	MapLocalToContainerFlags mode = ApplyContainerFlip;
		1991	if (fixed)
		1992	mode \|= IsFixed;
		1993	if (useTransforms)
		1994	mode \|= useTransforms;
		1995	mapLocalToContainer(0, transformState, mode);
1991	transformState.flatten();	1996	transformState.flatten();
1992		1997
1993	return transformState.lastPlanarPoint();	1998	return transformState.lastPlanarPoint();
Lines 2002-2008 FloatPoint RenderObject::absoluteToLocal Source/WebCore/rendering/RenderObject.cpp_sec2
2002	return transformState.lastPlanarPoint();	2007	return transformState.lastPlanarPoint();
2003	}	2008	}
2004		2009
2005	void RenderObject::mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool fixed, bool useTransforms, TransformState& transformState, ApplyContainerFlipOrNot applyContainerFlip, bool* wasFixed) const	2010	void RenderObject::mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState& transformState, MapLocalToContainerFlags mode, bool* wasFixed) const
2006	{	2011	{
2007	if (repaintContainer == this)	2012	if (repaintContainer == this)
2008	return;	2013	return;
Lines 2013-2022 void RenderObject::mapLocalToContainer(R Source/WebCore/rendering/RenderObject.cpp_sec3
2013		2018
2014	// FIXME: this should call offsetFromContainer to share code, but I'm not sure it's ever called.	2019	// FIXME: this should call offsetFromContainer to share code, but I'm not sure it's ever called.
2015	LayoutPoint centerPoint = roundedLayoutPoint(transformState.mappedPoint());	2020	LayoutPoint centerPoint = roundedLayoutPoint(transformState.mappedPoint());
2016	if (applyContainerFlip && o->isBox()) {	2021	if (mode & ApplyContainerFlip && o->isBox()) {
2017	if (o->style()->isFlippedBlocksWritingMode())	2022	if (o->style()->isFlippedBlocksWritingMode())
2018	transformState.move(toRenderBox(o)->flipForWritingModeIncludingColumns(roundedLayoutPoint(transformState.mappedPoint())) - centerPoint);	2023	transformState.move(toRenderBox(o)->flipForWritingModeIncludingColumns(roundedLayoutPoint(transformState.mappedPoint())) - centerPoint);
2019	applyContainerFlip = DoNotApplyContainerFlip;	2024	mode &= ~ApplyContainerFlip;
2020	}	2025	}
2021		2026
2022	LayoutSize columnOffset;	2027	LayoutSize columnOffset;
Lines 2027-2033 void RenderObject::mapLocalToContainer(R Source/WebCore/rendering/RenderObject.cpp_sec4
2027	if (o->hasOverflowClip())	2032	if (o->hasOverflowClip())
2028	transformState.move(-toRenderBox(o)->scrolledContentOffset());	2033	transformState.move(-toRenderBox(o)->scrolledContentOffset());
2029		2034
2030	o->mapLocalToContainer(repaintContainer, fixed, useTransforms, transformState, applyContainerFlip, wasFixed);	2035	o->mapLocalToContainer(repaintContainer, transformState, mode, wasFixed);
2031	}	2036	}
2032		2037
2033	const RenderObject* RenderObject::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const	2038	const RenderObject* RenderObject::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
Lines 2096-2116 void RenderObject::getTransformFromConta Source/WebCore/rendering/RenderObject.cpp_sec5
2096	#endif	2101	#endif
2097	}	2102	}
2098		2103
2099	FloatQuad RenderObject::localToContainerQuad(const FloatQuad& localQuad, RenderBoxModelObject* repaintContainer, bool fixed, bool* wasFixed) const	2104	FloatQuad RenderObject::localToContainerQuad(const FloatQuad& localQuad, RenderBoxModelObject* repaintContainer, bool snapOffsetForTransforms, bool fixed, bool* wasFixed) const
2100	{	2105	{
2101	// Track the point at the center of the quad's bounding box. As mapLocalToContainer() calls offsetFromContainer(),	2106	// Track the point at the center of the quad's bounding box. As mapLocalToContainer() calls offsetFromContainer(),
2102	// it will use that point as the reference point to decide which column's transform to apply in multiple-column blocks.	2107	// it will use that point as the reference point to decide which column's transform to apply in multiple-column blocks.
2103	TransformState transformState(TransformState::ApplyTransformDirection, localQuad.boundingBox().center(), localQuad);	2108	TransformState transformState(TransformState::ApplyTransformDirection, localQuad.boundingBox().center(), localQuad);
2104	mapLocalToContainer(repaintContainer, fixed, true, transformState, ApplyContainerFlip, wasFixed);	2109	MapLocalToContainerFlags mode = ApplyContainerFlip \| UseTransforms;
		2110	if (fixed)
		2111	mode \|= IsFixed;
		2112	if (snapOffsetForTransforms)
		2113	mode \|= SnapOffsetForTransforms;
		2114	mapLocalToContainer(repaintContainer, transformState, mode, wasFixed);
2105	transformState.flatten();	2115	transformState.flatten();
2106		2116
2107	return transformState.lastPlanarQuad();	2117	return transformState.lastPlanarQuad();
2108	}	2118	}
2109		2119
2110	FloatPoint RenderObject::localToContainerPoint(const FloatPoint& localPoint, RenderBoxModelObject* repaintContainer, bool fixed, bool* wasFixed) const	2120	FloatPoint RenderObject::localToContainerPoint(const FloatPoint& localPoint, RenderBoxModelObject* repaintContainer, bool snapOffsetForTransforms, bool fixed, bool* wasFixed) const
2111	{	2121	{
2112	TransformState transformState(TransformState::ApplyTransformDirection, localPoint);	2122	TransformState transformState(TransformState::ApplyTransformDirection, localPoint);
2113	mapLocalToContainer(repaintContainer, fixed, true, transformState, ApplyContainerFlip, wasFixed);	2123	MapLocalToContainerFlags mode = ApplyContainerFlip \| UseTransforms;
		2124	if (fixed)
		2125	mode \|= IsFixed;
		2126	if (snapOffsetForTransforms)
		2127	mode \|= SnapOffsetForTransforms;
		2128	mapLocalToContainer(repaintContainer, transformState, mode, wasFixed);
2114	transformState.flatten();	2129	transformState.flatten();
2115		2130
2116	return transformState.lastPlanarPoint();	2131	return transformState.lastPlanarPoint();

Lines 107-112 enum PlaceGeneratedRunInFlag { Source/WebCore/rendering/RenderObject.h_sec1
- Source/WebCore/rendering/RenderObject.h -5 / +12 lines
107	DoNotPlaceGeneratedRunIn	107	DoNotPlaceGeneratedRunIn
108	};	108	};
109		109
		110	enum MapLocalToContainerMode {
		111	IsFixed = 1 << 0,
		112	UseTransforms = 1 << 1,
		113	ApplyContainerFlip = 1 << 2,
		114	SnapOffsetForTransforms = 1 << 3
		115	};
		116	typedef unsigned MapLocalToContainerFlags;
		117
110	const int caretWidth = 1;	118	const int caretWidth = 1;
111		119
112	#if ENABLE(DASHBOARD_SUPPORT)	120	#if ENABLE(DASHBOARD_SUPPORT)
Lines 676-687 public: Source/WebCore/rendering/RenderObject.h_sec2
676	// Convert a local quad to absolute coordinates, taking transforms into account.	684	// Convert a local quad to absolute coordinates, taking transforms into account.
677	FloatQuad localToAbsoluteQuad(const FloatQuad& quad, bool fixed = false, bool* wasFixed = 0) const	685	FloatQuad localToAbsoluteQuad(const FloatQuad& quad, bool fixed = false, bool* wasFixed = 0) const
678	{	686	{
679	return localToContainerQuad(quad, 0, fixed, wasFixed);	687	return localToContainerQuad(quad, 0, true, fixed, wasFixed);
680	}	688	}
681		689
682	// Convert a local quad into the coordinate system of container, taking transforms into account.	690	// Convert a local quad into the coordinate system of container, taking transforms into account.
683	FloatQuad localToContainerQuad(const FloatQuad&, RenderBoxModelObject* repaintContainer, bool fixed = false, bool* wasFixed = 0) const;	691	FloatQuad localToContainerQuad(const FloatQuad&, RenderBoxModelObject* repaintContainer, bool snapOffsetsForTransforms = true, bool fixed = false, bool* wasFixed = 0) const;
684	FloatPoint localToContainerPoint(const FloatPoint&, RenderBoxModelObject* repaintContainer, bool fixed = false, bool* wasFixed = 0) const;	692	FloatPoint localToContainerPoint(const FloatPoint&, RenderBoxModelObject* repaintContainer, bool snapOffsetsForTransforms = true, bool fixed = false, bool* wasFixed = 0) const;
685		693
686	// Return the offset from the container() renderer (excluding transforms). In multi-column layout,	694	// Return the offset from the container() renderer (excluding transforms). In multi-column layout,
687	// different offsets apply at different points, so return the offset that applies to the given point.	695	// different offsets apply at different points, so return the offset that applies to the given point.
Lines 878-885 public: Source/WebCore/rendering/RenderObject.h_sec3
878		886
879	// Map points and quads through elements, potentially via 3d transforms. You should never need to call these directly; use	887	// Map points and quads through elements, potentially via 3d transforms. You should never need to call these directly; use
880	// localToAbsolute/absoluteToLocal methods instead.	888	// localToAbsolute/absoluteToLocal methods instead.
881	enum ApplyContainerFlipOrNot { DoNotApplyContainerFlip, ApplyContainerFlip };	889	virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState&, MapLocalToContainerFlags mode = SnapOffsetForTransforms \| ApplyContainerFlip, bool* wasFixed = 0) const;
882	virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool useTransforms, bool fixed, TransformState&, ApplyContainerFlipOrNot = ApplyContainerFlip, bool* wasFixed = 0) const;
883	virtual void mapAbsoluteToLocalPoint(bool fixed, bool useTransforms, TransformState&) const;	890	virtual void mapAbsoluteToLocalPoint(bool fixed, bool useTransforms, TransformState&) const;
884		891
885	// Pushes state onto RenderGeometryMap about how to map coordinates from this renderer to its container, or ancestorToStopAt (whichever is encountered first).	892	// Pushes state onto RenderGeometryMap about how to map coordinates from this renderer to its container, or ancestorToStopAt (whichever is encountered first).

Lines 165-184 void RenderView::layout() Source/WebCore/rendering/RenderView.cpp_sec1
- Source/WebCore/rendering/RenderView.cpp -4 / +4 lines
165	setNeedsLayout(false);	165	setNeedsLayout(false);
166	}	166	}
167		167
168	void RenderView::mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool fixed, bool useTransforms, TransformState& transformState, ApplyContainerFlipOrNot, bool* wasFixed) const	168	void RenderView::mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState& transformState, MapLocalToContainerFlags mode, bool* wasFixed) const
169	{	169	{
170	// If a container was specified, and was not 0 or the RenderView,	170	// If a container was specified, and was not 0 or the RenderView,
171	// then we should have found it by now.	171	// then we should have found it by now.
172	ASSERT_ARG(repaintContainer, !repaintContainer \|\| repaintContainer == this);	172	ASSERT_ARG(repaintContainer, !repaintContainer \|\| repaintContainer == this);
173	ASSERT_UNUSED(wasFixed, !wasFixed \|\| *wasFixed == fixed);	173	ASSERT_UNUSED(wasFixed, !wasFixed \|\| *wasFixed == (mode & IsFixed));
174		174
175	if (!repaintContainer && useTransforms && shouldUseTransformFromContainer(0)) {	175	if (!repaintContainer && mode & UseTransforms && shouldUseTransformFromContainer(0)) {
176	TransformationMatrix t;	176	TransformationMatrix t;
177	getTransformFromContainer(0, LayoutSize(), t);	177	getTransformFromContainer(0, LayoutSize(), t);
178	transformState.applyTransform(t);	178	transformState.applyTransform(t);
179	}	179	}
180		180
181	if (fixed && m_frameView)	181	if (mode & IsFixed && m_frameView)
182	transformState.move(m_frameView->scrollOffsetForFixedPosition());	182	transformState.move(m_frameView->scrollOffsetForFixedPosition());
183	}	183	}
184		184

Lines 79-87 void RenderSVGInline::computeFloatRectFo Source/WebCore/rendering/svg/RenderSVGInline.cpp_sec1
- Source/WebCore/rendering/svg/RenderSVGInline.cpp -2 / +2 lines
79	SVGRenderSupport::computeFloatRectForRepaint(this, repaintContainer, repaintRect, fixed);	79	SVGRenderSupport::computeFloatRectForRepaint(this, repaintContainer, repaintRect, fixed);
80	}	80	}
81		81
82	void RenderSVGInline::mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool /* useTransforms /, bool / fixed /, TransformState& transformState, ApplyContainerFlipOrNot, bool wasFixed) const	82	void RenderSVGInline::mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState& transformState, MapLocalToContainerFlags mode, bool* wasFixed) const
83	{	83	{
84	SVGRenderSupport::mapLocalToContainer(this, repaintContainer, transformState, wasFixed);	84	SVGRenderSupport::mapLocalToContainer(this, repaintContainer, transformState, mode & SnapOffsetForTransforms, wasFixed);
85	}	85	}
86		86
87	const RenderObject* RenderSVGInline::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const	87	const RenderObject* RenderSVGInline::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const

Lines 395-406 void RenderSVGRoot::computeFloatRectForR Source/WebCore/rendering/svg/RenderSVGRoot.cpp_sec1
- Source/WebCore/rendering/svg/RenderSVGRoot.cpp -4 / +4 lines
395	// This method expects local CSS box coordinates.	395	// This method expects local CSS box coordinates.
396	// Callers with local SVG viewport coordinates should first apply the localToBorderBoxTransform	396	// Callers with local SVG viewport coordinates should first apply the localToBorderBoxTransform
397	// to convert from SVG viewport coordinates to local CSS box coordinates.	397	// to convert from SVG viewport coordinates to local CSS box coordinates.
398	void RenderSVGRoot::mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool fixed, bool useTransforms, TransformState& transformState, ApplyContainerFlipOrNot, bool* wasFixed) const	398	void RenderSVGRoot::mapLocalToContainer(RenderBoxModelObject* repaintContainer, TransformState& transformState, MapLocalToContainerFlags mode, bool* wasFixed) const
399	{	399	{
400	ASSERT(!fixed); // We should have no fixed content in the SVG rendering tree.	400	ASSERT(mode & !IsFixed); // We should have no fixed content in the SVG rendering tree.
401	ASSERT(useTransforms); // mapping a point through SVG w/o respecting trasnforms is useless.	401	ASSERT(mode & UseTransforms); // mapping a point through SVG w/o respecting trasnforms is useless.
402		402
403	RenderReplaced::mapLocalToContainer(repaintContainer, fixed, useTransforms, transformState, ApplyContainerFlip, wasFixed);	403	RenderReplaced::mapLocalToContainer(repaintContainer, transformState, mode \| ApplyContainerFlip, wasFixed);
404	}	404	}
405		405
406	const RenderObject* RenderSVGRoot::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const	406	const RenderObject* RenderSVGRoot::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const

Lines 27-32 Source/WebCore/rendering/svg/SVGRenderSupport.h_sec1
- Source/WebCore/rendering/svg/SVGRenderSupport.h -2 / +2 lines
27	#if ENABLE(SVG)	27	#if ENABLE(SVG)
28	#include "LayoutTypes.h"	28	#include "LayoutTypes.h"
29	#include "PaintInfo.h"	29	#include "PaintInfo.h"
		30	#include "RenderObject.h"
30		31
31	namespace WebCore {	32	namespace WebCore {
32		33
Lines 35-41 class FloatRect; Source/WebCore/rendering/svg/SVGRenderSupport.h_sec2
35	class ImageBuffer;	36	class ImageBuffer;
36	class RenderBoxModelObject;	37	class RenderBoxModelObject;
37	class RenderGeometryMap;	38	class RenderGeometryMap;
38	class RenderObject;
39	class RenderStyle;	39	class RenderStyle;
40	class RenderSVGRoot;	40	class RenderSVGRoot;
41	class TransformState;	41	class TransformState;
Lines 64-70 public: Source/WebCore/rendering/svg/SVGRenderSupport.h_sec3
64	// Important functions used by nearly all SVG renderers centralizing coordinate transformations / repaint rect calculations	64	// Important functions used by nearly all SVG renderers centralizing coordinate transformations / repaint rect calculations
65	static LayoutRect clippedOverflowRectForRepaint(const RenderObject, RenderBoxModelObject repaintContainer);	65	static LayoutRect clippedOverflowRectForRepaint(const RenderObject, RenderBoxModelObject repaintContainer);
66	static void computeFloatRectForRepaint(const RenderObject, RenderBoxModelObject repaintContainer, FloatRect&, bool fixed);	66	static void computeFloatRectForRepaint(const RenderObject, RenderBoxModelObject repaintContainer, FloatRect&, bool fixed);
67	static void mapLocalToContainer(const RenderObject, RenderBoxModelObject repaintContainer, TransformState&, bool* wasFixed = 0);	67	static void mapLocalToContainer(const RenderObject, RenderBoxModelObject repaintContainer, TransformState&, bool snapOffsetsForTransforms = true, bool* wasFixed = 0);
68	static const RenderObject* pushMappingToContainer(const RenderObject, const RenderBoxModelObject ancestorToStopAt, RenderGeometryMap&);	68	static const RenderObject* pushMappingToContainer(const RenderObject, const RenderBoxModelObject ancestorToStopAt, RenderGeometryMap&);
69		69
70	// Shared between SVG renderers and resources.	70	// Shared between SVG renderers and resources.

Lines 1-3 LayoutTests/ChangeLog_sec1
- LayoutTests/ChangeLog +37 lines
		1	2012-07-31 Levi Weintraub <leviw@chromium.org>
		2
		3	Accumulate sub-pixel offsets through layers and transforms
		4	https://bugs.webkit.org/show_bug.cgi?id=89238
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* fast/sub-pixel/sub-pixel-accumulates-to-layers.html: Added.
		9	* platform/chromium-mac-snowleopard/compositing/shadows/shadow-drawing-expected.png:
		10	* platform/chromium-mac-snowleopard/fast/sub-pixel/sub-pixel-accumulates-to-layers-expected.png: Added.
		11	* platform/chromium-mac-snowleopard/fast/sub-pixel/sub-pixel-accumulates-to-layers-expected.txt: Added.
		12	* platform/chromium-mac-snowleopard/fast/transforms/rotated-transform-affects-scrolling-1-expected.png:
		13	* platform/chromium-mac-snowleopard/fast/transforms/rotated-transform-affects-scrolling-2-expected.png:
		14	* platform/chromium-mac/fast/clip/overflow-border-radius-composited-expected.txt:
		15	* platform/chromium-mac/fast/clip/overflow-border-radius-transformed-expected.txt:
		16	* platform/chromium-mac/fast/forms/validation-message-appearance-expected.txt:
		17	* platform/chromium-mac/fast/repaint/scroll-fixed-layer-with-transformed-parent-layer-expected.png:
		18	* platform/chromium-mac/fast/transforms/transformed-document-element-expected.png:
		19	* platform/chromium-mac/svg/transforms/svg-css-transforms-expected.png:
		20	* platform/chromium-mac/transforms/svg-vs-css-expected.png:
		21	* platform/chromium/TestExpectations:
		22	* platform/chromium/fast/transforms/rotated-transform-affects-scrolling-1-expected.txt:
		23	* platform/chromium/fast/transforms/rotated-transform-affects-scrolling-2-expected.txt:
		24	* platform/efl/Skipped:
		25	* platform/gtk/TestExpectations:
		26	* platform/mac-lion/Skipped:
		27	* platform/mac-snowleopard/Skipped:
		28	* platform/mac-wk2/Skipped:
		29	* platform/mac/Skipped:
		30	* platform/qt-4.8/Skipped:
		31	* platform/qt/Skipped:
		32	* platform/win-wk2/Skipped:
		33	* platform/win-xp/Skipped:
		34	* platform/win/Skipped:
		35	* platform/wincairo/Skipped:
		36	* platform/wk2/Skipped:
		37
1	2012-07-31 Max Vujovic <mvujovic@adobe.com>	38	2012-07-31 Max Vujovic <mvujovic@adobe.com>
2		39
3	[CSS Shaders] CSS parser rejects parameter names that are also CSS keywords	40	[CSS Shaders] CSS parser rejects parameter names that are also CSS keywords

Line 0 LayoutTests/fast/sub-pixel/sub-pixel-accumulates-to-layers.html_sec1
- LayoutTests/fast/sub-pixel/sub-pixel-accumulates-to-layers.html +41 lines
	1
	2	<!DOCTYPE html>
	3	<html>
	4	<head>
	5	<style>
	6	body {
	7	margin: 0;
	8	zoom: 0.9;
	9	-webkit-transform: scale(40);
	10	-webkit-transform-origin: 0 0;
	11	}
	12
	13	.container {
	14	position: absolute;
	15	top: 0px;
	16	left: 0px;
	17	width: 16px;
	18	height: 16px;
	19	}
	20
	21	.container > div {
	22	position: absolute;
	23	top: 0;
	24	left: 50%;
	25	width: 1.6px;
	26	height: 8px;
	27	margin-left: -0.8px;
	28
	29	background-color: red;
	30	}
	31	.rotated > div {
	32	background-color: green !important;
	33	-webkit-transform: rotateZ(0);
	34	}
	35	</style>
	36	</head>
	37	<body>
	38	<div class="container"><div></div></div>
	39	<div class="container rotated"><div></div></div>
	40	</body>
	41	</html>

Line 0 LayoutTests/platform/chromium-mac-snowleopard/fast/sub-pixel/sub-pixel-accumulates-to-layers-expected.txt_sec1
- LayoutTests/platform/chromium-mac-snowleopard/fast/sub-pixel/sub-pixel-accumulates-to-layers-expected.txt +12 lines
	1	layer at (0,0) size 32000x585
	2	RenderView at (0,0) size 800x585
	3	layer at (0,0) size 800x0
	4	RenderBlock {HTML} at (0,0) size 800x0
	5	layer at (0,0) size 14x14
	6	RenderBlock (positioned) {DIV} at (0,0) size 15x15
	7	layer at (6,0) size 2x7
	8	RenderBlock (positioned) {DIV} at (6,0) size 2x8 [bgcolor=#FF0000]
	9	layer at (0,0) size 14x14
	10	RenderBlock (positioned) {DIV} at (0,0) size 15x15
	11	layer at (6,0) size 2x7
	12	RenderBlock (positioned) {DIV} at (6,0) size 2x8 [bgcolor=#008000]

Lines 16-24 layer at (0,0) size 800x600 LayoutTests/platform/chromium-mac/fast/clip/overflow-border-radius-composited-expected.txt_sec1
- LayoutTests/platform/chromium-mac/fast/clip/overflow-border-radius-composited-expected.txt -5 / +5 lines
16	text run at (240,178) width 4: " "	16	text run at (240,178) width 4: " "
17	RenderBR {BR} at (244,192) size 0x0	17	RenderBR {BR} at (244,192) size 0x0
18	RenderText {#text} at (0,0) size 0x0	18	RenderText {#text} at (0,0) size 0x0
19	layer at (18,36) size 220x120 clip at (28,46) size 200x100 scrollWidth 206 scrollHeight 156	19	layer at (18,36) size 220x120 clip at (28,46) size 200x100 scrollWidth 207 scrollHeight 157
20	RenderBlock {DIV} at (10,28) size 220x120 [border: (10px solid #000000)]	20	RenderBlock {DIV} at (10,28) size 220x120 [border: (10px solid #000000)]
21	layer at (262,36) size 220x120 clip at (272,46) size 200x100 scrollWidth 206 scrollHeight 156	21	layer at (262,36) size 220x120 clip at (272,46) size 200x100 scrollWidth 207 scrollHeight 157
22	RenderBlock {DIV} at (254,28) size 220x120 [border: (10px solid #000000)]	22	RenderBlock {DIV} at (254,28) size 220x120 [border: (10px solid #000000)]
23	layer at (28,46) size 200x100	23	layer at (28,46) size 200x100
24	RenderBlock {DIV} at (10,10) size 200x100 [color=#FFFFFF] [bgcolor=#808080]	24	RenderBlock {DIV} at (10,10) size 200x100 [color=#FFFFFF] [bgcolor=#808080]
Lines 28-46 layer at (272,46) size 200x100 LayoutTests/platform/chromium-mac/fast/clip/overflow-border-radius-composited-expected.txt_sec2
28	RenderBlock (relative positioned) {DIV} at (10,10) size 200x100 [color=#FFFFFF] [bgcolor=#808080]	28	RenderBlock (relative positioned) {DIV} at (10,10) size 200x100 [color=#FFFFFF] [bgcolor=#808080]
29	RenderText {#text} at (0,0) size 95x18	29	RenderText {#text} at (0,0) size 95x18
30	text run at (0,0) width 95: "static > relative"	30	text run at (0,0) width 95: "static > relative"
31	layer at (506,36) size 220x120 clip at (516,46) size 200x100 scrollWidth 206 scrollHeight 156	31	layer at (506,36) size 220x120 clip at (516,46) size 200x100 scrollWidth 207 scrollHeight 157
32	RenderBlock (relative positioned) {DIV} at (498,28) size 220x120 [border: (10px solid #000000)]	32	RenderBlock (relative positioned) {DIV} at (498,28) size 220x120 [border: (10px solid #000000)]
33	layer at (516,46) size 200x100	33	layer at (516,46) size 200x100
34	RenderBlock {DIV} at (10,10) size 200x100 [color=#FFFFFF] [bgcolor=#808080]	34	RenderBlock {DIV} at (10,10) size 200x100 [color=#FFFFFF] [bgcolor=#808080]
35	RenderText {#text} at (0,0) size 95x18	35	RenderText {#text} at (0,0) size 95x18
36	text run at (0,0) width 95: "relative > static"	36	text run at (0,0) width 95: "relative > static"
37	layer at (18,176) size 220x120 clip at (28,186) size 200x100 scrollWidth 206 scrollHeight 156	37	layer at (18,176) size 220x120 clip at (28,186) size 200x100 scrollWidth 207 scrollHeight 157
38	RenderBlock (relative positioned) {DIV} at (10,168) size 220x120 [border: (10px solid #000000)]	38	RenderBlock (relative positioned) {DIV} at (10,168) size 220x120 [border: (10px solid #000000)]
39	layer at (28,186) size 200x100	39	layer at (28,186) size 200x100
40	RenderBlock (relative positioned) {DIV} at (10,10) size 200x100 [color=#FFFFFF] [bgcolor=#808080]	40	RenderBlock (relative positioned) {DIV} at (10,10) size 200x100 [color=#FFFFFF] [bgcolor=#808080]
41	RenderText {#text} at (0,0) size 109x18	41	RenderText {#text} at (0,0) size 109x18
42	text run at (0,0) width 109: "relative > relative"	42	text run at (0,0) width 109: "relative > relative"
43	layer at (18,316) size 220x120 clip at (28,326) size 200x100 scrollWidth 206 scrollHeight 156	43	layer at (18,316) size 220x120 clip at (28,326) size 200x100 scrollWidth 207 scrollHeight 157
44	RenderBlock (relative positioned) {DIV} at (10,308) size 220x120 [border: (10px solid #000000)]	44	RenderBlock (relative positioned) {DIV} at (10,308) size 220x120 [border: (10px solid #000000)]
45	layer at (28,326) size 200x100	45	layer at (28,326) size 200x100
46	RenderBlock (positioned) {DIV} at (10,10) size 200x100 [color=#FFFFFF] [bgcolor=#808080]	46	RenderBlock (positioned) {DIV} at (10,10) size 200x100 [color=#FFFFFF] [bgcolor=#808080]

Lines 3588-3593 BUGWK91372 WIN : css2.1/20110323/vertica LayoutTests/platform/chromium/TestExpectations_sec1
- LayoutTests/platform/chromium/TestExpectations +13 lines
3588	BUGWK90951 : fast/text/shaping/shaping-selection-rect.html = MISSING	3588	BUGWK90951 : fast/text/shaping/shaping-selection-rect.html = MISSING
3589	BUGWK90951 : fast/text/shaping/shaping-script-order.html = MISSING	3589	BUGWK90951 : fast/text/shaping/shaping-script-order.html = MISSING
3590		3590
		3591	// Need rebaseline after bots cycle
		3592	BUGLEVIW LION LEOPARD WIN LINUX : fast/sub-pixel/sub-pixel-accumulates-to-layers.html = PASS FAIL MISSING
		3593	BUGLEVIW LION LEOPARD WIN LINUX : fast/transforms/rotated-transform-affects-scrolling-1.html = PASS FAIL
		3594	BUGLEVIW LION LEOPARD WIN LINUX : fast/transforms/rotated-transform-affects-scrolling-2.html = PASS FAIL
		3595	BUGLEVIW LION LEOPARD WIN LINUX : fast/borders/border-antialiasing.html = PASS FAIL
		3596	BUGLEVIW LION LEOPARD WIN LINUX : fast/clip/overflow-border-radius-composited.html = PASS FAIL
		3597	BUGLEVIW LION LEOPARD WIN LINUX : fast/clip/overflow-border-radius-transformed.html = PASS FAIL
		3598	BUGLEVIW LION LEOPARD WIN LINUX : fast/forms/validation-message-appearance.html = PASS FAIL
		3599	BUGLEVIW LION LEOPARD WIN LINUX : fast/repaint/scroll-fixed-layer-with-transformed-parent-layer.html = PASS FAIL
		3600	BUGLEVIW LION LEOPARD WIN LINUX : fast/transforms/transformed-document-element.html = PASS FAIL
		3601	BUGLEVIW LION LEOPARD WIN LINUX : svg/transforms/svg-css-transforms.html = PASS FAIL
		3602	BUGLEVIW LION LEOPARD WIN LINUX : transforms/svg-vs-css.html = PASS FAIL
		3603	BUGLEVIW LION LEOPARD WIN LINUX : compositing/shadows/shadow-drawing.html = PASS FAIL
3591		3604
3592	// Started failing around r122770	3605	// Started failing around r122770
3593	BUGWK91445 LINUX : plugins/embed-attributes-style.html = PASS IMAGE	3606	BUGWK91445 LINUX : plugins/embed-attributes-style.html = PASS IMAGE

Line 5 LayoutTests/platform/chromium-mac-snowleopard/fast/transforms/rotated-transform-affects-scrolling-1-expected.png_sec1
- LayoutTests/platform/chromium-mac-snowleopard/fast/transforms/rotated-transform-affects-scrolling-1-expected.png +15 lines
	5	c+YEc2IFqmClWQjBqoQiLHMH6wihLixRAmIiIiIbFnLK8v5TH0GgDuX7uw4GhnFa2vVjy/f8Quf
	6	KF7p7Q/HSe53IDVNE7OiabNDJtEO2xJzgdnQa7pELqIiIhsVcdOHMuXdl6yqdUpn3lrRu1XY2Bp
	7	p1zrYLkvLtGCYiIiIhcN+sb62VpZskAHlh7oO9wZAwr29WPh+9/j/kDd2ivKP+9Um/A6jqnlEyX
	8	g5HJpw1AQtGaOpvD+1US2wjsTFCAyHUKkhUAiIiIiLXwvrGelmaWTKAB9Ye6DscGcMKRwB4+P73
	9	0OTzyfCBvf4JrN2Z3PFv/rtOe375JrzECAYU9FomkAboYlG2wRaqwMI90zBnsHuGj2IIiIiMpbl
	10	LzarybBCkcAePj+93qORG4L2TEKOWfcIadCSpmUIHV1Aro7NRPZ1vQWrIiIiNz0Tr56EoCFCwuu
	11	5Bp2z/9vi8+MqM9l9yS3DPFC9kzlExKiVK8tl510GXoCvU+3m16GURERCbAK//8Srm897LNbM74
	12	+Gs2q8mwPJ2AvLkX6P2K7mllVwIQFccdydl6FI9C5K9HkRPud6GtUMJiIiIyE3uzFtnDOChnz7U
	13	V8APP7loPYrkWvICmQHd2MrB3KBXCB5/c65VkFy3l2jBEREROQT+sdf/qMBHFk+0ncoMoYN7vFN
	14	w5FxrDJPv8V/9MAnnr2rr7DEblluTkhBoLVNqtoEHCCOY1B29YzIu3Hso6mv3BFREQmw/rGevnX
	15	sTd+qFV5DoxM/7P2S3+n59fZvr/GHDnn7Rc/k9nlBOj4VWGbeC3wwBW6IYtm7/6OfMzM0xPTysB
	16	bjTEZEviAoQERHZsF62LwMwND4UcybSiMkrZ3/s6P3QjuzMa40iskHp4hYRkQ1p9OBoUM6WTc9M
	17	L6P67pXdT5qtRqu61KtVjEmbHpGhUitVqNarVKtVlWAiIjI+nfghQMAFE8WbeFiQaM8CVAi7FTt
	18	TwZZths5yiYLm/ePvjjHq0tRJrM6u7G1NQUP//5z5mamsJai+M49U5J9Dy9SIiIyLpSGi8FZwpn
	19	pm+V88Yw8LCAm1tbQBcvnyZy5cvc+7cOf649A84nSnaOzN0tqU4vwBzi5aWjIPrgQEIoOpbrIWa