ChangeLog

2012-06-08  David Reveman  <reveman@chromium.org>

        [Chromium] Compositor doesn't support translucent root layers.

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

        Reviewed by NOBODY (OOPS!).

        * chromium/public/WebLayer.h:

        (WebLayer):

        * chromium/public/WebLayerTreeView.h:

        (WebLayerTreeView):

2012-06-06  Mark Pilgrim  <pilgrim@chromium.org>

        [Chromium] Move createMessagePortChannel to Platform.h

Source/WebCore/ChangeLog

2012-06-08  David Reveman  <reveman@chromium.org>

        [Chromium] Compositor doesn't support translucent root layers.

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

        Reviewed by NOBODY (OOPS!).

        Forward the isTransparent WebView setting to WebLayerTreeView,

        CCLayerTreeHost and CCLayerTreeHostImpl as hasTransparentBackground.

        Use hasTransparentBackground setting to determine how to clear the

        root render pass and draw the background. Set opaque flag correctly

        on the NonCompositedContentHost's graphics layer to make sure

        sub-pixel rendering is not used with a transparent WebView.

        Unit tests: CCLayerTreeHostImplTest.hasTransparentBackground

                    LayerRendererChromiumTest2.opaqueRenderPass

                    LayerRendererChromiumTest2.transparentRenderPass

        * platform/graphics/chromium/BitmapCanvasLayerTextureUpdater.cpp:

        (WebCore::BitmapCanvasLayerTextureUpdater::prepareToUpdate):

        * platform/graphics/chromium/LayerRendererChromium.cpp:

        (WebCore::LayerRendererChromium::clearRenderPass):

        (WebCore::LayerRendererChromium::drawRenderPass):

        (WebCore::LayerRendererChromium::drawBackgroundFilters):

        * platform/graphics/chromium/LayerRendererChromium.h:

        (LayerRendererChromium):

        * platform/graphics/chromium/SkPictureCanvasLayerTextureUpdater.cpp:

        (WebCore::SkPictureCanvasLayerTextureUpdater::prepareToUpdate):

        * platform/graphics/chromium/cc/CCLayerTreeHost.cpp:

        (WebCore::CCLayerTreeHost::CCLayerTreeHost):

        (WebCore::CCLayerTreeHost::finishCommitOnImplThread):

        * platform/graphics/chromium/cc/CCLayerTreeHost.h:

        (WebCore::CCLayerTreeHost::setHasTransparentBackground):

        (CCLayerTreeHost):

        * platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp:

        (WebCore::CCLayerTreeHostImpl::CCLayerTreeHostImpl):

        (WebCore::CCLayerTreeHostImpl::calculateRenderPasses):

        * platform/graphics/chromium/cc/CCLayerTreeHostImpl.h:

        (WebCore::CCLayerTreeHostImpl::hasTransparentBackground):

        (WebCore::CCLayerTreeHostImpl::setHasTransparentBackground):

        (CCLayerTreeHostImpl):

        * platform/graphics/chromium/cc/CCRenderPass.cpp:

        (WebCore::CCRenderPass::CCRenderPass):

        * platform/graphics/chromium/cc/CCRenderPass.h:

        (WebCore::CCRenderPass::hasTransparentBackground):

        (WebCore::CCRenderPass::setHasTransparentBackground):

        (CCRenderPass):

2012-06-08  Erik Arvidsson  <arv@chromium.org>

        [V8] Keep TextTrackList alive as long as its owner is alive

Source/WebKit/chromium/ChangeLog

2012-06-08  David Reveman  <reveman@chromium.org>

        [Chromium] Compositor doesn't support translucent root layers.

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

        Reviewed by NOBODY (OOPS!).

        * src/NonCompositedContentHost.cpp:

        (WebKit::NonCompositedContentHost::setOpaque):

        (WebKit):

        * src/NonCompositedContentHost.h:

        (NonCompositedContentHost):

        * src/WebLayerTreeView.cpp:

        (WebKit::WebLayerTreeView::setHasTransparentBackground):

        (WebKit):

        * src/WebViewImpl.cpp:

        (WebKit::WebViewImpl::setIsTransparent):

        (WebKit::WebViewImpl::setIsAcceleratedCompositingActive):

        * tests/CCLayerTreeHostImplTest.cpp:

        * tests/LayerRendererChromiumTest.cpp:

        (ClearCountingContext):

        (ClearCountingContext::ClearCountingContext):

        (ClearCountingContext::clear):

        (ClearCountingContext::clearCount):

        (TEST):

