Changeset 122160 in webkit

Timestamp:

Jul 9, 2012 3:31:25 PM (12 years ago)

Author:

danakj@chromium.org

Message:

[chromium] Decouple RenderPass drawing from CCRenderSurface
​https://bugs.webkit.org/show_bug.cgi?id=90573

Reviewed by Adrienne Walker.

Source/WebCore:

Removes the managed textures from CCRenderSurface and stores them in a
HashMap in LayerRendererChromium.

At the start of a frame, all textures for the frame are reserved, and
unneeded textures are deleted. After each quad is drawn, evicted textures
(ie temporary textures used for background filters) are deleted to keep
within memory limits. At the end of the frame, all surface contents
textures are kept reserved and thus not deleted.

We add a numeric identifier to CCRenderPass which can be used to
identify the pass across serialization in the future, and is used
in the interface to LayerRendererChromium. Also we add to the
CCRenderPass a contentsChangedSinceLastFrame() flag so that the
value does not need to be retrieved from the CCRenderSurface.

The pointer from CCRenderPass to CCRenderSurface remains for some
code in the CCLayerTreeHostImpl, and will be addressed in the future, but
the pointer is no longer used at all while drawing a frame inside
LayerRendererChromium.

Covered by existing tests, no intended change in behaviour.

• platform/graphics/chromium/LayerRendererChromium.cpp:

(WebCore::LayerRendererChromium::releaseRenderPassTextures):
(WebCore::LayerRendererChromium::decideRenderPassAllocationsForFrame):
(WebCore):
(WebCore::LayerRendererChromium::haveCachedResourcesForRenderPassId):
(WebCore::LayerRendererChromium::drawQuad):
(WebCore::LayerRendererChromium::drawBackgroundFilters):
(WebCore::LayerRendererChromium::drawRenderPassQuad):
(WebCore::LayerRendererChromium::finishDrawingFrame):
(WebCore::LayerRendererChromium::useRenderPass):
(WebCore::LayerRendererChromium::initializeSharedObjects):

• platform/graphics/chromium/LayerRendererChromium.h:

(LayerRendererChromium):

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

(WebCore::CCLayerTreeHostImpl::calculateRenderPasses):
(WebCore::CCLayerTreeHostImpl::removePassesWithCachedTextures):

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

(CCLayerTreeHostImpl):

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

(WebCore::CCRenderPass::create):
(WebCore::CCRenderPass::CCRenderPass):

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

(CCRenderPass):
(WebCore::CCRenderPass::id):
(WebCore::CCRenderPass::setFramebufferOutputRect):

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

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

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

(CCRenderPassDrawQuad):
(WebCore::CCRenderPassDrawQuad::renderPassId):
(WebCore::CCRenderPassDrawQuad::contentsChangedSinceLastFrame):

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

(WebCore::CCRenderSurface::appendQuads):

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

(WebCore):
(CCRenderSurface):

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

(CCRenderer):

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

(WebCore::CCTiledLayerImpl::pushTileProperties):

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

(CCTiledLayerImpl):

Source/WebKit/chromium:

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

(FakeCCRendererClient::FakeCCRendererClient):

Location:

trunk/Source

Files:

• WebCore/ChangeLog (modified) (1 diff)
• WebCore/platform/graphics/chromium/LayerRendererChromium.cpp (modified) (13 diffs)
• WebCore/platform/graphics/chromium/LayerRendererChromium.h (modified) (5 diffs)
• WebCore/platform/graphics/chromium/cc/CCLayerImpl.cpp (modified) (1 diff)
• WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp (modified) (4 diffs)
• WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.h (modified) (1 diff)
• WebCore/platform/graphics/chromium/cc/CCRenderPass.cpp (modified) (1 diff)
• WebCore/platform/graphics/chromium/cc/CCRenderPass.h (modified) (3 diffs)
• WebCore/platform/graphics/chromium/cc/CCRenderPassDrawQuad.cpp (modified) (1 diff)
• WebCore/platform/graphics/chromium/cc/CCRenderPassDrawQuad.h (modified) (2 diffs)
• WebCore/platform/graphics/chromium/cc/CCRenderSurface.cpp (modified) (3 diffs)
• WebCore/platform/graphics/chromium/cc/CCRenderSurface.h (modified) (6 diffs)
• WebCore/platform/graphics/chromium/cc/CCRenderer.h (modified) (1 diff)
• WebCore/platform/graphics/chromium/cc/CCTiledLayerImpl.cpp (modified) (2 diffs)
• WebCore/platform/graphics/chromium/cc/CCTiledLayerImpl.h (modified) (1 diff)
• WebKit/chromium/ChangeLog (modified) (1 diff)
• WebKit/chromium/tests/CCLayerTreeHostImplTest.cpp (modified) (49 diffs)
• WebKit/chromium/tests/CCOcclusionTrackerTest.cpp (modified) (1 diff)
• WebKit/chromium/tests/CCQuadCullerTest.cpp (modified) (1 diff)
• WebKit/chromium/tests/CCRenderSurfaceTest.cpp (modified) (2 diffs)
• WebKit/chromium/tests/CCSolidColorLayerImplTest.cpp (modified) (3 diffs)
• WebKit/chromium/tests/CCTiledLayerImplTest.cpp (modified) (1 diff)
• WebKit/chromium/tests/LayerRendererChromiumTest.cpp (modified) (1 diff)
• WebKit/chromium/tests/TiledLayerChromiumTest.cpp (modified) (22 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2012-07-09  Dana Jansens  <danakj@chromium.org>
+
+        [chromium] Decouple RenderPass drawing from CCRenderSurface
+        https://bugs.webkit.org/show_bug.cgi?id=90573
+
+        Reviewed by Adrienne Walker.
+
+        Removes the managed textures from CCRenderSurface and stores them in a
+        HashMap in LayerRendererChromium.
+
+        At the start of a frame, all textures for the frame are reserved, and
+        unneeded textures are deleted. After each quad is drawn, evicted textures
+        (ie temporary textures used for background filters) are deleted to keep
+        within memory limits. At the end of the frame, all surface contents
+        textures are kept reserved and thus not deleted.
+
+        We add a numeric identifier to CCRenderPass which can be used to
+        identify the pass across serialization in the future, and is used
+        in the interface to LayerRendererChromium. Also we add to the
+        CCRenderPass a contentsChangedSinceLastFrame() flag so that the
+        value does not need to be retrieved from the CCRenderSurface.
+
+        The pointer from CCRenderPass to CCRenderSurface remains for some
+        code in the CCLayerTreeHostImpl, and will be addressed in the future, but
+        the pointer is no longer used at all while drawing a frame inside
+        LayerRendererChromium.
+
+        Covered by existing tests, no intended change in behaviour.
+
+        * platform/graphics/chromium/LayerRendererChromium.cpp:
+        (WebCore::LayerRendererChromium::releaseRenderPassTextures):
+        (WebCore::LayerRendererChromium::decideRenderPassAllocationsForFrame):
+        (WebCore):
+        (WebCore::LayerRendererChromium::haveCachedResourcesForRenderPassId):
+        (WebCore::LayerRendererChromium::drawQuad):
+        (WebCore::LayerRendererChromium::drawBackgroundFilters):
+        (WebCore::LayerRendererChromium::drawRenderPassQuad):
+        (WebCore::LayerRendererChromium::finishDrawingFrame):
+        (WebCore::LayerRendererChromium::useRenderPass):
+        (WebCore::LayerRendererChromium::initializeSharedObjects):
+        * platform/graphics/chromium/LayerRendererChromium.h:
+        (LayerRendererChromium):
+        * platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp:
+        (WebCore::CCLayerTreeHostImpl::calculateRenderPasses):
+        (WebCore::CCLayerTreeHostImpl::removePassesWithCachedTextures):
+        * platform/graphics/chromium/cc/CCLayerTreeHostImpl.h:
+        (CCLayerTreeHostImpl):
+        * platform/graphics/chromium/cc/CCRenderPass.cpp:
+        (WebCore::CCRenderPass::create):
+        (WebCore::CCRenderPass::CCRenderPass):
+        * platform/graphics/chromium/cc/CCRenderPass.h:
+        (CCRenderPass):
+        (WebCore::CCRenderPass::id):
+        (WebCore::CCRenderPass::setFramebufferOutputRect):
+        * platform/graphics/chromium/cc/CCRenderPassDrawQuad.cpp:
+        (WebCore::CCRenderPassDrawQuad::create):
+        (WebCore::CCRenderPassDrawQuad::CCRenderPassDrawQuad):
+        * platform/graphics/chromium/cc/CCRenderPassDrawQuad.h:
+        (CCRenderPassDrawQuad):
+        (WebCore::CCRenderPassDrawQuad::renderPassId):
+        (WebCore::CCRenderPassDrawQuad::contentsChangedSinceLastFrame):
+        * platform/graphics/chromium/cc/CCRenderSurface.cpp:
+        (WebCore::CCRenderSurface::appendQuads):
+        * platform/graphics/chromium/cc/CCRenderSurface.h:
+        (WebCore):
+        (CCRenderSurface):
+        * platform/graphics/chromium/cc/CCRenderer.h:
+        (CCRenderer):
+        * platform/graphics/chromium/cc/CCTiledLayerImpl.cpp:
+        (WebCore::CCTiledLayerImpl::pushTileProperties):
+        * platform/graphics/chromium/cc/CCTiledLayerImpl.h:
+        (CCTiledLayerImpl):
+
 2012-07-09  Adam Klein  <adamk@chromium.org>
 

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

@@ -275 +275 @@
 void LayerRendererChromium::releaseRenderPassTextures()
 {
-    if (m_implTextureManager)
-        m_implTextureManager->evictAndDeleteAllTextures(m_implTextureAllocator.get());
+    if (!m_implTextureManager)
+        return;
+    m_renderPassTextures.clear();
+    m_implTextureManager->deleteEvictedTextures(m_implTextureAllocator.get());
 }
 
@@ -316 +318 @@
 void LayerRendererChromium::decideRenderPassAllocationsForFrame(const CCRenderPassList& renderPassesInDrawOrder)
 {
-    // FIXME: Get this memory limit from GPU Memory Manager
-    size_t contentsMemoryUseBytes = m_contentsTextureAllocator->currentMemoryUseBytes();
-    size_t maxLimitBytes = TextureManager::highLimitBytes(viewportSize());
-    size_t memoryLimitBytes = maxLimitBytes - contentsMemoryUseBytes > 0u ? maxLimitBytes - contentsMemoryUseBytes : 0u;
-
-    m_implTextureManager->setMaxMemoryLimitBytes(memoryLimitBytes);
+    HashMap<int, const CCRenderPass*> passesInFrame;
+    for (size_t i = 0; i < renderPassesInDrawOrder.size(); ++i)
+        passesInFrame.set(renderPassesInDrawOrder[i]->id(), renderPassesInDrawOrder[i].get());
+
+    Vector<int> passesToDelete;
+    HashMap<int, OwnPtr<ManagedTexture> >::const_iterator passIterator;
+    for (passIterator = m_renderPassTextures.begin(); passIterator != m_renderPassTextures.end(); ++passIterator) {
+        const CCRenderPass* renderPassInFrame = passesInFrame.get(passIterator->first);
+        if (!renderPassInFrame) {
+            passesToDelete.append(passIterator->first);
+            continue;
+        }
+
+        const IntSize& requiredSize = renderPassInFrame->framebufferOutputRect().size();
+        GC3Denum requiredFormat = GraphicsContext3D::RGBA;
+        ManagedTexture* texture = passIterator->second.get();
+        if (!texture || !texture->isValid(requiredSize, requiredFormat)) {
+            passesToDelete.append(passIterator->first);
+            continue;
+        }
+    }
+
+    // Delete RenderPass textures from the previous frame that will not be used again.
+    for (size_t i = 0; i < passesToDelete.size(); ++i)
+        m_renderPassTextures.remove(passesToDelete[i]);
+    m_implTextureManager->deleteEvictedTextures(m_implTextureAllocator.get());
+
+    // All RenderPass textures should be reserved for the current frame. Every RenderPass texture
+    // is kept reserved until it is removed and deleted.
+    for (size_t i = 0; i < renderPassesInDrawOrder.size(); ++i) {
+        ManagedTexture* texture = m_renderPassTextures.get(renderPassesInDrawOrder[i]->id());
+        if (!texture) {
+            OwnPtr<ManagedTexture> ownTexture = ManagedTexture::create(m_implTextureManager.get());
+            texture = ownTexture.get();
+            m_renderPassTextures.set(renderPassesInDrawOrder[i]->id(), ownTexture.release());
+        }
+
+        const IntSize& requiredSize = renderPassesInDrawOrder[i]->framebufferOutputRect().size();
+        GC3Denum requiredFormat = GraphicsContext3D::RGBA;
+        bool reserved = texture->reserve(requiredSize, requiredFormat);
+        ASSERT_UNUSED(reserved, reserved);
+    }
+}
+
+bool LayerRendererChromium::haveCachedResourcesForRenderPassId(int id) const
+{
+    ManagedTexture* texture = m_renderPassTextures.get(id);
+    return texture && texture->textureId();
 }
 
@@ -420 +464 @@
         break;
     }
