Allow using a larger-than-necessary texture as cached render pass backing

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 476 matching lines @@
     if (!backgroundTexture->Allocate(Renderer::ImplPool, quad->rect.size(), GL_RGBA, ResourceProvider::TextureUsageFramebuffer))
         return scoped_ptr<ScopedResource>();
 
     const RenderPass* targetRenderPass = frame.currentRenderPass;
     bool usingBackgroundTexture = useScopedTexture(frame, backgroundTexture.get(), quad->rect);
 
     if (usingBackgroundTexture) {
         // Copy the readback pixels from device to the background texture for the surface.
         gfx::Transform deviceToFramebufferTransform;
         deviceToFramebufferTransform.Translate(quad->rect.width() / 2.0, quad->rect.height() / 2.0);
-        deviceToFramebufferTransform.Scale3d(quad->rect.width(), quad->rect.height(), 1);
+        deviceToFramebufferTransform.Scale(quad->rect.width(), quad->rect.height());
         deviceToFramebufferTransform.PreconcatTransform(contentsDeviceTransformInverse);
         copyTextureToFramebuffer(frame, filteredDeviceBackgroundTextureId, deviceRect, deviceToFramebufferTransform);
     }
 
     useRenderPass(frame, targetRenderPass);
 
     if (!usingBackgroundTexture)
         return scoped_ptr<ScopedResource>();
     return backgroundTexture.Pass();
 }
@@ skipping 68 matching lines @@
         contentsResourceLock = make_scoped_ptr(new ResourceProvider::ScopedSamplerGL(m_resourceProvider, contentsTexture->id(),
                                                                                      GL_TEXTURE_2D, GL_LINEAR));
 
     int shaderQuadLocation = -1;
     int shaderEdgeLocation = -1;
     int shaderMaskSamplerLocation = -1;
     int shaderMaskTexCoordScaleLocation = -1;
     int shaderMaskTexCoordOffsetLocation = -1;
     int shaderMatrixLocation = -1;
     int shaderAlphaLocation = -1;
+    int shaderTexTransformLocation = -1;
+    int shaderTexScaleLocation = -1;
+
     if (useAA && maskTextureId) {
         const RenderPassMaskProgramAA* program = renderPassMaskProgramAA();
         setUseProgram(program->program());
         GLC(context(), context()->uniform1i(program->fragmentShader().samplerLocation(), 0));
 
         shaderQuadLocation = program->vertexShader().pointLocation();
         shaderEdgeLocation = program->fragmentShader().edgeLocation();
         shaderMaskSamplerLocation = program->fragmentShader().maskSamplerLocation();
         shaderMaskTexCoordScaleLocation = program->fragmentShader().maskTexCoordScaleLocation();
         shaderMaskTexCoordOffsetLocation = program->fragmentShader().maskTexCoordOffsetLocation();
         shaderMatrixLocation = program->vertexShader().matrixLocation();
         shaderAlphaLocation = program->fragmentShader().alphaLocation();
+        shaderTexScaleLocation = program->vertexShader().texScaleLocation();
     } else if (!useAA && maskTextureId) {
         const RenderPassMaskProgram* program = renderPassMaskProgram();
         setUseProgram(program->program());
         GLC(context(), context()->uniform1i(program->fragmentShader().samplerLocation(), 0));
 
         shaderMaskSamplerLocation = program->fragmentShader().maskSamplerLocation();
         shaderMaskTexCoordScaleLocation = program->fragmentShader().maskTexCoordScaleLocation();
         shaderMaskTexCoordOffsetLocation = program->fragmentShader().maskTexCoordOffsetLocation();
         shaderMatrixLocation = program->vertexShader().matrixLocation();
         shaderAlphaLocation = program->fragmentShader().alphaLocation();
+        shaderTexTransformLocation = program->vertexShader().texTransformLocation();
     } else if (useAA && !maskTextureId) {
         const RenderPassProgramAA* program = renderPassProgramAA();
         setUseProgram(program->program());
         GLC(context(), context()->uniform1i(program->fragmentShader().samplerLocation(), 0));
 
         shaderQuadLocation = program->vertexShader().pointLocation();
         shaderEdgeLocation = program->fragmentShader().edgeLocation();
         shaderMatrixLocation = program->vertexShader().matrixLocation();
         shaderAlphaLocation = program->fragmentShader().alphaLocation();
+        shaderTexScaleLocation = program->vertexShader().texScaleLocation();
     } else {
         const RenderPassProgram* program = renderPassProgram();
         setUseProgram(program->program());
         GLC(context(), context()->uniform1i(program->fragmentShader().samplerLocation(), 0));
 
         shaderMatrixLocation = program->vertexShader().matrixLocation();
         shaderAlphaLocation = program->fragmentShader().alphaLocation();
+        shaderTexTransformLocation = program->vertexShader().texTransformLocation();
+    }
+
+    float tex_scale_x = quad->rect.width() / static_cast<float>(contentsTexture->size().width());
+    float tex_scale_y = quad->rect.height() / static_cast<float>(contentsTexture->size().height());