2012-06-08  Jochen Eisinger  <jochen@chromium.org>

        Unreviewed.  Rolled DEPS.

Source/Platform/chromium/public/WebLayer.h

@@public:

    // Apply filters to pixels that show through the background of this layer.

    // Note: These filters are only possible on layers that are drawn directly

    // to the root render surface. This means if an ancestor of the background-

    // filtered layer sets certain properties (opacity, transforms), it may

    // conflict and hide the background filters.

    // to a root render surface with an opaque background. This means if an

    // ancestor of the background-filtered layer sets certain properties

    // (opacity, transforms), it may conflict and hide the background filters.

    WEBKIT_EXPORT void setBackgroundFilters(const WebFilterOperations&);

    WEBKIT_EXPORT void setDebugBorderColor(const WebColor&);

Source/Platform/chromium/public/WebLayerTreeView.h

@@public:

    // Sets the background color for the viewport.

    WEBKIT_EXPORT void setBackgroundColor(WebColor);

    // Sets the background transparency for the viewport. The default is 'false'.

    WEBKIT_EXPORT void setHasTransparentBackground(bool);

    // Sets whether this view is visible. In threaded mode, a view that is not visible will not

    // composite or trigger updateAnimations() or layout() calls until it becomes visible.

    WEBKIT_EXPORT void setVisible(bool);

Source/WebCore/platform/graphics/chromium/BitmapCanvasLayerTextureUpdater.cpp

@@void BitmapCanvasLayerTextureUpdater::prepareToUpdate(const IntRect& contentRect

    // Assumption: if a tiler is using border texels, then it is because the

    // layer is likely to be filtered or transformed. Because of it might be

    // transformed, draw the text in grayscale instead of subpixel antialiasing.

91 bool useGrayscaleText = borderTexels || !layerIsOpaque;

9192 PlatformCanvas::Painter::TextOption textOption =

92 borderTex~~els~~ ? PlatformCanvas::Painter::GrayscaleText : PlatformCanvas::Painter::SubpixelText;

93 useGrayscaleText ? PlatformCanvas::Painter::GrayscaleText : PlatformCanvas::Painter::SubpixelText;

    PlatformCanvas::Painter canvasPainter(&m_canvas, textOption);

    canvasPainter.skiaContext()->setTrackOpaqueRegion(!layerIsOpaque);

    paintContents(*canvasPainter.context(), *canvasPainter.skiaContext(), contentRect, contentsScale, resultingOpaqueRect);

Source/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp

@@void LayerRendererChromium::viewportChanged()

    m_currentRenderPass = 0;

}

405 void LayerRendererChromium::clearRenderPass(const CCRenderPass* renderPass, const ~~CCRenderPass* rootRenderPass, const~~ FloatRect& framebufferDamageRect)

405void LayerRendererChromium::clearRenderPass(const CCRenderPass* renderPass, const FloatRect& framebufferDamageRect)

