mix-blend-mode implementation for accelerated layers

content/common/cc_messages_unittest.cc

 // Copyright (c) 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 "content/common/cc_messages.h"
 
 #include <string.h>
 
 #include <algorithm>
 
@@ skipping 37 matching lines @@
     EXPECT_EQ(a->has_transparent_background, b->has_transparent_background);
   }
 
   void Compare(const SharedQuadState* a, const SharedQuadState* b) {
     EXPECT_EQ(a->content_to_target_transform, b->content_to_target_transform);
     EXPECT_EQ(a->content_bounds, b->content_bounds);
     EXPECT_EQ(a->visible_content_rect, b->visible_content_rect);
     EXPECT_EQ(a->clip_rect, b->clip_rect);
     EXPECT_EQ(a->is_clipped, b->is_clipped);
     EXPECT_EQ(a->opacity, b->opacity);
+    EXPECT_EQ(a->blend_mode, b->blend_mode);
   }
 
   void Compare(const DrawQuad* a, const DrawQuad* b) {
     ASSERT_NE(DrawQuad::INVALID, a->material);
     ASSERT_EQ(a->material, b->material);
     EXPECT_EQ(a->rect.ToString(), b->rect.ToString());
     EXPECT_EQ(a->opaque_rect.ToString(), b->opaque_rect.ToString());
     EXPECT_EQ(a->visible_rect.ToString(), b->visible_rect.ToString());
     EXPECT_EQ(a->needs_blending, b->needs_blending);
 
@@ skipping 155 matching lines @@
   gfx::PointF arbitrary_pointf2(26.5f, -35.8f);
   float arbitrary_float1 = 0.7f;
   float arbitrary_float2 = 0.3f;
   float arbitrary_float3 = 0.9f;
   float arbitrary_float_array[4] = {3.5f, 6.2f, 9.3f, 12.3f};
   bool arbitrary_bool1 = true;
   bool arbitrary_bool2 = false;
   bool arbitrary_bool3 = true;
   int arbitrary_int = 5;
   SkColor arbitrary_color = SkColorSetARGB(25, 36, 47, 58);
+  SkXfermode::Mode arbitrary_blend_mode1 = SkXfermode::kScreen_Mode;
+  SkXfermode::Mode arbitrary_blend_mode2 = SkXfermode::kLighten_Mode;
+  SkXfermode::Mode arbitrary_blend_mode3 = SkXfermode::kOverlay_Mode;
   IOSurfaceDrawQuad::Orientation arbitrary_orientation =
       IOSurfaceDrawQuad::UNFLIPPED;
   RenderPass::Id arbitrary_id(10, 14);
   ResourceProvider::ResourceId arbitrary_resourceid1 = 55;
   ResourceProvider::ResourceId arbitrary_resourceid2 = 47;
   ResourceProvider::ResourceId arbitrary_resourceid3 = 23;
   ResourceProvider::ResourceId arbitrary_resourceid4 = 16;
   SkScalar arbitrary_sigma = SkFloatToScalar(2.0f);
 
   FilterOperations arbitrary_filters1;
   arbitrary_filters1.Append(FilterOperation::CreateGrayscaleFilter(
       arbitrary_float1));
   skia::RefPtr<SkImageFilter> arbitrary_filter = skia::AdoptRef(
     new SkBlurImageFilter(arbitrary_sigma, arbitrary_sigma));
   arbitrary_filters1.Append(
       cc::FilterOperation::CreateReferenceFilter(arbitrary_filter));
 
   FilterOperations arbitrary_filters2;
   arbitrary_filters2.Append(FilterOperation::CreateBrightnessFilter(
       arbitrary_float2));
 
   scoped_ptr<SharedQuadState> shared_state1_in = SharedQuadState::Create();
   shared_state1_in->SetAll(arbitrary_matrix,
                            arbitrary_size1,
                            arbitrary_rect1,
                            arbitrary_rect2,
                            arbitrary_bool1,
-                           arbitrary_float1);
+                           arbitrary_float1,
+                           arbitrary_blend_mode1);
   scoped_ptr<SharedQuadState> shared_state1_cmp = shared_state1_in->Copy();
 
   scoped_ptr<CheckerboardDrawQuad> checkerboard_in =
       CheckerboardDrawQuad::Create();
   checkerboard_in->SetAll(shared_state1_in.get(),
                           arbitrary_rect1,
                           arbitrary_rect2_inside_rect1,
                           arbitrary_rect1_inside_rect1,
                           arbitrary_bool1,
                           arbitrary_color);
