Update from chromium https://crrev.com/302282

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 96 matching lines @@
     ASSERT_FALSE(renderer()->IsContextLost());
   }
 
   void TestShadersWithTexCoordPrecision(TexCoordPrecision precision) {
     for (int i = 0; i < NumBlendModes; ++i) {
       BlendMode blend_mode = static_cast<BlendMode>(i);
       EXPECT_PROGRAM_VALID(
           renderer()->GetRenderPassProgram(precision, blend_mode));
       EXPECT_PROGRAM_VALID(
           renderer()->GetRenderPassProgramAA(precision, blend_mode));
-      EXPECT_PROGRAM_VALID(
-          renderer()->GetRenderPassMaskProgram(precision, blend_mode));
-      EXPECT_PROGRAM_VALID(
-          renderer()->GetRenderPassMaskProgramAA(precision, blend_mode));
-      EXPECT_PROGRAM_VALID(
-          renderer()->GetRenderPassColorMatrixProgram(precision, blend_mode));
-      EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskColorMatrixProgramAA(
-          precision, blend_mode));
-      EXPECT_PROGRAM_VALID(
-          renderer()->GetRenderPassColorMatrixProgramAA(precision, blend_mode));
-      EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskColorMatrixProgram(
-          precision, blend_mode));
     }
     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));
@@ skipping 12 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));
+    for (int i = 0; i < NumBlendModes; ++i) {
+      BlendMode blend_mode = static_cast<BlendMode>(i);
+      EXPECT_PROGRAM_VALID(
+          renderer()->GetRenderPassMaskProgram(precision, sampler, blend_mode));
+      EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskProgramAA(
+          precision, sampler, blend_mode));
+      EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskColorMatrixProgramAA(
+          precision, sampler, blend_mode));
+      EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskColorMatrixProgram(
+          precision, sampler, blend_mode));
+    }
   }
 };
 
 namespace {
 
 #if !defined(OS_ANDROID)
 TEST_F(GLRendererShaderPixelTest, AllShadersCompile) { TestShaders(); }
 #endif
 
 class FakeRendererGL : public GLRenderer {
@@ skipping 88 matching lines @@
                                         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_);
   }
 
   void TestRenderPassMaskProgram(TexCoordPrecision precision,
+                                 SamplerType sampler,
                                  BlendMode blend_mode) {
     EXPECT_PROGRAM_VALID(
-        &renderer_->render_pass_mask_program_[precision][blend_mode]);
+        &renderer_->render_pass_mask_program_[precision][sampler][blend_mode]);
     EXPECT_EQ(
-        renderer_->render_pass_mask_program_[precision][blend_mode].program(),
+        renderer_->render_pass_mask_program_[precision][sampler][blend_mode]
+            .program(),
         renderer_->program_shadow_);
   }
 
   void TestRenderPassMaskColorMatrixProgram(TexCoordPrecision precision,
+                                            SamplerType sampler,
                                             BlendMode blend_mode) {
-    EXPECT_PROGRAM_VALID(
-        &renderer_
-             ->render_pass_mask_color_matrix_program_[precision][blend_mode]);
-    EXPECT_EQ(
-        renderer_->render_pass_mask_color_matrix_program_[precision][blend_mode]
-            .program(),
-        renderer_->program_shadow_);
+    EXPECT_PROGRAM_VALID(&renderer_->render_pass_mask_color_matrix_program_
+                              [precision][sampler][blend_mode]);
+    EXPECT_EQ(renderer_->render_pass_mask_color_matrix_program_
+                  [precision][sampler][blend_mode].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_);
   }
 
   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_);
   }
 
   void TestRenderPassMaskProgramAA(TexCoordPrecision precision,
+                                   SamplerType sampler,
                                    BlendMode blend_mode) {
     EXPECT_PROGRAM_VALID(
-        &renderer_->render_pass_mask_program_aa_[precision][blend_mode]);
-    EXPECT_EQ(renderer_->render_pass_mask_program_aa_[precision][blend_mode]
-                  .program(),
-              renderer_->program_shadow_);
-  }
-
-  void TestRenderPassMaskColorMatrixProgramAA(TexCoordPrecision precision,
-                                              BlendMode blend_mode) {
-    EXPECT_PROGRAM_VALID(&renderer_->render_pass_mask_color_matrix_program_aa_
-                              [precision][blend_mode]);
+        &renderer_
+             ->render_pass_mask_program_aa_[precision][sampler][blend_mode]);
     EXPECT_EQ(
-        renderer_
-            ->render_pass_mask_color_matrix_program_aa_[precision][blend_mode]
+        renderer_->render_pass_mask_program_aa_[precision][sampler][blend_mode]
             .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]);
+    EXPECT_EQ(renderer_->render_pass_mask_color_matrix_program_aa_
+                  [precision][sampler][blend_mode].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 1154 matching lines @@
                       gfx::Transform(),
                       xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
     renderer_->DrawFrame(&render_passes_in_draw_order_,
                          1.f,
                          viewport_rect,
                          viewport_rect,
                          false);
-    TestRenderPassMaskProgram(TexCoordPrecisionMedium, blend_mode);
+    TestRenderPassMaskProgram(
+        TexCoordPrecisionMedium, SamplerType2D, blend_mode);
 
     // 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(), xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
     renderer_->DrawFrame(&render_passes_in_draw_order_,
                          1.f,
                          viewport_rect,
                          viewport_rect,
                          false);
-    TestRenderPassMaskColorMatrixProgram(TexCoordPrecisionMedium, blend_mode);
+    TestRenderPassMaskColorMatrixProgram(
+        TexCoordPrecisionMedium, SamplerType2D, blend_mode);
 
     // 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 62 matching lines @@
                       transform_causing_aa,
                       xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
     renderer_->DrawFrame(&render_passes_in_draw_order_,
                          1.f,
                          viewport_rect,
                          viewport_rect,
                          false);
-    TestRenderPassMaskProgramAA(TexCoordPrecisionMedium, blend_mode);
+    TestRenderPassMaskProgramAA(
+        TexCoordPrecisionMedium, SamplerType2D, blend_mode);
 
     // 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, xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
     renderer_->DrawFrame(&render_passes_in_draw_order_,
                          1.f,
                          viewport_rect,
                          viewport_rect,
                          false);
-    TestRenderPassMaskColorMatrixProgramAA(TexCoordPrecisionMedium, blend_mode);
+    TestRenderPassMaskColorMatrixProgramAA(
+        TexCoordPrecisionMedium, SamplerType2D, blend_mode);
   }
 }
 
 // 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;
 
@@ skipping 269 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