Move filters to RenderPassDrawQuad

cc/gl_renderer.cc

 // Copyright 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/gl_renderer.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
@@ skipping 420 matching lines @@
     paint.setImageFilter(filter);
     canvas.clear(0x0);
     canvas.drawSprite(source, 0, 0, &paint);
     canvas.flush();
     context3d->flush();
     return device.accessBitmap(false);
 }
 
 scoped_ptr<ScopedResource> GLRenderer::drawBackgroundFilters(
     DrawingFrame& frame, const RenderPassDrawQuad* quad,
-    const WebKit::WebFilterOperations& filters,
     const gfx::Transform& contentsDeviceTransform,
     const gfx::Transform& contentsDeviceTransformInverse)
 {
     // This method draws a background filter, which applies a filter to any pixels behind the quad and seen through its background.
     // The algorithm works as follows:
     // 1. Compute a bounding box around the pixels that will be visible through the quad.
     // 2. Read the pixels in the bounding box into a buffer R.
     // 3. Apply the background filter to R, so that it is applied in the pixels' coordinate space.
     // 4. Apply the quad's inverse transform to map the pixels in R into the quad's content space. This implicitly
     // clips R by the content bounds of the quad since the destination texture has bounds matching the quad's content.
     // 5. Draw the background texture for the contents using the same transform as used to draw the contents itself. This is done
     // without blending to replace the current background pixels with the new filtered background.
     // 6. Draw the contents of the quad over drop of the new background with blending, as per usual. The filtered background
     // pixels will show through any non-opaque pixels in this draws.
     //
     // Pixel copies in this algorithm occur at steps 2, 3, 4, and 5.
 
     // FIXME: When this algorithm changes, update LayerTreeHost::prioritizeTextures() accordingly.
 
+    const WebKit::WebFilterOperations& filters = quad->background_filters;
     if (filters.isEmpty())
         return scoped_ptr<ScopedResource>();
 
     // 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 (frame.currentRenderPass->has_transparent_background)
         return scoped_ptr<ScopedResource>();
     DCHECK(!frame.currentTexture);
 
     // FIXME: Do a single readback for both the surface and replica and cache the filtered results (once filter textures are not reused).
@@ skipping 38 matching lines @@
         return scoped_ptr<ScopedResource>();
     return backgroundTexture.Pass();
 }
 
 void GLRenderer::drawRenderPassQuad(DrawingFrame& frame, const RenderPassDrawQuad* quad)
 {
     CachedResource* contentsTexture = m_renderPassTextures.get(quad->render_pass_id);
     if (!contentsTexture || !contentsTexture->id())
         return;
 
-    const RenderPass* renderPass = frame.renderPassesById->get(quad->render_pass_id);
-    DCHECK(renderPass);
-    if (!renderPass)
-        return;
-
     gfx::Transform quadRectMatrix;
     quadRectTransform(&quadRectMatrix, quad->quadTransform(), quad->rect);
     gfx::Transform contentsDeviceTransform = MathUtil::to2dTransform(frame.windowMatrix * frame.projectionMatrix * quadRectMatrix);
 
     // Can only draw surface if device matrix is invertible.
     if (!contentsDeviceTransform.IsInvertible())
         return;
 
     gfx::Transform contentsDeviceTransformInverse = MathUtil::inverse(contentsDeviceTransform);
     scoped_ptr<ScopedResource> backgroundTexture = drawBackgroundFilters(
-        frame, quad, renderPass->background_filters,
-        contentsDeviceTransform, contentsDeviceTransformInverse);
+        frame, quad, contentsDeviceTransform, contentsDeviceTransformInverse);
 
     // 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;
-    if (renderPass->filter) {
-        filterBitmap = applyImageFilter(this, renderPass->filter.get(), contentsTexture, m_client->hasImplThread());
+    if (quad->filter) {
+        filterBitmap = applyImageFilter(this, quad->filter.get(), contentsTexture, m_client->hasImplThread());
     } else {
-        filterBitmap = applyFilters(this, renderPass->filters, contentsTexture, m_client->hasImplThread());
+        filterBitmap = applyFilters(this, quad->filters, contentsTexture, m_client->hasImplThread());
     }
 
     // Draw the background texture if there is one.
     if (backgroundTexture) {
         DCHECK(backgroundTexture->size() == quad->rect.size());
         ResourceProvider::ScopedReadLockGL lock(m_resourceProvider, backgroundTexture->id());
         copyTextureToFramebuffer(frame, lock.textureId(), quad->rect, quad->quadTransform());
     }
 
     bool clipped = false;
@@ skipping 1242 matching lines @@
 
     releaseRenderPassTextures();
 }
 
 bool GLRenderer::isContextLost()
 {
     return (m_context->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc