ChangeLog

2013-08-30  Simon Fraser  <simon.fraser@apple.com>

        Video with object-fit: cover can spill outside the box

        https://bugs.webkit.org/show_bug.cgi?id=52103

        Reviewed by NOBODY (OOPS!).

        object-fit on renderers which use accelerated compositing needs special

        treatment.

        For directly composited images, and video, GraphicsLayer needs to know

        both the size of the content layer, and also a rectangle at which this

        should be clipped (because, for the first time, that content layer can be

        larger than the renderer's content box).

        AVFoundation would always aspect-ratio fit video by default, so plumb

        through MediaPlayer a way to override that when object-fit requires it.

        Added a LAYER_TREE_INCLUDES_CONTENT_LAYERS enum to the layerTreeAsText()

        flags so we can dump content layers for testing.

        Tests: compositing/images/direct-image-object-fit.html

               compositing/reflections/direct-image-object-fit-reflected.html

               compositing/video/video-object-fit.html

        * page/Frame.h: New LayerTreeFlagsIncludeContentLayers flag.

        * platform/graphics/GraphicsLayer.h: New flag.

        * platform/graphics/MediaPlayer.cpp:

        (WebCore::MediaPlayer::shouldMaintainAspectRatio):

        (WebCore::MediaPlayer::setShouldMaintainAspectRatio):

        * platform/graphics/MediaPlayer.h:

        * platform/graphics/MediaPlayerPrivate.h:

        (WebCore::MediaPlayerPrivateInterface::shouldMaintainAspectRatio):

        (WebCore::MediaPlayerPrivateInterface::setShouldMaintainAspectRatio):

        * platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.cpp:

        (WebCore::MediaPlayerPrivateAVFoundation::MediaPlayerPrivateAVFoundation):

        (WebCore::MediaPlayerPrivateAVFoundation::setShouldMaintainAspectRatio):

        * platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.h:

        * platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.cpp:

        (WebCore::MediaPlayerPrivateAVFoundationCF::updateVideoLayerGravity):

        (WebCore::AVFWrapper::platformLayer):

        * platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.h:

        * platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.h:

        * platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm:

        (WebCore::MediaPlayerPrivateAVFoundationObjC::createVideoLayer):

        (WebCore::MediaPlayerPrivateAVFoundationObjC::updateVideoLayerGravity):

        * platform/graphics/ca/GraphicsLayerCA.cpp: We need a new m_contentsClippingLayer to

        clip the contents layer, which only gets created when necessary. It has to be cloned

        for reflections.

        (WebCore::GraphicsLayerCA::willBeDestroyed):

        (WebCore::GraphicsLayerCA::setContentsRect):

        (WebCore::GraphicsLayerCA::setContentsClippingRect):

        (WebCore::GraphicsLayerCA::commitLayerChangesBeforeSublayers):

        (WebCore::GraphicsLayerCA::updateSublayerList):

        (WebCore::GraphicsLayerCA::updateContentsImage):

        (WebCore::GraphicsLayerCA::updateContentsMediaLayer):

        (WebCore::GraphicsLayerCA::updateContentsCanvasLayer):

        (WebCore::GraphicsLayerCA::updateContentsColorLayer):

        (WebCore::GraphicsLayerCA::updateContentsRects):

        (WebCore::GraphicsLayerCA::dumpAdditionalProperties):

        (WebCore::GraphicsLayerCA::ensureCloneLayers):

        (WebCore::GraphicsLayerCA::removeCloneLayers):

        (WebCore::GraphicsLayerCA::fetchCloneLayers):

        * platform/graphics/ca/GraphicsLayerCA.h:

        * rendering/RenderLayerBacking.cpp: Need to push both the contentsRect and

        the contentsClippingRect down to the GraphicsLayers. Most of the time they

        are the same, unless object-fit makes them different.

        (WebCore::RenderLayerBacking::resetContentsRect):

        (WebCore::RenderLayerBacking::positionOverflowControlsLayers):

        (WebCore::RenderLayerBacking::updateDirectlyCompositedBackgroundColor):

        (WebCore::RenderLayerBacking::updateDirectlyCompositedBackgroundImage):

        (WebCore::RenderLayerBacking::updateImageContents):

        (WebCore::RenderLayerBacking::contentsBox):

        * rendering/RenderLayerCompositor.cpp:

        (WebCore::RenderLayerCompositor::layerTreeAsText):

        * rendering/RenderVideo.cpp:

        (WebCore::RenderVideo::updatePlayer):

        * testing/Internals.cpp:

        (WebCore::Internals::layerTreeAsText):

        * testing/Internals.h:

        * testing/Internals.idl:

2013-08-30  Mikhail Pozdnyakov  <mikhail.pozdnyakov@intel.com>

        SimpleClassVectorTraits shall be used for RuleData

Source/WebCore/page/Frame.h

@@namespace WebCore {

        LayerTreeFlagsIncludeVisibleRects = 1 << 1,

        LayerTreeFlagsIncludeTileCaches = 1 << 2,

        LayerTreeFlagsIncludeRepaintRects = 1 << 3,

85 LayerTreeFlagsIncludePaintingPhases = 1 << 4

85 LayerTreeFlagsIncludePaintingPhases = 1 << 4,

86 LayerTreeFlagsIncludeContentLayers = 1 << 5

    };

    typedef unsigned LayerTreeFlags;

Source/WebCore/platform/graphics/GraphicsLayer.h

@@enum LayerTreeAsTextBehaviorFlags {

    LayerTreeAsTextIncludeVisibleRects = 1 << 1,

    LayerTreeAsTextIncludeTileCaches = 1 << 2,

    LayerTreeAsTextIncludeRepaintRects = 1 << 3,

53 LayerTreeAsTextIncludePaintingPhases = 1 << 4

53 LayerTreeAsTextIncludePaintingPhases = 1 << 4,

54 LayerTreeAsTextIncludeContentLayers = 1 << 5

};

typedef unsigned LayerTreeAsTextBehavior;

Source/WebCore/platform/graphics/MediaPlayer.cpp

@@bool MediaPlayer::supportsAcceleratedRendering() const

}

#endif // USE(ACCELERATED_COMPOSITING)

bool MediaPlayer::shouldMaintainAspectRatio() const

{

    return m_private->shouldMaintainAspectRatio();

}

void MediaPlayer::setShouldMaintainAspectRatio(bool maintainAspectRatio)

{

    m_private->setShouldMaintainAspectRatio(maintainAspectRatio);

}

bool MediaPlayer::hasSingleSecurityOrigin() const

{

    return m_private->hasSingleSecurityOrigin();

Source/WebCore/platform/graphics/MediaPlayer.h

@@public:

    void acceleratedRenderingStateChanged();

#endif

    bool shouldMaintainAspectRatio() const;

    void setShouldMaintainAspectRatio(bool);

#if PLATFORM(WIN) && USE(AVFOUNDATION)

    GraphicsDeviceAdapter* graphicsDeviceAdapter() const;

#endif

Source/WebCore/platform/graphics/MediaPlayerPrivate.h

@@public:

    virtual void acceleratedRenderingStateChanged() { }

#endif

    virtual bool shouldMaintainAspectRatio() const { return true; }

    virtual void setShouldMaintainAspectRatio(bool) { }

    virtual bool hasSingleSecurityOrigin() const { return false; }

    virtual bool didPassCORSAccessCheck() const { return false; }

Source/WebCore/platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.cpp

@@MediaPlayerPrivateAVFoundation::MediaPlayerPrivateAVFoundation(MediaPlayer* play

    , m_playWhenFramesAvailable(false)

    , m_inbandTrackConfigurationPending(false)

    , m_characteristicsChanged(false)

80 , m_shouldMaintainAspectRatio(true)

    , m_seekCount(0)

{

    LOG(Media, "MediaPlayerPrivateAVFoundation::MediaPlayerPrivateAVFoundation(%p)", this);

@@void MediaPlayerPrivateAVFoundation::acceleratedRenderingStateChanged()

    setUpVideoRendering();

}

void MediaPlayerPrivateAVFoundation::setShouldMaintainAspectRatio(bool maintainAspectRatio)

{

    if (maintainAspectRatio == m_shouldMaintainAspectRatio)

        return;

    m_shouldMaintainAspectRatio = maintainAspectRatio;

    updateVideoLayerGravity();

}

void MediaPlayerPrivateAVFoundation::metadataLoaded()

{

    m_loadingMetadata = false;

Source/WebCore/platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.h

@@protected:

    virtual bool supportsAcceleratedRendering() const = 0;

    virtual void acceleratedRenderingStateChanged();

#endif

    virtual bool shouldMaintainAspectRatio() const OVERRIDE { return m_shouldMaintainAspectRatio; }

    virtual void setShouldMaintainAspectRatio(bool) OVERRIDE;

    virtual MediaPlayer::MovieLoadType movieLoadType() const;

    virtual void prepareForRendering();

    virtual float mediaTimeForTimeValue(float) const = 0;

@@protected:

    virtual bool hasContextRenderer() const = 0;

    virtual bool hasLayerRenderer() const = 0;

234 virtual void updateVideoLayerGravity() = 0;

235

protected:

    void updateStates();

@@private:

    bool m_playWhenFramesAvailable;

    bool m_inbandTrackConfigurationPending;

    bool m_characteristicsChanged;

316 bool m_shouldMaintainAspectRatio;

    size_t m_seekCount;

};

Source/WebCore/platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.cpp

@@void MediaPlayerPrivateAVFoundationCF::cancelLoad()

    setDelayCallbacks(false);

}

void MediaPlayerPrivateAVFoundationCF::updateVideoLayerGravity()

{

    // We should call AVCFPlayerLayerSetVideoGravity() here, but it is not yet implemented.

}

bool MediaPlayerPrivateAVFoundationCF::hasLayerRenderer() const

{

    return videoLayer(m_avfWrapper);

@@PlatformLayer* AVFWrapper::platformLayer()

    CACFLayerInsertSublayer(m_videoLayerWrapper->platformLayer(), m_caVideoLayer.get(), 0);

    m_videoLayerWrapper->setAnchorPoint(FloatPoint3D());

    m_videoLayerWrapper->setNeedsLayout();

1574 updateVideoLayerGravity();

    return m_videoLayerWrapper->platformLayer();

}

Source/WebCore/platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.h

@@private:

    virtual bool hasContextRenderer() const;

    virtual bool hasLayerRenderer() const;

100 virtual void updateVideoLayerGravity() OVERRIDE;

101

    virtual void contentsNeedsDisplay();

    virtual String languageOfPrimaryAudioTrack() const OVERRIDE;

Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.h

@@private:

    virtual bool hasContextRenderer() const;

    virtual bool hasLayerRenderer() const;

151 virtual void updateVideoLayerGravity() OVERRIDE;

152

    virtual bool hasSingleSecurityOrigin() const;

#if __MAC_OS_X_VERSION_MIN_REQUIRED < 1080

Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm

@@SOFT_LINK_POINTER(AVFoundation, AVMediaTypeAudio, NSString *)

SOFT_LINK_POINTER(AVFoundation, AVPlayerItemDidPlayToEndTimeNotification, NSString *)

SOFT_LINK_POINTER(AVFoundation, AVAssetImageGeneratorApertureModeCleanAperture, NSString *)

SOFT_LINK_POINTER(AVFoundation, AVURLAssetReferenceRestrictionsKey, NSString *)

101SOFT_LINK_POINTER(AVFoundation, AVLayerVideoGravityResizeAspect, NSString *)

102SOFT_LINK_POINTER(AVFoundation, AVLayerVideoGravityResize, NSString *)

SOFT_LINK_CONSTANT(CoreMedia, kCMTimeZero, CMTime)

@@SOFT_LINK_CONSTANT(CoreMedia, kCMTimeZero, CMTime)

#define AVPlayerItemDidPlayToEndTimeNotification getAVPlayerItemDidPlayToEndTimeNotification()

#define AVAssetImageGeneratorApertureModeCleanAperture getAVAssetImageGeneratorApertureModeCleanAperture()

#define AVURLAssetReferenceRestrictionsKey getAVURLAssetReferenceRestrictionsKey()

121#define AVLayerVideoGravityResizeAspect getAVLayerVideoGravityResizeAspect()

122#define AVLayerVideoGravityResize getAVLayerVideoGravityResize()

#if HAVE(AVFOUNDATION_MEDIA_SELECTION_GROUP)

typedef AVMediaSelectionGroup AVMediaSelectionGroupType;

@@void MediaPlayerPrivateAVFoundationObjC::createVideoLayer()

#ifndef NDEBUG

        [m_videoLayer.get() setName:@"Video layer"];

#endif

379 updateVideoLayerGravity();

        LOG(Media, "MediaPlayerPrivateAVFoundationObjC::createVideoLayer(%p) - returning %p", this, m_videoLayer.get());

    }

}

