cc: Support texture rect targets for masks

cc/output/gl_renderer_unittest.cc

 // Copyright 2012 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 <set>
 
 #include "cc/base/math_util.h"
 #include "cc/output/compositor_frame_metadata.h"
@@ skipping 54 matching lines @@
     EXPECT_PROGRAM_VALID(renderer()->GetSolidColorProgram());
     EXPECT_PROGRAM_VALID(renderer()->GetSolidColorProgramAA());
     TestShadersWithTexCoordPrecision(TexCoordPrecisionMedium);
     TestShadersWithTexCoordPrecision(TexCoordPrecisionHigh);
     ASSERT_FALSE(renderer()->IsContextLost());
   }
 
   void TestShadersWithTexCoordPrecision(TexCoordPrecision precision) {
     EXPECT_PROGRAM_VALID(renderer()->GetRenderPassProgram(precision));
     EXPECT_PROGRAM_VALID(renderer()->GetRenderPassProgramAA(precision));
-    EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskProgram(precision));
-    EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskProgramAA(precision));
     EXPECT_PROGRAM_VALID(
         renderer()->GetRenderPassColorMatrixProgram(precision));
     EXPECT_PROGRAM_VALID(
-        renderer()->GetRenderPassMaskColorMatrixProgramAA(precision));
-    EXPECT_PROGRAM_VALID(
         renderer()->GetRenderPassColorMatrixProgramAA(precision));
-    EXPECT_PROGRAM_VALID(
-        renderer()->GetRenderPassMaskColorMatrixProgram(precision));
     EXPECT_PROGRAM_VALID(renderer()->GetTextureProgram(precision));
     EXPECT_PROGRAM_VALID(
         renderer()->GetNonPremultipliedTextureProgram(precision));
     EXPECT_PROGRAM_VALID(renderer()->GetTextureBackgroundProgram(precision));
     EXPECT_PROGRAM_VALID(
         renderer()->GetNonPremultipliedTextureBackgroundProgram(precision));
     EXPECT_PROGRAM_VALID(renderer()->GetTextureIOSurfaceProgram(precision));
     EXPECT_PROGRAM_VALID(renderer()->GetVideoYUVProgram(precision));
     EXPECT_PROGRAM_VALID(renderer()->GetVideoYUVAProgram(precision));
     // This is unlikely to be ever true in tests due to usage of osmesa.
@@ skipping 11 matching lines @@
   void TestShadersWithSamplerType(TexCoordPrecision precision,
                                   SamplerType sampler) {
     EXPECT_PROGRAM_VALID(renderer()->GetTileProgram(precision, sampler));
     EXPECT_PROGRAM_VALID(renderer()->GetTileProgramOpaque(precision, sampler));
     EXPECT_PROGRAM_VALID(renderer()->GetTileProgramAA(precision, sampler));
     EXPECT_PROGRAM_VALID(renderer()->GetTileProgramSwizzle(precision, sampler));
     EXPECT_PROGRAM_VALID(
         renderer()->GetTileProgramSwizzleOpaque(precision, sampler));
     EXPECT_PROGRAM_VALID(
         renderer()->GetTileProgramSwizzleAA(precision, sampler));
+    EXPECT_PROGRAM_VALID(
+        renderer()->GetRenderPassMaskProgram(precision, sampler));
+    EXPECT_PROGRAM_VALID(
+        renderer()->GetRenderPassMaskProgramAA(precision, sampler));
+    EXPECT_PROGRAM_VALID(
+        renderer()->GetRenderPassMaskColorMatrixProgramAA(precision, sampler));
+    EXPECT_PROGRAM_VALID(
+        renderer()->GetRenderPassMaskColorMatrixProgram(precision, sampler));
   }
 };
 
 namespace {
 
 #if !defined(OS_ANDROID)
 TEST_F(GLRendererShaderPixelTest, AllShadersCompile) { TestShaders(); }
 #endif
 
 class FakeRendererGL : public GLRenderer {
@@ skipping 84 matching lines @@
               renderer_->program_shadow_);
   }
 
   void TestRenderPassColorMatrixProgram(TexCoordPrecision precision) {
     EXPECT_PROGRAM_VALID(
         &renderer_->render_pass_color_matrix_program_[precision]);
     EXPECT_EQ(renderer_->render_pass_color_matrix_program_[precision].program(),
               renderer_->program_shadow_);
   }
 
