stop using SkXfermode -- use SkBlendMode instead

cc/layers/layer.h

 // Copyright 2010 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.
 
 #ifndef CC_LAYERS_LAYER_H_
 #define CC_LAYERS_LAYER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 14 matching lines @@
 #include "cc/layers/layer_position_constraint.h"
 #include "cc/layers/paint_properties.h"
 #include "cc/output/filter_operations.h"
 #include "cc/trees/element_id.h"
 #include "cc/trees/layer_tree.h"
 #include "cc/trees/mutator_host_client.h"
 #include "cc/trees/property_tree.h"
 #include "cc/trees/target_property.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkPicture.h"
-#include "third_party/skia/include/core/SkXfermode.h"
 #include "ui/gfx/geometry/point3_f.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/geometry/scroll_offset.h"
 #include "ui/gfx/transform.h"
 
 namespace gfx {
 class BoxF;
 }
 
@@ skipping 87 matching lines @@
   virtual void SetNeedsDisplayRect(const gfx::Rect& dirty_rect);
   void SetNeedsDisplay() { SetNeedsDisplayRect(gfx::Rect(bounds())); }
 
   virtual void SetOpacity(float opacity);
   float opacity() const { return inputs_.opacity; }
   float EffectiveOpacity() const;
   virtual bool OpacityCanAnimateOnImplThread() const;
 
   virtual bool AlwaysUseActiveTreeOpacity() const;
 
-  void SetBlendMode(SkXfermode::Mode blend_mode);
-  SkXfermode::Mode blend_mode() const { return inputs_.blend_mode; }
+  void SetBlendMode(SkBlendMode blend_mode);
+  SkBlendMode blend_mode() const { return inputs_.blend_mode; }
 
-  void set_draw_blend_mode(SkXfermode::Mode blend_mode) {
+  void set_draw_blend_mode(SkBlendMode blend_mode) {
     if (draw_blend_mode_ == blend_mode)
       return;
     draw_blend_mode_ = blend_mode;
     SetNeedsPushProperties();
   }
-  SkXfermode::Mode draw_blend_mode() const { return draw_blend_mode_; }
+  SkBlendMode draw_blend_mode() const { return draw_blend_mode_; }
 
   // A layer is root for an isolated group when it and all its descendants are
   // drawn over a black and fully transparent background, creating an isolated
   // group. It should be used along with SetBlendMode(), in order to restrict
   // layers within the group to blend with layers outside this group.
   void SetIsRootForIsolatedGroup(bool root);
   bool is_root_for_isolated_group() const {
     return inputs_.is_root_for_isolated_group;
   }
 
@@ skipping 428 matching lines @@
     // is not available and the update rect will remain empty.
     // Note this rect is in layer space (not content space).
     gfx::Rect update_rect;
 
     gfx::Size bounds;
     bool masks_to_bounds;
 
     scoped_refptr<Layer> mask_layer;
 
     float opacity;
-    SkXfermode::Mode blend_mode;
+    SkBlendMode blend_mode;
 
     bool is_root_for_isolated_group : 1;
 
     bool contents_opaque : 1;
 
     gfx::PointF position;
     gfx::Transform transform;
     gfx::Point3F transform_origin;
 
     bool is_drawable : 1;
@@ skipping 73 matching lines @@
   bool should_flatten_transform_from_property_tree_ : 1;
   bool draws_content_ : 1;
   bool use_local_transform_for_backface_visibility_ : 1;
   bool should_check_backface_visibility_ : 1;
   bool force_render_surface_for_testing_ : 1;
   bool subtree_property_changed_ : 1;
   bool may_contain_video_ : 1;
   SkColor safe_opaque_background_color_;
   // draw_blend_mode may be different than blend_mode_,
   // when a RenderSurface re-parents the layer's blend_mode.
-  SkXfermode::Mode draw_blend_mode_;
+  SkBlendMode draw_blend_mode_;
   std::unique_ptr<std::set<Layer*>> scroll_children_;
 
   std::unique_ptr<std::set<Layer*>> clip_children_;
 
   PaintProperties paint_properties_;
 
   // These all act like draw properties, so don't need push properties.
   gfx::Rect visible_layer_rect_;
   size_t num_unclipped_descendants_;
 
   DISALLOW_COPY_AND_ASSIGN(Layer);
 };
 
 }  // namespace cc
 
 #endif  // CC_LAYERS_LAYER_H_