Background filters are affected by 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 131 matching lines @@
     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 <= LAST_BLEND_MODE; ++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));
+      for (int l = 0; l <= 1; ++l) {
+        bool mask_for_background = (l == 1);
+        EXPECT_PROGRAM_VALID(
+            renderer()->GetRenderPassMaskProgram(precision,
+                                                 sampler,
+                                                 blend_mode,
+                                                 mask_for_background));
+        EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskProgramAA(
+            precision, sampler, blend_mode, mask_for_background));
+        EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskColorMatrixProgramAA(
+            precision, sampler, blend_mode, mask_for_background));
+        EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskColorMatrixProgram(
+            precision, sampler, blend_mode, mask_for_background));
+      }
     }
   }
 };
 
 namespace {
 
 #if !defined(OS_ANDROID)
 TEST_F(GLRendererShaderPixelTest, AllShadersCompile) { TestShaders(); }
 #endif
 
@@ skipping 92 matching lines @@
     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][sampler][blend_mode]);
+        &renderer_->render_pass_mask_program_[precision]
+                                             [sampler]
+                                             [blend_mode]
+                                             [0]);

[enne (OOO), 2015/03/03 23:27:47]

This is just a style nit, but I'm not super keen on 0 and 1, as it's not clear
to the reader what that's supposed to mean in a bunch of these callsites.  I
know there's only two values, but could you make this explicit with a HAS_MASK /
NO_MASK / LAST_MASK_VALUE enum?

     EXPECT_EQ(
-        renderer_->render_pass_mask_program_[precision][sampler][blend_mode]
-            .program(),
+        renderer_->render_pass_mask_program_[precision]
+                                            [sampler]
+                                            [blend_mode]
+                                            [0].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]);
+                              [precision][sampler][blend_mode][0]);
     EXPECT_EQ(renderer_->render_pass_mask_color_matrix_program_
-                  [precision][sampler][blend_mode].program(),
+                  [precision][sampler][blend_mode][0].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][sampler][blend_mode]);
+             ->render_pass_mask_program_aa_[precision][sampler][blend_mode][0]);
     EXPECT_EQ(
         renderer_->render_pass_mask_program_aa_[precision][sampler][blend_mode]
-            .program(),
+            [0].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]);
+                              [precision][sampler][blend_mode][0]);
     EXPECT_EQ(renderer_->render_pass_mask_color_matrix_program_aa_
-                  [precision][sampler][blend_mode].program(),
+                  [precision][sampler][blend_mode][0].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_);
   }
 
   RendererSettings settings_;
@@ skipping 1632 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