+
+    m_implTextureManager->deleteEvictedTextures(m_implTextureAllocator.get());
 }
 
@@ -489 +535 @@
 }
 
-void LayerRendererChromium::drawBackgroundFilters(const CCRenderPassDrawQuad* quad, const WebTransformationMatrix& contentsDeviceTransform)
+PassOwnPtr<ManagedTexture> LayerRendererChromium::drawBackgroundFilters(const CCRenderPassDrawQuad* quad, const WebTransformationMatrix& contentsDeviceTransform)
 {
     // This method draws a background filter, which applies a filter to any pixels behind the quad and seen through its background.
@@ -507 +553 @@
     // FIXME: When this algorithm changes, update CCLayerTreeHost::prioritizeTextures() accordingly.
 
-    CCRenderSurface* drawingSurface = quad->renderPass()->targetSurface();
     if (quad->backgroundFilters().isEmpty())
-        return;
+        return nullptr;
 
     // FIXME: We only allow background filters on an opaque render surface because other surfaces may contain
     // translucent pixels, and the contents behind those translucent pixels wouldn't have the filter applied.
     if (m_currentRenderPass->hasTransparentBackground())
-        return;
+        return nullptr;
     ASSERT(!m_currentManagedTexture);
 
@@ -529 +574 @@
     OwnPtr<ManagedTexture> deviceBackgroundTexture = ManagedTexture::create(m_implTextureManager.get());
     if (!getFramebufferTexture(deviceBackgroundTexture.get(), deviceRect))
-        return;
+        return nullptr;
 
     SkBitmap filteredDeviceBackground = applyFilters(this, quad->backgroundFilters(), deviceBackgroundTexture.get());
     if (!filteredDeviceBackground.getTexture())
-        return;
+        return nullptr;
 
     GrTexture* texture = reinterpret_cast<GrTexture*>(filteredDeviceBackground.getTexture());
     int filteredDeviceBackgroundTextureId = texture->getTextureHandle();
 
-    if (!drawingSurface->prepareBackgroundTexture(this))
-        return;
+    OwnPtr<ManagedTexture> backgroundTexture = ManagedTexture::create(m_implTextureManager.get());
+    if (!backgroundTexture->reserve(quad->quadRect().size(), GraphicsContext3D::RGBA))
+        return nullptr;
 
     const CCRenderPass* targetRenderPass = m_currentRenderPass;
-    if (useManagedTexture(drawingSurface->backgroundTexture(), quad->quadRect())) {
+    bool usingBackgroundTexture = useManagedTexture(backgroundTexture.get(), quad->quadRect());
+
+    if (usingBackgroundTexture) {
         // Copy the readback pixels from device to the background texture for the surface.
         WebTransformationMatrix deviceToFramebufferTransform;
@@ -552 +600 @@
 
         copyTextureToFramebuffer(filteredDeviceBackgroundTextureId, deviceRect.size(), deviceToFramebufferTransform);
-
-        useRenderPass(targetRenderPass);
-    }
+    }
+
+    useRenderPass(targetRenderPass);
+
+    if (!usingBackgroundTexture)
+        return nullptr;
+    return backgroundTexture.release();
 }
 
 void LayerRendererChromium::drawRenderPassQuad(const CCRenderPassDrawQuad* quad)
 {
-    // The replica is always drawn first, so free after drawing the contents.
-    bool shouldReleaseTextures = !quad->isReplica();
-
-    CCRenderSurface* drawingSurface = quad->renderPass()->targetSurface();
-
     WebTransformationMatrix renderTransform = quad->layerTransform();
     // Apply a scaling factor to size the quad from 1x1 to its intended size.
@@ -570 +617 @@
 
     // Can only draw surface if device matrix is invertible.
-    if (!contentsDeviceTransform.isInvertible() || !drawingSurface->hasValidContentsTexture()) {
-        if (shouldReleaseTextures) {
-            drawingSurface->releaseBackgroundTexture();
-            drawingSurface->releaseContentsTexture();
-        }
+    if (!contentsDeviceTransform.isInvertible())
         return;
-    }
-
-    drawBackgroundFilters(quad, contentsDeviceTransform);
+
+    ManagedTexture* contentsTexture = m_renderPassTextures.get(quad->renderPassId());
+    ASSERT(contentsTexture && contentsTexture->textureId());
+
+    OwnPtr<ManagedTexture> backgroundTexture = drawBackgroundFilters(quad, contentsDeviceTransform);
 
     // FIXME: Cache this value so that we don't have to do it for both the surface and its replica.
     // Apply filters to the contents texture.
-    SkBitmap filterBitmap = applyFilters(this, quad->filters(), drawingSurface->contentsTexture());
-    int contentsTextureId = drawingSurface->contentsTexture()->textureId();
+    SkBitmap filterBitmap = applyFilters(this, quad->filters(), contentsTexture);
+    int contentsTextureId = contentsTexture->textureId();
     if (filterBitmap.getTexture()) {
         GrTexture* texture = reinterpret_cast<GrTexture*>(filterBitmap.getTexture());
@@ -590 +635 @@
 
     // Draw the background texture if there is one.
-    if (drawingSurface->hasValidBackgroundTexture())
-        copyTextureToFramebuffer(drawingSurface->backgroundTexture()->textureId(), quad->quadRect().size(), quad->layerTransform());
+    if (backgroundTexture) {
+        ASSERT(backgroundTexture->size() == quad->quadRect().size());
+        copyTextureToFramebuffer(backgroundTexture->textureId(), quad->quadRect().size(), quad->layerTransform());
+    }
 
     bool clipped = false;
@@ -674 +721 @@
     drawTexturedQuad(quad->layerTransform(), quad->quadRect().width(), quad->quadRect().height(), quad->opacity(), surfaceQuad,
                      shaderMatrixLocation, shaderAlphaLocation, shaderQuadLocation);
-
-    if (shouldReleaseTextures) {
-        drawingSurface->releaseBackgroundTexture();
-        drawingSurface->releaseContentsTexture();
-    }
 }
 
@@ -1080 +1122 @@
     GLC(m_context, m_context->disable(GraphicsContext3D::SCISSOR_TEST));
     GLC(m_context, m_context->disable(GraphicsContext3D::BLEND));
-
-    m_implTextureManager->unprotectAllTextures();
-    m_implTextureManager->deleteEvictedTextures(m_implTextureAllocator.get());
 }
 
@@ -1340 +1379 @@
     }
 
-    if (!renderPass->targetSurface()->prepareContentsTexture(this))
-        return false;
-
-    return bindFramebufferToTexture(renderPass->targetSurface()->contentsTexture(), renderPass->framebufferOutputRect());
+    ManagedTexture* texture = m_renderPassTextures.get(renderPass->id());
+    ASSERT(texture);
+
+    return bindFramebufferToTexture(texture, renderPass->framebufferOutputRect());
 }
 
@@ -1432 +1471 @@
     GLC(m_context, m_context->flush());
 
-    m_implTextureManager = TextureManager::create(TextureManager::highLimitBytes(viewportSize()),
-                                                  TextureManager::reclaimLimitBytes(viewportSize()),
-                                                  m_capabilities.maxTextureSize);
+    m_implTextureManager = TextureManager::create(std::numeric_limits<size_t>::max(), std::numeric_limits<size_t>::max(), m_capabilities.maxTextureSize);
     m_textureCopier = AcceleratedTextureCopier::create(m_context, m_isUsingBindUniform);
     if (m_textureUploaderSetting == ThrottledUploader)

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

@@ -81 +81 @@
 
     virtual void decideRenderPassAllocationsForFrame(const CCRenderPassList&) OVERRIDE;
+    virtual bool haveCachedResourcesForRenderPassId(int id) const OVERRIDE;
+
     virtual void beginDrawingFrame(const CCRenderPass* defaultRenderPass) OVERRIDE;
     virtual void drawRenderPass(const CCRenderPass*, const FloatRect& framebufferDamageRect) OVERRIDE;
@@ -124 +126 @@
     bool initialize();
 
+    void releaseRenderPassTextures();
+
 private:
     static void toGLMatrix(float*, const WebKit::WebTransformationMatrix&);
@@ -130 +134 @@
     void drawCheckerboardQuad(const CCCheckerboardDrawQuad*);
     void drawDebugBorderQuad(const CCDebugBorderDrawQuad*);
-    void drawBackgroundFilters(const CCRenderPassDrawQuad*, const WebKit::WebTransformationMatrix& deviceTransform);
+    PassOwnPtr<ManagedTexture> drawBackgroundFilters(const CCRenderPassDrawQuad*, const WebKit::WebTransformationMatrix& deviceTransform);
     void drawRenderPassQuad(const CCRenderPassDrawQuad*);
     void drawSolidColorQuad(const CCSolidColorDrawQuad*);
@@ -149 +153 @@
 
     void clearRenderPass(const CCRenderPass*, const FloatRect& framebufferDamageRect);
-
-    void releaseRenderPassTextures();
 
     bool makeContextCurrent();
@@ -264 +266 @@
     OwnPtr<TrackingTextureAllocator> m_implTextureAllocator;
 
+    HashMap<int, OwnPtr<ManagedTexture> > m_renderPassTextures;
+
     WebKit::WebGraphicsContext3D* m_context;
 

trunk/Source/WebCore/platform/graphics/chromium/cc/CCLayerImpl.cpp

@@ -86 +86 @@
 {
     ASSERT(CCProxy::isImplThread());
-    ASSERT(m_layerId >= 0);
+    ASSERT(m_layerId > 0);
 }
 

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