-  void TestRenderPassMaskProgram(TexCoordPrecision precision) {
-    EXPECT_PROGRAM_VALID(&renderer_->render_pass_mask_program_[precision]);
-    EXPECT_EQ(renderer_->render_pass_mask_program_[precision].program(),
-              renderer_->program_shadow_);
-  }
-
-  void TestRenderPassMaskColorMatrixProgram(TexCoordPrecision precision) {
+  void TestRenderPassMaskProgram(TexCoordPrecision precision,
+                                 SamplerType sampler) {
     EXPECT_PROGRAM_VALID(
-        &renderer_->render_pass_mask_color_matrix_program_[precision]);
+        &renderer_->render_pass_mask_program_[precision][sampler]);
     EXPECT_EQ(
-        renderer_->render_pass_mask_color_matrix_program_[precision].program(),
+        renderer_->render_pass_mask_program_[precision][sampler].program(),
         renderer_->program_shadow_);
   }
 
+  void TestRenderPassMaskColorMatrixProgram(TexCoordPrecision precision,
+                                            SamplerType sampler) {
+    EXPECT_PROGRAM_VALID(
+        &renderer_->render_pass_mask_color_matrix_program_[precision][sampler]);
+    EXPECT_EQ(
+        renderer_->render_pass_mask_color_matrix_program_[precision][sampler]
+            .program(),
+        renderer_->program_shadow_);
+  }
+
   void TestRenderPassProgramAA(TexCoordPrecision precision) {
     EXPECT_PROGRAM_VALID(&renderer_->render_pass_program_aa_[precision]);
     EXPECT_EQ(renderer_->render_pass_program_aa_[precision].program(),
               renderer_->program_shadow_);
   }
 
   void TestRenderPassColorMatrixProgramAA(TexCoordPrecision precision) {
     EXPECT_PROGRAM_VALID(
         &renderer_->render_pass_color_matrix_program_aa_[precision]);
     EXPECT_EQ(
         renderer_->render_pass_color_matrix_program_aa_[precision].program(),
         renderer_->program_shadow_);
   }
 
