ChangeLog

112013-04-26 Noam Rosenthal <noam@webkit.org>

        Get rid of "non-composited contents" in CoordinatedLayerTreeHost

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

        Reviewed by NOBODY (OOPS!).

        When in force compositing mode, always assume that the main layer needs

        a backing store. Make setVisibleContentRectTrajectoryVector and accumulatedCoverRect

        recursive so that they don't rely on a specialized layer.

        No new testable behavior, changes to coverRect and trajectory vector only

        affect tiling latency in rare cases that are not trivial to test.

        * platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.cpp:

        (WebCore::CoordinatedGraphicsLayer:setVisibleContentRectTrajectoryVector):

            Make the trajectory vector recursive, though limited only to layers with

            translate/identity. This allows us to keep the trajectory vector while removing

            the non-composited contents specialization.

        (WebCore::CoordinatedGraphicsLayer::accumulatedCoverRect):

            Added accumulatedCoverRect, so that the coverRect calculations for the UI process

            are not bound to the non-composited contents layer.

        (WebCore::CoordinatedGraphicsLayer::findDescendantWithContentsRecursively):

            Instead of saving a reference to the non-composited contents layer, we assume that

            the first layer we found recursively which has contents is the one to be used for

            coverRect/trajectory calculations.

        (WebCore):

        * platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.h:

        (CoordinatedGraphicsLayer):

        * rendering/RenderLayerBacking.cpp:

        (WebCore::RenderLayerBacking::paintsIntoWindow):

            Always create a layer for the non-composited contents when in forceCompositing mode.

2013-04-26  Noam Rosenthal  <noam@webkit.org>

        [Qt] fast/canvas/webgl/webgl-composite-modes.html broken after r148433.

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

Source/WebKit2/ChangeLog

2013-04-26  Noam Rosenthal  <noam@webkit.org>

        Get rid of "non-composited contents" in CoordinatedLayerTreeHost

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

        Reviewed by NOBODY (OOPS!).

        Instead of using a special non-composited contents layer, we let RenderLayerCompositor create

        a proper GraphicsLayer for that content.

        CoordinatedLayerTreeHost now needs to find the main contents layer for the purpose of setting

        the trajectory vector and applying the cover rect.

        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.cpp:

        (WebKit::CoordinatedLayerTreeHost::CoordinatedLayerTreeHost):

        (WebKit::CoordinatedLayerTreeHost::setRootCompositingLayer):

            Don't create the non-composited layer, instead keep a raw pointer to the root

            compositing layer created by the WebCore compositor.

        (WebKit::CoordinatedLayerTreeHost::setNonCompositedContentsNeedDisplay):

        (WebKit::CoordinatedLayerTreeHost::setNonCompositedContentsNeedDisplayInRect):

        (WebKit::CoordinatedLayerTreeHost::scrollNonCompositedContents):

        (WebKit::CoordinatedLayerTreeHost::sizeDidChange):

        (WebKit::CoordinatedLayerTreeHost::paintContents):

        (WebKit::CoordinatedLayerTreeHost::deviceOrPageScaleFactorChanged):

        (WebKit::CoordinatedLayerTreeHost::setVisibleContentsRect):

            Remove non-composited layer specialization.

2013-04-23  Noam Rosenthal  <noam@webkit.org>

        [Coordinated Graphics] Remove the lockAnimations code path

Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.cpp

@@void CoordinatedGraphicsLayer::tiledBackingStorePaintBegin()

{

}

CoordinatedGraphicsLayer* CoordinatedGraphicsLayer::findFirstDescendantWithContentsRecursively()

{

    if (shouldHaveBackingStore())

        return this;

    for (size_t i = 0; i < children().size(); ++i) {

        CoordinatedGraphicsLayer* layer = toCoordinatedGraphicsLayer(children()[i])->findFirstDescendantWithContentsRecursively();

        if (layer)

            return layer;

    }

    return 0;

}

void CoordinatedGraphicsLayer::setVisibleContentRectTrajectoryVector(const FloatPoint& trajectoryVector)