@@ -296 +296 @@
         CCRenderSurface* renderSurface = renderSurfaceLayer->renderSurface();
 
-        OwnPtr<CCRenderPass> pass = CCRenderPass::create(renderSurface);
+        // FIXME: Make this unique across all CCLayerTreeHostImpls.
+        int globalRenderPassId = renderSurfaceLayer->id();
+
+        OwnPtr<CCRenderPass> pass = CCRenderPass::create(renderSurface, globalRenderPassId);
         surfacePassMap.add(renderSurface, pass.get());
         frame.renderPasses.append(pass.release());
@@ -352 +355 @@
 
     m_layerRenderer->decideRenderPassAllocationsForFrame(frame.renderPasses);
-    removePassesWithCachedTextures(frame.renderPasses, frame.skippedPasses);
+    removePassesWithCachedTextures(frame.renderPasses, frame.skippedPasses, m_layerRenderer.get());
 
     return drawFrame;
@@ -432 +435 @@
 }
 
-void CCLayerTreeHostImpl::removePassesWithCachedTextures(CCRenderPassList& passes, CCRenderPassList& skippedPasses)
+void CCLayerTreeHostImpl::removePassesWithCachedTextures(CCRenderPassList& passes, CCRenderPassList& skippedPasses, const CCRenderer* renderer)
 {
     for (int passIndex = passes.size() - 1; passIndex >= 0; --passIndex) {
@@ -446 +449 @@
 
             CCRenderPassDrawQuad* renderPassQuad = static_cast<CCRenderPassDrawQuad*>(currentQuad);
-            CCRenderSurface* targetSurface = renderPassQuad->renderPass()->targetSurface();
-
-            if (targetSurface->contentsChanged() || !targetSurface->hasCachedContentsTexture())
+            if (!renderPassQuad->contentsChangedSinceLastFrame().isEmpty())
                 continue;
-
-            // Reserve the texture immediately. We do not need to pass in layer renderer
-            // since the texture already exists, just needs to be reserved.
-            if (!targetSurface->prepareContentsTexture(0))
+            if (!renderer->haveCachedResourcesForRenderPassId(renderPassQuad->renderPassId()))
                 continue;
 

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

@@ -179 +179 @@
 
     // Removes all render passes for which we have cached textures, and which did not change their content.
-    static void removePassesWithCachedTextures(CCRenderPassList& passes, CCRenderPassList& skippedPasses);
+    static void removePassesWithCachedTextures(CCRenderPassList& passes, CCRenderPassList& skippedPasses, const CCRenderer*);
 
 protected:

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

@@ -38 +38 @@
 namespace WebCore {
 
-PassOwnPtr<CCRenderPass> CCRenderPass::create(CCRenderSurface* targetSurface)
+PassOwnPtr<CCRenderPass> CCRenderPass::create(CCRenderSurface* targetSurface, int id)
 {
-    return adoptPtr(new CCRenderPass(targetSurface));
+    return adoptPtr(new CCRenderPass(targetSurface, id));
 }
 
-CCRenderPass::CCRenderPass(CCRenderSurface* targetSurface)
-    : m_targetSurface(targetSurface)
+CCRenderPass::CCRenderPass(CCRenderSurface* targetSurface, int id)
+    : m_id(id)
+    , m_targetSurface(targetSurface)
     , m_framebufferOutputRect(targetSurface->contentRect())
     , m_hasTransparentBackground(true)
 {
-    ASSERT(m_targetSurface);
+    ASSERT(targetSurface);
+    ASSERT(id > 0);
 }
 

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

@@ -54 +54 @@
     WTF_MAKE_NONCOPYABLE(CCRenderPass);
 public:
-    static PassOwnPtr<CCRenderPass> create(CCRenderSurface*);
+    static PassOwnPtr<CCRenderPass> create(CCRenderSurface*, int id);
 
     void appendQuadsForLayer(CCLayerImpl*, CCOcclusionTrackerImpl*, bool& hadMissingTiles);
@@ -61 +61 @@
 
     const CCQuadList& quadList() const { return m_quadList; }
+
+    int id() const { return m_id; }
     CCRenderSurface* targetSurface() const { return m_targetSurface; }
+
     // This denotes the bounds in physical pixels of the output generated by this RenderPass.
     const IntRect& framebufferOutputRect() const { return m_framebufferOutputRect; }
@@ -69 +72 @@
 
 protected:
-    explicit CCRenderPass(CCRenderSurface*);
+    CCRenderPass(CCRenderSurface*, int id);
 
+    int m_id;
     CCRenderSurface* m_targetSurface;
     CCQuadList m_quadList;

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

@@ -28 +28 @@
 #include "cc/CCRenderPassDrawQuad.h"
 
+#include "cc/CCRenderPass.h"
+
 namespace WebCore {
 
-PassOwnPtr<CCRenderPassDrawQuad> CCRenderPassDrawQuad::create(const CCSharedQuadState* sharedQuadState, const IntRect& quadRect, const CCRenderPass* renderPass, bool isReplica, const WebKit::WebFilterOperations& filters, const WebKit::WebFilterOperations& backgroundFilters, unsigned maskTextureId)
+PassOwnPtr<CCRenderPassDrawQuad> CCRenderPassDrawQuad::create(const CCSharedQuadState* sharedQuadState, const IntRect& quadRect, const CCRenderPass* renderPass, bool isReplica, const WebKit::WebFilterOperations& filters, const WebKit::WebFilterOperations& backgroundFilters, unsigned maskTextureId, const IntRect& contentsChangedSinceLastFrame)
 {
-    return adoptPtr(new CCRenderPassDrawQuad(sharedQuadState, quadRect, renderPass, isReplica, filters, backgroundFilters, maskTextureId));
+    return adoptPtr(new CCRenderPassDrawQuad(sharedQuadState, quadRect, renderPass, isReplica, filters, backgroundFilters, maskTextureId, contentsChangedSinceLastFrame));
 }
 
-CCRenderPassDrawQuad::CCRenderPassDrawQuad(const CCSharedQuadState* sharedQuadState, const IntRect& quadRect, const CCRenderPass* renderPass, bool isReplica, const WebKit::WebFilterOperations& filters, const WebKit::WebFilterOperations& backgroundFilters, unsigned maskTextureId)
+CCRenderPassDrawQuad::CCRenderPassDrawQuad(const CCSharedQuadState* sharedQuadState, const IntRect& quadRect, const CCRenderPass* renderPass, bool isReplica, const WebKit::WebFilterOperations& filters, const WebKit::WebFilterOperations& backgroundFilters, unsigned maskTextureId, const IntRect& contentsChangedSinceLastFrame)
     : CCDrawQuad(sharedQuadState, CCDrawQuad::RenderPass, quadRect)
     , m_renderPass(renderPass)
+    , m_renderPassId(renderPass->id())
     , m_isReplica(isReplica)
     , m_filters(filters)
     , m_backgroundFilters(backgroundFilters)
     , m_maskTextureId(maskTextureId)
+    , m_contentsChangedSinceLastFrame(contentsChangedSinceLastFrame)
 {
     ASSERT(m_renderPass);

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

@@ -38 +38 @@
     WTF_MAKE_NONCOPYABLE(CCRenderPassDrawQuad);
 public:
-    static PassOwnPtr<CCRenderPassDrawQuad> create(const CCSharedQuadState*, const IntRect&, const CCRenderPass*, bool isReplica, const WebKit::WebFilterOperations& filters, const WebKit::WebFilterOperations& backgroundFilters, unsigned maskTextureId);
+    static PassOwnPtr<CCRenderPassDrawQuad> create(const CCSharedQuadState*, const IntRect&, const CCRenderPass*, bool isReplica, const WebKit::WebFilterOperations& filters, const WebKit::WebFilterOperations& backgroundFilters, unsigned maskTextureId, const IntRect& contentsChangedSinceLastFrame);
 
     const CCRenderPass* renderPass() const { return m_renderPass; }
+    int renderPassId() const { return m_renderPassId; }
     bool isReplica() const { return m_isReplica; }
     unsigned maskTextureId() const { return m_maskTextureId; }
+    const IntRect& contentsChangedSinceLastFrame() const { return m_contentsChangedSinceLastFrame; }
 
     const WebKit::WebFilterOperations& filters() const { return m_filters; }
@@ -48 +50 @@
 
 private:
-    CCRenderPassDrawQuad(const CCSharedQuadState*, const IntRect&, const CCRenderPass*, bool isReplica, const WebKit::WebFilterOperations& filters, const WebKit::WebFilterOperations& backgroundFilters, unsigned maskTextureId);
+    CCRenderPassDrawQuad(const CCSharedQuadState*, const IntRect&, const CCRenderPass*, bool isReplica, const WebKit::WebFilterOperations& filters, const WebKit::WebFilterOperations& backgroundFilters, unsigned maskTextureId, const IntRect& contentsChangedSinceLastFrame);
 
     const CCRenderPass* m_renderPass;
+    int m_renderPassId;
     bool m_isReplica;
     WebKit::WebFilterOperations m_filters;
     WebKit::WebFilterOperations m_backgroundFilters;
     unsigned m_maskTextureId;
+    IntRect m_contentsChangedSinceLastFrame;
 };
 

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

@@ -32 +32 @@
 #include "GraphicsContext3D.h"
 #include "LayerRendererChromium.h"
-#include "ManagedTexture.h"
 #include "TextStream.h"
 #include "cc/CCDamageTracker.h"
@@ -86 +85 @@
 }
 
-bool CCRenderSurface::prepareContentsTexture(LayerRendererChromium* layerRenderer)
-{
-    // FIXME: This method should be separated into two: one to reserve an
-    // existing surface, and one to create a new one. That way we will not
-    // need to pass null layerRenderer.
-    if (layerRenderer) {
-        TextureManager* textureManager = layerRenderer->implTextureManager();
-
-        if (!m_contentsTexture)
-            m_contentsTexture = ManagedTexture::create(textureManager);
-    }
-
-    if (!m_contentsTexture)
-        return false;
-
-    if (m_contentsTexture->isReserved())
-        return true;
-
-    if (!m_contentsTexture->reserve(m_contentRect.size(), GraphicsContext3D::RGBA))
-        return false;
-
-    return true;
-}
-
-void CCRenderSurface::releaseContentsTexture()
-{
-    if (!m_contentsTexture || !m_contentsTexture->isReserved())
-        return;
-    m_contentsTexture->unreserve();
-}
-
-bool CCRenderSurface::hasValidContentsTexture() const
-{
-    return m_contentsTexture && m_contentsTexture->isReserved() && m_contentsTexture->isValid(m_contentRect.size(), GraphicsContext3D::RGBA);
-}
-
-bool CCRenderSurface::hasCachedContentsTexture() const
-{
-    return m_contentsTexture && m_contentsTexture->isValid(m_contentRect.size(), GraphicsContext3D::RGBA);
-}
-
-bool CCRenderSurface::prepareBackgroundTexture(LayerRendererChromium* layerRenderer)
-{
-    TextureManager* textureManager = layerRenderer->implTextureManager();
-
-    if (!m_backgroundTexture)
-        m_backgroundTexture = ManagedTexture::create(textureManager);
-
-    if (m_backgroundTexture->isReserved())
-        return true;
-
-    if (!m_backgroundTexture->reserve(m_contentRect.size(), GraphicsContext3D::RGBA))
-        return false;
-
-    return true;
-}
-
-void CCRenderSurface::releaseBackgroundTexture()
-{
-    if (!m_backgroundTexture || !m_backgroundTexture->isReserved())
-        return;
-    m_backgroundTexture->unreserve();
-}
-
-bool CCRenderSurface::hasValidBackgroundTexture() const
-{
-    return m_backgroundTexture && m_backgroundTexture->isReserved() && m_backgroundTexture->isValid(m_contentRect.size(), GraphicsContext3D::RGBA);
-}
-
 String CCRenderSurface::name() const
 {
@@ -303 +233 @@
 
     int maskTextureId = maskLayer ? maskLayer->contentsTextureId() : 0;
-
-    quadList.appendSurface(CCRenderPassDrawQuad::create(sharedQuadState, contentRect(), renderPass, forReplica, filters(), backgroundFilters(), maskTextureId));
+    IntRect contentsChangedSinceLastFrame = contentsChanged() ? m_contentRect : IntRect();
+
+    quadList.appendSurface(CCRenderPassDrawQuad::create(sharedQuadState, contentRect(), renderPass, forReplica, filters(), backgroundFilters(), maskTextureId, contentsChangedSinceLastFrame));
 }
 

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

@@ -32 +32 @@
 #include "FloatRect.h"
 #include "IntRect.h"
-#include "TextureManager.h"
 #include <public/WebFilterOperations.h>
 #include <public/WebTransformationMatrix.h>
@@ -46 +45 @@
 class CCLayerImpl;
 class LayerRendererChromium;
-class ManagedTexture;
 class TextStream;
 
@@ -54 +52 @@
     explicit CCRenderSurface(CCLayerImpl*);
     virtual ~CCRenderSurface();
-
-    virtual bool prepareContentsTexture(LayerRendererChromium*);
-    void releaseContentsTexture();
-    bool hasValidContentsTexture() const;
-    virtual bool hasCachedContentsTexture() const;
-
-    bool prepareBackgroundTexture(LayerRendererChromium*);
-    void releaseBackgroundTexture();
-    bool hasValidBackgroundTexture() const;
 
     String name() const;
@@ -117 +106 @@
     const IntRect& scissorRect() const { return m_scissorRect; }
 
-    virtual bool contentsChanged() const;
+    bool contentsChanged() const;
 
     void setContentRect(const IntRect&);
@@ -124 +113 @@
     void clearLayerList() { m_layerList.clear(); }
     Vector<CCLayerImpl*>& layerList() { return m_layerList; }
-
-    ManagedTexture* contentsTexture() const { return m_contentsTexture.get(); }
-    ManagedTexture* backgroundTexture() const { return m_backgroundTexture.get(); }
 
     int owningLayerId() const;
@@ -155 +141 @@
     IntRect m_contentRect;
     bool m_surfacePropertyChanged;
-
-    OwnPtr<ManagedTexture> m_contentsTexture;
-    OwnPtr<ManagedTexture> m_backgroundTexture;
 
     float m_drawOpacity;

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

@@ -73 +73 @@
 
     virtual void decideRenderPassAllocationsForFrame(const CCRenderPassList&) = 0;
+    virtual bool haveCachedResourcesForRenderPassId(int) const = 0;
+
     virtual void beginDrawingFrame(const CCRenderPass* defaultRenderPass) = 0;
     virtual void drawRenderPass(const CCRenderPass*, const FloatRect& rootScissorRectInCurrentPass) = 0;

trunk/Source/WebCore/platform/graphics/chromium/cc/CCTiledLayerImpl.cpp

@@ -30 +30 @@
 #include "cc/CCTiledLayerImpl.h"
 
+#include "GraphicsContext3D.h"
 #include "SkColor.h"
 #include "TextStream.h"
@@ -221 +222 @@
 }
 
-void CCTiledLayerImpl::pushTileProperties(int i, int j, Platform3DObject textureId, const IntRect& opaqueRect)
+void CCTiledLayerImpl::pushTileProperties(int i, int j, unsigned textureId, const IntRect& opaqueRect)
 {
     DrawableTile* tile = tileAt(i, j);

trunk/Source/WebCore/platform/graphics/chromium/cc/CCTiledLayerImpl.h

@@ -51 +51 @@
     void setSkipsDraw(bool skipsDraw) { m_skipsDraw = skipsDraw; }
     void setTilingData(const CCLayerTilingData& tiler);
-    void pushTileProperties(int, int, Platform3DObject textureId, const IntRect& opaqueRect);
+    void pushTileProperties(int, int, unsigned textureId, const IntRect& opaqueRect);
 
     void setContentsSwizzled(bool contentsSwizzled) { m_contentsSwizzled = contentsSwizzled; }

trunk/Source/WebKit/chromium/ChangeLog

@@ +1 @@
+2012-07-09  Dana Jansens  <danakj@chromium.org>
+
+        [chromium] Decouple RenderPass drawing from CCRenderSurface
+        https://bugs.webkit.org/show_bug.cgi?id=90573
+
+        Reviewed by Adrienne Walker.
+
+        * tests/CCLayerTreeHostImplTest.cpp:
+        * tests/LayerRendererChromiumTest.cpp:
+        (FakeCCRendererClient::FakeCCRendererClient):
+
 2012-07-09  Adam Klein  <adamk@chromium.org>
 

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

@@ -128 +128 @@
     void setupScrollAndContentsLayers(const IntSize& contentSize)
     {
-        OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
+        OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
         root->setScrollable(true);
         root->setScrollPosition(IntPoint(0, 0));
         root->setMaxScrollPosition(contentSize);
-        OwnPtr<CCLayerImpl> contents = CCLayerImpl::create(1);
+        OwnPtr<CCLayerImpl> contents = CCLayerImpl::create(2);
         contents->setDrawsContent(true);
         contents->setBounds(contentSize);
@@ -187 +187 @@
 {
     {
-        OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
-        root->addChild(CCLayerImpl::create(1));
+        OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
         root->addChild(CCLayerImpl::create(2));
-        root->children()[1]->addChild(CCLayerImpl::create(3));
+        root->addChild(CCLayerImpl::create(3));
         root->children()[1]->addChild(CCLayerImpl::create(4));
-        root->children()[1]->children()[0]->addChild(CCLayerImpl::create(5));
+        root->children()[1]->addChild(CCLayerImpl::create(5));
+        root->children()[1]->children()[0]->addChild(CCLayerImpl::create(6));
         m_hostImpl->setRootLayer(root.release());
     }
@@ -215 +215 @@
     IntSize scrollDelta(11, -15);
     {
-        OwnPtr<CCLayerImpl> root = CCLayerImpl::create(10);
+        OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
         root->setScrollPosition(scrollPosition);
         root->setScrollable(true);
@@ -264 +264 @@
 TEST_F(CCLayerTreeHostImplTest, replaceTreeWhileScrolling)
 {
-    const int scrollLayerId = 0;
+    const int scrollLayerId = 1;
 
     setupScrollAndContentsLayers(IntSize(100, 100));
@@ -626 +626 @@
         setDrawsContent(true);
         setSkipsDraw(false);
+        setVisibleLayerRect(IntRect(0, 0, 10, 10));
 
         OwnPtr<CCLayerTilingData> tiler = CCLayerTilingData::create(IntSize(100, 100), CCLayerTilingData::HasBorderTexels);
+        tiler->setBounds(contentBounds());
         setTilingData(*tiler.get());
     }
@@ -640 +642 @@
     // The root layer is always drawn, so run this test on a child layer that
     // will be masked out by the root layer's bounds.
-    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(0));
+    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(1));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
     root->setMasksToBounds(true);
 
-    root->addChild(DidDrawCheckLayer::create(1));
+    root->addChild(DidDrawCheckLayer::create(2));
     DidDrawCheckLayer* layer = static_cast<DidDrawCheckLayer*>(root->children()[0].get());
     // Ensure visibleLayerRect for layer is empty
@@ -687 +689 @@
     m_hostImpl->setViewportSize(bigSize);
 
-    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(0));
+    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(1));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
 
-    root->addChild(DidDrawCheckLayer::create(1));
+    root->addChild(DidDrawCheckLayer::create(2));
     DidDrawCheckLayer* occludedLayer = static_cast<DidDrawCheckLayer*>(root->children()[0].get());
 
-    root->addChild(DidDrawCheckLayer::create(2));
+    root->addChild(DidDrawCheckLayer::create(3));
     DidDrawCheckLayer* topLayer = static_cast<DidDrawCheckLayer*>(root->children()[1].get());
     // This layer covers the occludedLayer above. Make this layer large so it can occlude.
@@ -719 +721 @@
 TEST_F(CCLayerTreeHostImplTest, didDrawCalledOnAllLayers)
 {
-    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(0));
+    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(1));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
 
-    root->addChild(DidDrawCheckLayer::create(1));
+    root->addChild(DidDrawCheckLayer::create(2));
     DidDrawCheckLayer* layer1 = static_cast<DidDrawCheckLayer*>(root->children()[0].get());
 
-    layer1->addChild(DidDrawCheckLayer::create(2));
+    layer1->addChild(DidDrawCheckLayer::create(3));
     DidDrawCheckLayer* layer2 = static_cast<DidDrawCheckLayer*>(layer1->children()[0].get());
 
@@ -770 +772 @@
 {
     // When the texture is not missing, we draw as usual.
-    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(0));
+    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(1));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
-    root->addChild(MissingTextureAnimatingLayer::create(1, false, false, true));
+    root->addChild(MissingTextureAnimatingLayer::create(2, false, false, true));
 
     CCLayerTreeHostImpl::FrameData frame;
@@ -781 +783 @@
 
     // When a texture is missing and we're not animating, we draw as usual with checkerboarding.
-    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(0));
+    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(1));
     root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
-    root->addChild(MissingTextureAnimatingLayer::create(1, true, false, false));
+    root->addChild(MissingTextureAnimatingLayer::create(2, true, false, false));
 
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
@@ -790 +792 @@
 
     // When a texture is missing and we're animating, we don't want to draw anything.
-    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(0));
+    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(1));
     root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
-    root->addChild(MissingTextureAnimatingLayer::create(1, true, false, true));
+    root->addChild(MissingTextureAnimatingLayer::create(2, true, false, true));
 
     EXPECT_FALSE(m_hostImpl->prepareToDraw(frame));
@@ -799 +801 @@
 
     // When the layer skips draw and we're animating, we still draw the frame.
-    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(0));
+    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(1));
     root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
-    root->addChild(MissingTextureAnimatingLayer::create(1, false, true, true));
+    root->addChild(MissingTextureAnimatingLayer::create(2, false, true, true));
 
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
@@ -810 +812 @@
 TEST_F(CCLayerTreeHostImplTest, scrollRootIgnored)
 {
-    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
+    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
     root->setScrollable(false);
     m_hostImpl->setRootLayer(root.release());
@@ -834 +836 @@
     contentLayer->setContentBounds(IntSize(surfaceSize.width() * 2, surfaceSize.height() * 2));
 
-    OwnPtr<CCLayerImpl> scrollLayer = CCLayerImpl::create(0);
+    OwnPtr<CCLayerImpl> scrollLayer = CCLayerImpl::create(2);
     scrollLayer->setScrollable(true);
     scrollLayer->setMaxScrollPosition(surfaceSize);
@@ -853 +855 @@
 {
     IntSize surfaceSize(10, 10);
-    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
-    root->addChild(createScrollableLayer(1, FloatPoint(5, 5), surfaceSize));
+    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
+    root->addChild(createScrollableLayer(2, FloatPoint(5, 5), surfaceSize));
     m_hostImpl->setRootLayer(root.release());
     m_hostImpl->setViewportSize(surfaceSize);
@@ -869 +871 @@
 {
     IntSize surfaceSize(10, 10);
-    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
-    root->addChild(createScrollableLayer(1, FloatPoint(5, 5), surfaceSize));
+    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
+    root->addChild(createScrollableLayer(2, FloatPoint(5, 5), surfaceSize));
     m_hostImpl->setRootLayer(root.release());
     m_hostImpl->setViewportSize(surfaceSize);
@@ -884 +886 @@
 {
     IntSize surfaceSize(10, 10);
-    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
-    OwnPtr<CCLayerImpl> child = createScrollableLayer(1, FloatPoint(5, 5), surfaceSize);
+    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
+    OwnPtr<CCLayerImpl> child = createScrollableLayer(2, FloatPoint(5, 5), surfaceSize);
     m_hostImpl->setViewportSize(surfaceSize);
 
@@ -907 +909 @@
 {
     IntSize surfaceSize(10, 10);
-    OwnPtr<CCLayerImpl> contentLayer = createScrollableLayer(0, FloatPoint(5, 5), surfaceSize);
+    OwnPtr<CCLayerImpl> contentLayer = createScrollableLayer(1, FloatPoint(5, 5), surfaceSize);
     contentLayer->setShouldScrollOnMainThread(true);
     contentLayer->setScrollable(false);
 
-    OwnPtr<CCLayerImpl> scrollLayer = createScrollableLayer(1, FloatPoint(5, 5), surfaceSize);
+    OwnPtr<CCLayerImpl> scrollLayer = createScrollableLayer(2, FloatPoint(5, 5), surfaceSize);
     scrollLayer->addChild(contentLayer.release());
 
@@ -926 +928 @@
     IntSize surfaceSize(10, 10);
     float pageScale = 2;
-    OwnPtr<CCLayerImpl> root = createScrollableLayer(0, FloatPoint(5, 5), surfaceSize);
+    OwnPtr<CCLayerImpl> root = createScrollableLayer(1, FloatPoint(5, 5), surfaceSize);
     m_hostImpl->setRootLayer(root.release());
     m_hostImpl->setViewportSize(surfaceSize);
@@ -944 +946 @@
     expectedScrollDelta.scale(pageScale);
     OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
-    expectContains(*scrollInfo.get(), 0, expectedScrollDelta);
+    expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedScrollDelta);
 
     // The scroll range should also have been updated.
@@ -957 +959 @@
     IntSize surfaceSize(10, 10);
     float pageScale = 2;
-    OwnPtr<CCLayerImpl> root = createScrollableLayer(0, FloatPoint(5, 5), surfaceSize);
+    OwnPtr<CCLayerImpl> root = createScrollableLayer(1, FloatPoint(5, 5), surfaceSize);
     m_hostImpl->setRootLayer(root.release());
     m_hostImpl->setViewportSize(surfaceSize);
@@ -977 +979 @@
     // The scroll delta is not scaled because the main thread did not scale.
     OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
-    expectContains(*scrollInfo.get(), 0, expectedScrollDelta);
+    expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedScrollDelta);
 
     // The scroll range should also have been updated.
@@ -989 +991 @@
 {
     IntSize surfaceSize(10, 10);
-    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
+    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
     // Also mark the root scrollable so it becomes the root scroll layer.
     root->setScrollable(true);
-    root->addChild(createScrollableLayer(1, FloatPoint(5, 5), surfaceSize));
+    int scrollLayerId = 2;
+    root->addChild(createScrollableLayer(scrollLayerId, FloatPoint(5, 5), surfaceSize));
     m_hostImpl->setRootLayer(root.release());
     m_hostImpl->setViewportSize(surfaceSize);
@@ -1012 +1015 @@
     expectedScrollDelta.scale(pageScale);
     OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
-    expectContains(*scrollInfo.get(), 1, expectedScrollDelta);
+    expectContains(*scrollInfo.get(), scrollLayerId, expectedScrollDelta);
 
     // The scroll range should not have changed.
@@ -1027 +1030 @@
     // scroll.
     IntSize surfaceSize(10, 10);
-    OwnPtr<CCLayerImpl> root = createScrollableLayer(0, FloatPoint(5, 5), surfaceSize);
-
-    OwnPtr<CCLayerImpl> grandChild = createScrollableLayer(2, FloatPoint(5, 5), surfaceSize);
+    OwnPtr<CCLayerImpl> root = createScrollableLayer(1, FloatPoint(5, 5), surfaceSize);
+
+    OwnPtr<CCLayerImpl> grandChild = createScrollableLayer(3, FloatPoint(5, 5), surfaceSize);
     grandChild->setScrollPosition(IntPoint(0, 5));
 
-    OwnPtr<CCLayerImpl> child = createScrollableLayer(1, FloatPoint(5, 5), surfaceSize);
+    OwnPtr<CCLayerImpl> child = createScrollableLayer(2, FloatPoint(5, 5), surfaceSize);
     child->setScrollPosition(IntPoint(3, 0));
     child->addChild(grandChild.release());
@@ -1063 +1066 @@
     // should be applied to one of its ancestors if possible.
     IntSize surfaceSize(10, 10);
-    OwnPtr<CCLayerImpl> root = createScrollableLayer(0, FloatPoint(5, 5), surfaceSize);
-    OwnPtr<CCLayerImpl> child = createScrollableLayer(1, FloatPoint(5, 5), surfaceSize);
+    OwnPtr<CCLayerImpl> root = createScrollableLayer(1, FloatPoint(5, 5), surfaceSize);
+    OwnPtr<CCLayerImpl> child = createScrollableLayer(2, FloatPoint(5, 5), surfaceSize);
 
     child->setScrollable(false);
@@ -1089 +1092 @@
 {
     IntSize surfaceSize(10, 10);
-    m_hostImpl->setRootLayer(createScrollableLayer(0, FloatPoint(5, 5), surfaceSize));
+    m_hostImpl->setRootLayer(createScrollableLayer(1, FloatPoint(5, 5), surfaceSize));
     m_hostImpl->setViewportSize(surfaceSize);
 
@@ -1095 +1098 @@
     initializeLayerRendererAndDrawFrame();
     m_hostImpl->detachLayerTree();
-    m_hostImpl->setRootLayer(createScrollableLayer(0, FloatPoint(5, 5), surfaceSize));
+    m_hostImpl->setRootLayer(createScrollableLayer(2, FloatPoint(5, 5), surfaceSize));
 
     // Scrolling should still work even though we did not draw yet.
@@ -1187 +1190 @@
 
     {
-        OwnPtr<CCLayerImpl> root = CCLayerImpl::create(0);
+        OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
         root->setAnchorPoint(FloatPoint(0, 0));
         root->setBounds(IntSize(10, 10));
@@ -1196 +1199 @@
     CCLayerImpl* root = m_hostImpl->rootLayer();
 
-    root->addChild(BlendStateCheckLayer::create(1));
+    root->addChild(BlendStateCheckLayer::create(2));
     BlendStateCheckLayer* layer1 = static_cast<BlendStateCheckLayer*>(root->children()[0].get());
 
@@ -1248 +1251 @@
     m_hostImpl->didDrawAllLayers(frame);
 
-    layer1->addChild(BlendStateCheckLayer::create(2));
+    layer1->addChild(BlendStateCheckLayer::create(3));
     BlendStateCheckLayer* layer2 = static_cast<BlendStateCheckLayer*>(layer1->children()[0].get());
 
@@ -1408 +1411 @@
     m_hostImpl->setViewportSize(viewportSize);
 
-    m_hostImpl->setRootLayer(BlendStateCheckLayer::create(0));
+    m_hostImpl->setRootLayer(BlendStateCheckLayer::create(1));
     BlendStateCheckLayer* root = static_cast<BlendStateCheckLayer*>(m_hostImpl->rootLayer());
     root->setExpectation(false, true);
@@ -1998 +2001 @@
 TEST_F(CCLayerTreeHostImplTest, contextLostAndRestoredNotificationSentToAllLayers)
 {
-    m_hostImpl->setRootLayer(ContextLostNotificationCheckLayer::create(0));
+    m_hostImpl->setRootLayer(ContextLostNotificationCheckLayer::create(1));
     ContextLostNotificationCheckLayer* root = static_cast<ContextLostNotificationCheckLayer*>(m_hostImpl->rootLayer());
 
@@ -2201 +2204 @@
 TEST_F(CCLayerTreeHostImplTest, dontUseOldResourcesAfterLostContext)
 {
-    OwnPtr<CCLayerImpl> rootLayer(CCLayerImpl::create(0));
-    rootLayer->setBounds(IntSize(10, 10));
-    rootLayer->setAnchorPoint(FloatPoint(0, 0));
-
-    OwnPtr<CCTiledLayerImpl> tileLayer = CCTiledLayerImpl::create(1);
-    tileLayer->setBounds(IntSize(10, 10));
-    tileLayer->setAnchorPoint(FloatPoint(0, 0));
-    tileLayer->setContentBounds(IntSize(10, 10));
-    tileLayer->setDrawsContent(true);
-    tileLayer->setSkipsDraw(false);
-    OwnPtr<CCLayerTilingData> tilingData(CCLayerTilingData::create(IntSize(10, 10), CCLayerTilingData::NoBorderTexels));
-    tilingData->setBounds(IntSize(10, 10));
-    tileLayer->setTilingData(*tilingData);
-    tileLayer->pushTileProperties(0, 0, 1, IntRect(0, 0, 10, 10));
-    rootLayer->addChild(tileLayer.release());
-
-    OwnPtr<CCTextureLayerImpl> textureLayer = CCTextureLayerImpl::create(2);
-    textureLayer->setBounds(IntSize(10, 10));
-    textureLayer->setAnchorPoint(FloatPoint(0, 0));
-    textureLayer->setContentBounds(IntSize(10, 10));
-    textureLayer->setDrawsContent(true);
-    textureLayer->setTextureId(1);
-    rootLayer->addChild(textureLayer.release());
-
-    FakeVideoFrameProvider provider;
-    OwnPtr<CCVideoLayerImpl> videoLayer = CCVideoLayerImpl::create(3, &provider);
-    videoLayer->setBounds(IntSize(10, 10));
-    videoLayer->setAnchorPoint(FloatPoint(0, 0));
-    videoLayer->setContentBounds(IntSize(10, 10));
-    videoLayer->setDrawsContent(true);
-    videoLayer->setLayerTreeHostImpl(m_hostImpl.get());
-    rootLayer->addChild(videoLayer.release());
-
-    OwnPtr<CCIOSurfaceLayerImpl> ioSurfaceLayer = CCIOSurfaceLayerImpl::create(4);
-    ioSurfaceLayer->setBounds(IntSize(10, 10));
-    ioSurfaceLayer->setAnchorPoint(FloatPoint(0, 0));
-    ioSurfaceLayer->setContentBounds(IntSize(10, 10));
-    ioSurfaceLayer->setDrawsContent(true);
-    ioSurfaceLayer->setIOSurfaceProperties(1, IntSize(10, 10));
-    ioSurfaceLayer->setLayerTreeHostImpl(m_hostImpl.get());
-    rootLayer->addChild(ioSurfaceLayer.release());
-
-    // Use a context that supports IOSurfaces
-    m_hostImpl->initializeLayerRenderer(CCGraphicsContext::create3D(adoptPtr(new FakeWebGraphicsContext3DWithIOSurface)), UnthrottledUploader);
-
-    m_hostImpl->setRootLayer(rootLayer.release());
-
-    CCLayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
-    m_hostImpl->drawLayers(frame);
-    m_hostImpl->didDrawAllLayers(frame);
-    m_hostImpl->swapBuffers();
-
-    // Lose the context, replacing it with a StrictWebGraphicsContext3DWithIOSurface,
-    // that will warn if any resource from the previous context gets used.
-    m_hostImpl->initializeLayerRenderer(CCGraphicsContext::create3D(adoptPtr(new StrictWebGraphicsContext3DWithIOSurface)), UnthrottledUploader);
-    EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
-    m_hostImpl->drawLayers(frame);
-    m_hostImpl->didDrawAllLayers(frame);
-    m_hostImpl->swapBuffers();
-}
-
-// Fake WebGraphicsContext3D that tracks the number of textures in use.
-class TrackingWebGraphicsContext3D : public FakeWebGraphicsContext3D {
-public:
-    TrackingWebGraphicsContext3D()
-        : FakeWebGraphicsContext3D()
-        , m_numTextures(0)
-    { }
-
-    virtual WebGLId createTexture() OVERRIDE
-    {
-        WebGLId id = FakeWebGraphicsContext3D::createTexture();
-
-        m_textures.set(id, true);
-        ++m_numTextures;
-        return id;
-    }
-
-    virtual void deleteTexture(WebGLId id) OVERRIDE
-    {
-        if (!m_textures.get(id))
-            return;
-
-        m_textures.set(id, false);
-        --m_numTextures;
-    }
-
-    virtual WebString getString(WGC3Denum name) OVERRIDE
-    {
-        if (name == WebCore::GraphicsContext3D::EXTENSIONS)
-            return WebString("GL_CHROMIUM_iosurface GL_ARB_texture_rectangle");
-
-        return WebString();
-    }
-
-    unsigned numTextures() const { return m_numTextures; }
-
-private:
-    HashMap<WebGLId, bool> m_textures;
-    unsigned m_numTextures;
-};
-
-TEST_F(CCLayerTreeHostImplTest, layersFreeTextures)
-{
     OwnPtr<CCLayerImpl> rootLayer(CCLayerImpl::create(1));
     rootLayer->setBounds(IntSize(10, 10));
@@ -2348 +2246 @@
     rootLayer->addChild(ioSurfaceLayer.release());
 
+    // Use a context that supports IOSurfaces
+    m_hostImpl->initializeLayerRenderer(CCGraphicsContext::create3D(adoptPtr(new FakeWebGraphicsContext3DWithIOSurface)), UnthrottledUploader);
+
+    m_hostImpl->setRootLayer(rootLayer.release());
+
+    CCLayerTreeHostImpl::FrameData frame;
+    EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
+    m_hostImpl->drawLayers(frame);
+    m_hostImpl->didDrawAllLayers(frame);
+    m_hostImpl->swapBuffers();
+
+    // Lose the context, replacing it with a StrictWebGraphicsContext3DWithIOSurface,
+    // that will warn if any resource from the previous context gets used.
+    m_hostImpl->initializeLayerRenderer(CCGraphicsContext::create3D(adoptPtr(new StrictWebGraphicsContext3DWithIOSurface)), UnthrottledUploader);
+    EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
+    m_hostImpl->drawLayers(frame);
+    m_hostImpl->didDrawAllLayers(frame);
+    m_hostImpl->swapBuffers();
+}
+
+// Fake WebGraphicsContext3D that tracks the number of textures in use.
+class TrackingWebGraphicsContext3D : public FakeWebGraphicsContext3D {
+public:
+    TrackingWebGraphicsContext3D()
+        : FakeWebGraphicsContext3D()
+        , m_numTextures(0)
+    { }
+
+    virtual WebGLId createTexture() OVERRIDE
+    {
+        WebGLId id = FakeWebGraphicsContext3D::createTexture();
+
+        m_textures.set(id, true);
+        ++m_numTextures;
+        return id;
+    }
+
+    virtual void deleteTexture(WebGLId id) OVERRIDE
+    {
+        if (!m_textures.get(id))
+            return;
+
+        m_textures.set(id, false);
+        --m_numTextures;
+    }
+
+    virtual WebString getString(WGC3Denum name) OVERRIDE
+    {
+        if (name == WebCore::GraphicsContext3D::EXTENSIONS)
+            return WebString("GL_CHROMIUM_iosurface GL_ARB_texture_rectangle");
+
+        return WebString();
+    }
+
+    unsigned numTextures() const { return m_numTextures; }
+
+private:
+    HashMap<WebGLId, bool> m_textures;
+    unsigned m_numTextures;
+};
+
+TEST_F(CCLayerTreeHostImplTest, layersFreeTextures)
+{
+    OwnPtr<CCLayerImpl> rootLayer(CCLayerImpl::create(1));
+    rootLayer->setBounds(IntSize(10, 10));
+    rootLayer->setAnchorPoint(FloatPoint(0, 0));
+
+    OwnPtr<CCTiledLayerImpl> tileLayer = CCTiledLayerImpl::create(2);
+    tileLayer->setBounds(IntSize(10, 10));
+    tileLayer->setAnchorPoint(FloatPoint(0, 0));
+    tileLayer->setContentBounds(IntSize(10, 10));
+    tileLayer->setDrawsContent(true);
+    tileLayer->setSkipsDraw(false);
+    OwnPtr<CCLayerTilingData> tilingData(CCLayerTilingData::create(IntSize(10, 10), CCLayerTilingData::NoBorderTexels));
+    tilingData->setBounds(IntSize(10, 10));
+    tileLayer->setTilingData(*tilingData);
+    tileLayer->pushTileProperties(0, 0, 1, IntRect(0, 0, 10, 10));
+    rootLayer->addChild(tileLayer.release());
+
+    OwnPtr<CCTextureLayerImpl> textureLayer = CCTextureLayerImpl::create(3);
+    textureLayer->setBounds(IntSize(10, 10));
+    textureLayer->setAnchorPoint(FloatPoint(0, 0));
+    textureLayer->setContentBounds(IntSize(10, 10));
+    textureLayer->setDrawsContent(true);
+    textureLayer->setTextureId(1);
+    rootLayer->addChild(textureLayer.release());
+
+    FakeVideoFrameProvider provider;
+    OwnPtr<CCVideoLayerImpl> videoLayer = CCVideoLayerImpl::create(4, &provider);
+    videoLayer->setBounds(IntSize(10, 10));
+    videoLayer->setAnchorPoint(FloatPoint(0, 0));
+    videoLayer->setContentBounds(IntSize(10, 10));
+    videoLayer->setDrawsContent(true);
+    videoLayer->setLayerTreeHostImpl(m_hostImpl.get());
+    rootLayer->addChild(videoLayer.release());
+
+    OwnPtr<CCIOSurfaceLayerImpl> ioSurfaceLayer = CCIOSurfaceLayerImpl::create(5);
+    ioSurfaceLayer->setBounds(IntSize(10, 10));
+    ioSurfaceLayer->setAnchorPoint(FloatPoint(0, 0));
+    ioSurfaceLayer->setContentBounds(IntSize(10, 10));
+    ioSurfaceLayer->setDrawsContent(true);
+    ioSurfaceLayer->setIOSurfaceProperties(1, IntSize(10, 10));
+    ioSurfaceLayer->setLayerTreeHostImpl(m_hostImpl.get());
+    rootLayer->addChild(ioSurfaceLayer.release());
+
     // Lose the context, replacing it with a TrackingWebGraphicsContext3D (which the CCLayerTreeHostImpl takes ownership of).
     OwnPtr<CCGraphicsContext> ccContext(CCGraphicsContext::create3D(adoptPtr(new TrackingWebGraphicsContext3D)));
@@ -2466 +2469 @@
 }
 
+class LayerRendererChromiumWithReleaseTextures : public LayerRendererChromium {
+public:
+    using LayerRendererChromium::releaseRenderPassTextures;
+};
+
 TEST_F(CCLayerTreeHostImplTest, surfaceTextureCaching)
 {
@@ -2549 +2557 @@
     }
 
-    // Change opacity again, but evict the cached surface texture
+    // Change opacity again, and evict the cached surface texture.
     surfaceLayerPtr->setOpacity(0.5f);
-    ManagedTexture* contentsTexture = surfaceLayerPtr->renderSurface()->contentsTexture();
-    ASSERT_TRUE(contentsTexture->isValid(contentsTexture->size(), contentsTexture->format()));
-    CCRenderer* renderer = myHostImpl->layerRenderer();
-    TextureManager* textureManager = renderer->implTextureManager();
-    size_t maxMemoryLimit = textureManager->maxMemoryLimitBytes();
-
-    // This should evice all cached surfaces
-    textureManager->setMaxMemoryLimitBytes(0);
-
-    // Restore original limit
-    textureManager->setMaxMemoryLimitBytes(maxMemoryLimit);
-
-    // Was our surface evicted?
-    ASSERT_FALSE(contentsTexture->isValid(contentsTexture->size(), contentsTexture->format()));
+    static_cast<LayerRendererChromiumWithReleaseTextures*>(myHostImpl->layerRenderer())->releaseRenderPassTextures();
 
     // Change opacity and draw
@@ -2583 +2578 @@
         CCRenderPassDrawQuad* quad = static_cast<CCRenderPassDrawQuad*>(frame.renderPasses[1]->quadList()[0].get());
         EXPECT_FALSE(quad->renderPass()->targetSurface()->contentsChanged());
+
+        // Was our surface evicted?
+        EXPECT_FALSE(myHostImpl->layerRenderer()->haveCachedResourcesForRenderPassId(quad->renderPass()->id()));
 
         myHostImpl->drawLayers(frame);
@@ -2707 +2705 @@
     }
 
-    // Change opacity again, but evict the cached surface texture
+    // Change opacity again, and evict the cached surface texture.
     surfaceLayerPtr->setOpacity(0.5f);
-    ManagedTexture* contentsTexture = surfaceLayerPtr->renderSurface()->contentsTexture();
-    ASSERT_TRUE(contentsTexture->isValid(contentsTexture->size(), contentsTexture->format()));
-    CCRenderer* renderer = myHostImpl->layerRenderer();
-    TextureManager* textureManager = renderer->implTextureManager();
-    size_t maxMemoryLimit = textureManager->maxMemoryLimitBytes();
-
-    // This should evice all cached surfaces
-    textureManager->setMaxMemoryLimitBytes(0);
-
-    // Restore original limit
-    textureManager->setMaxMemoryLimitBytes(maxMemoryLimit);
-
-    // Was our surface evicted?
-    ASSERT_FALSE(contentsTexture->isValid(contentsTexture->size(), contentsTexture->format()));
+    static_cast<LayerRendererChromiumWithReleaseTextures*>(myHostImpl->layerRenderer())->releaseRenderPassTextures();
 
     // Change opacity and draw
@@ -2741 +2726 @@
         CCRenderPassDrawQuad* quad = static_cast<CCRenderPassDrawQuad*>(frame.renderPasses[1]->quadList()[0].get());
         EXPECT_FALSE(quad->renderPass()->targetSurface()->contentsChanged());
+
+        // Was our surface evicted?
+        EXPECT_FALSE(myHostImpl->layerRenderer()->haveCachedResourcesForRenderPassId(quad->renderPass()->id()));
 
         myHostImpl->drawLayers(frame);
@@ -2899 +2887 @@
 };
 
-class FakeRenderSurface : public CCRenderSurface {
-private:
-    bool m_hasCachedTexture;
-    bool m_contentsChanged;
-
-public:
-    FakeRenderSurface(CCLayerImpl* layerImpl)
-        : CCRenderSurface(layerImpl),
-          m_hasCachedTexture(false)
-    {
-    }
-
-    virtual bool hasCachedContentsTexture() const OVERRIDE
-    {
-        return m_hasCachedTexture;
-    }
-
-    virtual bool prepareContentsTexture(LayerRendererChromium* lrc) OVERRIDE
-    {
-        return true;
-    }
-
-    virtual bool contentsChanged() const OVERRIDE
-    {
-        return m_contentsChanged;
-    }
-
-    void setHasCachedTexture(bool hasCachedTexture)
-    {
-        m_hasCachedTexture = hasCachedTexture;
-    }
-
-    void setContentsChanged(bool contentsChanged)
-    {
-        m_contentsChanged = contentsChanged;
-    }
-};
-
 class CCTestRenderPass: public CCRenderPass {
 public:
-    static PassOwnPtr<CCRenderPass> create(CCRenderSurface* targetSurface)
-    {
-        return adoptPtr(new CCTestRenderPass(targetSurface));
-    }
+    static PassOwnPtr<CCRenderPass> create(CCRenderSurface* targetSurface, int id) { return adoptPtr(new CCTestRenderPass(targetSurface, id)); }
+
+    void appendQuad(PassOwnPtr<CCDrawQuad> quad) { m_quadList.append(quad); }
 
 protected:
-    CCTestRenderPass(CCRenderSurface* surface)
-        : CCRenderPass(surface)
-    {
-    }
-
+    CCTestRenderPass(CCRenderSurface* targetSurface, int id) : CCRenderPass(targetSurface, id) { }
+};
+
+class CCTestRenderer : public LayerRendererChromium, public CCRendererClient {
 public:
-    void appendQuad(PassOwnPtr<CCDrawQuad> quad)
-    {
-        m_quadList.append(quad);
-    }
+    static PassOwnPtr<CCTestRenderer> create(WebKit::WebGraphicsContext3D* context)
+    {
+        OwnPtr<CCTestRenderer> renderer(adoptPtr(new CCTestRenderer(context)));
+        if (!renderer->initialize())
+            return nullptr;
+
+        return renderer.release();
+    }
+
+    void clearCachedTextures() { m_textures.clear(); }
+    void setHaveCachedResourcesForRenderPassId(int id) { m_textures.add(id); }
+
+    virtual bool haveCachedResourcesForRenderPassId(int id) const OVERRIDE { return m_textures.contains(id); }
+
+    // CCRendererClient implementation.
+    virtual const IntSize& deviceViewportSize() const OVERRIDE { return m_viewportSize; }
+    virtual const CCLayerTreeSettings& settings() const OVERRIDE { return m_settings; }
+    virtual void didLoseContext() OVERRIDE { }
+    virtual void onSwapBuffersComplete() OVERRIDE { }
+    virtual void setFullRootLayerDamage() OVERRIDE { }
+    virtual void releaseContentsTextures() OVERRIDE { }
+    virtual void setMemoryAllocationLimitBytes(size_t) OVERRIDE { }
+
+protected:
+    CCTestRenderer(WebKit::WebGraphicsContext3D* context) : LayerRendererChromium(this, context, UnthrottledUploader) { }
+
+private:
+    CCLayerTreeSettings m_settings;
+    IntSize m_viewportSize;
+    HashSet<int> m_textures;
 };
 
-static PassOwnPtr<CCRenderPass> createDummyRenderPass(RenderPassRemovalTestData& testData)
-{
-    OwnPtr<CCLayerImpl> layerImpl = CCLayerImpl::create(1);
-    CCRenderSurface* renderSurface = new FakeRenderSurface(layerImpl.get());
-    OwnPtr<CCRenderPass> renderPassPtr = CCTestRenderPass::create(renderSurface);
-
-    testData.renderSurfaceStore.append(adoptPtr(renderSurface));
+static PassOwnPtr<CCRenderPass> createDummyRenderPass(RenderPassRemovalTestData& testData, int id)
+{
+    OwnPtr<CCLayerImpl> layerImpl(CCLayerImpl::create(id));
+    OwnPtr<CCRenderSurface> renderSurface(adoptPtr(new CCRenderSurface(layerImpl.get())));
+    OwnPtr<CCRenderPass> renderPassPtr(CCTestRenderPass::create(renderSurface.get(), layerImpl->id()));
+
+    testData.renderSurfaceStore.append(renderSurface.release());
     testData.layerStore.append(layerImpl.release());
     return renderPassPtr.release();
 }
 
-static void configureRenderPassTestData(const char* testScript, RenderPassRemovalTestData& testData)
-{
+static void configureRenderPassTestData(const char* testScript, RenderPassRemovalTestData& testData, CCTestRenderer* renderer)
+{
+    renderer->clearCachedTextures();
+
     // One shared state for all quads - we don't need the correct details
     testData.sharedQuadState = CCSharedQuadState::create(WebTransformationMatrix(), WebTransformationMatrix(), IntRect(), IntRect(), 1.0, true);
@@ -2976 +2952 @@
 
     // Pre-create root pass
-    OwnPtr<CCRenderPass> rootRenderPass = createDummyRenderPass(testData);
-    testData.renderPassId.insert(std::pair<CCRenderPass*, char>(rootRenderPass.get(), testScript[0]));
-    testData.renderPassCache.insert(std::pair<char, RenderPassCacheEntry>(testScript[0], RenderPassCacheEntry(rootRenderPass.release())));
-    while (*currentChar != '\0') {
+    char rootRenderPassId = testScript[0];
+    OwnPtr<CCRenderPass> rootRenderPass = createDummyRenderPass(testData, rootRenderPassId);
+    testData.renderPassId.insert(std::pair<CCRenderPass*, char>(rootRenderPass.get(), rootRenderPassId));
+    testData.renderPassCache.insert(std::pair<char, RenderPassCacheEntry>(rootRenderPassId, RenderPassCacheEntry(rootRenderPass.release())));
+    while (*currentChar) {
         char renderPassId = currentChar[0];
         currentChar++;
@@ -2992 +2969 @@
 
         // Cycle through quad data and create all quads
-        while (*currentChar != '\n' && *currentChar != '\0') {
+        while (*currentChar && *currentChar != '\n') {
             if (*currentChar == 's') {
                 // Solid color draw quad
@@ -3002 +2979 @@
                 // RenderPass draw quad
                 char newRenderPassId = *currentChar;
+                ASSERT_NE(rootRenderPassId, newRenderPassId);
                 currentChar++;
                 bool hasTexture = false;
@@ -3008 +2986 @@
                 if (*currentChar == '[') {
                     currentChar++;
-                    while ((*currentChar != ']') && (*currentChar != '\0')) {
+                    while (*currentChar && *currentChar != ']') {
                         switch (*currentChar) {
                         case 'c':
@@ -3026 +3004 @@
 
                 if (testData.renderPassCache.find(newRenderPassId) == testData.renderPassCache.end()) {
-                    OwnPtr<CCRenderPass> refRenderPass = createDummyRenderPass(testData);
+                    if (hasTexture)
+                        renderer->setHaveCachedResourcesForRenderPassId(newRenderPassId);
+
+                    OwnPtr<CCRenderPass> refRenderPass = createDummyRenderPass(testData, newRenderPassId);
                     refRenderPassPtr = refRenderPass.get();
-                    FakeRenderSurface* refRenderSurface = static_cast<FakeRenderSurface*>(refRenderPass->targetSurface());
-                    refRenderSurface->setHasCachedTexture(hasTexture);
-                    refRenderSurface->setContentsChanged(contentsChanged);
                     testData.renderPassId.insert(std::pair<CCRenderPass*, char>(refRenderPass.get(), newRenderPassId));
                     testData.renderPassCache.insert(std::pair<char, RenderPassCacheEntry>(newRenderPassId, RenderPassCacheEntry(refRenderPass.release())));
@@ -3036 +3014 @@
                     refRenderPassPtr = testData.renderPassCache[newRenderPassId].renderPass;
 
-                OwnPtr<CCRenderPassDrawQuad> quad = CCRenderPassDrawQuad::create(testData.sharedQuadState.get(), IntRect(), refRenderPassPtr, isReplica, WebKit::WebFilterOperations(), WebKit::WebFilterOperations(), 1);
+                IntRect quadRect = IntRect(0, 0, 1, 1);
+                IntRect contentsChangedRect = contentsChanged ? quadRect : IntRect();
+                OwnPtr<CCRenderPassDrawQuad> quad = CCRenderPassDrawQuad::create(testData.sharedQuadState.get(), quadRect, refRenderPassPtr, isReplica, WebKit::WebFilterOperations(), WebKit::WebFilterOperations(), 1, contentsChangedRect);
                 static_cast<CCTestRenderPass*>(renderPass.get())->appendQuad(quad.release());
             }
         }
         testData.renderPassList.insert(0, renderPass.release());
-        if (*currentChar != '\0')
+        if (*currentChar)
             currentChar++;
     }
@@ -3064 +3044 @@
                 pos++;
                 break;
-            case CCDrawQuad::RenderPass:
-                {
-                    CCRenderPassDrawQuad* renderPassDrawQuad = static_cast<CCRenderPassDrawQuad*>(currentQuad);
-                    const CCRenderPass* refPass = renderPassDrawQuad->renderPass();
-                    char refPassId = testData.renderPassId.find(refPass)->second;
-                    *pos = refPassId;
-                    pos++;
-                }
+            case CCDrawQuad::RenderPass: {
+                CCRenderPassDrawQuad* renderPassDrawQuad = static_cast<CCRenderPassDrawQuad*>(currentQuad);
+                const CCRenderPass* refPass = renderPassDrawQuad->renderPass();
+                char refPassId = testData.renderPassId.find(refPass)->second;
+                *pos = refPassId;
+                pos++;
                 break;
+            }
             default:
                 *pos = 'x';
@@ -3236 +3215 @@
 }
 
-TEST(RenderPassRemovalTest, testRemoveRenderPasses)
-{
+TEST_F(CCLayerTreeHostImplTest, testRemoveRenderPasses)
+{
+    OwnPtr<CCGraphicsContext> context(createContext());
+    WebKit::WebGraphicsContext3D* context3d = context->context3D();
+    ASSERT_TRUE(context3d);
+    OwnPtr<CCTestRenderer> renderer(CCTestRenderer::create(context3d));
+
     int testCaseIndex = 0;
     while (removeRenderPassesCases[testCaseIndex].name) {
-        DebugScopedSetImplThread implThread;
         RenderPassRemovalTestData testData;
         CCRenderPassList skippedPasses;
-        configureRenderPassTestData(removeRenderPassesCases[testCaseIndex].initScript, testData);
-        CCLayerTreeHostImpl::removePassesWithCachedTextures(testData.renderPassList, skippedPasses);
+        configureRenderPassTestData(removeRenderPassesCases[testCaseIndex].initScript, testData, renderer.get());
+        CCLayerTreeHostImpl::removePassesWithCachedTextures(testData.renderPassList, skippedPasses, renderer.get());
         verifyRenderPassTestData(removeRenderPassesCases[testCaseIndex], testData);
         testCaseIndex++;

trunk/Source/WebKit/chromium/tests/CCOcclusionTrackerTest.cpp

@@ -157 +157 @@
 };
 
-int CCOcclusionTrackerTestImplThreadTypes::nextCCLayerImplId = 0;
+int CCOcclusionTrackerTestImplThreadTypes::nextCCLayerImplId = 1;
 
 template<typename Types, bool opaqueLayers>

trunk/Source/WebKit/chromium/tests/CCQuadCullerTest.cpp

@@ -61 +61 @@
 static PassOwnPtr<CCTiledLayerImpl> makeLayer(CCTiledLayerImpl* parent, const WebTransformationMatrix& drawTransform, const IntRect& layerRect, float opacity, bool opaque, const IntRect& layerOpaqueRect, Vector<CCLayerImpl*>& surfaceLayerList)
 {
-    OwnPtr<CCTiledLayerImpl> layer = CCTiledLayerImpl::create(0);
+    OwnPtr<CCTiledLayerImpl> layer = CCTiledLayerImpl::create(1);
     OwnPtr<CCLayerTilingData> tiler = CCLayerTilingData::create(IntSize(100, 100), CCLayerTilingData::NoBorderTexels);
     tiler->setBounds(layerRect.size());

trunk/Source/WebKit/chromium/tests/CCRenderSurfaceTest.cpp

@@ -58 +58 @@
     DebugScopedSetImplThread setImplThread;
 
-    OwnPtr<CCLayerImpl> owningLayer = CCLayerImpl::create(0);
+    OwnPtr<CCLayerImpl> owningLayer = CCLayerImpl::create(1);
     owningLayer->createRenderSurface();
     ASSERT_TRUE(owningLayer->renderSurface());
@@ -96 +96 @@
     DebugScopedSetImplThread setImplThread;
 
-    OwnPtr<CCLayerImpl> owningLayer = CCLayerImpl::create(0);
+    OwnPtr<CCLayerImpl> owningLayer = CCLayerImpl::create(1);
     owningLayer->createRenderSurface();
     ASSERT_TRUE(owningLayer->renderSurface());

trunk/Source/WebKit/chromium/tests/CCSolidColorLayerImplTest.cpp

@@ -48 +48 @@
     IntRect visibleLayerRect = IntRect(IntPoint(), layerSize);
 
-    OwnPtr<CCSolidColorLayerImpl> layer = CCSolidColorLayerImpl::create(0);
+    OwnPtr<CCSolidColorLayerImpl> layer = CCSolidColorLayerImpl::create(1);
     layer->setVisibleLayerRect(visibleLayerRect);
     layer->setBounds(layerSize);
@@ -69 +69 @@
     IntRect visibleLayerRect = IntRect(IntPoint(), layerSize);
 
-    OwnPtr<CCSolidColorLayerImpl> layer = CCSolidColorLayerImpl::create(0);
+    OwnPtr<CCSolidColorLayerImpl> layer = CCSolidColorLayerImpl::create(1);
     layer->setVisibleLayerRect(visibleLayerRect);
     layer->setBounds(layerSize);
@@ -92 +92 @@
     IntRect visibleLayerRect = IntRect(IntPoint(), layerSize);
 
-    OwnPtr<CCSolidColorLayerImpl> layer = CCSolidColorLayerImpl::create(0);
+    OwnPtr<CCSolidColorLayerImpl> layer = CCSolidColorLayerImpl::create(1);
     layer->setVisibleLayerRect(visibleLayerRect);
     layer->setBounds(layerSize);

trunk/Source/WebKit/chromium/tests/CCTiledLayerImplTest.cpp

@@ -44 +44 @@
 static PassOwnPtr<CCTiledLayerImpl> createLayer(const IntSize& tileSize, const IntSize& layerSize, CCLayerTilingData::BorderTexelOption borderTexels)
 {
-    OwnPtr<CCTiledLayerImpl> layer = CCTiledLayerImpl::create(0);
+    OwnPtr<CCTiledLayerImpl> layer = CCTiledLayerImpl::create(1);
     OwnPtr<CCLayerTilingData> tiler = CCLayerTilingData::create(tileSize, borderTexels);
     tiler->setBounds(layerSize);

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

@@ -80 +80 @@
     {
         m_rootLayer->createRenderSurface();
-        m_rootRenderPass = CCRenderPass::create(m_rootLayer->renderSurface());
+        m_rootRenderPass = CCRenderPass::create(m_rootLayer->renderSurface(), m_rootLayer->id());
     }
 

trunk/Source/WebKit/chromium/tests/TiledLayerChromiumTest.cpp

@@ -98 +98 @@
     RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(textureManager.get()));
     DebugScopedSetImplThread implThread;
-    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(0)));
+    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
@@ -135 +135 @@
     RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(textureManager.get()));
     DebugScopedSetImplThread implThread;
-    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(0)));
+    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
     TestCCOcclusionTracker occluded;
 
@@ -181 +181 @@
     RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(textureManager.get()));
     DebugScopedSetImplThread implThread;
-    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(0)));
+    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
@@ -227 +227 @@
     RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(textureManager.get()));
     DebugScopedSetImplThread implThread;
-    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(0)));
+    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
 
     // The tile size is 100x100. Setup 5x5 tiles with one visible tile in the center.
@@ -286 +286 @@
     DebugScopedSetImplThread implThread;
     RefPtr<FakeTiledLayerChromium> layer1 = adoptRef(new FakeTiledLayerChromium(textureManager.get()));
-    OwnPtr<FakeCCTiledLayerImpl> layerImpl1(adoptPtr(new FakeCCTiledLayerImpl(0)));
+    OwnPtr<FakeCCTiledLayerImpl> layerImpl1(adoptPtr(new FakeCCTiledLayerImpl(1)));
     RefPtr<FakeTiledLayerChromium> layer2 = adoptRef(new FakeTiledLayerChromium(textureManager.get()));
-    OwnPtr<FakeCCTiledLayerImpl> layerImpl2(adoptPtr(new FakeCCTiledLayerImpl(0)));
+    OwnPtr<FakeCCTiledLayerImpl> layerImpl2(adoptPtr(new FakeCCTiledLayerImpl(2)));
 
     // For this test we have two layers. layer1 exhausts most texture memory, leaving room for 2 more tiles from
@@ -369 +369 @@
     RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(textureManager.get()));
     DebugScopedSetImplThread implThread;
-    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(0)));
+    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
     TestCCOcclusionTracker occluded;
 
@@ -396 +396 @@
     RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(textureManager.get()));
     DebugScopedSetImplThread implThread;
-    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(0)));
+    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
@@ -423 +423 @@
     RefPtr<FakeTiledLayerChromium> layer2 = adoptRef(new FakeTiledLayerChromium(textureManager.get()));
     DebugScopedSetImplThread implThread;
-    OwnPtr<FakeCCTiledLayerImpl> layer1Impl(adoptPtr(new FakeCCTiledLayerImpl(0)));
-    OwnPtr<FakeCCTiledLayerImpl> layer2Impl(adoptPtr(new FakeCCTiledLayerImpl(0)));
+    OwnPtr<FakeCCTiledLayerImpl> layer1Impl(adoptPtr(new FakeCCTiledLayerImpl(1)));
+    OwnPtr<FakeCCTiledLayerImpl> layer2Impl(adoptPtr(new FakeCCTiledLayerImpl(2)));
 
     layer1->setBounds(IntSize(100, 200));
@@ -461 +461 @@
     RefPtr<FakeTiledLayerChromium> layer2 = adoptRef(new FakeTiledLayerChromium(textureManager.get()));
     DebugScopedSetImplThread implThread;
-    OwnPtr<FakeCCTiledLayerImpl> layer1Impl(adoptPtr(new FakeCCTiledLayerImpl(0)));
-    OwnPtr<FakeCCTiledLayerImpl> layer2Impl(adoptPtr(new FakeCCTiledLayerImpl(0)));
+    OwnPtr<FakeCCTiledLayerImpl> layer1Impl(adoptPtr(new FakeCCTiledLayerImpl(1)));
+    OwnPtr<FakeCCTiledLayerImpl> layer2Impl(adoptPtr(new FakeCCTiledLayerImpl(2)));
 
     layer1->setBounds(IntSize(100, 200));