[enne (OOO), 2012/12/12 23:41:54]

Can you assert here that scale_foo is <= 1?

[jamesr, 2012/12/13 01:15:06]

Sure

+
+    if (shaderTexTransformLocation != -1) {
+        GLC(context(), context()->uniform4f(shaderTexTransformLocation,
+                                            0.0f, 0.0f,
+                                            tex_scale_x, tex_scale_y));
+    } else if (shaderTexScaleLocation != -1) {
+        GLC(context(), context()->uniform2f(shaderTexScaleLocation,
+                                            tex_scale_x, tex_scale_y));
+    } else {
+      NOTREACHED();
     }
 
     if (shaderMaskSamplerLocation != -1) {
         DCHECK(shaderMaskTexCoordScaleLocation != 1);
         DCHECK(shaderMaskTexCoordOffsetLocation != 1);
         GLC(context(), context()->activeTexture(GL_TEXTURE1));
         GLC(context(), context()->uniform1i(shaderMaskSamplerLocation, 1));
-        GLC(context(), context()->uniform2f(shaderMaskTexCoordScaleLocation, quad->mask_tex_coord_scale_x, quad->mask_tex_coord_scale_y));
-        GLC(context(), context()->uniform2f(shaderMaskTexCoordOffsetLocation, quad->mask_tex_coord_offset_x, quad->mask_tex_coord_offset_y));
+        GLC(context(), context()->uniform2f(shaderMaskTexCoordOffsetLocation,
+                                            quad->mask_uv_rect.x(), quad->mask_uv_rect.y()));
+        GLC(context(), context()->uniform2f(shaderMaskTexCoordScaleLocation,
+                                            quad->mask_uv_rect.width() / tex_scale_x, quad->mask_uv_rect.height() / tex_scale_y));
         m_resourceProvider->bindForSampling(quad->mask_resource_id, GL_TEXTURE_2D, GL_LINEAR);
         GLC(context(), context()->activeTexture(GL_TEXTURE0));
     }
 
     if (shaderEdgeLocation != -1) {
         float edge[24];
         deviceLayerEdges.toFloatArray(edge);
         deviceLayerBounds.toFloatArray(&edge[12]);
         GLC(context(), context()->uniform3fv(shaderEdgeLocation, 8, edge));
     }
 
+
     // Map device space quad to surface space. contentsDeviceTransform has no 3d component since it was generated with to2dTransform() so we don't need to project.
     gfx::QuadF surfaceQuad = MathUtil::mapQuad(contentsDeviceTransformInverse, deviceLayerEdges.ToQuadF(), clipped);
     DCHECK(!clipped);
 
     setShaderOpacity(quad->opacity(), shaderAlphaLocation);
     setShaderQuadF(surfaceQuad, shaderQuadLocation);
     drawQuadGeometry(frame, quad->quadTransform(), quad->rect, shaderMatrixLocation);
 
     // Flush the compositor context before the filter bitmap goes out of
     // scope, so the draw gets processed before the filter texture gets deleted.
@@ skipping 567 matching lines @@
 }
 
 void GLRenderer::copyTextureToFramebuffer(const DrawingFrame& frame, int textureId, const gfx::Rect& rect, const gfx::Transform& drawMatrix)
 {
     const RenderPassProgram* program = renderPassProgram();
 
     GLC(context(), context()->bindTexture(GL_TEXTURE_2D, textureId));
 
     setUseProgram(program->program());
     GLC(context(), context()->uniform1i(program->fragmentShader().samplerLocation(), 0));
+    GLC(context(), context()->uniform4f(program->vertexShader().texTransformLocation(),

[enne (OOO), 2012/12/12 23:41:54]

It's kind of scary that this wasn't set before.

[jamesr, 2012/12/13 01:15:06]

Not as scary as it seems - I'm adding this vertex uniform in this patch :)

+                                        0.0f, 0.0f, 1.0f, 1.0f));
     setShaderOpacity(1, program->fragmentShader().alphaLocation());
     drawQuadGeometry(frame, drawMatrix, rect, program->vertexShader().matrixLocation());
 }
 
 void GLRenderer::finish()
 {
     TRACE_EVENT0("cc", "GLRenderer::finish");
     m_context->finish();
 }
 
@@ skipping 505 matching lines @@
 
     releaseRenderPassTextures();
 }
 
 bool GLRenderer::isContextLost()
 {
     return (m_context->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc