mix-blend-mode implementation for accelerated layers

cc/quads/render_pass_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/quads/render_pass.h"
 
 #include "cc/base/math_util.h"
 #include "cc/base/scoped_ptr_vector.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/quads/checkerboard_draw_quad.h"
@@ skipping 62 matching lines @@
   scoped_ptr<TestRenderPass> pass = TestRenderPass::Create();
   pass->SetAll(id,
                output_rect,
                damage_rect,
                transform_to_root,
                has_transparent_background);
   pass->copy_requests.push_back(CopyOutputRequest::CreateEmptyRequest());
 
   // Stick a quad in the pass, this should not get copied.
   scoped_ptr<SharedQuadState> shared_state = SharedQuadState::Create();
-  shared_state->SetAll(
-      gfx::Transform(), gfx::Size(), gfx::Rect(), gfx::Rect(), false, 1);
+  shared_state->SetAll(gfx::Transform(),
+                       gfx::Size(),
+                       gfx::Rect(),
+                       gfx::Rect(),
+                       false,
+                       1,
+                       SkXfermode::kSrcOver_Mode);
   pass->AppendSharedQuadState(shared_state.Pass());
 
   scoped_ptr<CheckerboardDrawQuad> checkerboard_quad =
       CheckerboardDrawQuad::Create();
   checkerboard_quad->SetNew(
       pass->shared_quad_state_list.back(), gfx::Rect(), SkColor());
   pass->quad_list.push_back(checkerboard_quad.PassAs<DrawQuad>());
 
   RenderPass::Id new_id(63, 4);
 
@@ skipping 24 matching lines @@
 
   scoped_ptr<TestRenderPass> pass = TestRenderPass::Create();
   pass->SetAll(id,
                output_rect,
                damage_rect,
                transform_to_root,
                has_transparent_background);
 
   // Two quads using one shared state.
   scoped_ptr<SharedQuadState> shared_state1 = SharedQuadState::Create();
-  shared_state1->SetAll(
-      gfx::Transform(), gfx::Size(1, 1), gfx::Rect(), gfx::Rect(), false, 1);
+  shared_state1->SetAll(gfx::Transform(),
+                        gfx::Size(1, 1),
+                        gfx::Rect(),
+                        gfx::Rect(),
+                        false,
+                        1,
+                        SkXfermode::kSrcOver_Mode);
   pass->AppendSharedQuadState(shared_state1.Pass());
 
   scoped_ptr<CheckerboardDrawQuad> checkerboard_quad1 =
       CheckerboardDrawQuad::Create();
   checkerboard_quad1->SetNew(
       pass->shared_quad_state_list.back(), gfx::Rect(1, 1, 1, 1), SkColor());
   pass->quad_list.push_back(checkerboard_quad1.PassAs<DrawQuad>());
 
   scoped_ptr<CheckerboardDrawQuad> checkerboard_quad2 =
       CheckerboardDrawQuad::Create();
   checkerboard_quad2->SetNew(
       pass->shared_quad_state_list.back(), gfx::Rect(2, 2, 2, 2), SkColor());
   pass->quad_list.push_back(checkerboard_quad2.PassAs<DrawQuad>());
 
   // And two quads using another shared state.
   scoped_ptr<SharedQuadState> shared_state2 = SharedQuadState::Create();
-  shared_state2->SetAll(
-      gfx::Transform(), gfx::Size(2, 2), gfx::Rect(), gfx::Rect(), false, 1);
+  shared_state2->SetAll(gfx::Transform(),
+                        gfx::Size(2, 2),
+                        gfx::Rect(),
+                        gfx::Rect(),
+                        false,
+                        1,
+                        SkXfermode::kSrcOver_Mode);
   pass->AppendSharedQuadState(shared_state2.Pass());
 
   scoped_ptr<CheckerboardDrawQuad> checkerboard_quad3 =
       CheckerboardDrawQuad::Create();
   checkerboard_quad3->SetNew(
       pass->shared_quad_state_list.back(), gfx::Rect(3, 3, 3, 3), SkColor());
   pass->quad_list.push_back(checkerboard_quad3.PassAs<DrawQuad>());
 
   scoped_ptr<CheckerboardDrawQuad> checkerboard_quad4 =
       CheckerboardDrawQuad::Create();
@@ skipping 10 matching lines @@
   bool contrib_has_transparent_background = true;
 
   scoped_ptr<TestRenderPass> contrib = TestRenderPass::Create();
   contrib->SetAll(contrib_id,
                   contrib_output_rect,
                   contrib_damage_rect,
                   contrib_transform_to_root,
                   contrib_has_transparent_background);
 
   scoped_ptr<SharedQuadState> contrib_shared_state = SharedQuadState::Create();
-  contrib_shared_state->SetAll(
-      gfx::Transform(), gfx::Size(2, 2), gfx::Rect(), gfx::Rect(), false, 1);
+  contrib_shared_state->SetAll(gfx::Transform(),
+                               gfx::Size(2, 2),
+                               gfx::Rect(),
+                               gfx::Rect(),
+                               false,
+                               1,
+                               SkXfermode::kSrcOver_Mode);
   contrib->AppendSharedQuadState(contrib_shared_state.Pass());
 
   scoped_ptr<CheckerboardDrawQuad> contrib_quad =
       CheckerboardDrawQuad::Create();
   contrib_quad->SetNew(
       contrib->shared_quad_state_list.back(), gfx::Rect(3, 3, 3, 3), SkColor());
   contrib->quad_list.push_back(contrib_quad.PassAs<DrawQuad>());
 
   // And a RenderPassDrawQuad for the contributing pass.
   scoped_ptr<RenderPassDrawQuad> pass_quad = RenderPassDrawQuad::Create();
@@ skipping 75 matching lines @@
 
   // Make a copy with CopyAll().
   RenderPassList copy_list;
   RenderPass::CopyAll(pass_list, &copy_list);
 
   CompareRenderPassLists(pass_list, copy_list);
 }
 
 }  // namespace
 }  // namespace cc