@@ -504 +504 @@
     RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(textureManager.get()));
     DebugScopedSetImplThread implThread;
-    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(0)));
+    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
 
     // Invalidates 9 tiles and then paints one visible tile.
@@ -538 +538 @@
     RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(textureManager.get()));
     DebugScopedSetImplThread implThread;
-    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(0)));
+    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
 
     // The layer's bounds are empty.
@@ -579 +579 @@
     RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(textureManager.get()));
     DebugScopedSetImplThread implThread;
-    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(0)));
+    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
 
     // Pretend the layer is animating.
@@ -626 +626 @@
     RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(textureManager.get()));
     DebugScopedSetImplThread implThread;
-    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(0)));
+    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
 
     // Invalidate the layer but make none of it visible, so nothing paints.
@@ -679 +679 @@
         for (int i = 0; width[i]; ++i) {
             RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(textureManager.get()));
-            OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(0)));
+            OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
 
             // Pretend the layer is animating.
@@ -748 +748 @@
     RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(textureManager.get()));
     DebugScopedSetImplThread implThread;
-    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(0)));
+    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
 
     FakeTextureAllocator fakeAllocator;
@@ -837 +837 @@
     RefPtr<FakeTiledLayerChromium> layer = adoptRef(new FakeTiledLayerChromium(textureManager.get()));
     DebugScopedSetImplThread implThread;