406406{

407 // Non-root layers should clear their entire contents to transparent. On DEBUG builds, the root layer

408 // is cleared to blue to easily see regions that were not drawn on the screen. If we

407 // On DEBUG builds, opaque render passes are cleared to blue to easily see regions that were not drawn on the screen. If we

    // are using partial swap / scissor optimization, then the surface should only

    // clear the damaged region, so that we don't accidentally clear un-changed portions

    // of the screen.

413 if (renderPass != ~~rootRenderPass~~)

412 if (renderPass->hasTransparentBackground())

        GLC(m_context, m_context->clearColor(0, 0, 0, 0));

    else

        GLC(m_context, m_context->clearColor(0, 0, 1, 1));

@@void LayerRendererChromium::clearRenderPass(const CCRenderPass* renderPass, cons

        GLC(m_context, m_context->disable(GraphicsContext3D::SCISSOR_TEST));

#if defined(NDEBUG)

424 if (renderPass != ~~rootRenderPass~~)

423 if (renderPass->hasTransparentBackground())

#endif

        m_context->clear(GraphicsContext3D::COLOR_BUFFER_BIT);

@@void LayerRendererChromium::drawRenderPass(const CCRenderPass* renderPass, const

    if (!useRenderPass(renderPass))

        return;

478 clearRenderPass(r~~enderPass, m_defaultR~~enderPass, framebufferDamageRect);

477 clearRenderPass(renderPass, framebufferDamageRect);

    const CCQuadList& quadList = renderPass->quadList();

    for (CCQuadList::constBackToFrontIterator it = quadList.backToFrontBegin(); it != quadList.backToFrontEnd(); ++it)

@@void LayerRendererChromium::drawBackgroundFilters(const CCRenderPassDrawQuad* qu

    if (quad->backgroundFilters().isEmpty())

        return;

618 // FIXME: We only allow background filters on th~~e root~~ render surface because other surfaces may contain

617 // FIXME: We only allow background filters on an opaque render surface because other surfaces may contain

619618 // translucent pixels, and the contents behind those translucent pixels wouldn't have the filter applied.

620 if (~~!isC~~urrentRenderPass~~(m_defaultR~~en~~derPass~~))

619 if (m_currentRenderPass->hasTransparentBackground())

621620 return;

621 ASSERT(!m_currentManagedTexture);

    // FIXME: Do a single readback for both the surface and replica and cache the filtered results (once filter textures are not reused).

    IntRect deviceRect = enclosingIntRect(CCMathUtil::mapClippedRect(contentsDeviceTransform, sharedGeometryQuad().boundingBox()));

Source/WebCore/platform/graphics/chromium/LayerRendererChromium.h

@@private:

    bool bindFramebufferToTexture(ManagedTexture*, const IntRect& viewportRect);

155 void clearRenderPass(const CCRenderPass*, const ~~CCRenderPass* rootRenderPass, const~~ FloatRect& framebufferDamageRect);

155 void clearRenderPass(const CCRenderPass*, const FloatRect& framebufferDamageRect);

    void releaseRenderPassTextures();

Source/WebCore/platform/graphics/chromium/SkPictureCanvasLayerTextureUpdater.cpp

@@void SkPictureCanvasLayerTextureUpdater::prepareToUpdate(const IntRect& contentR

    // layer is likely to be filtered or transformed. Because it might be

    // transformed, set image buffer flag to draw the text in grayscale

    // instead of using subpixel antialiasing.

61 platformContext.setDrawingToImageBuffer(borderTexels ? true : false);

61 bool useGrayscaleText = borderTexels || !m_layerIsOpaque;

62 platformContext.setDrawingToImageBuffer(useGrayscaleText);

    GraphicsContext graphicsContext(&platformContext);

    paintContents(graphicsContext, platformContext, contentRect, contentsScale, resultingOpaqueRect);

    m_picture.endRecording();

Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp

@@CCLayerTreeHost::CCLayerTreeHost(CCLayerTreeHostClient* client, const CCSettings

    , m_maxPageScaleFactor(1)

    , m_triggerIdlePaints(true)

    , m_backgroundColor(Color::white)

89 , m_hasTransparentBackground(false)

    , m_partialTextureUpdateRequests(0)

{

    ASSERT(CCProxy::isMainThread());

@@void CCLayerTreeHost::finishCommitOnImplThread(CCLayerTreeHostImpl* hostImpl)

    hostImpl->setViewportSize(viewportSize());

    hostImpl->setPageScaleFactorAndLimits(m_pageScaleFactor, m_minPageScaleFactor, m_maxPageScaleFactor);

    hostImpl->setBackgroundColor(m_backgroundColor);

256 hostImpl->setHasTransparentBackground(m_hasTransparentBackground);

    hostImpl->setVisible(m_visible);

    hostImpl->setSourceFrameCanBeDrawn(m_frameIsForDisplay);

Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.h

@@public:

    void setBackgroundColor(const Color& color) { m_backgroundColor = color; }

234 void setHasTransparentBackground(bool transparent) { m_hasTransparentBackground = transparent; }

235

    TextureManager* contentsTextureManager() const;

    void setContentsMemoryAllocationLimitBytes(size_t);

@@private:

    float m_minPageScaleFactor, m_maxPageScaleFactor;

    bool m_triggerIdlePaints;

    Color m_backgroundColor;

314 bool m_hasTransparentBackground;

    TextureList m_deleteTextureAfterCommitList;

    size_t m_partialTextureUpdateRequests;

Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp

@@CCLayerTreeHostImpl::CCLayerTreeHostImpl(const CCSettings& settings, CCLayerTree

    , m_sentPageScaleDelta(1)

    , m_minPageScale(0)

    , m_maxPageScale(0)

127 , m_hasTransparentBackground(false)

    , m_needsAnimateLayers(false)

    , m_pinchGestureActive(false)

    , m_fpsCounter(CCFrameRateCounter::create())

@@bool CCLayerTreeHostImpl::calculateRenderPasses(CCRenderPassList& passes, CCLaye

        occlusionTracker.leaveLayer(it);

    }

327 passes.last()->appendQuadsToFillScreen(m_rootLayerImpl.get(), m_backgroundColor, occlusionTracker);

    if (!m_hasTransparentBackground) {

        passes.last()->setHasTransparentBackground(false);

        passes.last()->appendQuadsToFillScreen(m_rootLayerImpl.get(), m_backgroundColor, occlusionTracker);

    }

    if (drawFrame)

        occlusionTracker.overdrawMetrics().recordMetrics(this);

Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.h

@@public:

    const Color& backgroundColor() const { return m_backgroundColor; }

    void setBackgroundColor(const Color& color) { m_backgroundColor = color; }

    bool hasTransparentBackground() const { return m_hasTransparentBackground; }

    void setHasTransparentBackground(bool transparent) { m_hasTransparentBackground = transparent; }

    bool needsAnimateLayers() const { return m_needsAnimateLayers; }

    void setNeedsAnimateLayers() { m_needsAnimateLayers = true; }

@@private:

    float m_minPageScale, m_maxPageScale;

    Color m_backgroundColor;

233 bool m_hasTransparentBackground;

    // If this is true, it is necessary to traverse the layer tree ticking the animators.

    bool m_needsAnimateLayers;

Source/WebCore/platform/graphics/chromium/cc/CCRenderPass.cpp

@@PassOwnPtr<CCRenderPass> CCRenderPass::create(CCRenderSurface* targetSurface)

CCRenderPass::CCRenderPass(CCRenderSurface* targetSurface)

    : m_targetSurface(targetSurface)

    , m_framebufferOutputRect(targetSurface->contentRect())

48 , m_hasTransparentBackground(true)

{

    ASSERT(m_targetSurface);

}

Source/WebCore/platform/graphics/chromium/cc/CCRenderPass.h

@@public:

    // This denotes the bounds in physical pixels of the output generated by this RenderPass.

    const IntRect& framebufferOutputRect() const { return m_framebufferOutputRect; }

    bool hasTransparentBackground() const { return m_hasTransparentBackground; }

    void setHasTransparentBackground(bool transparent) { m_hasTransparentBackground = transparent; }

private:

    explicit CCRenderPass(CCRenderSurface*);

@@private:

    CCQuadList m_quadList;

    IntRect m_framebufferOutputRect;

    Vector<OwnPtr<CCSharedQuadState> > m_sharedQuadStateList;

77 bool m_hasTransparentBackground;

};

typedef Vector<OwnPtr<CCRenderPass> > CCRenderPassList;

Source/WebKit/chromium/src/NonCompositedContentHost.cpp

@@void NonCompositedContentHost::setBackgroundColor(const WebCore::Color& color)

    m_graphicsLayer->platformLayer()->setBackgroundColor(color);

}

void NonCompositedContentHost::setOpaque(bool opaque)

{

    m_graphicsLayer->platformLayer()->setOpaque(opaque);

}

void NonCompositedContentHost::setScrollLayer(WebCore::GraphicsLayer* layer)

{

    m_graphicsLayer->setNeedsDisplay();

Source/WebKit/chromium/src/NonCompositedContentHost.h

@@public:

    void invalidateRect(const WebCore::IntRect&);

    void setBackgroundColor(const WebCore::Color&);

59 void setOpaque(bool);

    void setScrollLayer(WebCore::GraphicsLayer*);

    void setViewport(const WebCore::IntSize& viewportSize, const WebCore::IntSize& contentsSize, const WebCore::IntPoint& scrollPosition, float deviceScale, int layerAdjustX);

    WebCore::GraphicsLayer* topLevelRootLayer() const { return m_graphicsLayer.get(); }

Source/WebKit/chromium/src/WebLayerTreeView.cpp

@@void WebLayerTreeView::setBackgroundColor(WebColor color)

    m_private->layerTreeHost()->setBackgroundColor(color);

}

void WebLayerTreeView::setHasTransparentBackground(bool transparent)

{

    m_private->layerTreeHost()->setHasTransparentBackground(transparent);

}

void WebLayerTreeView::setVisible(bool visible)

{

    m_private->layerTreeHost()->setVisible(visible);

Source/WebKit/chromium/src/WebViewImpl.cpp

@@void WebViewImpl::setIsTransparent(bool isTransparent)

    // Future frames check this to know whether to be transparent.

    m_isTransparent = isTransparent;

    if (m_nonCompositedContentHost)

        m_nonCompositedContentHost->setOpaque(!isTransparent);

    m_layerTreeView.setHasTransparentBackground(isTransparent);

}

bool WebViewImpl::isTransparent() const

@@void WebViewImpl::setIsAcceleratedCompositingActive(bool active)

        m_nonCompositedContentHost = NonCompositedContentHost::create(WebViewImplContentPainter::create(this));

        m_nonCompositedContentHost->setShowDebugBorders(page()->settings()->showDebugBorders());

3483 m_nonCompositedContentHost->setOpaque(!isTransparent());

        if (m_webSettings->applyDefaultDeviceScaleFactorInCompositor() && page()->deviceScaleFactor() != 1) {

            ASSERT(page()->deviceScaleFactor());

@@void WebViewImpl::setIsAcceleratedCompositingActive(bool active)

            m_layerTreeView.setPageScaleFactorAndLimits(pageScaleFactor(), m_minimumPageScaleFactor, m_maximumPageScaleFactor);

            if (m_compositorSurfaceReady)

                m_layerTreeView.setSurfaceReady();

3498 m_layerTreeView.setHasTransparentBackground(isTransparent());

            updateLayerTreeViewport();

            m_client->didActivateCompositor(m_layerTreeView.compositorIdentifier());

            m_isAcceleratedCompositingActive = true;

Source/WebKit/chromium/tests/CCLayerTreeHostImplTest.cpp

@@TEST_F(CCLayerTreeHostImplTest, dontUseOldResourcesAfterLostContext)

    m_hostImpl->swapBuffers();

}

class MockDrawQuadsToFillScreenContext : public FakeWebGraphicsContext3D {

public:

    MOCK_METHOD1(useProgram, void(WebGLId program));

    MOCK_METHOD4(drawElements, void(WGC3Denum mode, WGC3Dsizei count, WGC3Denum type, WGC3Dintptr offset));

};

TEST_F(CCLayerTreeHostImplTest, hasTransparentBackground)

{

    MockDrawQuadsToFillScreenContext* mockContext = new MockDrawQuadsToFillScreenContext();

    RefPtr<CCGraphicsContext> context = CCGraphicsContext::create3D(GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(mockContext), GraphicsContext3D::RenderDirectlyToHostWindow));

    // Run test case

    OwnPtr<CCLayerTreeHostImpl> myHostImpl = createLayerTreeHost(false, context, CCLayerImpl::create(1));

    myHostImpl->setBackgroundColor(Color::white);

    // Verify one quad is drawn when transparent background set is not set.

    myHostImpl->setHasTransparentBackground(false);

    EXPECT_CALL(*mockContext, useProgram(_))

        .Times(1);

    EXPECT_CALL(*mockContext, drawElements(_, _, _, _))

        .Times(1);

    CCLayerTreeHostImpl::FrameData frame;

    EXPECT_TRUE(myHostImpl->prepareToDraw(frame));

    myHostImpl->drawLayers(frame);

    myHostImpl->didDrawAllLayers(frame);

    Mock::VerifyAndClearExpectations(&mockContext);

    // Verify no quads are drawn when transparent background is set.

    myHostImpl->setHasTransparentBackground(true);

    EXPECT_TRUE(myHostImpl->prepareToDraw(frame));

    myHostImpl->drawLayers(frame);

    myHostImpl->didDrawAllLayers(frame);

    Mock::VerifyAndClearExpectations(&mockContext);

}

17371772} // namespace

Source/WebKit/chromium/tests/LayerRendererChromiumTest.cpp

@@TEST(LayerRendererChromiumTest2, initializationWithoutGpuMemoryManagerExtensionS

    EXPECT_GT(mockClient.memoryAllocationLimitBytes(), 0ul);

}

class ClearCountingContext : public FakeWebGraphicsContext3D {

public:

    ClearCountingContext() : m_clear(0) { }

    virtual void clear(WGC3Dbitfield)

    {

        m_clear++;

    }

    int clearCount() const { return m_clear; }

private:

    int m_clear;

};

TEST(LayerRendererChromiumTest2, opaqueBackground)

{

    FakeCCRendererClient mockClient;

    RefPtr<GraphicsContext3D> context = GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(new ClearCountingContext), GraphicsContext3D::RenderDirectlyToHostWindow);

    FakeLayerRendererChromium layerRendererChromium(&mockClient, context);

    mockClient.rootRenderPass()->setHasTransparentBackground(false);

    EXPECT_TRUE(layerRendererChromium.initialize());

    layerRendererChromium.beginDrawingFrame(mockClient.rootRenderPass());

    layerRendererChromium.drawRenderPass(mockClient.rootRenderPass(), FloatRect());

    layerRendererChromium.finishDrawingFrame();

    // On DEBUG builds, render passes with opaque background clear to blue to

    // easily see regions that were not drawn on the screen.

#if defined(NDEBUG)

    EXPECT_EQ(0, static_cast<ClearCountingContext*>(GraphicsContext3DPrivate::extractWebGraphicsContext3D(context.get()))->clearCount());

#else

    EXPECT_EQ(1, static_cast<ClearCountingContext*>(GraphicsContext3DPrivate::extractWebGraphicsContext3D(context.get()))->clearCount());

#endif

}

TEST(LayerRendererChromiumTest2, transparentBackground)

{

    FakeCCRendererClient mockClient;

    RefPtr<GraphicsContext3D> context = GraphicsContext3DPrivate::createGraphicsContextFromWebContext(adoptPtr(new ClearCountingContext), GraphicsContext3D::RenderDirectlyToHostWindow);

    FakeLayerRendererChromium layerRendererChromium(&mockClient, context);

    mockClient.rootRenderPass()->setHasTransparentBackground(true);

    EXPECT_TRUE(layerRendererChromium.initialize());

    layerRendererChromium.beginDrawingFrame(mockClient.rootRenderPass());

    layerRendererChromium.drawRenderPass(mockClient.rootRenderPass(), FloatRect());

    layerRendererChromium.finishDrawingFrame();

    EXPECT_EQ(1, static_cast<ClearCountingContext*>(GraphicsContext3DPrivate::extractWebGraphicsContext3D(context.get()))->clearCount());

}