-  void TestRenderPassMaskProgramAA(TexCoordPrecision precision) {
-    EXPECT_PROGRAM_VALID(&renderer_->render_pass_mask_program_aa_[precision]);
-    EXPECT_EQ(renderer_->render_pass_mask_program_aa_[precision].program(),
-              renderer_->program_shadow_);
+  void TestRenderPassMaskProgramAA(TexCoordPrecision precision,
+                                   SamplerType sampler) {
+    EXPECT_PROGRAM_VALID(
+        &renderer_->render_pass_mask_program_aa_[precision][sampler]);
+    EXPECT_EQ(
+        renderer_->render_pass_mask_program_aa_[precision][sampler].program(),
+        renderer_->program_shadow_);
   }
 
-  void TestRenderPassMaskColorMatrixProgramAA(TexCoordPrecision precision) {
+  void TestRenderPassMaskColorMatrixProgramAA(TexCoordPrecision precision,
+                                              SamplerType sampler) {
     EXPECT_PROGRAM_VALID(
-        &renderer_->render_pass_mask_color_matrix_program_aa_[precision]);
-    EXPECT_EQ(renderer_->render_pass_mask_color_matrix_program_aa_[precision]
-                  .program(),
-              renderer_->program_shadow_);
+        &renderer_
+             ->render_pass_mask_color_matrix_program_aa_[precision][sampler]);
+    EXPECT_EQ(
+        renderer_->render_pass_mask_color_matrix_program_aa_[precision][sampler]
+            .program(),
+        renderer_->program_shadow_);
   }
 
   void TestSolidColorProgramAA() {
     EXPECT_PROGRAM_VALID(&renderer_->solid_color_program_aa_);
     EXPECT_EQ(renderer_->solid_color_program_aa_.program(),
               renderer_->program_shadow_);
   }
 
   LayerTreeSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
@@ skipping 1151 matching lines @@
 
   AddRenderPassQuad(
       root_pass, child_pass, mask, FilterOperations(), gfx::Transform());
 
   renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   renderer_->DrawFrame(&render_passes_in_draw_order_,
                        1.f,
                        viewport_rect,
                        viewport_rect,
                        false);
-  TestRenderPassMaskProgram(TexCoordPrecisionMedium);
+  TestRenderPassMaskProgram(TexCoordPrecisionMedium, SamplerType2D);
 
   // RenderPassMaskColorMatrixProgram
   render_passes_in_draw_order_.clear();
 
   child_pass = AddRenderPass(&render_passes_in_draw_order_,
                              child_pass_id,
                              child_rect,
                              gfx::Transform());
 
   root_pass = AddRenderPass(&render_passes_in_draw_order_,
                             root_pass_id,
                             viewport_rect,
                             gfx::Transform());
 
   AddRenderPassQuad(root_pass, child_pass, mask, filters, gfx::Transform());
 
   renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   renderer_->DrawFrame(&render_passes_in_draw_order_,
                        1.f,
                        viewport_rect,
                        viewport_rect,
                        false);
-  TestRenderPassMaskColorMatrixProgram(TexCoordPrecisionMedium);
+  TestRenderPassMaskColorMatrixProgram(TexCoordPrecisionMedium, SamplerType2D);
 
   // RenderPassProgramAA
   render_passes_in_draw_order_.clear();
 
   child_pass = AddRenderPass(&render_passes_in_draw_order_,
                              child_pass_id,
                              child_rect,
                              transform_causing_aa);
 
   root_pass = AddRenderPass(&render_passes_in_draw_order_,
@@ skipping 50 matching lines @@
 
   AddRenderPassQuad(
       root_pass, child_pass, mask, FilterOperations(), transform_causing_aa);
 
   renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   renderer_->DrawFrame(&render_passes_in_draw_order_,
                        1.f,
                        viewport_rect,
                        viewport_rect,
                        false);
-  TestRenderPassMaskProgramAA(TexCoordPrecisionMedium);
+  TestRenderPassMaskProgramAA(TexCoordPrecisionMedium, SamplerType2D);
 
   // RenderPassMaskColorMatrixProgramAA
   render_passes_in_draw_order_.clear();
 
   child_pass = AddRenderPass(&render_passes_in_draw_order_,
                              child_pass_id,
                              child_rect,
                              transform_causing_aa);
 
   root_pass = AddRenderPass(&render_passes_in_draw_order_,
                             root_pass_id,
                             viewport_rect,
                             transform_causing_aa);
 
   AddRenderPassQuad(root_pass, child_pass, mask, filters, transform_causing_aa);
 
   renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   renderer_->DrawFrame(&render_passes_in_draw_order_,
                        1.f,
                        viewport_rect,
                        viewport_rect,
                        false);
-  TestRenderPassMaskColorMatrixProgramAA(TexCoordPrecisionMedium);
+  TestRenderPassMaskColorMatrixProgramAA(TexCoordPrecisionMedium,
+                                         SamplerType2D);
 }
 
 // At this time, the AA code path cannot be taken if the surface's rect would
 // project incorrectly by the given transform, because of w<0 clipping.
 TEST_F(GLRendererShaderTest, DrawRenderPassQuadSkipsAAForClippingTransform) {
   gfx::Rect child_rect(50, 50);
   RenderPassId child_pass_id(2, 0);
   TestRenderPass* child_pass;
 
   gfx::Rect viewport_rect(1, 1);
@@ skipping 265 matching lines @@
   base::MessageLoop::current()->Run();
 
   // The sync point should have happened.
   EXPECT_EQ(1, sync_point_callback_count);
   EXPECT_EQ(1, other_callback_count);
 }
 #endif  // OS_ANDROID
 
 }  // namespace
 }  // namespace cc