-    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(0)));
+    OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
 
     // Create a layer with one tile.
@@ -1002 +1002 @@
     {
         DebugScopedSetImplThread implThread;
-        OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(0)));
+        OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
         updateTextures(4);
         EXPECT_EQ(4, layer->fakeLayerTextureUpdater()->updateCount());
@@ -1020 +1020 @@
     {
         DebugScopedSetImplThread implThread;
-        OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(0)));
+        OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
         updateTextures(4);
         EXPECT_EQ(3, layer->fakeLayerTextureUpdater()->updateCount());
@@ -1037 +1037 @@
     {
         DebugScopedSetImplThread implThread;
-        OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(0)));
+        OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
         ccLayerTreeHost->updateLayers(updater, std::numeric_limits<size_t>::max());
         updateTextures(4);
@@ -1055 +1055 @@
     {
         DebugScopedSetImplThread implThread;
-        OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(0)));
+        OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
         layer->pushPropertiesTo(layerImpl.get());
     }
@@ -1064 +1064 @@
     {
         DebugScopedSetImplThread implThread;
-        OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(0)));
+        OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
         ccLayerTreeHost->updateLayers(updater, std::numeric_limits<size_t>::max());
         updateTextures(4);
@@ -1082 +1082 @@
     {
         DebugScopedSetImplThread implThread;
-        OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(0)));
+        OwnPtr<FakeCCTiledLayerImpl> layerImpl(adoptPtr(new FakeCCTiledLayerImpl(1)));
         ccLayerTreeHost->updateLayers(updater, std::numeric_limits<size_t>::max());
         updateTextures(4);