Changeset 119419 in webkit


Ignore:
Timestamp:
Jun 4, 2012 12:53:39 PM (12 years ago)
Author:
danakj@chromium.org
Message:

[chromium] Make LayerRendererChromium use RenderPasses instead of RenderSurfaces
​https://bugs.webkit.org/show_bug.cgi?id=88132

Reviewed by Adrienne Walker.

Source/WebCore:

This patch is partly renaming, partly moving data into CCRenderPass
and CCRenderPassDrawQuad. LayerRendererChromium should accept as input
a set of RenderPasses and this should be sufficient for drawing. It
should have no notion of RenderSurfaces at all.

First, what isn't done: RenderSurfaces still hold the textures
where RenderPasses are drawn to/from, so that these textures can
persist across frames. This will be addressed separately.

Otherwise, this completely removes the concept of RenderSurface from
LayerRenderChromium and the CCDrawQuad, replacing it with RenderPass.
The "renderSurfaceTextureManager" is renamed to the "implTextureManager"
and like-wise for the TextureAllocator, as these are not used
exclusively for render surfaces (passes), and a texture manager for
render passes that does not require a RenderSurface* will be the focus
of future changes.

Covered by existing tests.

  • WebCore.gypi:
  • platform/graphics/chromium/LayerRendererChromium.cpp:

(WebCore::LayerRendererChromium::LayerRendererChromium):
(WebCore::LayerRendererChromium::setVisible):
(WebCore::LayerRendererChromium::releaseRenderPassTextures):
(WebCore::LayerRendererChromium::viewportChanged):
(WebCore::LayerRendererChromium::clearRenderPass):
(WebCore::LayerRendererChromium::beginDrawingFrame):
(WebCore::LayerRendererChromium::drawRenderPass):
(WebCore::LayerRendererChromium::drawQuad):
(WebCore::LayerRendererChromium::drawBackgroundFilters):
(WebCore::LayerRendererChromium::drawRenderPassQuad):
(WebCore::LayerRendererChromium::copyPlaneToTexture):
(WebCore::LayerRendererChromium::drawHeadsUpDisplay):
(WebCore::LayerRendererChromium::finishDrawingFrame):
(WebCore::LayerRendererChromium::copyTextureToFramebuffer):
(WebCore::LayerRendererChromium::getFramebufferTexture):
(WebCore::LayerRendererChromium::isCurrentRenderPass):
(WebCore::LayerRendererChromium::useRenderPass):
(WebCore::LayerRendererChromium::useManagedTexture):
(WebCore::LayerRendererChromium::bindFramebufferToTexture):
(WebCore::LayerRendererChromium::setScissorToRect):
(WebCore::LayerRendererChromium::setDrawFramebufferRect):
(WebCore::LayerRendererChromium::initializeSharedObjects):
(WebCore::LayerRendererChromium::renderPassProgram):
(WebCore::LayerRendererChromium::renderPassProgramAA):
(WebCore::LayerRendererChromium::renderPassMaskProgram):
(WebCore::LayerRendererChromium::renderPassMaskProgramAA):
(WebCore::LayerRendererChromium::cleanupSharedObjects):

  • platform/graphics/chromium/LayerRendererChromium.h:

(WebCore):
(LayerRendererChromium):

  • platform/graphics/chromium/cc/CCDrawQuad.cpp:

(WebCore::CCDrawQuad::toRenderPassDrawQuad):

  • platform/graphics/chromium/cc/CCDrawQuad.h:

(WebCore):
(CCDrawQuad):

  • platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:

(WebCore::CCHeadsUpDisplay::draw):

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

(WebCore::CCLayerTreeHostImpl::calculateRenderPasses):
(WebCore::CCLayerTreeHostImpl::drawLayers):

  • platform/graphics/chromium/cc/CCQuadCuller.cpp:
  • platform/graphics/chromium/cc/CCRenderPass.cpp:

(WebCore::CCRenderPass::CCRenderPass):
(WebCore::CCRenderPass::appendQuadsForRenderSurfaceLayer):

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

(CCRenderPass):
(WebCore::CCRenderPass::framebufferOutputRect):

  • platform/graphics/chromium/cc/CCRenderPassDrawQuad.cpp: Renamed from Source/WebCore/platform/graphics/chromium/cc/CCRenderSurfaceDrawQuad.cpp.

(WebCore):
(WebCore::CCRenderPassDrawQuad::create):
(WebCore::CCRenderPassDrawQuad::CCRenderPassDrawQuad):

  • platform/graphics/chromium/cc/CCRenderPassDrawQuad.h: Renamed from Source/WebCore/platform/graphics/chromium/cc/CCRenderSurfaceDrawQuad.h.

(WebCore):
(CCRenderPassDrawQuad):
(WebCore::CCRenderPassDrawQuad::renderPass):
(WebCore::CCRenderPassDrawQuad::isReplica):
(WebCore::CCRenderPassDrawQuad::maskTextureId):
(WebCore::CCRenderPassDrawQuad::filters):
(WebCore::CCRenderPassDrawQuad::backgroundFilters):

  • platform/graphics/chromium/cc/CCRenderSurface.cpp:

(WebCore::CCRenderSurface::prepareContentsTexture):
(WebCore::CCRenderSurface::prepareBackgroundTexture):
(WebCore::CCRenderSurface::appendQuads):

  • platform/graphics/chromium/cc/CCRenderSurface.h:

(WebCore):
(CCRenderSurface):

  • platform/graphics/chromium/cc/CCRenderer.h:

(CCRenderer):

  • platform/graphics/chromium/cc/CCScrollbarLayerImpl.cpp:

(WebCore::CCScrollbarLayerImpl::willDraw):

  • platform/graphics/chromium/cc/CCVideoLayerImpl.cpp:

(WebCore::CCVideoLayerImpl::reserveTextures):

Source/WebKit/chromium:

  • tests/CCLayerTreeHostImplTest.cpp:
  • tests/LayerRendererChromiumTest.cpp:

(FakeCCRendererClient::FakeCCRendererClient):
(FakeCCRendererClient::rootRenderPass):
(FakeCCRendererClient):
(TEST_F):