@@float MediaPlayerPrivateAVFoundationObjC::mediaTimeForTimeValue(float timeValue)

    return timeValue;

}

void MediaPlayerPrivateAVFoundationObjC::updateVideoLayerGravity()

{

    if (!m_videoLayer)

        return;

    [CATransaction begin];

    [CATransaction setDisableActions:YES];    

    NSString* gravity = shouldMaintainAspectRatio() ? AVLayerVideoGravityResizeAspect : AVLayerVideoGravityResize;

    [m_videoLayer.get() setVideoGravity:gravity];

    [CATransaction commit];

}

void MediaPlayerPrivateAVFoundationObjC::tracksChanged()

{

    String primaryAudioTrackLanguage = m_languageOfPrimaryAudioTrack;

Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp

@@void GraphicsLayerCA::willBeDestroyed()

    
    if (m_contentsLayer)

        m_contentsLayer->setOwner(0);

    if (m_contentsClippingLayer)

        m_contentsClippingLayer->setOwner(0);

        
    if (m_structuralLayer)

        m_structuralLayer->setOwner(0);

@@void GraphicsLayerCA::setContentsRect(const IntRect& rect)

        return;

    GraphicsLayer::setContentsRect(rect);

672 noteLayerPropertyChanged(ContentsRectChanged);

    noteLayerPropertyChanged(ContentsRectsChanged);

}

void GraphicsLayerCA::setContentsClippingRect(const IntRect& rect)

{

    if (rect == m_contentsClippingRect)

        return;

    GraphicsLayer::setContentsClippingRect(rect);

    noteLayerPropertyChanged(ContentsRectsChanged);

}

bool GraphicsLayerCA::shouldRepaintOnSizeChange() const

@@void GraphicsLayerCA::commitLayerChangesBeforeSublayers(CommitState& commitState

    if (m_uncommittedChanges & DirtyRectsChanged)

        repaintLayerDirtyRects();

1217 if (m_uncommittedChanges & ContentsRectChanged)

1218 updateContentsRect();

1229 if (m_uncommittedChanges & ContentsRectsChanged) // Needs to happen before ChildrenChanged

1230 updateContentsRects();

    if (m_uncommittedChanges & MaskLayerChanged)

        updateMaskLayer();

@@void GraphicsLayerCA::updateSublayerList(bool maxLayerDepthReached)

        // FIXME: add the contents layer in the correct order with negative z-order children.

        // This does not cause visible rendering issues because currently contents layers are only used

        // for replaced elements that don't have children.

1300 primaryLayerChildren.append(m_contentsLayer);

1312 primaryLayerChildren.append(m_contentsClippingLayer ? m_contentsClippingLayer : m_contentsLayer);

    }

    const Vector<GraphicsLayer*>& childLayers = children();

@@void GraphicsLayerCA::updateContentsImage()

                it->value->setContents(m_contentsLayer->contents());

        }

1725 updateContentsRect();

1737 updateContentsRects();

    } else {

        // No image.

        // m_contentsLayer will be removed via updateSublayerList.

@@void GraphicsLayerCA::updateContentsMediaLayer()

    // Video layer was set as m_contentsLayer, and will get parented in updateSublayerList().

    setupContentsLayer(m_contentsLayer.get());

1740 updateContentsRect();

1752 updateContentsRects();

}

void GraphicsLayerCA::updateContentsCanvasLayer()

@@void GraphicsLayerCA::updateContentsCanvasLayer()

    // CanvasLayer was set as m_contentsLayer, and will get parented in updateSublayerList().

    setupContentsLayer(m_contentsLayer.get());

    m_contentsLayer->setNeedsDisplay();

1751 updateContentsRect();

1763 updateContentsRects();

}

void GraphicsLayerCA::updateContentsColorLayer()

@@void GraphicsLayerCA::updateContentsColorLayer()

        return;

    setupContentsLayer(m_contentsLayer.get());

1761 updateContentsRect();

1773 updateContentsRects();

    ASSERT(m_contentsSolidColor.isValid());

    m_contentsLayer->setBackgroundColor(m_contentsSolidColor);

@@void GraphicsLayerCA::updateContentsColorLayer()

    }

}

1772 void GraphicsLayerCA::updateContentsRect()

1784void GraphicsLayerCA::updateContentsRects()

