cc: Allow TEXTURE_RECTANGLE_ARB to be used for tile textures.

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 58 matching lines @@
     EXPECT_PROGRAM_VALID(renderer()->GetTileCheckerboardProgram());
     EXPECT_PROGRAM_VALID(renderer()->GetDebugBorderProgram());
     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()->GetTileProgram(precision));
-    EXPECT_PROGRAM_VALID(renderer()->GetTileProgramOpaque(precision));
-    EXPECT_PROGRAM_VALID(renderer()->GetTileProgramAA(precision));
-    EXPECT_PROGRAM_VALID(renderer()->GetTileProgramSwizzle(precision));
-    EXPECT_PROGRAM_VALID(renderer()->GetTileProgramSwizzleOpaque(precision));
-    EXPECT_PROGRAM_VALID(renderer()->GetTileProgramSwizzleAA(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.
     if (renderer()->Capabilities().using_egl_image)
       EXPECT_PROGRAM_VALID(renderer()->GetVideoStreamTextureProgram(precision));
     else
       EXPECT_FALSE(renderer()->GetVideoStreamTextureProgram(precision));
+    TestShadersWithSamplerType(precision, SamplerType2D);
+    TestShadersWithSamplerType(precision, SamplerType2DRect);
+    // This is unlikely to be ever true in tests due to usage of osmesa.
+    if (renderer()->Capabilities().using_egl_image)
+      TestShadersWithSamplerType(precision, SamplerTypeExternalOES);
+  }
+
+  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));
   }
 };
 
 namespace {
 
 #if !defined(OS_ANDROID)
 TEST_F(GLRendererShaderPixelTest, AllShadersCompile) { TestShaders(); }
 #endif
 
 class FrameCountingContext : public TestWebGraphicsContext3D {
@@ skipping 133 matching lines @@
 
     resource_provider_ = ResourceProvider::Create(
         output_surface_.get(), NULL, 0, false, 1).Pass();
     renderer_.reset(new FakeRendererGL(&renderer_client_,
                                        &settings_,
                                        output_surface_.get(),
                                        resource_provider_.get()));
     renderer_->Initialize();
   }
 
-  void TestRenderPassProgram() {
-    EXPECT_PROGRAM_VALID(&renderer_->render_pass_program_);
-    EXPECT_EQ(renderer_->render_pass_program_.program(),
+  void TestRenderPassProgram(TexCoordPrecision precision) {
+    EXPECT_PROGRAM_VALID(&renderer_->render_pass_program_[precision]);
+    EXPECT_EQ(renderer_->render_pass_program_[precision].program(),
               renderer_->program_shadow_);
   }
 
-  void TestRenderPassColorMatrixProgram() {
-    EXPECT_PROGRAM_VALID(&renderer_->render_pass_color_matrix_program_);
-    EXPECT_EQ(renderer_->render_pass_color_matrix_program_.program(),
+  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 TestRenderPassMaskProgram() {
-    EXPECT_PROGRAM_VALID(&renderer_->render_pass_mask_program_);
-    EXPECT_EQ(renderer_->render_pass_mask_program_.program(),
+  void TestRenderPassMaskColorMatrixProgram(TexCoordPrecision precision) {
+    EXPECT_PROGRAM_VALID(
+        &renderer_->render_pass_mask_color_matrix_program_[precision]);
+    EXPECT_EQ(renderer_->
+              render_pass_mask_color_matrix_program_[precision].program(),
               renderer_->program_shadow_);
   }
 
-  void TestRenderPassMaskColorMatrixProgram() {
-    EXPECT_PROGRAM_VALID(&renderer_->render_pass_mask_color_matrix_program_);
-    EXPECT_EQ(renderer_->render_pass_mask_color_matrix_program_.program(),
+  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 TestRenderPassProgramAA() {
-    EXPECT_PROGRAM_VALID(&renderer_->render_pass_program_aa_);
-    EXPECT_EQ(renderer_->render_pass_program_aa_.program(),
+  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 TestRenderPassColorMatrixProgramAA() {
-    EXPECT_PROGRAM_VALID(&renderer_->render_pass_color_matrix_program_aa_);
-    EXPECT_EQ(renderer_->render_pass_color_matrix_program_aa_.program(),
+  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() {
-    EXPECT_PROGRAM_VALID(&renderer_->render_pass_mask_program_aa_);
-    EXPECT_EQ(renderer_->render_pass_mask_program_aa_.program(),
+  void TestRenderPassMaskColorMatrixProgramAA(TexCoordPrecision precision) {
+    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_);
   }
 
-  void TestRenderPassMaskColorMatrixProgramAA() {
-    EXPECT_PROGRAM_VALID(&renderer_->render_pass_mask_color_matrix_program_aa_);
-    EXPECT_EQ(renderer_->render_pass_mask_color_matrix_program_aa_.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_;
   scoped_ptr<FakeOutputSurface> output_surface_;
   FakeRendererClient renderer_client_;
@@ skipping 1038 matching lines @@
   AddRenderPassQuad(root_pass,
                     child_pass,
                     0,
                     FilterOperations(),
                     gfx::Transform());
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *renderer_client_.render_passes_in_draw_order());
   renderer_->DrawFrame(
       renderer_client_.render_passes_in_draw_order(), NULL, 1.f, true, false);
-  TestRenderPassProgram();
+  TestRenderPassProgram(TexCoordPrecisionMedium);
 
   // RenderPassColorMatrixProgram
   render_passes->clear();
 
   child_pass = AddRenderPass(
       render_passes, child_pass_id, child_rect, transform_causing_aa);
 
   root_pass = AddRenderPass(
       render_passes, root_pass_id, viewport_rect, gfx::Transform());
 
   AddRenderPassQuad(root_pass, child_pass, 0, filters, gfx::Transform());
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *renderer_client_.render_passes_in_draw_order());
   renderer_->DrawFrame(
       renderer_client_.render_passes_in_draw_order(), NULL, 1.f, true, false);
-  TestRenderPassColorMatrixProgram();
+  TestRenderPassColorMatrixProgram(TexCoordPrecisionMedium);
 
   // RenderPassMaskProgram
   render_passes->clear();
 
   child_pass = AddRenderPass(
       render_passes, child_pass_id, child_rect, gfx::Transform());
 
   root_pass = AddRenderPass(
       render_passes, root_pass_id, viewport_rect, gfx::Transform());
 
   AddRenderPassQuad(root_pass,
                     child_pass,
                     mask,
                     FilterOperations(),
                     gfx::Transform());
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *renderer_client_.render_passes_in_draw_order());
   renderer_->DrawFrame(
       renderer_client_.render_passes_in_draw_order(), NULL, 1.f, true, false);
-  TestRenderPassMaskProgram();
+  TestRenderPassMaskProgram(TexCoordPrecisionMedium);
 
   // RenderPassMaskColorMatrixProgram
   render_passes->clear();
 
   child_pass = AddRenderPass(
       render_passes, child_pass_id, child_rect, gfx::Transform());
 
   root_pass = AddRenderPass(
       render_passes, root_pass_id, viewport_rect, gfx::Transform());
 
   AddRenderPassQuad(root_pass, child_pass, mask, filters, gfx::Transform());
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *renderer_client_.render_passes_in_draw_order());
   renderer_->DrawFrame(
       renderer_client_.render_passes_in_draw_order(), NULL, 1.f, true, false);
-  TestRenderPassMaskColorMatrixProgram();
+  TestRenderPassMaskColorMatrixProgram(TexCoordPrecisionMedium);
 
   // RenderPassProgramAA
   render_passes->clear();
 
   child_pass = AddRenderPass(
       render_passes, child_pass_id, child_rect, transform_causing_aa);
 
   root_pass = AddRenderPass(
       render_passes, root_pass_id, viewport_rect, gfx::Transform());
 
   AddRenderPassQuad(root_pass,
                     child_pass,
                     0,
                     FilterOperations(),
                     transform_causing_aa);
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *renderer_client_.render_passes_in_draw_order());
   renderer_->DrawFrame(
       renderer_client_.render_passes_in_draw_order(), NULL, 1.f, true, false);
-  TestRenderPassProgramAA();
+  TestRenderPassProgramAA(TexCoordPrecisionMedium);
 
   // RenderPassColorMatrixProgramAA
   render_passes->clear();
 
   child_pass = AddRenderPass(
       render_passes, child_pass_id, child_rect, transform_causing_aa);
 
   root_pass = AddRenderPass(
       render_passes, root_pass_id, viewport_rect, gfx::Transform());
 
   AddRenderPassQuad(root_pass, child_pass, 0, filters, transform_causing_aa);
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *renderer_client_.render_passes_in_draw_order());
   renderer_->DrawFrame(
       renderer_client_.render_passes_in_draw_order(), NULL, 1.f, true, false);
-  TestRenderPassColorMatrixProgramAA();
+  TestRenderPassColorMatrixProgramAA(TexCoordPrecisionMedium);
 
   // RenderPassMaskProgramAA
   render_passes->clear();
 
   child_pass = AddRenderPass(render_passes, child_pass_id, child_rect,
       transform_causing_aa);
 
   root_pass = AddRenderPass(render_passes, root_pass_id, viewport_rect,
       gfx::Transform());
 
   AddRenderPassQuad(root_pass, child_pass, mask, FilterOperations(),
       transform_causing_aa);
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *renderer_client_.render_passes_in_draw_order());
   renderer_->DrawFrame(
       renderer_client_.render_passes_in_draw_order(), NULL, 1.f, true, false);
-  TestRenderPassMaskProgramAA();
+  TestRenderPassMaskProgramAA(TexCoordPrecisionMedium);
 
   // RenderPassMaskColorMatrixProgramAA
   render_passes->clear();
 
   child_pass = AddRenderPass(render_passes, child_pass_id, child_rect,
       transform_causing_aa);
 
   root_pass = AddRenderPass(render_passes, root_pass_id, viewport_rect,
       transform_causing_aa);
 
   AddRenderPassQuad(root_pass, child_pass, mask, filters, transform_causing_aa);
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *renderer_client_.render_passes_in_draw_order());
   renderer_->DrawFrame(
       renderer_client_.render_passes_in_draw_order(), NULL, 1.f, true, false);
-  TestRenderPassMaskColorMatrixProgramAA();
+  TestRenderPassMaskColorMatrixProgramAA(TexCoordPrecisionMedium);
 }
 
 // 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);
   RenderPass::Id child_pass_id(2, 0);
   TestRenderPass* child_pass;
 
   gfx::Rect viewport_rect(renderer_client_.DeviceViewport());
@@ skipping 31 matching lines @@
                     FilterOperations(),
                     transform_preventing_aa);
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *renderer_client_.render_passes_in_draw_order());
   renderer_->DrawFrame(
       renderer_client_.render_passes_in_draw_order(), NULL, 1.f, true, false);
 
   // If use_aa incorrectly ignores clipping, it will use the
   // RenderPassProgramAA shader instead of the RenderPassProgram.
-  TestRenderPassProgram();
+  TestRenderPassProgram(TexCoordPrecisionMedium);
 }
 
 TEST_F(GLRendererShaderTest, DrawSolidColorShader) {
   gfx::Rect viewport_rect(renderer_client_.DeviceViewport());
   ScopedPtrVector<RenderPass>* render_passes =
       renderer_client_.render_passes_in_draw_order();
 
   RenderPass::Id root_pass_id(1, 0);
   TestRenderPass* root_pass;
 
@@ skipping 215 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