stop using SkXfermode -- use SkBlendMode instead

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 <stdint.h>
 
 #include <set>
 #include <vector>
@@ skipping 61 matching lines @@
 
   RenderPassList render_passes_in_draw_order_;
 };
 
 #define EXPECT_PROGRAM_VALID(program_binding)      \
   do {                                             \
     EXPECT_TRUE((program_binding)->program());     \
     EXPECT_TRUE((program_binding)->initialized()); \
   } while (false)
 
-static inline SkXfermode::Mode BlendModeToSkXfermode(BlendMode blend_mode) {
+static inline SkBlendMode BlendModeToSkXfermode(BlendMode blend_mode) {
   switch (blend_mode) {
     case BLEND_MODE_NONE:
     case BLEND_MODE_NORMAL:
-      return SkXfermode::kSrcOver_Mode;
+      return SkBlendMode::kSrcOver;
     case BLEND_MODE_SCREEN:
-      return SkXfermode::kScreen_Mode;
+      return SkBlendMode::kScreen;
     case BLEND_MODE_OVERLAY:
-      return SkXfermode::kOverlay_Mode;
+      return SkBlendMode::kOverlay;
     case BLEND_MODE_DARKEN:
-      return SkXfermode::kDarken_Mode;
+      return SkBlendMode::kDarken;
     case BLEND_MODE_LIGHTEN:
-      return SkXfermode::kLighten_Mode;
+      return SkBlendMode::kLighten;
     case BLEND_MODE_COLOR_DODGE:
-      return SkXfermode::kColorDodge_Mode;
+      return SkBlendMode::kColorDodge;
     case BLEND_MODE_COLOR_BURN:
-      return SkXfermode::kColorBurn_Mode;
+      return SkBlendMode::kColorBurn;
     case BLEND_MODE_HARD_LIGHT:
-      return SkXfermode::kHardLight_Mode;
+      return SkBlendMode::kHardLight;
     case BLEND_MODE_SOFT_LIGHT:
-      return SkXfermode::kSoftLight_Mode;
+      return SkBlendMode::kSoftLight;
     case BLEND_MODE_DIFFERENCE:
-      return SkXfermode::kDifference_Mode;
+      return SkBlendMode::kDifference;
     case BLEND_MODE_EXCLUSION:
-      return SkXfermode::kExclusion_Mode;
+      return SkBlendMode::kExclusion;
     case BLEND_MODE_MULTIPLY:
-      return SkXfermode::kMultiply_Mode;
+      return SkBlendMode::kMultiply;
     case BLEND_MODE_HUE:
-      return SkXfermode::kHue_Mode;
+      return SkBlendMode::kHue;
     case BLEND_MODE_SATURATION:
-      return SkXfermode::kSaturation_Mode;
+      return SkBlendMode::kSaturation;
     case BLEND_MODE_COLOR:
-      return SkXfermode::kColor_Mode;
+      return SkBlendMode::kColor;
     case BLEND_MODE_LUMINOSITY:
-      return SkXfermode::kLuminosity_Mode;
+      return SkBlendMode::kLuminosity;
   }
-  return SkXfermode::kSrcOver_Mode;
+  return SkBlendMode::kSrcOver;
 }
 
 // Explicitly named to be a friend in GLRenderer for shader access.
 class GLRendererShaderPixelTest : public GLRendererPixelTest {
  public:
   void SetUp() override {
     GLRendererPixelTest::SetUp();
     ASSERT_FALSE(renderer()->IsContextLost());
   }
 
@@ skipping 1085 matching lines @@
   FilterOperations filters;
   filters.Append(
       FilterOperation::CreateReferenceFilter(SkColorFilterImageFilter::Make(
           SkColorFilter::MakeMatrixFilterRowMajor255(matrix), nullptr)));
 
   gfx::Transform transform_causing_aa;
   transform_causing_aa.Rotate(20.0);
 
   for (int i = 0; i <= LAST_BLEND_MODE; ++i) {
     BlendMode blend_mode = static_cast<BlendMode>(i);
-    SkXfermode::Mode xfer_mode = BlendModeToSkXfermode(blend_mode);
+    SkBlendMode xfer_mode = BlendModeToSkXfermode(blend_mode);
     settings_.force_blending_with_shaders = (blend_mode != BLEND_MODE_NONE);
     // 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,
                               gfx::Rect(viewport_size), gfx::Transform());
@@ skipping 185 matching lines @@
   ASSERT_TRUE(clipped);
 
   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,
                             gfx::Rect(viewport_size), gfx::Transform());
 
-  AddRenderPassQuad(root_pass,
-                    child_pass,
-                    0,
-                    FilterOperations(),
-                    transform_preventing_aa,
-                    SkXfermode::kSrcOver_Mode);
+  AddRenderPassQuad(root_pass, child_pass, 0, FilterOperations(),
+                    transform_preventing_aa, SkBlendMode::kSrcOver);
 
   renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   DrawFrame(renderer_.get(), viewport_size);
 
   // If use_aa incorrectly ignores clipping, it will use the
   // RenderPassProgramAA shader instead of the RenderPassProgram.
   TestRenderPassProgram(TEX_COORD_PRECISION_MEDIUM, BLEND_MODE_NONE);
 }
 
 TEST_F(GLRendererShaderTest, DrawSolidColorShader) {
@@ skipping 383 matching lines @@
   bool nearest_neighbor = false;
   float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f};
   gfx::PointF uv_top_left(0, 0);
   gfx::PointF uv_bottom_right(1, 1);
 
   TextureDrawQuad* overlay_quad =
       root_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
   SharedQuadState* shared_state = root_pass->CreateAndAppendSharedQuadState();
   shared_state->SetAll(gfx::Transform(), viewport_size,
                        gfx::Rect(viewport_size), gfx::Rect(viewport_size),
-                       false, 1, SkXfermode::kSrcOver_Mode, 0);
+                       false, 1, SkBlendMode::kSrcOver, 0);
   overlay_quad->SetNew(shared_state, gfx::Rect(viewport_size),
                        gfx::Rect(viewport_size), gfx::Rect(viewport_size),
                        resource_id, premultiplied_alpha, uv_top_left,
                        uv_bottom_right, SK_ColorTRANSPARENT, vertex_opacity,
                        flipped, nearest_neighbor, false);
 
   // Verify that overlay_quad actually gets turned into an overlay, and even
   // though it's not drawn, that its sync point is waited on.
   EXPECT_CALL(*context, waitSyncToken(MatchesSyncToken(sync_token))).Times(1);
   EXPECT_CALL(
@@ skipping 131 matching lines @@
   renderer_->SetVisible(true);
   Mock::VerifyAndClearExpectations(context_support_ptr_);
 
   EXPECT_CALL(*context_support_ptr_, SetAggressivelyFreeResources(true));
   renderer_->SetVisible(false);
   Mock::VerifyAndClearExpectations(context_support_ptr_);
 }
 
 }  // namespace
 }  // namespace cc