Moves sampler binding from init to draw time during batched drawing.

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 967 matching lines @@
     // Check to see if we have anything to draw.
     if (m_drawCache.program_id == 0)
       return;
 
     // Set the correct blending mode.
     setBlendEnabled(m_drawCache.needs_blending);
 
     // Bind the program to the GL state.
     setUseProgram(m_drawCache.program_id);
 
+    // Bind the correct texture sampler location.
+    GLC(context(), context()->uniform1i(m_drawCache.sampler_location, 0));
+
     // Assume the current active textures is 0.
     ResourceProvider::ScopedReadLockGL lockedQuad(m_resourceProvider, m_drawCache.resource_id);
     GLC(context(), context()->bindTexture(GL_TEXTURE_2D, lockedQuad.textureId()));
 
     // set up premultiplied alpha.
     if (!m_drawCache.use_premultiplied_alpha) {
       // As it turns out, the premultiplied alpha blending function (ONE, ONE_MINUS_SRC_ALPHA)
         // will never cause the alpha channel to be set to anything less than 1.0 if it is
         // initialized to that value! Therefore, premultipliedAlpha being false is the first
         // situation we can generally see an alpha channel less than 1.0 coming out of the
@@ skipping 47 matching lines @@
         flushTextureQuadCache();
         m_drawCache.program_id = binding.programId;
         m_drawCache.resource_id = resourceID;
         m_drawCache.alpha = quad->opacity();
         m_drawCache.use_premultiplied_alpha = quad->premultiplied_alpha;
         m_drawCache.needs_blending = quad->ShouldDrawWithBlending();
 
         m_drawCache.alpha_location = binding.alphaLocation;
         m_drawCache.uv_xform_location = binding.texTransformLocation;
         m_drawCache.matrix_location = binding.matrixLocation;
+        m_drawCache.sampler_location = binding.samplerLocation;
     }
 
     // Generate the uv-transform
     const gfx::RectF& uvRect = quad->uv_rect;
     Float4 uv = {uvRect.x(), uvRect.y(), uvRect.width(), uvRect.height()};
     m_drawCache.uv_xform_data.push_back(uv);
 
     // Generate the transform matrix
     gfx::Transform quadRectMatrix;
     quadRectTransform(&quadRectMatrix, quad->quadTransform(), quad->rect);
@@ skipping 574 matching lines @@
     return m_tileProgramSwizzleAA.get();
 }
 
 const GLRenderer::TextureProgram* GLRenderer::textureProgram()
 {
     if (!m_textureProgram)
         m_textureProgram = make_scoped_ptr(new TextureProgram(m_context));
     if (!m_textureProgram->initialized()) {
         TRACE_EVENT0("cc", "GLRenderer::textureProgram::initialize");
         m_textureProgram->initialize(m_context, m_isUsingBindUniform);
-        GLC(context(), context()->uniform1i(m_textureProgram.get()->fragmentShader().samplerLocation(), 0));
     }
     return m_textureProgram.get();
 }
 
 const GLRenderer::TextureProgramFlip* GLRenderer::textureProgramFlip()
 {
     if (!m_textureProgramFlip)
         m_textureProgramFlip = make_scoped_ptr(new TextureProgramFlip(m_context));
     if (!m_textureProgramFlip->initialized()) {
         TRACE_EVENT0("cc", "GLRenderer::textureProgramFlip::initialize");
         m_textureProgramFlip->initialize(m_context, m_isUsingBindUniform);
-        GLC(context(), context()->uniform1i(m_textureProgramFlip.get()->fragmentShader().samplerLocation(), 0));
     }
     return m_textureProgramFlip.get();
 }
 
 const GLRenderer::TextureIOSurfaceProgram* GLRenderer::textureIOSurfaceProgram()
 {
     if (!m_textureIOSurfaceProgram)
         m_textureIOSurfaceProgram = make_scoped_ptr(new TextureIOSurfaceProgram(m_context));
     if (!m_textureIOSurfaceProgram->initialized()) {
         TRACE_EVENT0("cc", "GLRenderer::textureIOSurfaceProgram::initialize");
@@ skipping 74 matching lines @@
 
     releaseRenderPassTextures();
 }
 
 bool GLRenderer::isContextLost()
 {
     return (m_context->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc