The great shader refactor: Move all programs to a common cache

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 <stdint.h>
 
 #include <set>
 #include <vector>
@@ skipping 366 matching lines @@
     resource_provider_ = FakeResourceProvider::Create(
         output_surface_->context_provider(), shared_bitmap_manager_.get());
     renderer_.reset(new FakeRendererGL(&settings_, output_surface_.get(),
                                        resource_provider_.get()));
     renderer_->Initialize();
     renderer_->SetVisible(true);
   }
 
   void TestRenderPassProgram(TexCoordPrecision precision,
                              BlendMode blend_mode) {
-    EXPECT_PROGRAM_VALID(
-        &renderer_->render_pass_program_[precision][blend_mode]);
-    EXPECT_EQ(renderer_->render_pass_program_[precision][blend_mode].program(),
-              renderer_->program_shadow_);
+    const GLRenderer::Program* program = renderer_->GetProgramForTesting(
+        ProgramKey::RenderPass(precision, SAMPLER_TYPE_2D, blend_mode, NO_AA,
+                               NO_MASK, false, false));
+    EXPECT_PROGRAM_VALID(program);
+    EXPECT_EQ(program->program(), renderer_->program_shadow_);
   }
 
   void TestRenderPassColorMatrixProgram(TexCoordPrecision precision,
                                         BlendMode blend_mode) {
-    EXPECT_PROGRAM_VALID(
-        &renderer_->render_pass_color_matrix_program_[precision][blend_mode]);
-    EXPECT_EQ(
-        renderer_->render_pass_color_matrix_program_[precision][blend_mode]
-            .program(),
-        renderer_->program_shadow_);
+    const GLRenderer::Program* program = renderer_->GetProgramForTesting(
+        ProgramKey::RenderPass(precision, SAMPLER_TYPE_2D, blend_mode, NO_AA,
+                               NO_MASK, false, true));
+    EXPECT_PROGRAM_VALID(program);
+    EXPECT_EQ(program->program(), renderer_->program_shadow_);
   }
 
   void TestRenderPassMaskProgram(TexCoordPrecision precision,
                                  SamplerType sampler,
                                  BlendMode blend_mode) {
-    EXPECT_PROGRAM_VALID(
-        &renderer_->render_pass_mask_program_[precision]
-                                             [sampler]
-                                             [blend_mode]
-                                             [NO_MASK]);
-    EXPECT_EQ(
-        renderer_->render_pass_mask_program_[precision]
-                                            [sampler]
-                                            [blend_mode]
-                                            [NO_MASK].program(),
-        renderer_->program_shadow_);
+    const GLRenderer::Program* program =
+        renderer_->GetProgramForTesting(ProgramKey::RenderPass(
+            precision, sampler, blend_mode, NO_AA, HAS_MASK, false, false));
+    EXPECT_PROGRAM_VALID(program);
+    EXPECT_EQ(program->program(), renderer_->program_shadow_);
   }
 
   void TestRenderPassMaskColorMatrixProgram(TexCoordPrecision precision,
                                             SamplerType sampler,
                                             BlendMode blend_mode) {
-    EXPECT_PROGRAM_VALID(&renderer_->render_pass_mask_color_matrix_program_
-                              [precision][sampler][blend_mode][NO_MASK]);
-    EXPECT_EQ(renderer_->render_pass_mask_color_matrix_program_
-                  [precision][sampler][blend_mode][NO_MASK].program(),
-              renderer_->program_shadow_);
+    const GLRenderer::Program* program =
+        renderer_->GetProgramForTesting(ProgramKey::RenderPass(
+            precision, sampler, blend_mode, NO_AA, HAS_MASK, false, true));
+    EXPECT_PROGRAM_VALID(program);
+    EXPECT_EQ(program->program(), renderer_->program_shadow_);
   }
 
   void TestRenderPassProgramAA(TexCoordPrecision precision,
                                BlendMode blend_mode) {
-    EXPECT_PROGRAM_VALID(
-        &renderer_->render_pass_program_aa_[precision][blend_mode]);
-    EXPECT_EQ(
-        renderer_->render_pass_program_aa_[precision][blend_mode].program(),
-        renderer_->program_shadow_);
+    const GLRenderer::Program* program = renderer_->GetProgramForTesting(
+        ProgramKey::RenderPass(precision, SAMPLER_TYPE_2D, blend_mode, USE_AA,
+                               NO_MASK, false, false));
+    EXPECT_PROGRAM_VALID(program);
+    EXPECT_EQ(program->program(), renderer_->program_shadow_);
   }
 
   void TestRenderPassColorMatrixProgramAA(TexCoordPrecision precision,
                                           BlendMode blend_mode) {
-    EXPECT_PROGRAM_VALID(
-        &renderer_
-             ->render_pass_color_matrix_program_aa_[precision][blend_mode]);
-    EXPECT_EQ(
-        renderer_->render_pass_color_matrix_program_aa_[precision][blend_mode]
-            .program(),
-        renderer_->program_shadow_);
+    const GLRenderer::Program* program = renderer_->GetProgramForTesting(
+        ProgramKey::RenderPass(precision, SAMPLER_TYPE_2D, blend_mode, USE_AA,
+                               NO_MASK, false, true));
+    EXPECT_PROGRAM_VALID(program);
+    EXPECT_EQ(program->program(), renderer_->program_shadow_);
   }
 
   void TestRenderPassMaskProgramAA(TexCoordPrecision precision,
                                    SamplerType sampler,
                                    BlendMode blend_mode) {
-    EXPECT_PROGRAM_VALID(
-        &renderer_
-             ->render_pass_mask_program_aa_
-                 [precision][sampler][blend_mode][NO_MASK]);
-    EXPECT_EQ(
-        renderer_->render_pass_mask_program_aa_[precision][sampler][blend_mode]
-            [NO_MASK].program(),
-        renderer_->program_shadow_);
+    const GLRenderer::Program* program =
+        renderer_->GetProgramForTesting(ProgramKey::RenderPass(
+            precision, sampler, blend_mode, USE_AA, HAS_MASK, false, false));
+    EXPECT_PROGRAM_VALID(program);
+    EXPECT_EQ(program->program(), renderer_->program_shadow_);
   }
 
   void TestRenderPassMaskColorMatrixProgramAA(TexCoordPrecision precision,
                                               SamplerType sampler,
                                               BlendMode blend_mode) {
-    EXPECT_PROGRAM_VALID(&renderer_->render_pass_mask_color_matrix_program_aa_
-                              [precision][sampler][blend_mode][NO_MASK]);
-    EXPECT_EQ(renderer_->render_pass_mask_color_matrix_program_aa_
-                  [precision][sampler][blend_mode][NO_MASK].program(),
-              renderer_->program_shadow_);
+    const GLRenderer::Program* program =
+        renderer_->GetProgramForTesting(ProgramKey::RenderPass(
+            precision, sampler, blend_mode, USE_AA, HAS_MASK, false, true));
+    EXPECT_PROGRAM_VALID(program);
+    EXPECT_EQ(program->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_);
+    const GLRenderer::Program* program =
+        renderer_->GetProgramForTesting(ProgramKey::SolidColor(USE_AA));
+    EXPECT_PROGRAM_VALID(program);
+    EXPECT_EQ(program->program(), renderer_->program_shadow_);
   }
 
   RendererSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
   std::unique_ptr<FakeOutputSurface> output_surface_;
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
   std::unique_ptr<ResourceProvider> resource_provider_;
   std::unique_ptr<FakeRendererGL> renderer_;
 };
 
@@ skipping 1485 matching lines @@
   renderer_->SetVisible(true);
   Mock::VerifyAndClearExpectations(context_support_ptr_);
 
   EXPECT_CALL(*context_support_ptr_, SetAggressivelyFreeResources(true));
   renderer_->SetVisible(false);
   Mock::VerifyAndClearExpectations(context_support_ptr_);
 }
 
 }  // namespace
 }  // namespace cc