Implement mix-blend-mode in GL renderer using shaders.

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 52 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()->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));
+    for (SkXfermode::Mode mode = kDefaultBlendMode; mode <= kLastBlendMode;) {
+      EXPECT_PROGRAM_VALID(renderer()->GetRenderPassProgram(precision, mode));
+      EXPECT_PROGRAM_VALID(renderer()->GetRenderPassProgramAA(precision, mode));
+      EXPECT_PROGRAM_VALID(
+          renderer()->GetRenderPassMaskProgram(precision, mode));
+      EXPECT_PROGRAM_VALID(
+          renderer()->GetRenderPassMaskProgramAA(precision, mode));
+      EXPECT_PROGRAM_VALID(
+          renderer()->GetRenderPassColorMatrixProgram(precision, mode));
+      EXPECT_PROGRAM_VALID(
+          renderer()->GetRenderPassMaskColorMatrixProgramAA(precision, mode));
+      EXPECT_PROGRAM_VALID(
+          renderer()->GetRenderPassColorMatrixProgramAA(precision, mode));
+      EXPECT_PROGRAM_VALID(
+          renderer()->GetRenderPassMaskColorMatrixProgram(precision, mode));
+      if (mode < kFirstBlendMode)
+        mode = kFirstBlendMode;
+      else
+        mode = static_cast<SkXfermode::Mode>(mode + 1);
+    }
     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 100 matching lines @@
                                                   0,
                                                   false,
                                                   1,
                                                   false).Pass();
     renderer_.reset(new FakeRendererGL(&renderer_client_,
                                        &settings_,
                                        output_surface_.get(),
                                        resource_provider_.get()));
   }
 
-  void TestRenderPassProgram(TexCoordPrecision precision) {
-    EXPECT_PROGRAM_VALID(&renderer_->render_pass_program_[precision]);
-    EXPECT_EQ(renderer_->render_pass_program_[precision].program(),
+  void TestRenderPassProgram(TexCoordPrecision precision,
+                             SkXfermode::Mode mode) {
+    int bm = index_for_blend_mode(mode);
+    EXPECT_PROGRAM_VALID(&renderer_->render_pass_program_[precision][bm]);
+    EXPECT_EQ(renderer_->render_pass_program_[precision][bm].program(),
               renderer_->program_shadow_);
   }
 
-  void TestRenderPassColorMatrixProgram(TexCoordPrecision precision) {
+  void TestRenderPassColorMatrixProgram(TexCoordPrecision precision,
+                                        SkXfermode::Mode mode) {
+    int bm = index_for_blend_mode(mode);
     EXPECT_PROGRAM_VALID(
-        &renderer_->render_pass_color_matrix_program_[precision]);
-    EXPECT_EQ(renderer_->render_pass_color_matrix_program_[precision].program(),
+        &renderer_->render_pass_color_matrix_program_[precision][bm]);
+    EXPECT_EQ(
+        renderer_->render_pass_color_matrix_program_[precision][bm].program(),
+        renderer_->program_shadow_);
+  }
+
+  void TestRenderPassMaskProgram(TexCoordPrecision precision,
+                                 SkXfermode::Mode mode) {
+    int bm = index_for_blend_mode(mode);
+    EXPECT_PROGRAM_VALID(&renderer_->render_pass_mask_program_[precision][bm]);
+    EXPECT_EQ(renderer_->render_pass_mask_program_[precision][bm].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 TestRenderPassMaskColorMatrixProgram(TexCoordPrecision precision,
+                                            SkXfermode::Mode mode) {
+    int bm = index_for_blend_mode(mode);
     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 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 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]
+        &renderer_->render_pass_mask_color_matrix_program_[precision][bm]);
+    EXPECT_EQ(renderer_->render_pass_mask_color_matrix_program_[precision][bm]
                   .program(),
               renderer_->program_shadow_);
   }
 
+  void TestRenderPassProgramAA(TexCoordPrecision precision,
+                               SkXfermode::Mode mode) {
+    int bm = index_for_blend_mode(mode);
+    EXPECT_PROGRAM_VALID(&renderer_->render_pass_program_aa_[precision][bm]);
+    EXPECT_EQ(renderer_->render_pass_program_aa_[precision][bm].program(),
+              renderer_->program_shadow_);
+  }
+
+  void TestRenderPassColorMatrixProgramAA(TexCoordPrecision precision,
+                                          SkXfermode::Mode mode) {
+    int bm = index_for_blend_mode(mode);
+    EXPECT_PROGRAM_VALID(
+        &renderer_->render_pass_color_matrix_program_aa_[precision][bm]);
+    EXPECT_EQ(renderer_->render_pass_color_matrix_program_aa_[precision][bm]
+                  .program(),
+              renderer_->program_shadow_);
+  }
+
+  void TestRenderPassMaskProgramAA(TexCoordPrecision precision,
+                                   SkXfermode::Mode mode) {
+    int bm = index_for_blend_mode(mode);
+    EXPECT_PROGRAM_VALID(
+        &renderer_->render_pass_mask_program_aa_[precision][bm]);
+    EXPECT_EQ(renderer_->render_pass_mask_program_aa_[precision][bm].program(),
+              renderer_->program_shadow_);
+  }
+
+  void TestRenderPassMaskColorMatrixProgramAA(TexCoordPrecision precision,
+                                              SkXfermode::Mode mode) {
+    int bm = index_for_blend_mode(mode);
+    EXPECT_PROGRAM_VALID(
+        &renderer_->render_pass_mask_color_matrix_program_aa_[precision][bm]);
+    EXPECT_EQ(
+        renderer_->render_pass_mask_color_matrix_program_aa_[precision][bm]
+            .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 1097 matching lines @@
   skia::RefPtr<SkColorFilter> color_filter(
       skia::AdoptRef(SkColorMatrixFilter::Create(matrix)));
   skia::RefPtr<SkImageFilter> filter = skia::AdoptRef(
       SkColorFilterImageFilter::Create(color_filter.get(), NULL));
   FilterOperations filters;
   filters.Append(FilterOperation::CreateReferenceFilter(filter));
 
   gfx::Transform transform_causing_aa;
   transform_causing_aa.Rotate(20.0);
 
-  // RenderPassProgram
-  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, 0, FilterOperations(), gfx::Transform());
-
-  renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
-  renderer_->DrawFrame(&render_passes_in_draw_order_,
-                       1.f,
-                       viewport_rect,
-                       viewport_rect,
-                       false);
-  TestRenderPassProgram(TexCoordPrecisionMedium);
-
-  // RenderPassColorMatrixProgram
-  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,
-                            gfx::Transform());
-
-  AddRenderPassQuad(root_pass, child_pass, 0, filters, gfx::Transform());
-
-  renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
-  renderer_->DrawFrame(&render_passes_in_draw_order_,
-                       1.f,
-                       viewport_rect,
-                       viewport_rect,
-                       false);
-  TestRenderPassColorMatrixProgram(TexCoordPrecisionMedium);
-
-  // RenderPassMaskProgram
-  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, 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);
-
-  // 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);
-
-  // 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_,
-                            root_pass_id,
-                            viewport_rect,
-                            gfx::Transform());
-
-  AddRenderPassQuad(
-      root_pass, child_pass, 0, 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);
-  TestRenderPassProgramAA(TexCoordPrecisionMedium);
-
-  // RenderPassColorMatrixProgramAA
-  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,
-                            gfx::Transform());
-
-  AddRenderPassQuad(root_pass, child_pass, 0, 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);
-  TestRenderPassColorMatrixProgramAA(TexCoordPrecisionMedium);
-
-  // RenderPassMaskProgramAA
-  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,
-                            gfx::Transform());
-
-  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);
-
-  // 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);
+  for (SkXfermode::Mode mode = kDefaultBlendMode; mode <= kLastBlendMode;) {
+    // RenderPassProgram
+    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, 0, FilterOperations(), gfx::Transform(), mode);
+
+    renderer_->DecideRenderPassAllocationsForFrame(
+        render_passes_in_draw_order_);
+    renderer_->DrawFrame(&render_passes_in_draw_order_,
+                         1.f,
+                         viewport_rect,
+                         viewport_rect,
+                         false);
+    TestRenderPassProgram(TexCoordPrecisionMedium, mode);
+
+    // RenderPassColorMatrixProgram
+    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,
+                              gfx::Transform());
+
+    AddRenderPassQuad(
+        root_pass, child_pass, 0, filters, gfx::Transform(), mode);
+
+    renderer_->DecideRenderPassAllocationsForFrame(
+        render_passes_in_draw_order_);
+    renderer_->DrawFrame(&render_passes_in_draw_order_,
+                         1.f,
+                         viewport_rect,
+                         viewport_rect,
+                         false);
+    TestRenderPassColorMatrixProgram(TexCoordPrecisionMedium, mode);
+
+    // RenderPassMaskProgram
+    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,
+                      FilterOperations(),
+                      gfx::Transform(),
+                      mode);
+
+    renderer_->DecideRenderPassAllocationsForFrame(
+        render_passes_in_draw_order_);
+    renderer_->DrawFrame(&render_passes_in_draw_order_,
+                         1.f,
+                         viewport_rect,
+                         viewport_rect,
+                         false);
+    TestRenderPassMaskProgram(TexCoordPrecisionMedium, 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(), mode);
+
+    renderer_->DecideRenderPassAllocationsForFrame(
+        render_passes_in_draw_order_);
+    renderer_->DrawFrame(&render_passes_in_draw_order_,
+                         1.f,
+                         viewport_rect,
+                         viewport_rect,
+                         false);
+    TestRenderPassMaskColorMatrixProgram(TexCoordPrecisionMedium, 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_,
+                              root_pass_id,
+                              viewport_rect,
+                              gfx::Transform());
+
+    AddRenderPassQuad(root_pass,
+                      child_pass,
+                      0,
+                      FilterOperations(),
+                      transform_causing_aa,
+                      mode);
+
+    renderer_->DecideRenderPassAllocationsForFrame(
+        render_passes_in_draw_order_);
+    renderer_->DrawFrame(&render_passes_in_draw_order_,
+                         1.f,
+                         viewport_rect,
+                         viewport_rect,
+                         false);
+    TestRenderPassProgramAA(TexCoordPrecisionMedium, mode);
+
+    // RenderPassColorMatrixProgramAA
+    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,
+                              gfx::Transform());
+
+    AddRenderPassQuad(
+        root_pass, child_pass, 0, filters, transform_causing_aa, mode);
+
+    renderer_->DecideRenderPassAllocationsForFrame(
+        render_passes_in_draw_order_);
+    renderer_->DrawFrame(&render_passes_in_draw_order_,
+                         1.f,
+                         viewport_rect,
+                         viewport_rect,
+                         false);
+    TestRenderPassColorMatrixProgramAA(TexCoordPrecisionMedium, mode);
+
+    // RenderPassMaskProgramAA
+    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,
+                              gfx::Transform());
+
+    AddRenderPassQuad(root_pass,
+                      child_pass,
+                      mask,
+                      FilterOperations(),
+                      transform_causing_aa,
+                      mode);
+
+    renderer_->DecideRenderPassAllocationsForFrame(
+        render_passes_in_draw_order_);
+    renderer_->DrawFrame(&render_passes_in_draw_order_,
+                         1.f,
+                         viewport_rect,
+                         viewport_rect,
+                         false);
+    TestRenderPassMaskProgramAA(TexCoordPrecisionMedium, 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, mode);
+
+    renderer_->DecideRenderPassAllocationsForFrame(
+        render_passes_in_draw_order_);
+    renderer_->DrawFrame(&render_passes_in_draw_order_,
+                         1.f,
+                         viewport_rect,
+                         viewport_rect,
+                         false);
+    TestRenderPassMaskColorMatrixProgramAA(TexCoordPrecisionMedium, mode);
+
+    if (mode < kFirstBlendMode)
+      mode = kFirstBlendMode;
+    else
+      mode = static_cast<SkXfermode::Mode>(mode + 1);
+  }
 }
 
 // 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 14 matching lines @@
   child_pass = AddRenderPass(&render_passes_in_draw_order_,
                              child_pass_id,
                              child_rect,
                              transform_preventing_aa);
 
   root_pass = AddRenderPass(&render_passes_in_draw_order_,
                             root_pass_id,
                             viewport_rect,
                             gfx::Transform());
 
-  AddRenderPassQuad(
-      root_pass, child_pass, 0, FilterOperations(), transform_preventing_aa);
+  AddRenderPassQuad(root_pass,
+                    child_pass,
+                    0,
+                    FilterOperations(),
+                    transform_preventing_aa,
+                    kDefaultBlendMode);
 
   renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   renderer_->DrawFrame(&render_passes_in_draw_order_,
                        1.f,
                        viewport_rect,
                        viewport_rect,
                        false);
 
   // If use_aa incorrectly ignores clipping, it will use the
   // RenderPassProgramAA shader instead of the RenderPassProgram.
-  TestRenderPassProgram(TexCoordPrecisionMedium);
+  TestRenderPassProgram(TexCoordPrecisionMedium, kDefaultBlendMode);
 }
 
 TEST_F(GLRendererShaderTest, DrawSolidColorShader) {
   gfx::Rect viewport_rect(1, 1);
   RenderPassId root_pass_id(1, 0);
   TestRenderPass* root_pass;
 
   gfx::Transform pixel_aligned_transform_causing_aa;
   pixel_aligned_transform_causing_aa.Translate(25.5f, 25.5f);
   pixel_aligned_transform_causing_aa.Scale(0.5f, 0.5f);
@@ skipping 217 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