cc: Render TextureLayer which texture target is not GL_TEXTURE_2D correctly.

cc/output/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/output/gl_renderer.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 2142 matching lines @@
 
   // Bind the correct texture sampler location.
   gl_->Uniform1i(draw_cache_.sampler_location, 0);
 
   // Assume the current active textures is 0.
   ResourceProvider::ScopedSamplerGL locked_quad(
       resource_provider_,
       draw_cache_.resource_id,
       draw_cache_.nearest_neighbor ? GL_NEAREST : GL_LINEAR);
   DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));
-  gl_->BindTexture(GL_TEXTURE_2D, locked_quad.texture_id());
+  gl_->BindTexture(locked_quad.target(), locked_quad.texture_id());
 
   static_assert(sizeof(Float4) == 4 * sizeof(float),
                 "Float4 struct should be densely packed");
   static_assert(sizeof(Float16) == 16 * sizeof(float),
                 "Float16 struct should be densely packed");
 
   // Upload the tranforms for both points and uvs.
   gl_->UniformMatrix4fv(
       static_cast<int>(draw_cache_.matrix_location),
       static_cast<int>(draw_cache_.matrix_data.size()), false,
@@ skipping 41 matching lines @@
     // queue using the shared_geometry and not clipped_geometry
     FlushTextureQuadCache(SHARED_BINDING);
   }
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       gl_,
       &highp_threshold_cache_,
       highp_threshold_min_,
       quad->shared_quad_state->visible_content_rect.bottom_right());
 
+  ResourceProvider::ScopedReadLockGL lock(resource_provider_,
+                                          quad->resource_id);
+  const SamplerType sampler = SamplerTypeFromTextureTarget(lock.target());
   // Choose the correct texture program binding
   TexTransformTextureProgramBinding binding;
   if (quad->premultiplied_alpha) {
     if (quad->background_color == SK_ColorTRANSPARENT) {
-      binding.Set(GetTextureProgram(tex_coord_precision));
+      binding.Set(GetTextureProgram(tex_coord_precision, sampler));
     } else {
-      binding.Set(GetTextureBackgroundProgram(tex_coord_precision));
+      binding.Set(GetTextureBackgroundProgram(tex_coord_precision, sampler));
     }
   } else {
     if (quad->background_color == SK_ColorTRANSPARENT) {
-      binding.Set(GetNonPremultipliedTextureProgram(tex_coord_precision));
+      binding.Set(
+          GetNonPremultipliedTextureProgram(tex_coord_precision, sampler));
     } else {
-      binding.Set(
-          GetNonPremultipliedTextureBackgroundProgram(tex_coord_precision));
+      binding.Set(GetNonPremultipliedTextureBackgroundProgram(
+          tex_coord_precision, sampler));
     }
   }
 
   int resource_id = quad->resource_id;
 
   if (draw_cache_.program_id != binding.program_id ||
       draw_cache_.resource_id != resource_id ||
       draw_cache_.needs_blending != quad->ShouldDrawWithBlending() ||
       draw_cache_.nearest_neighbor != quad->nearest_neighbor ||
       draw_cache_.background_color != quad->background_color ||
@@ skipping 941 matching lines @@
   TileProgramSwizzleAA* program = &tile_program_swizzle_aa_[precision][sampler];
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::tileProgramSwizzleAA::initialize");
     program->Initialize(
         output_surface_->context_provider(), precision, sampler);
   }
   return program;
 }
 
 const GLRenderer::TextureProgram* GLRenderer::GetTextureProgram(
-    TexCoordPrecision precision) {
+    TexCoordPrecision precision,
+    SamplerType sampler) {
   DCHECK_GE(precision, 0);
   DCHECK_LE(precision, LAST_TEX_COORD_PRECISION);
-  TextureProgram* program = &texture_program_[precision];
+  DCHECK_GE(sampler, 0);
+  DCHECK_LE(sampler, LAST_SAMPLER_TYPE);
+  TextureProgram* program = &texture_program_[precision][sampler];
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::textureProgram::initialize");
     program->Initialize(output_surface_->context_provider(), precision,
-                        SAMPLER_TYPE_2D);
+                        sampler);
   }
   return program;
 }
 
 const GLRenderer::NonPremultipliedTextureProgram*
-GLRenderer::GetNonPremultipliedTextureProgram(TexCoordPrecision precision) {
+GLRenderer::GetNonPremultipliedTextureProgram(TexCoordPrecision precision,
+                                              SamplerType sampler) {
   DCHECK_GE(precision, 0);
   DCHECK_LE(precision, LAST_TEX_COORD_PRECISION);
+  DCHECK_GE(sampler, 0);
+  DCHECK_LE(sampler, LAST_SAMPLER_TYPE);
   NonPremultipliedTextureProgram* program =
-      &nonpremultiplied_texture_program_[precision];
+      &nonpremultiplied_texture_program_[precision][sampler];
   if (!program->initialized()) {
     TRACE_EVENT0("cc",
                  "GLRenderer::NonPremultipliedTextureProgram::Initialize");
     program->Initialize(output_surface_->context_provider(), precision,
-                        SAMPLER_TYPE_2D);
+                        sampler);
   }
   return program;
 }
 
 const GLRenderer::TextureBackgroundProgram*
-GLRenderer::GetTextureBackgroundProgram(TexCoordPrecision precision) {
+GLRenderer::GetTextureBackgroundProgram(TexCoordPrecision precision,
+                                        SamplerType sampler) {
   DCHECK_GE(precision, 0);
   DCHECK_LE(precision, LAST_TEX_COORD_PRECISION);
-  TextureBackgroundProgram* program = &texture_background_program_[precision];
+  DCHECK_GE(sampler, 0);
+  DCHECK_LE(sampler, LAST_SAMPLER_TYPE);
+  TextureBackgroundProgram* program =
+      &texture_background_program_[precision][sampler];
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::textureProgram::initialize");
     program->Initialize(output_surface_->context_provider(), precision,
-                        SAMPLER_TYPE_2D);
+                        sampler);
   }
   return program;
 }
 
 const GLRenderer::NonPremultipliedTextureBackgroundProgram*
 GLRenderer::GetNonPremultipliedTextureBackgroundProgram(
-    TexCoordPrecision precision) {
+    TexCoordPrecision precision,
+    SamplerType sampler) {
   DCHECK_GE(precision, 0);
   DCHECK_LE(precision, LAST_TEX_COORD_PRECISION);
+  DCHECK_GE(sampler, 0);
+  DCHECK_LE(sampler, LAST_SAMPLER_TYPE);
   NonPremultipliedTextureBackgroundProgram* program =
-      &nonpremultiplied_texture_background_program_[precision];
+      &nonpremultiplied_texture_background_program_[precision][sampler];
   if (!program->initialized()) {
     TRACE_EVENT0("cc",
                  "GLRenderer::NonPremultipliedTextureProgram::Initialize");
     program->Initialize(output_surface_->context_provider(), precision,
-                        SAMPLER_TYPE_2D);
+                        sampler);
   }
   return program;
 }
 
 const GLRenderer::TextureProgram* GLRenderer::GetTextureIOSurfaceProgram(
     TexCoordPrecision precision) {
   DCHECK_GE(precision, 0);
   DCHECK_LE(precision, LAST_TEX_COORD_PRECISION);
   TextureProgram* program = &texture_io_surface_program_[precision];
   if (!program->initialized()) {
@@ skipping 67 matching lines @@
         }
       }
     }
     for (int j = 0; j <= LAST_BLEND_MODE; j++) {
       render_pass_program_[i][j].Cleanup(gl_);
       render_pass_program_aa_[i][j].Cleanup(gl_);
       render_pass_color_matrix_program_[i][j].Cleanup(gl_);
       render_pass_color_matrix_program_aa_[i][j].Cleanup(gl_);
     }
 
-    texture_program_[i].Cleanup(gl_);
-    nonpremultiplied_texture_program_[i].Cleanup(gl_);
-    texture_background_program_[i].Cleanup(gl_);
-    nonpremultiplied_texture_background_program_[i].Cleanup(gl_);
+    for (int j = 0; j <= LAST_SAMPLER_TYPE; ++j) {
+      texture_program_[i][j].Cleanup(gl_);
+      nonpremultiplied_texture_program_[i][j].Cleanup(gl_);
+      texture_background_program_[i][j].Cleanup(gl_);
+      nonpremultiplied_texture_background_program_[i][j].Cleanup(gl_);
+    }
     texture_io_surface_program_[i].Cleanup(gl_);
 
     video_yuv_program_[i].Cleanup(gl_);
     video_yuva_program_[i].Cleanup(gl_);
     video_stream_texture_program_[i].Cleanup(gl_);
   }
 
   tile_checkerboard_program_.Cleanup(gl_);
 
   debug_border_program_.Cleanup(gl_);
@@ skipping 83 matching lines @@
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order,
         overlay.transform,
         pending_overlay_resources_.back()->texture_id(),
         ToNearestRect(overlay.display_rect),
         overlay.uv_rect);
   }
 }
 
 }  // namespace cc