@@ skipping 24 matching lines @@
                        arbitrary_orientation);
   scoped_ptr<DrawQuad> iosurface_cmp = iosurface_in->Copy(
       iosurface_in->shared_quad_state);
 
   scoped_ptr<SharedQuadState> shared_state2_in = SharedQuadState::Create();
   shared_state2_in->SetAll(arbitrary_matrix,
                            arbitrary_size2,
                            arbitrary_rect2,
                            arbitrary_rect3,
                            arbitrary_bool1,
-                           arbitrary_float2);
+                           arbitrary_float2,
+                           arbitrary_blend_mode2);
   scoped_ptr<SharedQuadState> shared_state2_cmp = shared_state2_in->Copy();
 
   scoped_ptr<RenderPassDrawQuad> renderpass_in =
       RenderPassDrawQuad::Create();
   renderpass_in->SetAll(shared_state2_in.get(),
                         arbitrary_rect1,
                         arbitrary_rect2_inside_rect1,
                         arbitrary_rect1_inside_rect1,
                         arbitrary_bool1,
                         arbitrary_id,
                         arbitrary_bool2,
                         arbitrary_resourceid2,
                         arbitrary_rect1,
                         arbitrary_rectf1,
                         arbitrary_filters1,
                         arbitrary_filters2);
   scoped_ptr<RenderPassDrawQuad> renderpass_cmp = renderpass_in->Copy(
       renderpass_in->shared_quad_state, renderpass_in->render_pass_id);
 
   scoped_ptr<SharedQuadState> shared_state3_in = SharedQuadState::Create();
   shared_state3_in->SetAll(arbitrary_matrix,
                            arbitrary_size3,
                            arbitrary_rect3,
                            arbitrary_rect1,
                            arbitrary_bool1,
-                           arbitrary_float3);
+                           arbitrary_float3,
+                           arbitrary_blend_mode3);
   scoped_ptr<SharedQuadState> shared_state3_cmp = shared_state3_in->Copy();
 
   scoped_ptr<SolidColorDrawQuad> solidcolor_in =
       SolidColorDrawQuad::Create();
   solidcolor_in->SetAll(shared_state3_in.get(),
                         arbitrary_rect3,
                         arbitrary_rect1_inside_rect3,
                         arbitrary_rect2_inside_rect3,
                         arbitrary_bool1,
                         arbitrary_color,
@@ skipping 155 matching lines @@
 
   scoped_ptr<RenderPass> pass_in = RenderPass::Create();
   pass_in->SetAll(RenderPass::Id(1, 1),
                   gfx::Rect(100, 100),
                   gfx::RectF(),
                   gfx::Transform(),
                   false);
 
   // The first SharedQuadState is used.
   scoped_ptr<SharedQuadState> shared_state1_in = SharedQuadState::Create();
-  shared_state1_in->SetAll(
-      gfx::Transform(), gfx::Size(1, 1), gfx::Rect(), gfx::Rect(), false, 1.f);
+  shared_state1_in->SetAll(gfx::Transform(),
+                           gfx::Size(1, 1),
+                           gfx::Rect(),
+                           gfx::Rect(),
+                           false,
+                           1.f,
+                           SkXfermode::kSrcOver_Mode);
 
   quad = CheckerboardDrawQuad::Create();
   quad->SetAll(shared_state1_in.get(),
                gfx::Rect(10, 10),
                gfx::Rect(10, 10),
                gfx::Rect(10, 10),
                false,
                SK_ColorRED);
   pass_in->quad_list.push_back(quad.PassAs<DrawQuad>());
 
   // The second and third SharedQuadStates are not used.
   scoped_ptr<SharedQuadState> shared_state2_in = SharedQuadState::Create();
-  shared_state2_in->SetAll(
-      gfx::Transform(), gfx::Size(2, 2), gfx::Rect(), gfx::Rect(), false, 1.f);
+  shared_state2_in->SetAll(gfx::Transform(),
+                           gfx::Size(2, 2),
+                           gfx::Rect(),
+                           gfx::Rect(),
+                           false,
+                           1.f,
+                           SkXfermode::kSrcOver_Mode);
 
   scoped_ptr<SharedQuadState> shared_state3_in = SharedQuadState::Create();
-  shared_state3_in->SetAll(
-      gfx::Transform(), gfx::Size(3, 3), gfx::Rect(), gfx::Rect(), false, 1.f);
+  shared_state3_in->SetAll(gfx::Transform(),
+                           gfx::Size(3, 3),
+                           gfx::Rect(),
+                           gfx::Rect(),
+                           false,
+                           1.f,
+                           SkXfermode::kSrcOver_Mode);
 
   // The fourth SharedQuadState is used.
   scoped_ptr<SharedQuadState> shared_state4_in = SharedQuadState::Create();
-  shared_state4_in->SetAll(
-      gfx::Transform(), gfx::Size(4, 4), gfx::Rect(), gfx::Rect(), false, 1.f);
+  shared_state4_in->SetAll(gfx::Transform(),
+                           gfx::Size(4, 4),
+                           gfx::Rect(),
+                           gfx::Rect(),
+                           false,
+                           1.f,
+                           SkXfermode::kSrcOver_Mode);
 
   quad = CheckerboardDrawQuad::Create();
   quad->SetAll(shared_state4_in.get(),
                gfx::Rect(10, 10),
                gfx::Rect(10, 10),
                gfx::Rect(10, 10),
                false,
                SK_ColorRED);
   pass_in->quad_list.push_back(quad.PassAs<DrawQuad>());
 
   // The fifth is not used again.
   scoped_ptr<SharedQuadState> shared_state5_in = SharedQuadState::Create();
-  shared_state5_in->SetAll(
-      gfx::Transform(), gfx::Size(5, 5), gfx::Rect(), gfx::Rect(), false, 1.f);
+  shared_state5_in->SetAll(gfx::Transform(),
+                           gfx::Size(5, 5),
+                           gfx::Rect(),
+                           gfx::Rect(),
+                           false,
+                           1.f,
+                           SkXfermode::kSrcOver_Mode);
 
   pass_in->shared_quad_state_list.push_back(shared_state1_in.Pass());
   pass_in->shared_quad_state_list.push_back(shared_state2_in.Pass());
   pass_in->shared_quad_state_list.push_back(shared_state3_in.Pass());
   pass_in->shared_quad_state_list.push_back(shared_state4_in.Pass());
   pass_in->shared_quad_state_list.push_back(shared_state5_in.Pass());
 
   // 5 SharedQuadStates go in.
   ASSERT_EQ(5u, pass_in->shared_quad_state_list.size());
   ASSERT_EQ(2u, pass_in->quad_list.size());
@@ skipping 126 matching lines @@
   }
 
   // Verify the largest DrawQuad type is RenderPassDrawQuad. If this ever
   // changes, then the ReserveSizeForRenderPassWrite() method needs to be
   // updated as well to use the new largest quad.
   EXPECT_EQ(sizeof(RenderPassDrawQuad), largest);
 }
 
 }  // namespace
 }  // namespace content