cc: Support texture rect targets for masks

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 1141 matching lines @@
   int shader_tex_transform_location = -1;
   int shader_backdrop_location = -1;
   int shader_backdrop_rect_location = -1;
 
   BlendMode shader_blend_mode = ((background_texture || background_image) &&
                                  !CanApplyBlendModeUsingBlendFunc(blend_mode))
                                     ? BlendModeFromSkXfermode(blend_mode)
                                     : BlendModeNormal;
 
   if (use_aa && mask_texture_id && !use_color_matrix) {
-    const RenderPassMaskProgramAA* program =
-        GetRenderPassMaskProgramAA(tex_coord_precision, shader_blend_mode);
+    const RenderPassMaskProgramAA* program = GetRenderPassMaskProgramAA(
+        tex_coord_precision, mask_sampler, shader_blend_mode);
     SetUseProgram(program->program());
     GLC(gl_, gl_->Uniform1i(program->fragment_shader().sampler_location(), 0));
 
     shader_quad_location = program->vertex_shader().quad_location();
     shader_edge_location = program->vertex_shader().edge_location();
     shader_viewport_location = program->vertex_shader().viewport_location();
     shader_mask_sampler_location =
         program->fragment_shader().mask_sampler_location();
     shader_mask_tex_coord_scale_location =
         program->fragment_shader().mask_tex_coord_scale_location();
     shader_mask_tex_coord_offset_location =
         program->fragment_shader().mask_tex_coord_offset_location();
     shader_matrix_location = program->vertex_shader().matrix_location();
     shader_alpha_location = program->fragment_shader().alpha_location();
     shader_tex_transform_location =
         program->vertex_shader().tex_transform_location();
     shader_backdrop_location = program->fragment_shader().backdrop_location();
     shader_backdrop_rect_location =
         program->fragment_shader().backdrop_rect_location();
   } else if (!use_aa && mask_texture_id && !use_color_matrix) {
-    const RenderPassMaskProgram* program =
-        GetRenderPassMaskProgram(tex_coord_precision, shader_blend_mode);
+    const RenderPassMaskProgram* program = GetRenderPassMaskProgram(
+        tex_coord_precision, mask_sampler, shader_blend_mode);
     SetUseProgram(program->program());
     GLC(gl_, gl_->Uniform1i(program->fragment_shader().sampler_location(), 0));
 
     shader_mask_sampler_location =
         program->fragment_shader().mask_sampler_location();
     shader_mask_tex_coord_scale_location =
         program->fragment_shader().mask_tex_coord_scale_location();
     shader_mask_tex_coord_offset_location =
         program->fragment_shader().mask_tex_coord_offset_location();
     shader_matrix_location = program->vertex_shader().matrix_location();
@@ skipping 14 matching lines @@
     shader_viewport_location = program->vertex_shader().viewport_location();
     shader_matrix_location = program->vertex_shader().matrix_location();
     shader_alpha_location = program->fragment_shader().alpha_location();
     shader_tex_transform_location =
         program->vertex_shader().tex_transform_location();
     shader_backdrop_location = program->fragment_shader().backdrop_location();
     shader_backdrop_rect_location =
         program->fragment_shader().backdrop_rect_location();
   } else if (use_aa && mask_texture_id && use_color_matrix) {
     const RenderPassMaskColorMatrixProgramAA* program =
-        GetRenderPassMaskColorMatrixProgramAA(tex_coord_precision,
-                                              shader_blend_mode);
+        GetRenderPassMaskColorMatrixProgramAA(
+            tex_coord_precision, mask_sampler, shader_blend_mode);
     SetUseProgram(program->program());
     GLC(gl_, gl_->Uniform1i(program->fragment_shader().sampler_location(), 0));
 
     shader_matrix_location = program->vertex_shader().matrix_location();
     shader_quad_location = program->vertex_shader().quad_location();
     shader_tex_transform_location =
         program->vertex_shader().tex_transform_location();
     shader_edge_location = program->vertex_shader().edge_location();
     shader_viewport_location = program->vertex_shader().viewport_location();
     shader_alpha_location = program->fragment_shader().alpha_location();
@@ skipping 26 matching lines @@
     shader_alpha_location = program->fragment_shader().alpha_location();
     shader_color_matrix_location =
         program->fragment_shader().color_matrix_location();
     shader_color_offset_location =
         program->fragment_shader().color_offset_location();
     shader_backdrop_location = program->fragment_shader().backdrop_location();
     shader_backdrop_rect_location =
         program->fragment_shader().backdrop_rect_location();
   } else if (!use_aa && mask_texture_id && use_color_matrix) {
     const RenderPassMaskColorMatrixProgram* program =
-        GetRenderPassMaskColorMatrixProgram(tex_coord_precision,
-                                            shader_blend_mode);
+        GetRenderPassMaskColorMatrixProgram(
+            tex_coord_precision, mask_sampler, shader_blend_mode);
     SetUseProgram(program->program());
     GLC(gl_, gl_->Uniform1i(program->fragment_shader().sampler_location(), 0));
 
     shader_matrix_location = program->vertex_shader().matrix_location();
     shader_tex_transform_location =
         program->vertex_shader().tex_transform_location();
     shader_mask_sampler_location =
         program->fragment_shader().mask_sampler_location();
     shader_mask_tex_coord_scale_location =
         program->fragment_shader().mask_tex_coord_scale_location();
@@ skipping 50 matching lines @@
   // texture is already oriented the same way as the framebuffer, but the
   // projection transform does a flip.
   GLC(gl_,
       gl_->Uniform4f(shader_tex_transform_location,
                      0.0f,
                      tex_scale_y,
                      tex_scale_x,
                      -tex_scale_y));
 
   GLint last_texture_unit = 0;
-  scoped_ptr<ResourceProvider::ScopedSamplerGL> shader_mask_sampler_lock;
   if (shader_mask_sampler_location != -1) {
     DCHECK_NE(shader_mask_tex_coord_scale_location, 1);
     DCHECK_NE(shader_mask_tex_coord_offset_location, 1);
-    DCHECK_EQ(SamplerType2D, mask_sampler);
     GLC(gl_, gl_->Uniform1i(shader_mask_sampler_location, 1));
 
     gfx::RectF mask_uv_rect = quad->MaskUVRect();
+    if (mask_sampler != SamplerType2D) {
+      mask_uv_rect.Scale(quad->mask_texture_size.width(),
+                         quad->mask_texture_size.height());
+    }
 
     // Mask textures are oriented vertically flipped relative to the framebuffer
     // and the RenderPass contents texture, so we flip the tex coords from the
     // RenderPass texture to find the mask texture coords.
     GLC(gl_,
         gl_->Uniform2f(shader_mask_tex_coord_offset_location,
                        mask_uv_rect.x(),
                        mask_uv_rect.bottom()));
     GLC(gl_,
         gl_->Uniform2f(shader_mask_tex_coord_scale_location,
@@ skipping 1524 matching lines @@
     program->Initialize(output_surface_->context_provider(),
                         precision,
                         SamplerType2D,
                         blend_mode);
   }
   return program;
 }
 
 const GLRenderer::RenderPassMaskProgram* GLRenderer::GetRenderPassMaskProgram(
     TexCoordPrecision precision,
+    SamplerType sampler,
     BlendMode blend_mode) {
   DCHECK_GE(precision, 0);
   DCHECK_LT(precision, NumTexCoordPrecisions);
+  DCHECK_GE(sampler, 0);
+  DCHECK_LT(sampler, NumSamplerTypes);
   DCHECK_GE(blend_mode, 0);
   DCHECK_LT(blend_mode, NumBlendModes);
   RenderPassMaskProgram* program =
-      &render_pass_mask_program_[precision][blend_mode];
+      &render_pass_mask_program_[precision][sampler][blend_mode];
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::renderPassMaskProgram::initialize");
-    program->Initialize(output_surface_->context_provider(),
-                        precision,
-                        SamplerType2D,
-                        blend_mode);
+    program->Initialize(
+        output_surface_->context_provider(), precision, sampler, blend_mode);
   }
   return program;
 }
 
 const GLRenderer::RenderPassMaskProgramAA*
 GLRenderer::GetRenderPassMaskProgramAA(TexCoordPrecision precision,
+                                       SamplerType sampler,
                                        BlendMode blend_mode) {
   DCHECK_GE(precision, 0);
   DCHECK_LT(precision, NumTexCoordPrecisions);
+  DCHECK_GE(sampler, 0);
+  DCHECK_LT(sampler, NumSamplerTypes);
   DCHECK_GE(blend_mode, 0);
   DCHECK_LT(blend_mode, NumBlendModes);
   RenderPassMaskProgramAA* program =
-      &render_pass_mask_program_aa_[precision][blend_mode];
+      &render_pass_mask_program_aa_[precision][sampler][blend_mode];
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::renderPassMaskProgramAA::initialize");
-    program->Initialize(output_surface_->context_provider(),
-                        precision,
-                        SamplerType2D,
-                        blend_mode);
+    program->Initialize(
+        output_surface_->context_provider(), precision, sampler, blend_mode);
   }
   return program;
 }
 
 const GLRenderer::RenderPassColorMatrixProgram*
 GLRenderer::GetRenderPassColorMatrixProgram(TexCoordPrecision precision,
                                             BlendMode blend_mode) {
   DCHECK_GE(precision, 0);
   DCHECK_LT(precision, NumTexCoordPrecisions);
   DCHECK_GE(blend_mode, 0);
@@ skipping 25 matching lines @@
     program->Initialize(output_surface_->context_provider(),
                         precision,
                         SamplerType2D,
                         blend_mode);
   }
   return program;
 }
 
 const GLRenderer::RenderPassMaskColorMatrixProgram*
 GLRenderer::GetRenderPassMaskColorMatrixProgram(TexCoordPrecision precision,
+                                                SamplerType sampler,
                                                 BlendMode blend_mode) {
   DCHECK_GE(precision, 0);
   DCHECK_LT(precision, NumTexCoordPrecisions);
+  DCHECK_GE(sampler, 0);
+  DCHECK_LT(sampler, NumSamplerTypes);
   DCHECK_GE(blend_mode, 0);
   DCHECK_LT(blend_mode, NumBlendModes);
   RenderPassMaskColorMatrixProgram* program =
-      &render_pass_mask_color_matrix_program_[precision][blend_mode];
+      &render_pass_mask_color_matrix_program_[precision][sampler][blend_mode];
   if (!program->initialized()) {
     TRACE_EVENT0("cc",
                  "GLRenderer::renderPassMaskColorMatrixProgram::initialize");
-    program->Initialize(output_surface_->context_provider(),
-                        precision,
-                        SamplerType2D,
-                        blend_mode);
+    program->Initialize(
+        output_surface_->context_provider(), precision, sampler, blend_mode);
   }
   return program;
 }
 
 const GLRenderer::RenderPassMaskColorMatrixProgramAA*
 GLRenderer::GetRenderPassMaskColorMatrixProgramAA(TexCoordPrecision precision,
+                                                  SamplerType sampler,
                                                   BlendMode blend_mode) {
   DCHECK_GE(precision, 0);
   DCHECK_LT(precision, NumTexCoordPrecisions);
+  DCHECK_GE(sampler, 0);
+  DCHECK_LT(sampler, NumSamplerTypes);
   DCHECK_GE(blend_mode, 0);
   DCHECK_LT(blend_mode, NumBlendModes);
   RenderPassMaskColorMatrixProgramAA* program =
-      &render_pass_mask_color_matrix_program_aa_[precision][blend_mode];
+      &render_pass_mask_color_matrix_program_aa_[precision][sampler]
+                                                [blend_mode];
   if (!program->initialized()) {
     TRACE_EVENT0("cc",
                  "GLRenderer::renderPassMaskColorMatrixProgramAA::initialize");
-    program->Initialize(output_surface_->context_provider(),
-                        precision,
-                        SamplerType2D,
-                        blend_mode);
+    program->Initialize(
+        output_surface_->context_provider(), precision, sampler, blend_mode);
   }
   return program;
 }
 
 const GLRenderer::TileProgram* GLRenderer::GetTileProgram(
     TexCoordPrecision precision,
     SamplerType sampler) {
   DCHECK_GE(precision, 0);
   DCHECK_LT(precision, NumTexCoordPrecisions);
   DCHECK_GE(sampler, 0);
@@ skipping 204 matching lines @@
   shared_geometry_ = nullptr;
 
   for (int i = 0; i < NumTexCoordPrecisions; ++i) {
     for (int j = 0; j < NumSamplerTypes; ++j) {
       tile_program_[i][j].Cleanup(gl_);
       tile_program_opaque_[i][j].Cleanup(gl_);
       tile_program_swizzle_[i][j].Cleanup(gl_);
       tile_program_swizzle_opaque_[i][j].Cleanup(gl_);
       tile_program_aa_[i][j].Cleanup(gl_);
       tile_program_swizzle_aa_[i][j].Cleanup(gl_);
+
+      for (int k = 0; k < NumBlendModes; k++) {
+        render_pass_mask_program_[i][j][k].Cleanup(gl_);
+        render_pass_mask_program_aa_[i][j][k].Cleanup(gl_);
+        render_pass_mask_color_matrix_program_aa_[i][j][k].Cleanup(gl_);
+        render_pass_mask_color_matrix_program_[i][j][k].Cleanup(gl_);
+      }
     }
     for (int j = 0; j < NumBlendModes; j++) {
-      render_pass_mask_program_[i][j].Cleanup(gl_);
       render_pass_program_[i][j].Cleanup(gl_);
-      render_pass_mask_program_aa_[i][j].Cleanup(gl_);
       render_pass_program_aa_[i][j].Cleanup(gl_);
       render_pass_color_matrix_program_[i][j].Cleanup(gl_);
-      render_pass_mask_color_matrix_program_aa_[i][j].Cleanup(gl_);
       render_pass_color_matrix_program_aa_[i][j].Cleanup(gl_);
-      render_pass_mask_color_matrix_program_[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_);
     texture_io_surface_program_[i].Cleanup(gl_);
 
     video_yuv_program_[i].Cleanup(gl_);
     video_yuva_program_[i].Cleanup(gl_);
@@ skipping 89 matching lines @@
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order,
         overlay.transform,
         pending_overlay_resources_.back()->texture_id(),
         overlay.display_rect,
         overlay.uv_rect);
   }
 }
 
 }  // namespace cc