{

    if (!m_contentsLayer)

        return;

1777 FloatPoint point(m_contentsRect.x(), m_contentsRect.y());

1778 FloatRect rect(0, 0, m_contentsRect.width(), m_contentsRect.height());

    FloatPoint contentOrigin;

    FloatRect contentBounds(0, 0, m_contentsRect.width(), m_contentsRect.height());

    FloatPoint clippingOrigin;

    FloatRect clippingBounds;

    bool needContentsClippingLayer = !m_contentsClippingRect.contains(m_contentsRect);

    bool gainedOrLostClippingLayer = false;

    if (needContentsClippingLayer) {

        if (!m_contentsClippingLayer) {

            m_contentsClippingLayer = PlatformCALayer::create(PlatformCALayer::LayerTypeLayer, this);

            m_contentsClippingLayer->setMasksToBounds(true);

            m_contentsClippingLayer->setAnchorPoint(FloatPoint());

#ifndef NDEBUG

            m_contentsClippingLayer->setName("Contents Clipping");

#endif

            m_contentsLayer->removeFromSuperlayer();

            m_contentsClippingLayer->appendSublayer(m_contentsLayer.get());

            gainedOrLostClippingLayer = true;

        }

        clippingOrigin = m_contentsClippingRect.location();

        clippingBounds.setSize(m_contentsClippingRect.size());

        contentOrigin = toPoint(m_contentsRect.location() - m_contentsClippingRect.location());

        m_contentsClippingLayer->setPosition(clippingOrigin);

        m_contentsClippingLayer->setBounds(clippingBounds);

        m_contentsLayer->setPosition(contentOrigin);

        m_contentsLayer->setBounds(contentBounds);

    } else {

        if (m_contentsClippingLayer) {

            m_contentsLayer->removeFromSuperlayer();

17791824

1780 m_contentsLayer->setPosition(point);

1781 m_contentsLayer->setBounds(rect);

            m_contentsClippingLayer->removeFromSuperlayer();

            m_contentsClippingLayer->setOwner(0);

            m_contentsClippingLayer = nullptr;

            gainedOrLostClippingLayer = true;

        }

        contentOrigin = m_contentsRect.location();

    }

    if (gainedOrLostClippingLayer)

        noteSublayersChanged();

    m_contentsLayer->setPosition(contentOrigin);

    m_contentsLayer->setBounds(contentBounds);

    if (m_contentsLayerClones) {

        LayerMap::const_iterator end = m_contentsLayerClones->end();

        for (LayerMap::const_iterator it = m_contentsLayerClones->begin(); it != end; ++it) {

1786 it->value->setPosition(point);

1787 it->value->setBounds(rect);

            it->value->setPosition(contentOrigin);

            it->value->setBounds(contentBounds);

        }

    }

    if (m_contentsClippingLayerClones) {

        LayerMap::const_iterator end = m_contentsClippingLayerClones->end();

        for (LayerMap::const_iterator it = m_contentsClippingLayerClones->begin(); it != end; ++it) {

            it->value->setPosition(clippingOrigin);

            it->value->setBounds(clippingBounds);

@@void GraphicsLayerCA::dumpAdditionalProperties(TextStream& textStream, int inden

        writeIndent(textStream, indent + 1);

        textStream << "(top left tile " << gridExtent.x() << ", " << gridExtent.y() << " tiles grid " << gridExtent.width() << " x " << gridExtent.height() << ")\n";

    }

    
    if (behavior & LayerTreeAsTextIncludeContentLayers) {

        if (m_contentsClippingLayer) {

            writeIndent(textStream, indent + 1);

            textStream << "(contents clipping layer " << m_contentsClippingLayer->position().x() << ", " << m_contentsClippingLayer->position().y()

                << " " << m_contentsClippingLayer->bounds().width() << " x " << m_contentsClippingLayer->bounds().height() << ")\n";

        }

        if (m_contentsLayer) {

            writeIndent(textStream, indent + 1);

            textStream << "(contents layer " << m_contentsLayer->position().x() << ", " << m_contentsLayer->position().y()

                << " " << m_contentsLayer->bounds().width() << " x " << m_contentsLayer->bounds().height() << ")\n";

        }

    }

}

void GraphicsLayerCA::setDebugBorder(const Color& color, float borderWidth)

@@PassRefPtr<PlatformCALayer> GraphicsLayerCA::findOrMakeClone(CloneID cloneID, Pl

    return resultLayer;

}   

2798 void GraphicsLayerCA::ensureCloneLayers(CloneID cloneID, RefPtr<PlatformCALayer>& primaryLayer, RefPtr<PlatformCALayer>& structuralLayer, RefPtr<PlatformCALayer>& contentsLayer, CloneLevel cloneLevel)

2877void GraphicsLayerCA::ensureCloneLayers(CloneID cloneID, RefPtr<PlatformCALayer>& primaryLayer, RefPtr<PlatformCALayer>& structuralLayer,

2878 RefPtr<PlatformCALayer>& contentsLayer, RefPtr<PlatformCALayer>& contentsClippingLayer, CloneLevel cloneLevel)

{

    structuralLayer = 0;

    contentsLayer = 0;

@@void GraphicsLayerCA::ensureCloneLayers(CloneID cloneID, RefPtr<PlatformCALayer>

    if (!m_contentsLayerClones && m_contentsLayer)

        m_contentsLayerClones = adoptPtr(new LayerMap);

    if (!m_contentsClippingLayerClones && m_contentsClippingLayer)

        m_contentsClippingLayerClones = adoptPtr(new LayerMap);

    primaryLayer = findOrMakeClone(cloneID, m_layer.get(), m_layerClones.get(), cloneLevel);

    structuralLayer = findOrMakeClone(cloneID, m_structuralLayer.get(), m_structuralLayerClones.get(), cloneLevel);

    contentsLayer = findOrMakeClone(cloneID, m_contentsLayer.get(), m_contentsLayerClones.get(), cloneLevel);

2898 contentsClippingLayer = findOrMakeClone(cloneID, m_contentsClippingLayer.get(), m_contentsClippingLayerClones.get(), cloneLevel);

}

void GraphicsLayerCA::removeCloneLayers()

@@void GraphicsLayerCA::removeCloneLayers()

    m_layerClones = nullptr;

    m_structuralLayerClones = nullptr;

    m_contentsLayerClones = nullptr;

2906 m_contentsClippingLayerClones = nullptr;

}

FloatPoint GraphicsLayerCA::positionForCloneRootLayer() const

@@PassRefPtr<PlatformCALayer> GraphicsLayerCA::fetchCloneLayers(GraphicsLayer* rep

    RefPtr<PlatformCALayer> primaryLayer;

    RefPtr<PlatformCALayer> structuralLayer;

    RefPtr<PlatformCALayer> contentsLayer;

2852 ensureCloneLayers(replicaState.cloneID(), primaryLayer, structuralLayer, contentsLayer, cloneLevel);

2937 RefPtr<PlatformCALayer> contentsClippingLayer;

2938 ensureCloneLayers(replicaState.cloneID(), primaryLayer, structuralLayer, contentsLayer, contentsClippingLayer, cloneLevel);

    if (m_maskLayer) {

        RefPtr<PlatformCALayer> maskClone = static_cast<GraphicsLayerCA*>(m_maskLayer)->fetchCloneLayers(replicaRoot, replicaState, IntermediateCloneLevel);

@@PassRefPtr<PlatformCALayer> GraphicsLayerCA::fetchCloneLayers(GraphicsLayer* rep

        replicaLayer = static_cast<GraphicsLayerCA*>(m_replicaLayer)->fetchCloneLayers(replicaRoot, replicaState, RootCloneLevel);

        replicaState.setBranchType(ReplicaState::ChildBranch);

    }

    if (contentsClippingLayer) {

        ASSERT(contentsLayer);

        contentsClippingLayer->appendSublayer(contentsLayer.get());

    }

28852976

2886 if (replicaLayer || structuralLayer || contentsLayer || childLayers.size() > 0) {

2977 if (replicaLayer || structuralLayer || contentsLayer || contentsClippingLayer || childLayers.size() > 0) {

        if (structuralLayer) {

            // Replicas render behind the actual layer content.

            if (replicaLayer)

@@PassRefPtr<PlatformCALayer> GraphicsLayerCA::fetchCloneLayers(GraphicsLayer* rep

                
            // Add the primary layer next. Even if we have negative z-order children, the primary layer always comes behind.

            clonalSublayers.append(primaryLayer);

        } else if (contentsClippingLayer) {

            // FIXME: add the contents layer in the correct order with negative z-order children.

            // This does not cause visible rendering issues because currently contents layers are only used

            // for replaced elements that don't have children.

            clonalSublayers.append(contentsClippingLayer);

        } else if (contentsLayer) {

            // FIXME: add the contents layer in the correct order with negative z-order children.

            // This does not cause visible rendering issues because currently contents layers are only used

@@PassRefPtr<PlatformCALayer> GraphicsLayerCA::fetchCloneLayers(GraphicsLayer* rep

    if (structuralLayer) {

        structuralLayer->setSublayers(clonalSublayers);

2922 if (contentsLayer) {

3018 if (contentsClippingLayer || contentsLayer) {

            // If we have a transform layer, then the contents layer is parented in the 

            // primary layer (which is itself a child of the transform layer).

            primaryLayer->removeAllSublayers();

2926 primaryLayer->appendSublayer(contentsLayer.get());

3022 primaryLayer->appendSublayer(contentsClippingLayer ? contentsClippingLayer.get() : contentsLayer.get());

        }

        result = structuralLayer;

Source/WebCore/platform/graphics/ca/GraphicsLayerCA.h

@@public:

    virtual void setContentsNeedsDisplay();

    virtual void setContentsRect(const IntRect&);

108 virtual void setContentsClippingRect(const IntRect&) OVERRIDE;

    
    virtual void suspendAnimations(double time);

    virtual void resumeAnimations();

@@private:

    PassRefPtr<PlatformCALayer> cloneLayer(PlatformCALayer *, CloneLevel);

    PassRefPtr<PlatformCALayer> findOrMakeClone(CloneID, PlatformCALayer *, LayerMap*, CloneLevel);

317 void ensureCloneLayers(CloneID cloneID, RefPtr<PlatformCALayer>& primaryLayer, RefPtr<PlatformCALayer>& structuralLayer, RefPtr<PlatformCALayer>& contentsLayer, CloneLevel cloneLevel);

318 void ensureCloneLayers(CloneID, RefPtr<PlatformCALayer>& primaryLayer, RefPtr<PlatformCALayer>& structuralLayer,

319 RefPtr<PlatformCALayer>& contentsLayer, RefPtr<PlatformCALayer>& contentsClippingLayer, CloneLevel);

    bool hasCloneLayers() const { return m_layerClones; }

    void removeCloneLayers();

@@private:

    void updateContentsMediaLayer();

    void updateContentsCanvasLayer();

    void updateContentsColorLayer();

343 void updateContentsRect();

345 void updateContentsRects();

    void updateMaskLayer();

    void updateReplicatedLayers();

@@private:

        ContentsMediaLayerChanged = 1 << 16,

        ContentsCanvasLayerChanged = 1 << 17,

        ContentsColorLayerChanged = 1 << 18,

395 ContentsRectChanged = 1 << 19,

397 ContentsRectsChanged = 1 << 19,

        MaskLayerChanged = 1 << 20,

        ReplicatedLayerChanged = 1 << 21,

        ContentsNeedsDisplay = 1 << 22,

@@private:

    RefPtr<PlatformCALayer> m_layer; // The main layer

    RefPtr<PlatformCALayer> m_structuralLayer; // A layer used for structural reasons, like preserves-3d or replica-flattening. Is the parent of m_layer.

418 RefPtr<PlatformCALayer> m_contentsClippingLayer; // A layer used to clip inner content

    RefPtr<PlatformCALayer> m_contentsLayer; // A layer used for inner content, like image and video

    // References to clones of our layers, for replicated layers.

    OwnPtr<LayerMap> m_layerClones;

    OwnPtr<LayerMap> m_structuralLayerClones;

    OwnPtr<LayerMap> m_contentsLayerClones;

425 OwnPtr<LayerMap> m_contentsClippingLayerClones;

#ifdef VISIBLE_TILE_WASH

    RefPtr<PlatformCALayer> m_visibleTileWashLayer;

Source/WebCore/rendering/RenderLayerBacking.cpp

@@void RenderLayerBacking::updateInternalHierarchy()

void RenderLayerBacking::resetContentsRect()

{

928 IntRect rect = pixelSnappedIntRect(contentsBox());

929 m_graphicsLayer->setContentsRect(rect);

    m_graphicsLayer->setContentsRect(pixelSnappedIntRect(contentsBox()));

    LayoutRect contentsClippingRect;

    if (renderer().isBox())

        contentsClippingRect = toRenderBox(&renderer())->contentBoxRect();

    contentsClippingRect.move(contentOffsetInCompostingLayer());

    m_graphicsLayer->setContentsClippingRect(pixelSnappedIntRect(contentsClippingRect));

    m_graphicsLayer->setContentsTileSize(IntSize());

    m_graphicsLayer->setContentsTilePhase(IntPoint());

}

@@void RenderLayerBacking::positionOverflowControlsLayers(const IntSize& offsetFro

        if (hBar) {

            layer->setPosition(hBar->frameRect().location() - offsetFromRoot - offsetFromRenderer);

            layer->setSize(hBar->frameRect().size());

1081 if (layer->hasContentsLayer())

1082 layer->setContentsRect(IntRect(IntPoint(), hBar->frameRect().size()));

            if (layer->hasContentsLayer()) {

                IntRect barRect = IntRect(IntPoint(), hBar->frameRect().size());

                layer->setContentsRect(barRect);

                layer->setContentsClippingRect(barRect);

            }

        }

        layer->setDrawsContent(hBar && !layer->hasContentsLayer());

    }

@@void RenderLayerBacking::positionOverflowControlsLayers(const IntSize& offsetFro

        if (vBar) {

            layer->setPosition(vBar->frameRect().location() - offsetFromRoot - offsetFromRenderer);

            layer->setSize(vBar->frameRect().size());

1092 if (layer->hasContentsLayer())

1093 layer->setContentsRect(IntRect(IntPoint(), vBar->frameRect().size()));

            if (layer->hasContentsLayer()) {

                IntRect barRect = IntRect(IntPoint(), vBar->frameRect().size());

                layer->setContentsRect(barRect);

                layer->setContentsClippingRect(barRect);

            }

        }

        layer->setDrawsContent(vBar && !layer->hasContentsLayer());

    }

@@void RenderLayerBacking::updateDirectlyCompositedBackgroundColor(bool isSimpleCo

    // An unset (invalid) color will remove the solid color.

    m_graphicsLayer->setContentsToSolidColor(backgroundColor);

1386 m_graphicsLayer->setContentsRect(backgroundBox());

    IntRect contentsRect = backgroundBox();

    m_graphicsLayer->setContentsRect(contentsRect);

    m_graphicsLayer->setContentsClippingRect(contentsRect);

    didUpdateContentsRect = true;

}

@@void RenderLayerBacking::updateDirectlyCompositedBackgroundImage(bool isSimpleCo

    m_graphicsLayer->setContentsTileSize(tileSize);

    m_graphicsLayer->setContentsTilePhase(phase);

    m_graphicsLayer->setContentsRect(destRect);

1461 m_graphicsLayer->setContentsClippingRect(destRect);

    m_graphicsLayer->setContentsToImage(image.get());

    didUpdateContentsRect = true;

}

@@void RenderLayerBacking::updateImageContents()

    // This is a no-op if the layer doesn't have an inner layer for the image.

    m_graphicsLayer->setContentsRect(pixelSnappedIntRect(contentsBox()));

    LayoutRect contentsClippingRect = imageRenderer->contentBoxRect();

    contentsClippingRect.move(contentOffsetInCompostingLayer());

    m_graphicsLayer->setContentsClippingRect(pixelSnappedIntRect(contentsClippingRect));

    m_graphicsLayer->setContentsToImage(image);

    bool isSimpleContainer = false;

    updateDrawsContent(isSimpleContainer);

@@LayoutRect RenderLayerBacking::contentsBox() const

    if (!renderer().isBox())

        return LayoutRect();

1796 RenderBox& renderBox = *toRenderBox(&renderer());

17751797 LayoutRect contentsRect;

17761798#if ENABLE(VIDEO)

1777 if (render~~er()~~.isVideo()) {

1778 RenderVideo* videoRenderer = toRenderVideo(&render~~er()~~);

1799 if (renderBox.isVideo()) {

1800 RenderVideo* videoRenderer = toRenderVideo(&renderBox);

        contentsRect = videoRenderer->videoBox();

    } else

#endif

1782 contentsRect = toRenderBox(&renderer())->contentBoxRect();

    if (renderBox.isRenderReplaced()) {

        RenderReplaced& renderReplaced = *toRenderReplaced(&renderBox);

        contentsRect = renderReplaced.replacedContentRect(renderBox.intrinsicSize());

    } else

        contentsRect = renderBox.contentBoxRect();

    contentsRect.move(contentOffsetInCompostingLayer());

    return contentsRect;

Source/WebCore/rendering/RenderLayerCompositor.cpp

@@String RenderLayerCompositor::layerTreeAsText(LayerTreeFlags flags)

        layerTreeBehavior |= LayerTreeAsTextIncludeRepaintRects;

    if (flags & LayerTreeFlagsIncludePaintingPhases)

        layerTreeBehavior |= LayerTreeAsTextIncludePaintingPhases;

1393 if (flags & LayerTreeFlagsIncludeContentLayers)

1394 layerTreeBehavior |= LayerTreeAsTextIncludeContentLayers;

    // We skip dumping the scroll and clip layers to keep layerTreeAsText output

    // similar between platforms.

Source/WebCore/rendering/RenderVideo.cpp

@@void RenderVideo::updatePlayer()

    mediaPlayer->setFrameView(&view().frameView());

    mediaPlayer->setSize(IntSize(videoBounds.width(), videoBounds.height()));

    mediaPlayer->setVisible(true);

249 mediaPlayer->setShouldMaintainAspectRatio(style()->objectFit() != ObjectFitFill);

}

LayoutUnit RenderVideo::computeReplacedLogicalWidth(ShouldComputePreferred shouldComputePreferred) const

Source/WebCore/testing/Internals.cpp

@@String Internals::layerTreeAsText(Document* document, unsigned flags, ExceptionC

        layerTreeFlags |= LayerTreeFlagsIncludeRepaintRects;

    if (flags & LAYER_TREE_INCLUDES_PAINTING_PHASES)

        layerTreeFlags |= LayerTreeFlagsIncludePaintingPhases;

1608 if (flags & LAYER_TREE_INCLUDES_CONTENT_LAYERS)

1609 layerTreeFlags |= LayerTreeFlagsIncludeContentLayers;

    return document->frame()->layerTreeAsText(layerTreeFlags);

}

Source/WebCore/testing/Internals.h

@@public:

        LAYER_TREE_INCLUDES_VISIBLE_RECTS = 1,

        LAYER_TREE_INCLUDES_TILE_CACHES = 2,

        LAYER_TREE_INCLUDES_REPAINT_RECTS = 4,

228 LAYER_TREE_INCLUDES_PAINTING_PHASES = 8

228 LAYER_TREE_INCLUDES_PAINTING_PHASES = 8,

229 LAYER_TREE_INCLUDES_CONTENT_LAYERS = 16

    };

    String layerTreeAsText(Document*, unsigned flags, ExceptionCode&) const;

    String layerTreeAsText(Document*, ExceptionCode&) const;

Source/WebCore/testing/Internals.idl

    const unsigned short LAYER_TREE_INCLUDES_TILE_CACHES = 2;

    const unsigned short LAYER_TREE_INCLUDES_REPAINT_RECTS = 4;

    const unsigned short LAYER_TREE_INCLUDES_PAINTING_PHASES = 8;

178 const unsigned short LAYER_TREE_INCLUDES_CONTENT_LAYERS = 16;

    [RaisesException] DOMString layerTreeAsText(Document document, optional unsigned short flags);

    [RaisesException] DOMString scrollingStateTreeAsText(Document document);

LayoutTests/ChangeLog

2013-08-30  Simon Fraser  <simon.fraser@apple.com>

        Video with object-fit: cover can spill outside the box

        https://bugs.webkit.org/show_bug.cgi?id=52103

        Reviewed by NOBODY (OOPS!).

        Test cases for directly composited image with object-fit, the same with

        reflections, and one with video.

        Tests dump content GraphicsLayers, so have platform-specific results.

        * compositing/images/direct-image-object-fit-expected.txt: Added.

        * compositing/images/direct-image-object-fit.html: Added.

        * compositing/reflections/direct-image-object-fit-reflected-expected.txt: Added.

        * compositing/reflections/direct-image-object-fit-reflected.html: Added.

        * compositing/video/video-object-fit-expected.txt: Added.

        * compositing/video/video-object-fit.html: Added.

        * media/video-object-fit-change.html: Fixed

        * platform/mac/TestExpectations: Unskip two tests.

        * platform/mac/compositing/images/direct-image-object-fit-expected.txt: Added.

        * platform/mac/compositing/reflections/direct-image-object-fit-reflected-expected.txt: Added.

        * platform/mac/compositing/video/video-object-fit-expected.txt: Added.

2013-08-30  Ádám Kallai  <kadam@inf.u-szeged.hu>

        [Qt] Added platform specific expected files after r15470 and r154780.

LayoutTests/compositing/images/direct-image-object-fit-expected.txt

(GraphicsLayer

  (bounds 800.00 600.00)

  (children 1

    (GraphicsLayer

      (bounds 800.00 600.00)

      (contentsOpaque 1)

      (children 3

        (GraphicsLayer

          (position 58.00 20.00)

          (bounds 200.00 120.00)

        )

        (GraphicsLayer

          (position 58.00 160.00)

          (bounds 200.00 120.00)

        )

        (GraphicsLayer

          (position 58.00 300.00)

          (bounds 200.00 120.00)

        )

      )

    )

  )

)

LayoutTests/compositing/images/direct-image-object-fit.html

<!DOCTYPE html>

<html>

<head>

    <style>

        img {

            display: block;

            height: 120px;

            width: 200px;

            margin: 20px 50px;

        }

        .composited {

            -webkit-transform: translateZ(0);

        }

    </style>

    <script>

        if (window.testRunner)

            testRunner.dumpAsText();

        function doTest()

        {

            if (window.internals)

                document.getElementById('results').innerText = window.internals.layerTreeAsText(document, internals.LAYER_TREE_INCLUDES_CONTENT_LAYERS);

        }

        window.addEventListener('load', doTest, false);

    </script>

</head>

<body>

    <img class="composited" src="../../fast/css/resources/circles-landscape.png" style="object-fit: cover"></div>

    <img class="composited" src="../../fast/css/resources/circles-landscape.png" style="object-fit: contain"></div>

    <img class="composited" src="../../fast/css/resources/circles-landscape.png" style="object-fit: none"></div>

<pre id="results"></pre>

</body>

</html>

LayoutTests/compositing/reflections/direct-image-object-fit-reflected-expected.txt

    
(GraphicsLayer

  (bounds 800.00 600.00)

  (children 1

    (GraphicsLayer

      (bounds 800.00 600.00)

      (contentsOpaque 1)

      (children 3

        (GraphicsLayer

          (position 28.00 28.00)

          (bounds 200.00 120.00)

          (replica layer)

            (GraphicsLayer

              (bounds 200.00 120.00)

              (transform [1.00 0.00 0.00 0.00] [0.00 -1.00 0.00 0.00] [0.00 0.00 1.00 0.00] [0.00 140.00 0.00 1.00])

              (replicated layer)

            )

        )

        (GraphicsLayer

          (position 272.00 28.00)

          (bounds 200.00 120.00)

          (replica layer)

            (GraphicsLayer

              (bounds 200.00 120.00)

              (transform [1.00 0.00 0.00 0.00] [0.00 -1.00 0.00 0.00] [0.00 0.00 1.00 0.00] [0.00 140.00 0.00 1.00])

              (replicated layer)

            )

        )

        (GraphicsLayer

          (position 516.00 28.00)

          (bounds 200.00 120.00)

          (replica layer)

            (GraphicsLayer

              (bounds 200.00 120.00)

              (transform [1.00 0.00 0.00 0.00] [0.00 -1.00 0.00 0.00] [0.00 0.00 1.00 0.00] [0.00 140.00 0.00 1.00])

              (replicated layer)

            )

        )

      )

    )

  )

)

LayoutTests/compositing/reflections/direct-image-object-fit-reflected.html

<!DOCTYPE html>

<html>

<head>

    <style>

        img {

            height: 120px;

            width: 200px;

            margin: 20px;

            -webkit-box-reflect: below 20px;

        }

        img:hover {

            height: 160px;

        }

        .composited {

            -webkit-transform: translateZ(0);

        }

    </style>

    <script>

        if (window.testRunner)

            testRunner.dumpAsText();

        function doTest()

        {

            if (window.internals)

                document.getElementById('results').innerText = window.internals.layerTreeAsText(document, internals.LAYER_TREE_INCLUDES_CONTENT_LAYERS);

        }

        window.addEventListener('load', doTest, false);

    </script>

</head>

<body>

    <img class="composited" src="../../fast/css/resources/circles-landscape.png" style="object-fit: cover"></div>

    <img class="composited" src="../../fast/css/resources/circles-landscape.png" style="object-fit: contain"></div>

    <img class="composited" src="../../fast/css/resources/circles-landscape.png" style="object-fit: none"></div>

<pre id="results"></pre>

</body>

</html>

LayoutTests/compositing/video/video-object-fit-expected.txt

   
(GraphicsLayer

  (bounds 785.00 775.00)

  (children 1

    (GraphicsLayer

      (bounds 785.00 775.00)

      (contentsOpaque 1)

      (children 6

        (GraphicsLayer

          (position 13.00 13.00)

          (bounds 124.00 204.00)

          (contentsOpaque 1)

          (drawsContent 1)

        )

        (GraphicsLayer

          (position 151.00 13.00)

          (bounds 124.00 204.00)

          (contentsOpaque 1)

          (drawsContent 1)

        )

        (GraphicsLayer

          (position 289.00 13.00)

          (bounds 124.00 204.00)

          (contentsOpaque 1)

          (drawsContent 1)

        )

        (GraphicsLayer

          (position 13.00 231.00)

          (bounds 354.00 304.00)

          (contentsOpaque 1)

          (drawsContent 1)

        )

        (GraphicsLayer

          (position 13.00 569.00)

          (bounds 404.00 184.00)

          (contentsOpaque 1)

          (drawsContent 1)

        )

        (GraphicsLayer

          (position 431.00 549.00)

          (bounds 124.00 204.00)

          (contentsOpaque 1)

          (drawsContent 1)

        )

      )

    )

  )

)

LayoutTests/compositing/video/video-object-fit.html

<!DOCTYPE html>

<html>

<head>

<style>

  video {

/*    display: block;*/

    width: 120px;

    height: 200px;

    margin: 5px;

    border: 2px solid blue;

    background-color: gray;

  }

  .big {

      height: 300px;

      width: 350px;

  }

  .smaller {

      height: 180px;

      width: 400px;

  }

</style>

<script src="../../media/media-file.js"></script>

<script>

    if (window.testRunner) {

        testRunner.waitUntilDone();

        testRunner.dumpAsText();

    }

    function init()

    {

        setSrcByTagName("video", findMediaFile("video", "../../media/content/test"));

        var totalCount = document.getElementsByTagName('video').length;

        var count = totalCount;

        document.addEventListener("canplaythrough", function () {

            if (!--count) {

                if (window.testRunner)

                    setTimeout(function() {

                        if (window.internals)

                            document.getElementById('results').innerText = window.internals.layerTreeAsText(document, internals.LAYER_TREE_INCLUDES_CONTENT_LAYERS);

                        testRunner.notifyDone();

                    }, totalCount * 150);

            }

        }, true);

        if (window.testRunner) {

            setTimeout(function() {

                document.body.appendChild(document.createTextNode('FAIL'));

                if (window.testRunner)

                    testRunner.notifyDone();

            }, 1500);

        }

    }

</script>

</head>

<body onload="init();">

    <video style="object-fit: fill"></video>

    <video style="object-fit: cover"></video>

    <video style="object-fit: contain"></video>

    <video class="big" style="object-fit: scale-down"></video>

    <video class="smaller" style="object-fit: scale-down"></video>

    <video style="object-fit: none"></video>

<pre id="results"></pre>

</body>

</html>

LayoutTests/media/video-object-fit-change.html

        function init()

        {

21 setSrcByTagName("video", findMediaFile("video", "~~../../media/~~content/test"));

21 setSrcByTagName("video", findMediaFile("video", "content/test"));

            var totalCount = document.getElementsByTagName('video').length;

            var count = totalCount;

            document.addEventListener("canplaythrough", function () {

                if (!--count)

27 setTimeout(function() { changeStyle(); }, 500);

27 setTimeout(function() { changeStyle(); }, 250);

            }, true);

            if (window.testRunner) {

	    video3.style.objectFit = 'fill';

	    video4.style.objectFit = 'scale-down';

            if (window.testRunner) {

                setTimeout(function() { testRunner.notifyDone(); }, 500);

            }

46 if (window.testRunner)

47 setTimeout(function() { testRunner.notifyDone(); }, 250);

	}

    </script>

LayoutTests/platform/mac/TestExpectations

@@plugins/reloadplugins-and-pages.html

# This test requires ogg codecs

media/media-can-play-ogg.html

webkit.org/b/52103 media/video-object-fit-change.html

webkit.org/b/52103 media/video-object-fit.html

# This test requires flac codec

media/media-can-play-flac-audio.html

LayoutTests/platform/mac/compositing/images/direct-image-object-fit-expected.txt

(GraphicsLayer

  (bounds 800.00 600.00)

  (children 1

    (GraphicsLayer

      (bounds 800.00 600.00)

      (contentsOpaque 1)

      (children 3

        (GraphicsLayer

          (position 58.00 20.00)

          (bounds 200.00 120.00)

          (contents clipping layer 0.00, 0.00 200.00 x 120.00)

          (contents layer -20.00, 0.00 240.00 x 120.00)

        )

        (GraphicsLayer

          (position 58.00 160.00)

          (bounds 200.00 120.00)

          (contents layer 0.00, 10.00 200.00 x 100.00)

        )

        (GraphicsLayer

          (position 58.00 300.00)

          (bounds 200.00 120.00)

          (contents clipping layer 0.00, 0.00 200.00 x 120.00)

          (contents layer -44.00, -12.00 288.00 x 144.00)

        )

      )

    )

  )

)

LayoutTests/platform/mac/compositing/reflections/direct-image-object-fit-reflected-expected.txt

    
(GraphicsLayer

  (bounds 800.00 600.00)

  (children 1

    (GraphicsLayer

      (bounds 800.00 600.00)

      (contentsOpaque 1)

      (children 3

        (GraphicsLayer

          (position 28.00 28.00)

          (bounds 200.00 120.00)

          (replica layer)

            (GraphicsLayer

              (bounds 200.00 120.00)

              (transform [1.00 0.00 0.00 0.00] [0.00 -1.00 0.00 0.00] [0.00 0.00 1.00 0.00] [0.00 140.00 0.00 1.00])

              (replicated layer)

            )

          (contents clipping layer 0.00, 0.00 200.00 x 120.00)

          (contents layer -20.00, 0.00 240.00 x 120.00)

        )

        (GraphicsLayer

          (position 272.00 28.00)

          (bounds 200.00 120.00)

          (replica layer)

            (GraphicsLayer

              (bounds 200.00 120.00)

              (transform [1.00 0.00 0.00 0.00] [0.00 -1.00 0.00 0.00] [0.00 0.00 1.00 0.00] [0.00 140.00 0.00 1.00])

              (replicated layer)

            )

          (contents layer 0.00, 10.00 200.00 x 100.00)

        )

        (GraphicsLayer

          (position 516.00 28.00)

          (bounds 200.00 120.00)

          (replica layer)

            (GraphicsLayer

              (bounds 200.00 120.00)

              (transform [1.00 0.00 0.00 0.00] [0.00 -1.00 0.00 0.00] [0.00 0.00 1.00 0.00] [0.00 140.00 0.00 1.00])

              (replicated layer)

            )

          (contents clipping layer 0.00, 0.00 200.00 x 120.00)

          (contents layer -44.00, -12.00 288.00 x 144.00)

        )

      )

    )

  )

)

LayoutTests/platform/mac/compositing/video/video-object-fit-expected.txt

   
(GraphicsLayer

  (bounds 785.00 775.00)

  (children 1

    (GraphicsLayer

      (bounds 785.00 775.00)

      (contentsOpaque 1)

      (children 6

        (GraphicsLayer

          (position 13.00 13.00)

          (bounds 124.00 204.00)

          (contentsOpaque 1)

          (drawsContent 1)

        )

        (GraphicsLayer

          (position 151.00 13.00)

          (bounds 124.00 204.00)

          (contentsOpaque 1)

          (drawsContent 1)

        )

        (GraphicsLayer

          (position 289.00 13.00)

          (bounds 124.00 204.00)

          (contentsOpaque 1)

          (drawsContent 1)

        )

        (GraphicsLayer

          (position 13.00 231.00)

          (bounds 354.00 304.00)

          (contentsOpaque 1)

          (drawsContent 1)

        )

        (GraphicsLayer

          (position 13.00 569.00)

          (bounds 404.00 184.00)

          (contentsOpaque 1)

          (drawsContent 1)

        )

        (GraphicsLayer

          (position 431.00 549.00)

          (bounds 124.00 204.00)

          (contentsOpaque 1)

          (drawsContent 1)

        )

      )

    )

  )

)