{

    if (!m_mainBackingStore)

Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.h

@@public:

    bool hasPendingVisibleChanges();

    static void setShouldSupportContentsTiling(bool);

151

151 CoordinatedGraphicsLayer* findFirstDescendantWithContentsRecursively();

private:

#if USE(GRAPHICS_SURFACE)

    enum PendingCanvasOperation {

Source/WebCore/rendering/RenderLayerBacking.cpp

@@bool RenderLayerBacking::paintsIntoWindow() const

        return false;

    if (m_owningLayer->isRootLayer()) {

1848 #if PLATFORM(BLACKBERRY)

1848#if PLATFORM(BLACKBERRY) || USE(COORDINATED_GRAPHICS)

        if (compositor()->inForcedCompositingMode())

            return false;

#endif

Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.cpp

@@CoordinatedLayerTreeHost::~CoordinatedLayerTreeHost()

CoordinatedLayerTreeHost::CoordinatedLayerTreeHost(WebPage* webPage)

    : LayerTreeHost(webPage)

83 , m_rootCompositingLayer(0)

    , m_notifyAfterScheduledLayerFlush(false)

    , m_isValid(true)

    , m_isPurging(false)

@@CoordinatedLayerTreeHost::CoordinatedLayerTreeHost(WebPage* webPage)

    // Create a root layer.

    m_rootLayer = GraphicsLayer::create(this, this);

102 CoordinatedGraphicsLayer* coordinatedRootLayer = toCoordinatedGraphicsLayer(m_rootLayer.get());

#ifndef NDEBUG

    m_rootLayer->setName("CoordinatedLayerTreeHost root layer");

#endif

    m_rootLayer->setDrawsContent(false);

    m_rootLayer->setSize(m_webPage->size());

    m_layerTreeContext.coordinatedLayerID = toCoordinatedGraphicsLayer(coordinatedRootLayer)->id();

    m_nonCompositedContentLayer = GraphicsLayer::create(this, this);

#ifndef NDEBUG

    m_nonCompositedContentLayer->setName("CoordinatedLayerTreeHost non-composited content");

#endif

    m_nonCompositedContentLayer->setDrawsContent(true);

    m_nonCompositedContentLayer->setSize(m_webPage->size());

    m_nonCompositedContentLayer->setShowDebugBorder(m_webPage->corePage()->settings()->showDebugBorders());

    m_nonCompositedContentLayer->setShowRepaintCounter(m_webPage->corePage()->settings()->showRepaintCounter());

    m_rootLayer->addChild(m_nonCompositedContentLayer.get());

108 m_layerTreeContext.coordinatedLayerID = toCoordinatedGraphicsLayer(m_rootLayer.get())->id();

    CoordinatedSurface::setFactory(createCoordinatedSurface);

@@void CoordinatedLayerTreeHost::setShouldNotifyAfterNextScheduledLayerFlush(bool

void CoordinatedLayerTreeHost::setRootCompositingLayer(WebCore::GraphicsLayer* graphicsLayer)

{

170 ~~m_n~~onComposit~~edContent~~Layer~~->removeAllChildren(~~);

171 m_nonComposit~~edContent~~Layer->s~~etContentsOpaque(m_webPage->drawsBackground() && !m_webPage->drawsTransp~~arent~~Background())~~;

158 if (m_rootCompositingLayer)

159 m_rootCompositingLayer->removeFromParent();

172160

    // Add the accelerated layer tree hierarchy.

    if (graphicsLayer)

        m_nonCompositedContentLayer->addChild(graphicsLayer);

    m_rootCompositingLayer = graphicsLayer;

    if (m_rootCompositingLayer)

        m_rootLayer->addChildAtIndex(m_rootCompositingLayer, 0);

}

void CoordinatedLayerTreeHost::invalidate()

@@void CoordinatedLayerTreeHost::invalidate()

    m_isValid = false;

}

void CoordinatedLayerTreeHost::setNonCompositedContentsNeedDisplay()

{

    m_nonCompositedContentLayer->setNeedsDisplay();

    if (m_pageOverlayLayer)

        m_pageOverlayLayer->setNeedsDisplay();

    scheduleLayerFlush();

}

void CoordinatedLayerTreeHost::setNonCompositedContentsNeedDisplayInRect(const WebCore::IntRect& rect)

{

    m_nonCompositedContentLayer->setNeedsDisplayInRect(rect);

    if (m_pageOverlayLayer)

        m_pageOverlayLayer->setNeedsDisplayInRect(rect);

    scheduleLayerFlush();

}

void CoordinatedLayerTreeHost::scrollNonCompositedContents(const WebCore::IntRect&)

{

    if (!m_webPage->useFixedLayout())

        setNonCompositedContentsNeedDisplay();

    scheduleLayerFlush();

}

void CoordinatedLayerTreeHost::forceRepaint()

{

    // This is necessary for running layout tests. Since in this case we are not waiting for a UIProcess to reply nicely.

@@bool CoordinatedLayerTreeHost::forceRepaintAsync(uint64_t callbackID)

void CoordinatedLayerTreeHost::sizeDidChange(const WebCore::IntSize& newSize)

{

    if (m_rootLayer->size() == newSize)

        return;

239198 m_rootLayer->setSize(newSize);

    // If the newSize exposes new areas of the non-composited content a setNeedsDisplay is needed

    // for those newly exposed areas.

    FloatSize oldSize = m_nonCompositedContentLayer->size();

    m_nonCompositedContentLayer->setSize(newSize);

    if (newSize.width() > oldSize.width()) {

        float height = std::min(static_cast<float>(newSize.height()), oldSize.height());

        m_nonCompositedContentLayer->setNeedsDisplayInRect(FloatRect(oldSize.width(), 0, newSize.width() - oldSize.width(), height));

    }

    if (newSize.height() > oldSize.height())

        m_nonCompositedContentLayer->setNeedsDisplayInRect(FloatRect(0, oldSize.height(), newSize.width(), newSize.height() - oldSize.height()));

    if (m_pageOverlayLayer)

        m_pageOverlayLayer->setSize(newSize);

    scheduleLayerFlush();

}

@@bool CoordinatedLayerTreeHost::flushPendingLayerChanges()

    TemporaryChange<bool> protector(m_isFlushingLayerChanges, true);

    createCompositingLayers();

299

    initializeRootCompositingLayerIfNeeded();

    m_rootLayer->flushCompositingStateForThisLayerOnly();

303 m_nonCompositedContentLayer->flushCompositingStateForThisLayerOnly();

    if (m_pageOverlayLayer)

        m_pageOverlayLayer->flushCompositingStateForThisLayerOnly();

    bool didSync = m_webPage->corePage()->mainFrame()->view()->flushCompositingStateIncludingSubframes();

    flushPendingImageBackingChanges();

310

    deleteCompositingLayers();

    if (m_shouldSyncFrame) {

        didSync = true;

316 m_state.contentsSize = roundedIntSize(m_nonCompositedContentLayer->size());

317 m_state.coveredRect = toCoordinatedGraphicsLayer(m_nonCompositedContentLayer.get())->coverRect();

        if (m_rootCompositingLayer) {

            m_state.contentsSize = roundedIntSize(m_rootCompositingLayer->size());

            if (CoordinatedGraphicsLayer* contentsLayer = mainContentsLayer())

                m_state.coveredRect = contentsLayer->coverRect();

        }

        m_state.scrollPosition = m_visibleContentsRect.location();

        m_webPage->send(Messages::CoordinatedLayerTreeHostProxy::CommitCoordinatedGraphicsState(m_state));

@@void CoordinatedLayerTreeHost::notifyFlushRequired(const WebCore::GraphicsLayer*

void CoordinatedLayerTreeHost::paintContents(const WebCore::GraphicsLayer* graphicsLayer, WebCore::GraphicsContext& graphicsContext, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect& clipRect)

{

    if (graphicsLayer == m_nonCompositedContentLayer) {

        m_webPage->drawRect(graphicsContext, clipRect);

        return;

    }

    if (graphicsLayer == m_pageOverlayLayer) {

        // Overlays contain transparent contents and won't clear the context as part of their rendering, so we do it here.

        graphicsContext.clearRect(clipRect);

@@WebCore::FloatRect CoordinatedLayerTreeHost::visibleContentsRect() const

    return m_visibleContentsRect;

}

CoordinatedGraphicsLayer* CoordinatedLayerTreeHost::mainContentsLayer()

{

    if (!m_rootCompositingLayer)

        return 0;

    return toCoordinatedGraphicsLayer(m_rootCompositingLayer)->findFirstDescendantWithContentsRecursively();

}

void CoordinatedLayerTreeHost::setVisibleContentsRect(const FloatRect& rect, const FloatPoint& trajectoryVector)

{

    // A zero trajectoryVector indicates that tiles all around the viewport are requested.

666 toCoordinatedGraphicsLayer(m_nonCompositedContentLayer.get())->setVisibleContentRectTrajectoryVector(trajectoryVector);

612 if (CoordinatedGraphicsLayer* contentsLayer = mainContentsLayer())

613 contentsLayer->setVisibleContentRectTrajectoryVector(trajectoryVector);

    bool contentsRectDidChange = rect != m_visibleContentsRect;

    if (contentsRectDidChange) {

@@void CoordinatedLayerTreeHost::setVisibleContentsRect(const FloatRect& rect, con

void CoordinatedLayerTreeHost::deviceOrPageScaleFactorChanged()

{

    m_rootLayer->deviceOrPageScaleFactorChanged();

689 m_nonCompositedContentLayer->deviceOrPageScaleFactorChanged();

    if (m_pageOverlayLayer)

        m_pageOverlayLayer->deviceOrPageScaleFactorChanged();

}

Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedLayerTreeHost.h

@@public:

    virtual void setRootCompositingLayer(WebCore::GraphicsLayer*);

    virtual void invalidate();

    virtual void setNonCompositedContentsNeedDisplay() OVERRIDE;

    virtual void setNonCompositedContentsNeedDisplayInRect(const WebCore::IntRect&) OVERRIDE;

    virtual void scrollNonCompositedContents(const WebCore::IntRect&) OVERRIDE;

    virtual void setNonCompositedContentsNeedDisplay() OVERRIDE { }

    virtual void setNonCompositedContentsNeedDisplayInRect(const WebCore::IntRect&) OVERRIDE { }

    virtual void scrollNonCompositedContents(const WebCore::IntRect&) OVERRIDE { }

    virtual void forceRepaint();

    virtual bool forceRepaintAsync(uint64_t callbackID);

    virtual void sizeDidChange(const WebCore::IntSize& newSize);

@@public:

    virtual void setVisibleContentsRect(const WebCore::FloatRect&, const WebCore::FloatPoint&);

    virtual void didReceiveCoordinatedLayerTreeHostMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);

    virtual WebCore::GraphicsLayerFactory* graphicsLayerFactory() OVERRIDE;

91 WebCore::CoordinatedGraphicsLayer* mainContentsLayer();

#if ENABLE(REQUEST_ANIMATION_FRAME)

    virtual void scheduleAnimation() OVERRIDE;

@@private:

    void performScheduledLayerFlush();

    void didPerformScheduledLayerFlush();

    void syncDisplayState();

146

    void layerFlushTimerFired(WebCore::Timer<CoordinatedLayerTreeHost>*);

    void scheduleReleaseInactiveAtlases();

@@private:

#endif

    OwnPtr<WebCore::GraphicsLayer> m_rootLayer;

    // The layer which contains all non-composited content.

    OwnPtr<WebCore::GraphicsLayer> m_nonCompositedContentLayer;

167 WebCore::GraphicsLayer* m_rootCompositingLayer;

    // The page overlay layer. Will be null if there's no page overlay.

    OwnPtr<WebCore::GraphicsLayer> m_pageOverlayLayer;