Location:
trunk/Source
Files:
19 edited
2 moved

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r119409 r119419  
     12012-06-04  Dana Jansens  <danakj@chromium.org>
     2
     3        [chromium] Make LayerRendererChromium use RenderPasses instead of RenderSurfaces
     4        https://bugs.webkit.org/show_bug.cgi?id=88132
     5
     6        Reviewed by Adrienne Walker.
     7
     8        This patch is partly renaming, partly moving data into CCRenderPass
     9        and CCRenderPassDrawQuad. LayerRendererChromium should accept as input
     10        a set of RenderPasses and this should be sufficient for drawing. It
     11        should have no notion of RenderSurfaces at all.
     12
     13        First, what isn't done: RenderSurfaces still hold the textures
     14        where RenderPasses are drawn to/from, so that these textures can
     15        persist across frames. This will be addressed separately.
     16
     17        Otherwise, this completely removes the concept of RenderSurface from
     18        LayerRenderChromium and the CCDrawQuad, replacing it with RenderPass.
     19        The "renderSurfaceTextureManager" is renamed to the "implTextureManager"
     20        and like-wise for the TextureAllocator, as these are not used
     21        exclusively for render surfaces (passes), and a texture manager for
     22        render passes that does not require a RenderSurface* will be the focus
     23        of future changes.
     24
     25        Covered by existing tests.
     26
     27        * WebCore.gypi:
     28        * platform/graphics/chromium/LayerRendererChromium.cpp:
     29        (WebCore::LayerRendererChromium::LayerRendererChromium):
     30        (WebCore::LayerRendererChromium::setVisible):
     31        (WebCore::LayerRendererChromium::releaseRenderPassTextures):
     32        (WebCore::LayerRendererChromium::viewportChanged):
     33        (WebCore::LayerRendererChromium::clearRenderPass):
     34        (WebCore::LayerRendererChromium::beginDrawingFrame):
     35        (WebCore::LayerRendererChromium::drawRenderPass):
     36        (WebCore::LayerRendererChromium::drawQuad):
     37        (WebCore::LayerRendererChromium::drawBackgroundFilters):
     38        (WebCore::LayerRendererChromium::drawRenderPassQuad):
     39        (WebCore::LayerRendererChromium::copyPlaneToTexture):
     40        (WebCore::LayerRendererChromium::drawHeadsUpDisplay):
     41        (WebCore::LayerRendererChromium::finishDrawingFrame):
     42        (WebCore::LayerRendererChromium::copyTextureToFramebuffer):
     43        (WebCore::LayerRendererChromium::getFramebufferTexture):
     44        (WebCore::LayerRendererChromium::isCurrentRenderPass):
     45        (WebCore::LayerRendererChromium::useRenderPass):
     46        (WebCore::LayerRendererChromium::useManagedTexture):
     47        (WebCore::LayerRendererChromium::bindFramebufferToTexture):
     48        (WebCore::LayerRendererChromium::setScissorToRect):
     49        (WebCore::LayerRendererChromium::setDrawFramebufferRect):
     50        (WebCore::LayerRendererChromium::initializeSharedObjects):
     51        (WebCore::LayerRendererChromium::renderPassProgram):
     52        (WebCore::LayerRendererChromium::renderPassProgramAA):
     53        (WebCore::LayerRendererChromium::renderPassMaskProgram):
     54        (WebCore::LayerRendererChromium::renderPassMaskProgramAA):
     55        (WebCore::LayerRendererChromium::cleanupSharedObjects):
     56        * platform/graphics/chromium/LayerRendererChromium.h:
     57        (WebCore):
     58        (LayerRendererChromium):
     59        * platform/graphics/chromium/cc/CCDrawQuad.cpp:
     60        (WebCore::CCDrawQuad::toRenderPassDrawQuad):
     61        * platform/graphics/chromium/cc/CCDrawQuad.h:
     62        (WebCore):
     63        (CCDrawQuad):
     64        * platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp:
     65        (WebCore::CCHeadsUpDisplay::draw):
     66        * platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp:
     67        (WebCore::CCLayerTreeHostImpl::calculateRenderPasses):
     68        (WebCore::CCLayerTreeHostImpl::drawLayers):
     69        * platform/graphics/chromium/cc/CCQuadCuller.cpp:
     70        * platform/graphics/chromium/cc/CCRenderPass.cpp:
     71        (WebCore::CCRenderPass::CCRenderPass):
     72        (WebCore::CCRenderPass::appendQuadsForRenderSurfaceLayer):
     73        * platform/graphics/chromium/cc/CCRenderPass.h:
     74        (CCRenderPass):
     75        (WebCore::CCRenderPass::framebufferOutputRect):
     76        * platform/graphics/chromium/cc/CCRenderPassDrawQuad.cpp: Renamed from Source/WebCore/platform/graphics/chromium/cc/CCRenderSurfaceDrawQuad.cpp.
     77        (WebCore):
     78        (WebCore::CCRenderPassDrawQuad::create):
     79        (WebCore::CCRenderPassDrawQuad::CCRenderPassDrawQuad):
     80        * platform/graphics/chromium/cc/CCRenderPassDrawQuad.h: Renamed from Source/WebCore/platform/graphics/chromium/cc/CCRenderSurfaceDrawQuad.h.
     81        (WebCore):
     82        (CCRenderPassDrawQuad):
     83        (WebCore::CCRenderPassDrawQuad::renderPass):
     84        (WebCore::CCRenderPassDrawQuad::isReplica):
     85        (WebCore::CCRenderPassDrawQuad::maskTextureId):
     86        (WebCore::CCRenderPassDrawQuad::filters):
     87        (WebCore::CCRenderPassDrawQuad::backgroundFilters):
     88        * platform/graphics/chromium/cc/CCRenderSurface.cpp:
     89        (WebCore::CCRenderSurface::prepareContentsTexture):
     90        (WebCore::CCRenderSurface::prepareBackgroundTexture):
     91        (WebCore::CCRenderSurface::appendQuads):
     92        * platform/graphics/chromium/cc/CCRenderSurface.h:
     93        (WebCore):
     94        (CCRenderSurface):
     95        * platform/graphics/chromium/cc/CCRenderer.h:
     96        (CCRenderer):
     97        * platform/graphics/chromium/cc/CCScrollbarLayerImpl.cpp:
     98        (WebCore::CCScrollbarLayerImpl::willDraw):
     99        * platform/graphics/chromium/cc/CCVideoLayerImpl.cpp:
     100        (WebCore::CCVideoLayerImpl::reserveTextures):
     101
    11022012-06-04  Abhishek Arya  <inferno@chromium.org>
    2103

  • trunk/Source/WebCore/WebCore.gypi

    r119367 r119419  
    37303730            'platform/graphics/chromium/cc/CCRenderPass.cpp',
    37313731            'platform/graphics/chromium/cc/CCRenderPass.h',
     3732            'platform/graphics/chromium/cc/CCRenderPassDrawQuad.cpp',
     3733            'platform/graphics/chromium/cc/CCRenderPassDrawQuad.h',
    37323734            'platform/graphics/chromium/cc/CCRenderSurface.cpp',
    37333735            'platform/graphics/chromium/cc/CCRenderSurface.h',
    3734             'platform/graphics/chromium/cc/CCRenderSurfaceDrawQuad.cpp',
    3735             'platform/graphics/chromium/cc/CCRenderSurfaceDrawQuad.h',
    37363736            'platform/graphics/chromium/cc/CCRenderSurfaceFilters.cpp',
    37373737            'platform/graphics/chromium/cc/CCRenderSurfaceFilters.h',

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

    r119401 r119419  
    4646#include "PlatformColor.h"
    4747#include "PlatformContextSkia.h"
    48 #include "RenderSurfaceChromium.h"
    4948#include "SharedGraphicsContext3D.h"
    5049#include "SkBitmap.h"
    … …  
    6463#include "cc/CCProxy.h"
    6564#include "cc/CCRenderPass.h"
    66 #include "cc/CCRenderSurfaceDrawQuad.h"
     65#include "cc/CCRenderPassDrawQuad.h"
    6766#include "cc/CCRenderSurfaceFilters.h"
    6867#include "cc/CCSolidColorDrawQuad.h"
    … …  
    231230                                             TextureUploaderOption textureUploaderSetting)
    232231    : CCRenderer(client)
    233     , m_currentRenderSurface(0)
     232    , m_currentRenderPass(0)
    234233    , m_currentManagedTexture(0)
    235234    , m_offscreenFramebufferId(0)
    236235    , m_sharedGeometryQuad(FloatRect(-0.5f, -0.5f, 1.0f, 1.0f))
    237236    , m_context(context)
    238     , m_defaultRenderSurface(0)
     237    , m_defaultRenderPass(0)
    239238    , m_isViewportChanged(false)
    240239    , m_isFramebufferDiscarded(false)
    … …  
    362361{
    363362    if (!visible)
    364         releaseRenderSurfaceTextures();
     363        releaseRenderPassTextures();
    365364
    366365    // TODO: Replace setVisibilityCHROMIUM with an extension to explicitly manage front/backbuffers
    … …  
    372371}
    373372
    374 void LayerRendererChromium::releaseRenderSurfaceTextures()
    375 {
    376     if (m_renderSurfaceTextureManager)
    377         m_renderSurfaceTextureManager->evictAndDeleteAllTextures(m_renderSurfaceTextureAllocator.get());
     373void LayerRendererChromium::releaseRenderPassTextures()
     374{
     375    if (m_implTextureManager)
     376        m_implTextureManager->evictAndDeleteAllTextures(m_implTextureAllocator.get());
    378377}
    379378
    … …  
    382381    m_isViewportChanged = true;
    383382
    384     // Reset the current render surface to force an update of the viewport and
    385     // projection matrix next time useRenderSurface is called.
    386     m_currentRenderSurface = 0;
    387 }
    388 
    389 void LayerRendererChromium::clearRenderSurface(CCRenderSurface* renderSurface, CCRenderSurface* rootRenderSurface, const FloatRect& rootScissorRectInCurrentSurface)
     383    // Reset the current RenderPass to force an update of the viewport and
     384    // projection matrix next time useRenderPass is called.
     385    m_currentRenderPass = 0;
     386}
     387
     388void LayerRendererChromium::clearRenderPass(const CCRenderPass* renderPass, const CCRenderPass* rootRenderPass, const FloatRect& framebufferDamageRect)
    390389{
    391390    // Non-root layers should clear their entire contents to transparent. On DEBUG builds, the root layer
    … …  
    395394    // of the screen.
    396395
    397     if (renderSurface != rootRenderSurface)
     396    if (renderPass != rootRenderPass)
    398397        GLC(m_context, m_context->clearColor(0, 0, 0, 0));
    399398    else
    … …  
    401400
    402401    if (m_capabilities.usingPartialSwap)
    403         setScissorToRect(enclosingIntRect(rootScissorRectInCurrentSurface));
     402        setScissorToRect(enclosingIntRect(framebufferDamageRect));
    404403    else
    405404        GLC(m_context, m_context->disable(GraphicsContext3D::SCISSOR_TEST));
    406405
    407406#if defined(NDEBUG)
    408     if (renderSurface != rootRenderSurface)
     407    if (renderPass != rootRenderPass)
    409408#endif
    410409        m_context->clear(GraphicsContext3D::COLOR_BUFFER_BIT);
    … …  
    413412}
    414413
    415 void LayerRendererChromium::beginDrawingFrame(CCRenderSurface* defaultRenderSurface)
     414void LayerRendererChromium::beginDrawingFrame(const CCRenderPass* rootRenderPass)
    416415{
    417416    // FIXME: Remove this once framebuffer is automatically recreated on first use
    418417    ensureFramebuffer();
    419418
    420     m_defaultRenderSurface = defaultRenderSurface;
    421     ASSERT(m_defaultRenderSurface);
     419    m_defaultRenderPass = rootRenderPass;
     420    ASSERT(m_defaultRenderPass);
    422421
    423422    size_t contentsMemoryUseBytes = m_contentsTextureAllocator->currentMemoryUseBytes();
    424423    size_t maxLimit = TextureManager::highLimitBytes(viewportSize());
    425424    size_t newLimit = (maxLimit > contentsMemoryUseBytes) ? maxLimit - contentsMemoryUseBytes : 0;
    426     m_renderSurfaceTextureManager->setMaxMemoryLimitBytes(newLimit);
     425    m_implTextureManager->setMaxMemoryLimitBytes(newLimit);
    427426
    428427    if (viewportSize().isEmpty())
    … …  
    455454}
    456455
    457 void LayerRendererChromium::drawRenderPass(const CCRenderPass* renderPass, const FloatRect& rootScissorRectInCurrentSurface)
    458 {
    459     CCRenderSurface* renderSurface = renderPass->targetSurface();
    460     if (!useRenderSurface(renderSurface))
     456void LayerRendererChromium::drawRenderPass(const CCRenderPass* renderPass, const FloatRect& framebufferDamageRect)
     457{
     458    if (!useRenderPass(renderPass))
    461459        return;
    462460
    463     clearRenderSurface(renderSurface, m_defaultRenderSurface, rootScissorRectInCurrentSurface);
     461    clearRenderPass(renderPass, m_defaultRenderPass, framebufferDamageRect);
    464462
    465463    const CCQuadList& quadList = renderPass->quadList();
    … …  
    496494        drawIOSurfaceQuad(quad->toIOSurfaceDrawQuad());
    497495        break;
    498     case CCDrawQuad::RenderSurface:
    499         drawRenderSurfaceQuad(quad->toRenderSurfaceDrawQuad());
     496    case CCDrawQuad::RenderPass:
     497        drawRenderPassQuad(quad->toRenderPassDrawQuad());
    500498        break;
    501499    case CCDrawQuad::SolidColor:
    … …  
    581579}
    582580
    583 void LayerRendererChromium::drawBackgroundFilters(const CCRenderSurfaceDrawQuad* quad, const WebTransformationMatrix& contentsDeviceTransform)
     581void LayerRendererChromium::drawBackgroundFilters(const CCRenderPassDrawQuad* quad, const WebTransformationMatrix& contentsDeviceTransform)
    584582{
    585583    // This method draws a background filter, which applies a filter to any pixels behind the quad and seen through its background.
    … …  
    597595    // Pixel copies in this algorithm occur at steps 2, 3, 4, and 5.
    598596
    599     CCRenderSurface* drawingSurface = quad->layer()->renderSurface();
     597    CCRenderSurface* drawingSurface = quad->renderPass()->targetSurface();
    600598    if (quad->backgroundFilters().isEmpty())
    601599        return;
    … …  
    603601    // FIXME: We only allow background filters on the root render surface because other surfaces may contain
    604602    // translucent pixels, and the contents behind those translucent pixels wouldn't have the filter applied.
    605     if (!isCurrentRenderSurface(m_defaultRenderSurface))
     603    if (!isCurrentRenderPass(m_defaultRenderPass))
    606604        return;
    607605
    … …  
    614612    deviceRect.expand(left + right, top + bottom);
    615613
    616     deviceRect.intersect(m_currentRenderSurface->contentRect());
    617 
    618     OwnPtr<ManagedTexture> deviceBackgroundTexture = ManagedTexture::create(m_renderSurfaceTextureManager.get());
     614    deviceRect.intersect(m_currentRenderPass->framebufferOutputRect());
     615
     616    OwnPtr<ManagedTexture> deviceBackgroundTexture = ManagedTexture::create(m_implTextureManager.get());
    619617    if (!getFramebufferTexture(deviceBackgroundTexture.get(), deviceRect))
    620618        return;
    … …  
    630628        return;
    631629
    632     CCRenderSurface* targetRenderSurface = m_currentRenderSurface;
     630    const CCRenderPass* targetRenderPass = m_currentRenderPass;
    633631    if (useManagedTexture(drawingSurface->backgroundTexture(), quad->quadRect())) {
    634632        // Copy the readback pixels from device to the background texture for the surface.
    635         WebTransformationMatrix deviceToSurfaceTransform;
    636         deviceToSurfaceTransform.translate(quad->quadRect().width() / 2.0, quad->quadRect().height() / 2.0);
    637         deviceToSurfaceTransform.scale3d(quad->quadRect().width(), quad->quadRect().height(), 1);
    638         deviceToSurfaceTransform.multiply(contentsDeviceTransform.inverse());
    639         deviceToSurfaceTransform.translate(deviceRect.width() / 2.0, deviceRect.height() / 2.0);
    640         deviceToSurfaceTransform.translate(deviceRect.x(), deviceRect.y());
    641 
    642         copyTextureToFramebuffer(filteredDeviceBackgroundTextureId, deviceRect.size(), deviceToSurfaceTransform);
    643 
    644         useRenderSurface(targetRenderSurface);
    645     }
    646 }
    647 
    648 void LayerRendererChromium::drawRenderSurfaceQuad(const CCRenderSurfaceDrawQuad* quad)
     633        WebTransformationMatrix deviceToFramebufferTransform;
     634        deviceToFramebufferTransform.translate(quad->quadRect().width() / 2.0, quad->quadRect().height() / 2.0);
     635        deviceToFramebufferTransform.scale3d(quad->quadRect().width(), quad->quadRect().height(), 1);
     636        deviceToFramebufferTransform.multiply(contentsDeviceTransform.inverse());
     637        deviceToFramebufferTransform.translate(deviceRect.width() / 2.0, deviceRect.height() / 2.0);
     638        deviceToFramebufferTransform.translate(deviceRect.x(), deviceRect.y());
     639
     640        copyTextureToFramebuffer(filteredDeviceBackgroundTextureId, deviceRect.size(), deviceToFramebufferTransform);
     641
     642        useRenderPass(targetRenderPass);
     643    }
     644}
     645
     646void LayerRendererChromium::drawRenderPassQuad(const CCRenderPassDrawQuad* quad)
    649647{
    650648    // The replica is always drawn first, so free after drawing the contents.
    651649    bool shouldReleaseTextures = !quad->isReplica();
    652650
    653     CCRenderSurface* drawingSurface = quad->layer()->renderSurface();
     651    CCRenderSurface* drawingSurface = quad->renderPass()->targetSurface();
    654652
    655653    WebTransformationMatrix renderTransform = quad->layerTransform();
    … …  
    706704    int shaderAlphaLocation = -1;
    707705    if (useAA && useMask) {
    708         const RenderSurfaceMaskProgramAA* program = renderSurfaceMaskProgramAA();
     706        const RenderPassMaskProgramAA* program = renderPassMaskProgramAA();
    709707        GLC(context(), context()->useProgram(program->program()));
    710708        GLC(context(), context()->uniform1i(program->fragmentShader().samplerLocation(), 0));
    … …  
    716714        shaderAlphaLocation = program->fragmentShader().alphaLocation();
    717715    } else if (!useAA && useMask) {
    718         const RenderSurfaceMaskProgram* program = renderSurfaceMaskProgram();
     716        const RenderPassMaskProgram* program = renderPassMaskProgram();
    719717        GLC(context(), context()->useProgram(program->program()));
    720718        GLC(context(), context()->uniform1i(program->fragmentShader().samplerLocation(), 0));
    … …  
    724722        shaderAlphaLocation = program->fragmentShader().alphaLocation();
    725723    } else if (useAA && !useMask) {
    726         const RenderSurfaceProgramAA* program = renderSurfaceProgramAA();
     724        const RenderPassProgramAA* program = renderPassProgramAA();
    727725        GLC(context(), context()->useProgram(program->program()));
    728726        GLC(context(), context()->uniform1i(program->fragmentShader().samplerLocation(), 0));
    … …  
    733731        shaderAlphaLocation = program->fragmentShader().alphaLocation();
    734732    } else {
    735         const RenderSurfaceProgram* program = renderSurfaceProgram();
     733        const RenderPassProgram* program = renderPassProgram();
    736734        GLC(context(), context()->useProgram(program->program()));
    737735        GLC(context(), context()->uniform1i(program->fragmentShader().samplerLocation(), 0));
    … …  
    10671065{
    10681066    CCVideoLayerImpl::Texture& texture = quad->textures()[index];
    1069     TextureAllocator* allocator = renderSurfaceTextureAllocator();
    10701067    RefPtr<CCGraphicsContext> ccContext = CCGraphicsContext::create3D(m_context);
    1071     texture.m_texture->bindTexture(ccContext.get(), allocator);
     1068    texture.m_texture->bindTexture(ccContext.get(), m_implTextureAllocator.get());
    10721069    GC3Denum format = texture.m_texture->format();
    10731070    IntSize dimensions = texture.m_texture->size();
    … …  
    12041201    GLC(m_context, m_context->blendFunc(GraphicsContext3D::ONE, GraphicsContext3D::ONE_MINUS_SRC_ALPHA));
    12051202    GLC(m_context, m_context->disable(GraphicsContext3D::SCISSOR_TEST));
    1206     useRenderSurface(m_defaultRenderSurface);
     1203    useRenderPass(m_defaultRenderPass);
    12071204
    12081205    const HeadsUpDisplayProgram* program = headsUpDisplayProgram();
    … …  
    12101207    GLC(m_context, m_context->activeTexture(GraphicsContext3D::TEXTURE0));
    12111208    RefPtr<CCGraphicsContext> ccContext = CCGraphicsContext::create3D(m_context);
    1212     hudTexture->bindTexture(ccContext.get(), renderSurfaceTextureAllocator());
     1209    hudTexture->bindTexture(ccContext.get(), m_implTextureAllocator.get());
    12131210    GLC(m_context, m_context->useProgram(program->program()));
    12141211    GLC(m_context, m_context->uniform1i(program->fragmentShader().samplerLocation(), 0));
    … …  
    12271224    GLC(m_context, m_context->disable(GraphicsContext3D::BLEND));
    12281225
    1229     m_renderSurfaceTextureManager->unprotectAllTextures();
     1226    m_implTextureManager->unprotectAllTextures();
    12301227
    12311228    size_t contentsMemoryUseBytes = m_contentsTextureAllocator->currentMemoryUseBytes();
    12321229    size_t reclaimLimit = TextureManager::reclaimLimitBytes(viewportSize());
    12331230    size_t preferredLimit = reclaimLimit > contentsMemoryUseBytes ? reclaimLimit - contentsMemoryUseBytes : 0;
    1234     m_renderSurfaceTextureManager->setPreferredMemoryLimitBytes(preferredLimit);
    1235     m_renderSurfaceTextureManager->reduceMemoryToLimit(preferredLimit);
    1236     m_renderSurfaceTextureManager->deleteEvictedTextures(m_renderSurfaceTextureAllocator.get());
     1231    m_implTextureManager->setPreferredMemoryLimitBytes(preferredLimit);
     1232    m_implTextureManager->reduceMemoryToLimit(preferredLimit);
     1233    m_implTextureManager->deleteEvictedTextures(m_implTextureAllocator.get());
    12371234}
    12381235
    … …  
    12941291void LayerRendererChromium::copyTextureToFramebuffer(int textureId, const IntSize& bounds, const WebTransformationMatrix& drawMatrix)
    12951292{
    1296     const RenderSurfaceProgram* program = renderSurfaceProgram();
     1293    const RenderPassProgram* program = renderPassProgram();
    12971294
    12981295    GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0));
    … …  
    14361433
    14371434    RefPtr<CCGraphicsContext> ccContext = CCGraphicsContext::create3D(m_context);
    1438     texture->bindTexture(ccContext.get(), m_renderSurfaceTextureAllocator.get());
     1435    texture->bindTexture(ccContext.get(), m_implTextureAllocator.get());
    14391436    GLC(m_context, m_context->copyTexImage2D(GraphicsContext3D::TEXTURE_2D, 0, texture->format(),
    14401437                                             deviceRect.x(), deviceRect.y(), deviceRect.width(), deviceRect.height(), 0));
    … …  
    14421439}
    14431440
    1444 bool LayerRendererChromium::isCurrentRenderSurface(CCRenderSurface* renderSurface)
    1445 {
    1446     // If renderSurface is 0, we can't tell if we are already using it, since m_currentRenderSurface is
    1447     // initialized to 0.
    1448     return m_currentRenderSurface == renderSurface && !m_currentManagedTexture;
    1449 }
    1450 
    1451 bool LayerRendererChromium::useRenderSurface(CCRenderSurface* renderSurface)
    1452 {
    1453     m_currentRenderSurface = renderSurface;
     1441bool LayerRendererChromium::isCurrentRenderPass(const CCRenderPass* renderPass)
     1442{
     1443    return m_currentRenderPass == renderPass && !m_currentManagedTexture;
     1444}
     1445
     1446bool LayerRendererChromium::useRenderPass(const CCRenderPass* renderPass)
     1447{
     1448    m_currentRenderPass = renderPass;
    14541449    m_currentManagedTexture = 0;
    14551450
    1456     if (renderSurface == m_defaultRenderSurface) {
     1451    if (renderPass == m_defaultRenderPass) {
    14571452        GLC(m_context, m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, 0));
    1458         setDrawViewportRect(renderSurface->contentRect(), true);
     1453        setDrawFramebufferRect(renderPass->framebufferOutputRect(), true);
    14591454        return true;
    14601455    }
    14611456
    1462     if (!renderSurface->prepareContentsTexture(this))
     1457    if (!renderPass->targetSurface()->prepareContentsTexture(this))
    14631458        return false;
    14641459
    1465     return bindFramebufferToTexture(renderSurface->contentsTexture(), renderSurface->contentRect());
     1460    return bindFramebufferToTexture(renderPass->targetSurface()->contentsTexture(), renderPass->framebufferOutputRect());
    14661461}
    14671462
    14681463bool LayerRendererChromium::useManagedTexture(ManagedTexture* texture, const IntRect& viewportRect)
    14691464{
    1470     m_currentRenderSurface = 0;
     1465    m_currentRenderPass = 0;
    14711466    m_currentManagedTexture = texture;
    14721467
    … …  
    14741469}
    14751470
    1476 bool LayerRendererChromium::bindFramebufferToTexture(ManagedTexture* texture, const IntRect& viewportRect)
     1471bool LayerRendererChromium::bindFramebufferToTexture(ManagedTexture* texture, const IntRect& framebufferRect)
    14771472{
    14781473    GLC(m_context, m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_offscreenFramebufferId));
    14791474
    14801475    RefPtr<CCGraphicsContext> ccContext = CCGraphicsContext::create3D(m_context);
    1481     texture->framebufferTexture2D(ccContext.get(), m_renderSurfaceTextureAllocator.get());
     1476    texture->framebufferTexture2D(ccContext.get(), m_implTextureAllocator.get());
    14821477
    14831478#if !defined ( NDEBUG )
    … …  
    14881483#endif
    14891484
    1490     setDrawViewportRect(viewportRect, false);
     1485    setDrawFramebufferRect(framebufferRect, false);
    14911486
    14921487    return true;
    … …  
    14971492void LayerRendererChromium::setScissorToRect(const IntRect& scissorRect)
    14981493{
    1499     IntRect contentRect = (m_currentRenderSurface ? m_currentRenderSurface->contentRect() : m_defaultRenderSurface->contentRect());
     1494    IntRect framebufferOutputRect = (m_currentRenderPass ? m_currentRenderPass->framebufferOutputRect() : m_defaultRenderPass->framebufferOutputRect());
    15001495
    15011496    GLC(m_context, m_context->enable(GraphicsContext3D::SCISSOR_TEST));
    15021497
    15031498    // The scissor coordinates must be supplied in viewport space so we need to offset
    1504     // by the relative position of the top left corner of the current render surface.
    1505     int scissorX = scissorRect.x() - contentRect.x();
     1499    // by the relative position of the top left corner of the current render pass.
     1500    int scissorX = scissorRect.x() - framebufferOutputRect.x();
    15061501    // When rendering to the default render surface we're rendering upside down so the top
    15071502    // of the GL scissor is the bottom of our layer.
    15081503    // But, if rendering to offscreen texture, we reverse our sense of 'upside down'.
    15091504    int scissorY;
    1510     if (isCurrentRenderSurface(m_defaultRenderSurface))
    1511         scissorY = m_currentRenderSurface->contentRect().height() - (scissorRect.maxY() - m_currentRenderSurface->contentRect().y());
     1505    if (isCurrentRenderPass(m_defaultRenderPass))
     1506        scissorY = framebufferOutputRect.height() - (scissorRect.maxY() - framebufferOutputRect.y());
    15121507    else
    1513         scissorY = scissorRect.y() - contentRect.y();
     1508        scissorY = scissorRect.y() - framebufferOutputRect.y();
    15141509    GLC(m_context, m_context->scissor(scissorX, scissorY, scissorRect.width(), scissorRect.height()));
    15151510}
    … …  
    15231518// The target render surface is assumed to have an origin at 0, 0 and the width and height of
    15241519// of the drawRect.
    1525 void LayerRendererChromium::setDrawViewportRect(const IntRect& drawRect, bool flipY)
     1520void LayerRendererChromium::setDrawFramebufferRect(const IntRect& drawRect, bool flipY)
    15261521{
    15271522    if (flipY)
    … …  
    15451540    // start while we do other work. Other programs are created lazily on first access.
    15461541    m_sharedGeometry = adoptPtr(new GeometryBinding(m_context.get()));
    1547     m_renderSurfaceProgram = adoptPtr(new RenderSurfaceProgram(m_context.get()));
     1542    m_renderPassProgram = adoptPtr(new RenderPassProgram(m_context.get()));
    15481543    m_tileProgram = adoptPtr(new TileProgram(m_context.get()));
    15491544    m_tileProgramOpaque = adoptPtr(new TileProgramOpaque(m_context.get()));
    … …  
    15511546    GLC(m_context, m_context->flush());
    15521547
    1553     m_renderSurfaceTextureManager = TextureManager::create(TextureManager::highLimitBytes(viewportSize()),
    1554                                                            TextureManager::reclaimLimitBytes(viewportSize()),
    1555                                                            m_capabilities.maxTextureSize);
     1548    m_implTextureManager = TextureManager::create(TextureManager::highLimitBytes(viewportSize()),
     1549                                                  TextureManager::reclaimLimitBytes(viewportSize()),
     1550                                                  m_capabilities.maxTextureSize);
    15561551    m_textureCopier = AcceleratedTextureCopier::create(m_context.get());
    15571552    if (m_textureUploaderSetting == ThrottledUploader)
    … …  
    15601555        m_textureUploader = UnthrottledTextureUploader::create();
    15611556    m_contentsTextureAllocator = TrackingTextureAllocator::create(m_context.get());
    1562     m_renderSurfaceTextureAllocator = TrackingTextureAllocator::create(m_context.get());
     1557    m_implTextureAllocator = TrackingTextureAllocator::create(m_context.get());
    15631558    if (m_capabilities.usingTextureUsageHint)
    1564         m_renderSurfaceTextureAllocator->setTextureUsageHint(TrackingTextureAllocator::FramebufferAttachment);
     1559        m_implTextureAllocator->setTextureUsageHint(TrackingTextureAllocator::FramebufferAttachment);
    15651560    if (m_capabilities.usingTextureStorageExtension) {
    15661561        m_contentsTextureAllocator->setUseTextureStorageExt(true);
    1567         m_renderSurfaceTextureAllocator->setUseTextureStorageExt(true);
     1562        m_implTextureAllocator->setUseTextureStorageExt(true);
    15681563    }
    15691564
    … …  
    16041599}
    16051600
    1606 const LayerRendererChromium::RenderSurfaceProgram* LayerRendererChromium::renderSurfaceProgram()
    1607 {
    1608     ASSERT(m_renderSurfaceProgram);
    1609     if (!m_renderSurfaceProgram->initialized()) {
    1610         TRACE_EVENT("LayerRendererChromium::renderSurfaceProgram::initialize", this, 0);
    1611         m_renderSurfaceProgram->initialize(m_context.get());
    1612     }
    1613     return m_renderSurfaceProgram.get();
    1614 }
    1615 
    1616 const LayerRendererChromium::RenderSurfaceProgramAA* LayerRendererChromium::renderSurfaceProgramAA()
    1617 {
    1618     if (!m_renderSurfaceProgramAA)
    1619         m_renderSurfaceProgramAA = adoptPtr(new RenderSurfaceProgramAA(m_context.get()));
    1620     if (!m_renderSurfaceProgramAA->initialized()) {
    1621         TRACE_EVENT("LayerRendererChromium::renderSurfaceProgramAA::initialize", this, 0);
    1622         m_renderSurfaceProgramAA->initialize(m_context.get());
    1623     }
    1624     return m_renderSurfaceProgramAA.get();
    1625 }
    1626 
    1627 const LayerRendererChromium::RenderSurfaceMaskProgram* LayerRendererChromium::renderSurfaceMaskProgram()
    1628 {
    1629     if (!m_renderSurfaceMaskProgram)
    1630         m_renderSurfaceMaskProgram = adoptPtr(new RenderSurfaceMaskProgram(m_context.get()));
    1631     if (!m_renderSurfaceMaskProgram->initialized()) {
    1632         TRACE_EVENT("LayerRendererChromium::renderSurfaceMaskProgram::initialize", this, 0);
    1633         m_renderSurfaceMaskProgram->initialize(m_context.get());
    1634     }
    1635     return m_renderSurfaceMaskProgram.get();
    1636 }
    1637 
    1638 const LayerRendererChromium::RenderSurfaceMaskProgramAA* LayerRendererChromium::renderSurfaceMaskProgramAA()
    1639 {
    1640     if (!m_renderSurfaceMaskProgramAA)
    1641         m_renderSurfaceMaskProgramAA = adoptPtr(new RenderSurfaceMaskProgramAA(m_context.get()));
    1642     if (!m_renderSurfaceMaskProgramAA->initialized()) {
    1643         TRACE_EVENT("LayerRendererChromium::renderSurfaceMaskProgramAA::initialize", this, 0);
    1644         m_renderSurfaceMaskProgramAA->initialize(m_context.get());
    1645     }
    1646     return m_renderSurfaceMaskProgramAA.get();
     1601const LayerRendererChromium::RenderPassProgram* LayerRendererChromium::renderPassProgram()
     1602{
     1603    ASSERT(m_renderPassProgram);
     1604    if (!m_renderPassProgram->initialized()) {
     1605        TRACE_EVENT("LayerRendererChromium::renderPassProgram::initialize", this, 0);
     1606        m_renderPassProgram->initialize(m_context.get());
     1607    }
     1608    return m_renderPassProgram.get();
     1609}
     1610
     1611const LayerRendererChromium::RenderPassProgramAA* LayerRendererChromium::renderPassProgramAA()
     1612{
     1613    if (!m_renderPassProgramAA)
     1614        m_renderPassProgramAA = adoptPtr(new RenderPassProgramAA(m_context.get()));
     1615    if (!m_renderPassProgramAA->initialized()) {
     1616        TRACE_EVENT("LayerRendererChromium::renderPassProgramAA::initialize", this, 0);
     1617        m_renderPassProgramAA->initialize(m_context.get());
     1618    }
     1619    return m_renderPassProgramAA.get();
     1620}
     1621
     1622const LayerRendererChromium::RenderPassMaskProgram* LayerRendererChromium::renderPassMaskProgram()
     1623{
     1624    if (!m_renderPassMaskProgram)
     1625        m_renderPassMaskProgram = adoptPtr(new RenderPassMaskProgram(m_context.get()));
     1626    if (!m_renderPassMaskProgram->initialized()) {
     1627        TRACE_EVENT("LayerRendererChromium::renderPassMaskProgram::initialize", this, 0);
     1628        m_renderPassMaskProgram->initialize(m_context.get());
     1629    }
     1630    return m_renderPassMaskProgram.get();
     1631}
     1632
     1633const LayerRendererChromium::RenderPassMaskProgramAA* LayerRendererChromium::renderPassMaskProgramAA()
     1634{
     1635    if (!m_renderPassMaskProgramAA)
     1636        m_renderPassMaskProgramAA = adoptPtr(new RenderPassMaskProgramAA(m_context.get()));
     1637    if (!m_renderPassMaskProgramAA->initialized()) {
     1638        TRACE_EVENT("LayerRendererChromium::renderPassMaskProgramAA::initialize", this, 0);
     1639        m_renderPassMaskProgramAA->initialize(m_context.get());
     1640    }
     1641    return m_renderPassMaskProgramAA.get();
    16471642}
    16481643
    … …  
    17871782        m_tileCheckerboardProgram->cleanup(m_context.get());
    17881783
    1789     if (m_renderSurfaceMaskProgram)
    1790         m_renderSurfaceMaskProgram->cleanup(m_context.get());
    1791     if (m_renderSurfaceProgram)
    1792         m_renderSurfaceProgram->cleanup(m_context.get());
    1793     if (m_renderSurfaceMaskProgramAA)
    1794         m_renderSurfaceMaskProgramAA->cleanup(m_context.get());
    1795     if (m_renderSurfaceProgramAA)
    1796         m_renderSurfaceProgramAA->cleanup(m_context.get());
     1784    if (m_renderPassMaskProgram)
     1785        m_renderPassMaskProgram->cleanup(m_context.get());
     1786    if (m_renderPassProgram)
     1787        m_renderPassProgram->cleanup(m_context.get());
     1788    if (m_renderPassMaskProgramAA)
     1789        m_renderPassMaskProgramAA->cleanup(m_context.get());
     1790    if (m_renderPassProgramAA)
     1791        m_renderPassProgramAA->cleanup(m_context.get());
    17971792
    17981793    if (m_textureProgram)
    … …  
    18201815    m_textureUploader.clear();
    18211816
    1822     releaseRenderSurfaceTextures();
     1817    releaseRenderPassTextures();
    18231818}
    18241819

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

    r119401 r119419  
    4747class CCDrawQuad;
    4848class CCIOSurfaceDrawQuad;
    49 class CCRenderSurfaceDrawQuad;
     49class CCRenderPassDrawQuad;
    5050class CCSolidColorDrawQuad;
    5151class CCTextureDrawQuad;
    … …  
    7676    const FloatQuad& sharedGeometryQuad() const { return m_sharedGeometryQuad; }
    7777
    78     virtual void beginDrawingFrame(CCRenderSurface* defaultRenderSurface) OVERRIDE;
    79     virtual void drawRenderPass(const CCRenderPass*, const FloatRect& rootScissorRectInCurrentSurface) OVERRIDE;
     78    virtual void beginDrawingFrame(const CCRenderPass* defaultRenderPass) OVERRIDE;
     79    virtual void drawRenderPass(const CCRenderPass*, const FloatRect& framebufferDamageRect) OVERRIDE;
    8080    virtual void finishDrawingFrame() OVERRIDE;
    8181
    … …  
    9393    const GeometryBinding* sharedGeometry() const { return m_sharedGeometry.get(); }
    9494
    95 
    9695    virtual void getFramebufferPixels(void *pixels, const IntRect&) OVERRIDE;
    9796    bool getFramebufferTexture(ManagedTexture*, const IntRect& deviceRect);
    9897
    99     virtual TextureManager* renderSurfaceTextureManager() const OVERRIDE { return m_renderSurfaceTextureManager.get(); }
     98    virtual TextureManager* implTextureManager() const OVERRIDE { return m_implTextureManager.get(); }
    10099    virtual TextureCopier* textureCopier() const OVERRIDE { return m_textureCopier.get(); }
    101100    virtual TextureUploader* textureUploader() const OVERRIDE { return m_textureUploader.get(); }
    102     virtual TextureAllocator* renderSurfaceTextureAllocator() const OVERRIDE { return m_renderSurfaceTextureAllocator.get(); }
     101    virtual TextureAllocator* implTextureAllocator() const OVERRIDE { return m_implTextureAllocator.get(); }
    103102    virtual TextureAllocator* contentsTextureAllocator() const OVERRIDE { return m_contentsTextureAllocator.get(); }
    104103
    … …  
    129128    void drawCheckerboardQuad(const CCCheckerboardDrawQuad*);
    130129    void drawDebugBorderQuad(const CCDebugBorderDrawQuad*);
    131     void drawBackgroundFilters(const CCRenderSurfaceDrawQuad*, const WebKit::WebTransformationMatrix& deviceTransform);
    132     void drawRenderSurfaceQuad(const CCRenderSurfaceDrawQuad*);
     130    void drawBackgroundFilters(const CCRenderPassDrawQuad*, const WebKit::WebTransformationMatrix& deviceTransform);
     131    void drawRenderPassQuad(const CCRenderPassDrawQuad*);
    133132    void drawSolidColorQuad(const CCSolidColorDrawQuad*);
    134133    void drawTextureQuad(const CCTextureDrawQuad*);
    … …  
    145144    void drawYUV(const CCVideoDrawQuad*);
    146145
    147     void setDrawViewportRect(const IntRect&, bool flipY);
    148 
    149     // The current drawing target is either a RenderSurface or ManagedTexture. Use these functions to switch to a new drawing target.
    150     bool useRenderSurface(CCRenderSurface*);
     146    void setDrawFramebufferRect(const IntRect&, bool flipY);
     147
     148    // The current drawing target is either a RenderPass or ManagedTexture. Use these functions to switch to a new drawing target.
     149    bool useRenderPass(const CCRenderPass*);
    151150    bool useManagedTexture(ManagedTexture*, const IntRect& viewportRect);
    152     bool isCurrentRenderSurface(CCRenderSurface*);
     151    bool isCurrentRenderPass(const CCRenderPass*);
    153152
    154153    bool bindFramebufferToTexture(ManagedTexture*, const IntRect& viewportRect);
    155154
    156     void clearRenderSurface(CCRenderSurface*, CCRenderSurface* rootRenderSurface, const FloatRect& rootScissorRectInCurrentSurface);
    157 
    158     void releaseRenderSurfaceTextures();
     155    void clearRenderPass(const CCRenderPass*, const CCRenderPass* rootRenderPass, const FloatRect& framebufferDamageRect);
     156
     157    void releaseRenderPassTextures();
    159158
    160159    bool makeContextCurrent();
    … …  
    168167    LayerRendererCapabilities m_capabilities;
    169168
    170     CCRenderSurface* m_currentRenderSurface;
     169    const CCRenderPass* m_currentRenderPass;
    171170    ManagedTexture* m_currentManagedTexture;
    172171    unsigned m_offscreenFramebufferId;
    … …  
    187186
    188187    // Render surface shaders.
    189     // CCRenderSurface::drawLayers() needs to see these programs currently.
    190     // FIXME: Draw with a quad type for render surfaces and get rid of this friendlyness.
    191     friend class CCRenderSurface;
    192     typedef ProgramBinding<VertexShaderPosTex, FragmentShaderRGBATexAlpha> RenderSurfaceProgram;
    193     typedef ProgramBinding<VertexShaderPosTex, FragmentShaderRGBATexAlphaMask> RenderSurfaceMaskProgram;
    194     typedef ProgramBinding<VertexShaderQuad, FragmentShaderRGBATexAlphaAA> RenderSurfaceProgramAA;
    195     typedef ProgramBinding<VertexShaderQuad, FragmentShaderRGBATexAlphaMaskAA> RenderSurfaceMaskProgramAA;
     188    typedef ProgramBinding<VertexShaderPosTex, FragmentShaderRGBATexAlpha> RenderPassProgram;
     189    typedef ProgramBinding<VertexShaderPosTex, FragmentShaderRGBATexAlphaMask> RenderPassMaskProgram;
     190    typedef ProgramBinding<VertexShaderQuad, FragmentShaderRGBATexAlphaAA> RenderPassProgramAA;
     191    typedef ProgramBinding<VertexShaderQuad, FragmentShaderRGBATexAlphaMaskAA> RenderPassMaskProgramAA;
    196192
    197193    // Texture shaders.
    … …  
    219215    const TileCheckerboardProgram* tileCheckerboardProgram();
    220216
    221     const RenderSurfaceProgram* renderSurfaceProgram();
    222     const RenderSurfaceProgramAA* renderSurfaceProgramAA();
    223     const RenderSurfaceMaskProgram* renderSurfaceMaskProgram();
    224     const RenderSurfaceMaskProgramAA* renderSurfaceMaskProgramAA();
     217    const RenderPassProgram* renderPassProgram();
     218    const RenderPassProgramAA* renderPassProgramAA();
     219    const RenderPassMaskProgram* renderPassMaskProgram();
     220    const RenderPassMaskProgramAA* renderPassMaskProgramAA();
    225221
    226222    const TextureProgram* textureProgram();
    … …  
    243239    OwnPtr<TileCheckerboardProgram> m_tileCheckerboardProgram;
    244240
    245     OwnPtr<RenderSurfaceProgram> m_renderSurfaceProgram;
    246     OwnPtr<RenderSurfaceProgramAA> m_renderSurfaceProgramAA;
    247     OwnPtr<RenderSurfaceMaskProgram> m_renderSurfaceMaskProgram;
    248     OwnPtr<RenderSurfaceMaskProgramAA> m_renderSurfaceMaskProgramAA;
     241    OwnPtr<RenderPassProgram> m_renderPassProgram;
     242    OwnPtr<RenderPassProgramAA> m_renderPassProgramAA;
     243    OwnPtr<RenderPassMaskProgram> m_renderPassMaskProgram;
     244    OwnPtr<RenderPassMaskProgramAA> m_renderPassMaskProgramAA;
    249245
    250246    OwnPtr<TextureProgram> m_textureProgram;
    … …  
    258254    OwnPtr<HeadsUpDisplayProgram> m_headsUpDisplayProgram;
    259255
    260     OwnPtr<TextureManager> m_renderSurfaceTextureManager;
     256    OwnPtr<TextureManager> m_implTextureManager;
    261257    OwnPtr<AcceleratedTextureCopier> m_textureCopier;
    262258    OwnPtr<TextureUploader> m_textureUploader;
    263259    OwnPtr<TrackingTextureAllocator> m_contentsTextureAllocator;
    264     OwnPtr<TrackingTextureAllocator> m_renderSurfaceTextureAllocator;
     260    OwnPtr<TrackingTextureAllocator> m_implTextureAllocator;
    265261
    266262    RefPtr<GraphicsContext3D> m_context;
    267263
    268     CCRenderSurface* m_defaultRenderSurface;
     264    const CCRenderPass* m_defaultRenderPass;
    269265
    270266    bool m_isViewportChanged;

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCDrawQuad.cpp

    r115394 r119419  
    3232#include "cc/CCIOSurfaceDrawQuad.h"
    3333#include "cc/CCLayerImpl.h"
    34 #include "cc/CCRenderSurfaceDrawQuad.h"
     34#include "cc/CCRenderPassDrawQuad.h"
    3535#include "cc/CCSolidColorDrawQuad.h"
    3636#include "cc/CCTextureDrawQuad.h"
    … …  
    8585}
    8686
    87 const CCRenderSurfaceDrawQuad* CCDrawQuad::toRenderSurfaceDrawQuad() const
     87const CCRenderPassDrawQuad* CCDrawQuad::toRenderPassDrawQuad() const
    8888{
    89     ASSERT(m_material == RenderSurface);
    90     return static_cast<const CCRenderSurfaceDrawQuad*>(this);
     89    ASSERT(m_material == RenderPass);
     90    return static_cast<const CCRenderPassDrawQuad*>(this);
    9191}
    9292

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCDrawQuad.h

    r119401 r119419  
    3434class CCDebugBorderDrawQuad;
    3535class CCIOSurfaceDrawQuad;
    36 class CCRenderSurfaceDrawQuad;
     36class CCRenderPassDrawQuad;
    3737class CCSolidColorDrawQuad;
    3838class CCTextureDrawQuad;
    … …  
    6868        DebugBorder,
    6969        IOSurfaceContent,
    70         RenderSurface,
     70        RenderPass,
    7171        TextureContent,
    7272        SolidColor,
    … …  
    8181    const CCDebugBorderDrawQuad* toDebugBorderDrawQuad() const;
    8282    const CCIOSurfaceDrawQuad* toIOSurfaceDrawQuad() const;
    83     const CCRenderSurfaceDrawQuad* toRenderSurfaceDrawQuad() const;
     83    const CCRenderPassDrawQuad* toRenderPassDrawQuad() const;
    8484    const CCSolidColorDrawQuad* toSolidColorDrawQuad() const;
    8585    const CCTextureDrawQuad* toTextureDrawQuad() const;

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplay.cpp

    r119313 r119419  
    7777    }
    7878    if (!m_hudTexture)
    79         m_hudTexture = ManagedTexture::create(layerRenderer->renderSurfaceTextureManager());
     79        m_hudTexture = ManagedTexture::create(layerRenderer->implTextureManager());
    8080
    8181    const CCSettings& settings = layerTreeHostImpl->settings();
    … …  
    106106        PlatformCanvas::AutoLocker locker(&canvas);
    107107
    108         m_hudTexture->bindTexture(layerTreeHostImpl->context(), layerRenderer->renderSurfaceTextureAllocator());
     108        m_hudTexture->bindTexture(layerTreeHostImpl->context(), layerRenderer->implTextureAllocator());
    109109        bool uploadedViaMap = false;
    110110        if (layerRenderer->capabilities().usingMapSub) {

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

    r119401 r119419  
    4343#include "cc/CCMathUtil.h"
    4444#include "cc/CCPageScaleAnimation.h"
    45 #include "cc/CCRenderSurfaceDrawQuad.h"
    4645#include "cc/CCSingleThreadProxy.h"
    4746#include "cc/CCThreadTask.h"
    … …  
    304303        occlusionTracker.enterLayer(it);
    305304
    306         if (it.representsContributingRenderSurface() && !it->renderSurface()->scissorRect().isEmpty())
    307             pass->appendQuadsForRenderSurfaceLayer(*it, &occlusionTracker);
    308         else if (it.representsItself() && !it->visibleLayerRect().isEmpty() &&  !it->scissorRect().isEmpty()) {
     305        if (it.representsContributingRenderSurface() && !it->renderSurface()->scissorRect().isEmpty()) {
     306            CCRenderPass* contributingRenderPass = surfacePassMap.get(it->renderSurface());
     307            pass->appendQuadsForRenderSurfaceLayer(*it, contributingRenderPass, &occlusionTracker);
     308        } else if (it.representsItself() && !it->visibleLayerRect().isEmpty() && !it->scissorRect().isEmpty()) {
    309309            it->willDraw(m_layerRenderer.get(), context());
    310310            pass->appendQuadsForLayer(*it, &occlusionTracker, hadMissingTiles);
    … …  
    400400    TRACE_EVENT("CCLayerTreeHostImpl::drawLayers", this, 0);
    401401    ASSERT(canDraw());
     402    ASSERT(!frame.renderPasses.isEmpty());
    402403
    403404    // FIXME: use the frame begin time from the overall compositor scheduler.
    … …  
    405406    // RenderWidget.
    406407
     408    // The root RenderPass is the last one to be drawn.
     409    CCRenderPass* rootRenderPass = frame.renderPasses.last().get();
     410
    407411    m_fpsCounter->markBeginningOfFrame(currentTime());
    408     m_layerRenderer->beginDrawingFrame(m_rootLayerImpl->renderSurface());
     412    m_layerRenderer->beginDrawingFrame(rootRenderPass);
    409413
    410414    for (size_t i = 0; i < frame.renderPasses.size(); ++i) {

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCQuadCuller.cpp

    r119178 r119419  
    3535#include "cc/CCOverdrawMetrics.h"
    3636#include "cc/CCRenderPass.h"
    37 #include "cc/CCRenderSurfaceDrawQuad.h"
    3837#include <public/WebTransformationMatrix.h>
    3938

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

    r119401 r119419  
    4545CCRenderPass::CCRenderPass(CCRenderSurface* targetSurface)
    4646    : m_targetSurface(targetSurface)
     47    , m_framebufferOutputRect(targetSurface->contentRect())
    4748{
    4849    ASSERT(m_targetSurface);
    … …  
    5960}
    6061
    61 void CCRenderPass::appendQuadsForRenderSurfaceLayer(CCLayerImpl* layer, CCOcclusionTrackerImpl* occlusionTracker)
     62void CCRenderPass::appendQuadsForRenderSurfaceLayer(CCLayerImpl* layer, const CCRenderPass* contributingRenderPass, CCOcclusionTrackerImpl* occlusionTracker)
    6263{
    6364    // FIXME: render surface layers should be a CCLayerImpl-derived class and
    … …  
    6970    OwnPtr<CCSharedQuadState> sharedQuadState = surface->createSharedQuadState();
    7071    bool isReplica = false;
    71     surface->appendQuads(quadCuller, sharedQuadState.get(), isReplica);
     72    surface->appendQuads(quadCuller, sharedQuadState.get(), isReplica, contributingRenderPass);
    7273    m_sharedQuadStateList.append(sharedQuadState.release());
    7374
    … …  
    7879    OwnPtr<CCSharedQuadState> replicaSharedQuadState = surface->createReplicaSharedQuadState();
    7980    isReplica = true;
    80     surface->appendQuads(quadCuller, replicaSharedQuadState.get(), isReplica);
     81    surface->appendQuads(quadCuller, replicaSharedQuadState.get(), isReplica, contributingRenderPass);
    8182    m_sharedQuadStateList.append(replicaSharedQuadState.release());
    8283}

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

    r119401 r119419  
    5757
    5858    void appendQuadsForLayer(CCLayerImpl*, CCOcclusionTrackerImpl*, bool& hadMissingTiles);
    59     void appendQuadsForRenderSurfaceLayer(CCLayerImpl*, CCOcclusionTrackerImpl*);
     59    void appendQuadsForRenderSurfaceLayer(CCLayerImpl*, const CCRenderPass* contributingRenderPass, CCOcclusionTrackerImpl*);
    6060    void appendQuadsToFillScreen(CCLayerImpl* rootLayer, const Color& screenBackgroundColor, const CCOcclusionTrackerImpl&);
    6161
    6262    const CCQuadList& quadList() const { return m_quadList; }
    6363    CCRenderSurface* targetSurface() const { return m_targetSurface; }
     64    // This denotes the bounds in physical pixels of the output generated by this RenderPass.
     65    const IntRect& framebufferOutputRect() const { return m_framebufferOutputRect; }
    6466
    6567private:
    … …  
    6870    CCRenderSurface* m_targetSurface;
    6971    CCQuadList m_quadList;
     72    IntRect m_framebufferOutputRect;
    7073    Vector<OwnPtr<CCSharedQuadState> > m_sharedQuadStateList;
    7174};

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCRenderPassDrawQuad.cpp

    r119417 r119419  
    2626#include "config.h"
    2727
    28 #include "cc/CCRenderSurfaceDrawQuad.h"
     28#include "cc/CCRenderPassDrawQuad.h"
    2929
    3030namespace WebCore {
    3131
    32 PassOwnPtr<CCRenderSurfaceDrawQuad> CCRenderSurfaceDrawQuad::create(const CCSharedQuadState* sharedQuadState, const IntRect& quadRect, CCLayerImpl* layer, bool isReplica, const WebKit::WebFilterOperations& filters, const WebKit::WebFilterOperations& backgroundFilters, unsigned maskTextureId)
     32PassOwnPtr<CCRenderPassDrawQuad> CCRenderPassDrawQuad::create(const CCSharedQuadState* sharedQuadState, const IntRect& quadRect, const CCRenderPass* renderPass, bool isReplica, const WebKit::WebFilterOperations& filters, const WebKit::WebFilterOperations& backgroundFilters, unsigned maskTextureId)
    3333{
    34     return adoptPtr(new CCRenderSurfaceDrawQuad(sharedQuadState, quadRect, layer, isReplica, filters, backgroundFilters, maskTextureId));
     34    return adoptPtr(new CCRenderPassDrawQuad(sharedQuadState, quadRect, renderPass, isReplica, filters, backgroundFilters, maskTextureId));
    3535}
    3636
    37 CCRenderSurfaceDrawQuad::CCRenderSurfaceDrawQuad(const CCSharedQuadState* sharedQuadState, const IntRect& quadRect, CCLayerImpl* layer, bool isReplica, const WebKit::WebFilterOperations& filters, const WebKit::WebFilterOperations& backgroundFilters, unsigned maskTextureId)
    38     : CCDrawQuad(sharedQuadState, CCDrawQuad::RenderSurface, quadRect)
    39     , m_layer(layer)
     37CCRenderPassDrawQuad::CCRenderPassDrawQuad(const CCSharedQuadState* sharedQuadState, const IntRect& quadRect, const CCRenderPass* renderPass, bool isReplica, const WebKit::WebFilterOperations& filters, const WebKit::WebFilterOperations& backgroundFilters, unsigned maskTextureId)
     38    : CCDrawQuad(sharedQuadState, CCDrawQuad::RenderPass, quadRect)
     39    , m_renderPass(renderPass)
    4040    , m_isReplica(isReplica)
    4141    , m_filters(filters)
    … …  
    4343    , m_maskTextureId(maskTextureId)
    4444{
    45     ASSERT(m_layer);
     45    ASSERT(m_renderPass);
    4646}
    4747

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCRenderPassDrawQuad.h

    r119417 r119419  
    2424 */
    2525
    26 #ifndef CCRenderSurfaceDrawQuad_h
    27 #define CCRenderSurfaceDrawQuad_h
     26#ifndef CCRenderPassDrawQuad_h
     27#define CCRenderPassDrawQuad_h
    2828
    2929#include "cc/CCDrawQuad.h"
    … …  
    3333namespace WebCore {
    3434
    35 class CCLayerImpl;
     35class CCRenderPass;
    3636
    37 class CCRenderSurfaceDrawQuad : public CCDrawQuad {
    38     WTF_MAKE_NONCOPYABLE(CCRenderSurfaceDrawQuad);
     37class CCRenderPassDrawQuad : public CCDrawQuad {
     38    WTF_MAKE_NONCOPYABLE(CCRenderPassDrawQuad);
    3939public:
    40     static PassOwnPtr<CCRenderSurfaceDrawQuad> create(const CCSharedQuadState*, const IntRect&, CCLayerImpl*, bool isReplica, const WebKit::WebFilterOperations& filters, const WebKit::WebFilterOperations& backgroundFilters, unsigned maskTextureId);
     40    static PassOwnPtr<CCRenderPassDrawQuad> create(const CCSharedQuadState*, const IntRect&, const CCRenderPass*, bool isReplica, const WebKit::WebFilterOperations& filters, const WebKit::WebFilterOperations& backgroundFilters, unsigned maskTextureId);
    4141
    42     CCLayerImpl* layer() const { return m_layer; }
     42    const CCRenderPass* renderPass() const { return m_renderPass; }
    4343    bool isReplica() const { return m_isReplica; }
    4444    unsigned maskTextureId() const { return m_maskTextureId; }
    … …  
    4848
    4949private:
    50     CCRenderSurfaceDrawQuad(const CCSharedQuadState*, const IntRect&, CCLayerImpl*, bool isReplica, const WebKit::WebFilterOperations& filters, const WebKit::WebFilterOperations& backgroundFilters, unsigned maskTextureId);
     50    CCRenderPassDrawQuad(const CCSharedQuadState*, const IntRect&, const CCRenderPass*, bool isReplica, const WebKit::WebFilterOperations& filters, const WebKit::WebFilterOperations& backgroundFilters, unsigned maskTextureId);
    5151
    52     CCLayerImpl* m_layer;
     52    const CCRenderPass* m_renderPass;
    5353    bool m_isReplica;
    5454    WebKit::WebFilterOperations m_filters;

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCRenderSurface.cpp

    r119401 r119419  
    4040#include "cc/CCMathUtil.h"
    4141#include "cc/CCQuadCuller.h"
    42 #include "cc/CCRenderSurfaceDrawQuad.h"
     42#include "cc/CCRenderPassDrawQuad.h"
    4343#include "cc/CCSharedQuadState.h"
    4444#include <public/WebTransformationMatrix.h>
    … …  
    8989bool CCRenderSurface::prepareContentsTexture(LayerRendererChromium* layerRenderer)
    9090{
    91     TextureManager* textureManager = layerRenderer->renderSurfaceTextureManager();
     91    TextureManager* textureManager = layerRenderer->implTextureManager();
    9292
    9393    if (!m_contentsTexture)
    … …  
    117117bool CCRenderSurface::prepareBackgroundTexture(LayerRendererChromium* layerRenderer)
    118118{
    119     TextureManager* textureManager = layerRenderer->renderSurfaceTextureManager();
     119    TextureManager* textureManager = layerRenderer->implTextureManager();
    120120
    121121    if (!m_backgroundTexture)
    … …  
    257257}
    258258
    259 void CCRenderSurface::appendQuads(CCQuadCuller& quadList, CCSharedQuadState* sharedQuadState, bool forReplica)
     259void CCRenderSurface::appendQuads(CCQuadCuller& quadList, CCSharedQuadState* sharedQuadState, bool forReplica, const CCRenderPass* renderPass)
    260260{
    261261    ASSERT(!forReplica || hasReplica());
    … …  
    287287    int maskTextureId = maskLayer ? maskLayer->contentsTextureId() : 0;
    288288
    289     quadList.appendSurface(CCRenderSurfaceDrawQuad::create(sharedQuadState, contentRect(), m_owningLayer, forReplica, filters(), backgroundFilters(), maskTextureId));
     289    quadList.appendSurface(CCRenderPassDrawQuad::create(sharedQuadState, contentRect(), renderPass, forReplica, filters(), backgroundFilters(), maskTextureId));
    290290}
    291291

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCRenderSurface.h

    r119401 r119419  
    4242class CCDamageTracker;
    4343class CCQuadCuller;
     44class CCRenderPass;
    4445class CCSharedQuadState;
    4546class CCLayerImpl;
    … …  
    140141    PassOwnPtr<CCSharedQuadState> createReplicaSharedQuadState() const;
    141142
    142     void appendQuads(CCQuadCuller&, CCSharedQuadState*, bool forReplica);
     143    void appendQuads(CCQuadCuller&, CCSharedQuadState*, bool forReplica, const CCRenderPass*);
     144
    143145    FloatRect computeRootScissorRectInCurrentSurface(const FloatRect& rootScissorRect) const;
    144146

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCRenderer.h

    r119401 r119419  
    6969    const WebKit::WebTransformationMatrix& windowMatrix() const { return m_windowMatrix; }
    7070
    71     virtual void beginDrawingFrame(CCRenderSurface* defaultRenderSurface) = 0;
    72     virtual void drawRenderPass(const CCRenderPass*, const FloatRect& rootScissorRectInCurrentSurface) = 0;
     71    virtual void beginDrawingFrame(const CCRenderPass* defaultRenderPass) = 0;
     72    virtual void drawRenderPass(const CCRenderPass*, const FloatRect& rootScissorRectInCurrentPass) = 0;
    7373    virtual void finishDrawingFrame() = 0;
    7474
    … …  
    8484    virtual void getFramebufferPixels(void *pixels, const IntRect&) = 0;
    8585
    86     virtual TextureManager* renderSurfaceTextureManager() const = 0;
     86    virtual TextureManager* implTextureManager() const = 0;
    8787    virtual TextureCopier* textureCopier() const = 0;
    8888    virtual TextureUploader* textureUploader() const = 0;
    89     virtual TextureAllocator* renderSurfaceTextureAllocator() const = 0;
     89    virtual TextureAllocator* implTextureAllocator() const = 0;
    9090    virtual TextureAllocator* contentsTextureAllocator() const = 0;
    9191

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCScrollbarLayerImpl.cpp

    r119313 r119419  
    5959
    6060    if (!m_texture)
    61         m_texture = ManagedTexture::create(layerRenderer->renderSurfaceTextureManager());
     61        m_texture = ManagedTexture::create(layerRenderer->implTextureManager());
    6262
    6363    // The context could have been lost since the last frame and the old texture
    6464    // manager may no longer be valid.
    65     m_texture->setTextureManager(layerRenderer->renderSurfaceTextureManager());
     65    m_texture->setTextureManager(layerRenderer->implTextureManager());
    6666
    6767    IntSize textureSize = contentBounds();
    … …  
    7878    {
    7979        PlatformCanvas::AutoLocker locker(&canvas);
    80         m_texture->bindTexture(context, layerRenderer->renderSurfaceTextureAllocator());
     80        m_texture->bindTexture(context, layerRenderer->implTextureAllocator());
    8181
    8282        // FIXME: Skia uses BGRA actually, we correct that with the swizzle pixel shader.

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCVideoLayerImpl.cpp

    r119313 r119419  
    257257            return false;
    258258        if (!m_textures[plane].m_texture) {
    259             m_textures[plane].m_texture = ManagedTexture::create(layerRenderer->renderSurfaceTextureManager());
     259            m_textures[plane].m_texture = ManagedTexture::create(layerRenderer->implTextureManager());
    260260            if (!m_textures[plane].m_texture)
    261261                return false;
    262262            m_textures[plane].m_visibleSize = IntSize();
    263263        } else {
    264             // The renderSurfaceTextureManager may have been destroyed and recreated since the last frame, so pass the new one.
     264            // The implTextureManager may have been destroyed and recreated since the last frame, so pass the new one.
    265265            // This is a no-op if the TextureManager is still around.
    266             m_textures[plane].m_texture->setTextureManager(layerRenderer->renderSurfaceTextureManager());
     266            m_textures[plane].m_texture->setTextureManager(layerRenderer->implTextureManager());
    267267        }
    268268        if (m_textures[plane].m_texture->size() != requiredTextureSize)

  • trunk/Source/WebKit/chromium/ChangeLog

    r119411 r119419  
     12012-06-04  Dana Jansens  <danakj@chromium.org>
     2
     3        [chromium] Make LayerRendererChromium use RenderPasses instead of RenderSurfaces
     4        https://bugs.webkit.org/show_bug.cgi?id=88132
     5
     6        Reviewed by Adrienne Walker.
     7
     8        * tests/CCLayerTreeHostImplTest.cpp:
     9        * tests/LayerRendererChromiumTest.cpp:
     10        (FakeCCRendererClient::FakeCCRendererClient):
     11        (FakeCCRendererClient::rootRenderPass):
     12        (FakeCCRendererClient):
     13        (TEST_F):
     14
    1152012-06-04  David Dorwin  <ddorwin@chromium.org>
    216

  • trunk/Source/WebKit/chromium/tests/CCLayerTreeHostImplTest.cpp

    r119401 r119419  
    13891389        ASSERT_EQ(1U, frame.renderPasses[1]->quadList().size());
    13901390        EXPECT_EQ(CCDrawQuad::SolidColor, frame.renderPasses[0]->quadList()[0]->material());
    1391         EXPECT_EQ(CCDrawQuad::RenderSurface, frame.renderPasses[1]->quadList()[0]->material());
     1391        EXPECT_EQ(CCDrawQuad::RenderPass, frame.renderPasses[1]->quadList()[0]->material());
    13921392    }
    13931393}
    … …  
    14101410        ASSERT_EQ(1U, frame.renderPasses[1]->quadList().size());
    14111411        EXPECT_EQ(CCDrawQuad::SolidColor, frame.renderPasses[0]->quadList()[0]->material());
    1412         EXPECT_EQ(CCDrawQuad::RenderSurface, frame.renderPasses[1]->quadList()[0]->material());
     1412        EXPECT_EQ(CCDrawQuad::RenderPass, frame.renderPasses[1]->quadList()[0]->material());
    14131413    }
    14141414}

  • trunk/Source/WebKit/chromium/tests/LayerRendererChromiumTest.cpp

    r119313 r119419  
    6969    {
    7070        m_rootLayer->createRenderSurface();
     71        m_rootRenderPass = CCRenderPass::create(m_rootLayer->renderSurface());
    7172    }
    7273
    … …  
    8283    int setFullRootLayerDamageCount() const { return m_setFullRootLayerDamageCount; }
    8384
    84     CCLayerImpl* rootLayer() { return m_rootLayer.get(); }
     85    CCRenderPass* rootRenderPass() { return m_rootRenderPass.get(); }
    8586
    8687private:
    … …  
    8889    DebugScopedSetImplThread m_implThread;
    8990    OwnPtr<CCLayerImpl> m_rootLayer;
     91    OwnPtr<CCRenderPass> m_rootRenderPass;
    9092};
    9193
    … …  
    195197    EXPECT_EQ(1, m_mockClient.setFullRootLayerDamageCount());
    196198
    197     m_layerRendererChromium.beginDrawingFrame(m_mockClient.rootLayer()->renderSurface());
     199    m_layerRendererChromium.beginDrawingFrame(m_mockClient.rootRenderPass());
    198200    EXPECT_FALSE(m_layerRendererChromium.isFramebufferDiscarded());
    199201
Note: See TracChangeset for help on using the changeset viewer.