Make PaintFlags a separate object from SkPaint

In order to add serialization for PaintFlags internals, store the
SkPaint internals directly in PaintFlags instead of storing in
an SkPaint itself.

Reland of: https://chromium-review.googlesource.com/c/575511/
TBR=vmpstr@chromium.org,msw@chromium.org,junov@chromium.org

Bug: 737629
Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2
Change-Id: Ida37d539b3d5a5612acdf1466445f4d30b75d5ad
Reviewed-on: https://chromium-review.googlesource.com/580149
Commit-Queue: enne <enne@chromium.org>
Reviewed-by: Dan Erat <derat@chromium.org>
Reviewed-by: Steven Bennetts <stevenjb@chromium.org>
Cr-Commit-Position: refs/heads/master@{#488502}

ash/autoclick/common/BUILD.gn

@@ -15,6 +15,7 @@ source_set("autoclick") {
 
   deps = [
     "//base",
+    "//cc/paint",
     "//skia",
     "//ui/aura",
     "//ui/compositor",

cc/paint/discardable_image_map.cc

@@ -205,8 +205,9 @@ class DiscardableImageGenerator {
     const SkMatrix& ctm = canvas_.getTotalMatrix();
 
     SkRect paint_rect = MapRect(ctm, rect);
+    SkPaint paint = flags.ToSkPaint();
     bool computed_paint_bounds =
-        canvas_.ComputePaintBounds(paint_rect, ToSkPaint(&flags), &paint_rect);
+        canvas_.ComputePaintBounds(paint_rect, &paint, &paint_rect);
     if (!computed_paint_bounds) {
       // TODO(vmpstr): UMA this case.
       paint_rect = clip_rect;

cc/paint/paint_flags.cc

@@ -4,13 +4,67 @@
 
 #include "cc/paint/paint_flags.h"
 
+namespace {
+
+static bool affects_alpha(const SkColorFilter* cf) {
+  return cf && !(cf->getFlags() & SkColorFilter::kAlphaUnchanged_Flag);
+}
+
+}  // namespace
+
 namespace cc {
 
+// Match SkPaint defaults.
+PaintFlags::PaintFlags()
+    : flags_(0u),
+      cap_type_(SkPaint::kDefault_Cap),
+      join_type_(SkPaint::kDefault_Join),
+      style_(SkPaint::kFill_Style),
+      text_encoding_(SkPaint::kUTF8_TextEncoding),
+      hinting_(SkPaint::kNormal_Hinting),
+      filter_quality_(SkFilterQuality::kNone_SkFilterQuality) {}
+
+PaintFlags::PaintFlags(const PaintFlags& flags) = default;
+
+PaintFlags::~PaintFlags() = default;
+
+bool PaintFlags::nothingToDraw() const {
+  // Duplicated from SkPaint to avoid having to construct an SkPaint to
+  // answer this question.
+  if (getLooper())
+    return false;
+
+  switch (getBlendMode()) {
+    case SkBlendMode::kSrcOver:
+    case SkBlendMode::kSrcATop:
+    case SkBlendMode::kDstOut:
+    case SkBlendMode::kDstOver:
+    case SkBlendMode::kPlus:
+      if (getAlpha() == 0) {
+        return !affects_alpha(color_filter_.get()) && !image_filter_;
+      }
+      break;
+    case SkBlendMode::kDst:
+      return true;
+    default:
+      break;
+  }
+  return false;
+}
+
+bool PaintFlags::getFillPath(const SkPath& src,
+                             SkPath* dst,
+                             const SkRect* cull_rect,
+                             SkScalar res_scale) const {
+  SkPaint paint = ToSkPaint();
+  return paint.getFillPath(src, dst, cull_rect, res_scale);
+}
+
 bool PaintFlags::IsSimpleOpacity() const {
   uint32_t color = getColor();
   if (SK_ColorTRANSPARENT != SkColorSetA(color, SK_AlphaTRANSPARENT))
     return false;
-  if (!isSrcOver())
+  if (getBlendMode() != SkBlendMode::kSrcOver)
     return false;
   if (getLooper())
     return false;
@@ -28,7 +82,7 @@ bool PaintFlags::IsSimpleOpacity() const {
 }
 
 bool PaintFlags::SupportsFoldingAlpha() const {
-  if (!isSrcOver())
+  if (getBlendMode() != SkBlendMode::kSrcOver)
     return false;
   if (getColorFilter())
     return false;
@@ -39,4 +93,30 @@ bool PaintFlags::SupportsFoldingAlpha() const {
   return true;
 }
 
+SkPaint PaintFlags::ToSkPaint() const {
+  SkPaint paint;
+  paint.setTypeface(typeface_);
+  paint.setPathEffect(path_effect_);
+  if (shader_)
+    paint.setShader(shader_->GetSkShader());
+  paint.setMaskFilter(mask_filter_);
+  paint.setColorFilter(color_filter_);
+  paint.setDrawLooper(draw_looper_);
+  paint.setImageFilter(image_filter_);
+  paint.setTextSize(text_size_);
+  paint.setTextScaleX(text_scale_x_);
+  paint.setColor(color_);
+  paint.setStrokeWidth(width_);
+  paint.setStrokeMiter(miter_limit_);
+  paint.setBlendMode(getBlendMode());
+  paint.setFlags(flags_);
+  paint.setStrokeCap(static_cast<SkPaint::Cap>(getStrokeCap()));
+  paint.setStrokeJoin(static_cast<SkPaint::Join>(getStrokeJoin()));
+  paint.setStyle(static_cast<SkPaint::Style>(getStyle()));
+  paint.setTextEncoding(static_cast<SkPaint::TextEncoding>(getTextEncoding()));
+  paint.setHinting(static_cast<SkPaint::Hinting>(getHinting()));
+  paint.setFilterQuality(getFilterQuality());
+  return paint;
+}
+
 }  // namespace cc

cc/paint/paint_op_buffer.cc

@@ -1106,8 +1106,9 @@ void DrawArcOp::RasterWithFlags(const PaintOpWithFlags* base_op,
                                 SkCanvas* canvas,
                                 const SkMatrix& original_ctm) {
   auto* op = static_cast<const DrawArcOp*>(base_op);
+  SkPaint paint = flags->ToSkPaint();
   canvas->drawArc(op->oval, op->start_angle, op->sweep_angle, op->use_center,
-                  ToSkPaint(*flags));
+                  paint);
 }
 
 void DrawCircleOp::RasterWithFlags(const PaintOpWithFlags* base_op,
@@ -1115,7 +1116,8 @@ void DrawCircleOp::RasterWithFlags(const PaintOpWithFlags* base_op,
                                    SkCanvas* canvas,
                                    const SkMatrix& original_ctm) {
   auto* op = static_cast<const DrawCircleOp*>(base_op);
-  canvas->drawCircle(op->cx, op->cy, op->radius, ToSkPaint(*flags));
+  SkPaint paint = flags->ToSkPaint();
+  canvas->drawCircle(op->cx, op->cy, op->radius, paint);
 }
 
 void DrawColorOp::Raster(const PaintOp* base_op,
@@ -1130,7 +1132,8 @@ void DrawDRRectOp::RasterWithFlags(const PaintOpWithFlags* base_op,
                                    SkCanvas* canvas,
                                    const SkMatrix& original_ctm) {
   auto* op = static_cast<const DrawDRRectOp*>(base_op);
-  canvas->drawDRRect(op->outer, op->inner, ToSkPaint(*flags));
+  SkPaint paint = flags->ToSkPaint();
+  canvas->drawDRRect(op->outer, op->inner, paint);
 }
 
 void DrawImageOp::RasterWithFlags(const PaintOpWithFlags* base_op,
@@ -1138,8 +1141,8 @@ void DrawImageOp::RasterWithFlags(const PaintOpWithFlags* base_op,
                                   SkCanvas* canvas,
                                   const SkMatrix& original_ctm) {
   auto* op = static_cast<const DrawImageOp*>(base_op);
-  canvas->drawImage(op->image.sk_image().get(), op->left, op->top,
-                    ToSkPaint(flags));
+  SkPaint paint = flags->ToSkPaint();
+  canvas->drawImage(op->image.sk_image().get(), op->left, op->top, &paint);
 }
 
 void DrawImageRectOp::RasterWithFlags(const PaintOpWithFlags* base_op,
@@ -1150,8 +1153,9 @@ void DrawImageRectOp::RasterWithFlags(const PaintOpWithFlags* base_op,
   // TODO(enne): Probably PaintCanvas should just use the skia enum directly.
   SkCanvas::SrcRectConstraint skconstraint =
       static_cast<SkCanvas::SrcRectConstraint>(op->constraint);
-  canvas->drawImageRect(op->image.sk_image().get(), op->src, op->dst,
-                        ToSkPaint(flags), skconstraint);
+  SkPaint paint = flags->ToSkPaint();
+  canvas->drawImageRect(op->image.sk_image().get(), op->src, op->dst, &paint,
+                        skconstraint);
 }
 
 void DrawIRectOp::RasterWithFlags(const PaintOpWithFlags* base_op,
@@ -1159,7 +1163,8 @@ void DrawIRectOp::RasterWithFlags(const PaintOpWithFlags* base_op,
                                   SkCanvas* canvas,
                                   const SkMatrix& original_ctm) {
   auto* op = static_cast<const DrawIRectOp*>(base_op);
-  canvas->drawIRect(op->rect, ToSkPaint(*flags));
+  SkPaint paint = flags->ToSkPaint();
+  canvas->drawIRect(op->rect, paint);
 }
 
 void DrawLineOp::RasterWithFlags(const PaintOpWithFlags* base_op,
@@ -1167,7 +1172,8 @@ void DrawLineOp::RasterWithFlags(const PaintOpWithFlags* base_op,
                                  SkCanvas* canvas,
                                  const SkMatrix& original_ctm) {
   auto* op = static_cast<const DrawLineOp*>(base_op);
-  canvas->drawLine(op->x0, op->y0, op->x1, op->y1, ToSkPaint(*flags));
+  SkPaint paint = flags->ToSkPaint();
+  canvas->drawLine(op->x0, op->y0, op->x1, op->y1, paint);
 }
 
 void DrawOvalOp::RasterWithFlags(const PaintOpWithFlags* base_op,
@@ -1175,7 +1181,8 @@ void DrawOvalOp::RasterWithFlags(const PaintOpWithFlags* base_op,
                                  SkCanvas* canvas,
                                  const SkMatrix& original_ctm) {
   auto* op = static_cast<const DrawOvalOp*>(base_op);
-  canvas->drawOval(op->oval, ToSkPaint(*flags));
+  SkPaint paint = flags->ToSkPaint();
+  canvas->drawOval(op->oval, paint);
 }
 
 void DrawPathOp::RasterWithFlags(const PaintOpWithFlags* base_op,
@@ -1183,7 +1190,8 @@ void DrawPathOp::RasterWithFlags(const PaintOpWithFlags* base_op,
                                  SkCanvas* canvas,
                                  const SkMatrix& original_ctm) {
   auto* op = static_cast<const DrawPathOp*>(base_op);
-  canvas->drawPath(op->path, ToSkPaint(*flags));
+  SkPaint paint = flags->ToSkPaint();
+  canvas->drawPath(op->path, paint);
 }
 
 void DrawPosTextOp::RasterWithFlags(const PaintOpWithFlags* base_op,
@@ -1191,8 +1199,8 @@ void DrawPosTextOp::RasterWithFlags(const PaintOpWithFlags* base_op,
                                     SkCanvas* canvas,
                                     const SkMatrix& original_ctm) {
   auto* op = static_cast<const DrawPosTextOp*>(base_op);
-  canvas->drawPosText(op->GetData(), op->bytes, op->GetArray(),
-                      ToSkPaint(*flags));
+  SkPaint paint = flags->ToSkPaint();
+  canvas->drawPosText(op->GetData(), op->bytes, op->GetArray(), paint);
 }
 
 void DrawRecordOp::Raster(const PaintOp* base_op,
@@ -1208,7 +1216,8 @@ void DrawRectOp::RasterWithFlags(const PaintOpWithFlags* base_op,
                                  SkCanvas* canvas,
                                  const SkMatrix& original_ctm) {
   auto* op = static_cast<const DrawRectOp*>(base_op);
-  canvas->drawRect(op->rect, ToSkPaint(*flags));
+  SkPaint paint = flags->ToSkPaint();
+  canvas->drawRect(op->rect, paint);
 }
 
 void DrawRRectOp::RasterWithFlags(const PaintOpWithFlags* base_op,
@@ -1216,7 +1225,8 @@ void DrawRRectOp::RasterWithFlags(const PaintOpWithFlags* base_op,
                                   SkCanvas* canvas,
                                   const SkMatrix& original_ctm) {
   auto* op = static_cast<const DrawRRectOp*>(base_op);
-  canvas->drawRRect(op->rrect, ToSkPaint(*flags));
+  SkPaint paint = flags->ToSkPaint();
+  canvas->drawRRect(op->rrect, paint);
 }
 
 void DrawTextOp::RasterWithFlags(const PaintOpWithFlags* base_op,
@@ -1224,7 +1234,8 @@ void DrawTextOp::RasterWithFlags(const PaintOpWithFlags* base_op,
                                  SkCanvas* canvas,
                                  const SkMatrix& original_ctm) {
   auto* op = static_cast<const DrawTextOp*>(base_op);
-  canvas->drawText(op->GetData(), op->bytes, op->x, op->y, ToSkPaint(*flags));
+  SkPaint paint = flags->ToSkPaint();
+  canvas->drawText(op->GetData(), op->bytes, op->x, op->y, paint);
 }
 
 void DrawTextBlobOp::RasterWithFlags(const PaintOpWithFlags* base_op,
@@ -1232,7 +1243,8 @@ void DrawTextBlobOp::RasterWithFlags(const PaintOpWithFlags* base_op,
                                      SkCanvas* canvas,
                                      const SkMatrix& original_ctm) {
   auto* op = static_cast<const DrawTextBlobOp*>(base_op);
-  canvas->drawTextBlob(op->blob.get(), op->x, op->y, ToSkPaint(*flags));
+  SkPaint paint = flags->ToSkPaint();
+  canvas->drawTextBlob(op->blob.get(), op->x, op->y, paint);
 }
 
 void RestoreOp::Raster(const PaintOp* base_op,
@@ -1262,7 +1274,8 @@ void SaveLayerOp::RasterWithFlags(const PaintOpWithFlags* base_op,
   // See PaintOp::kUnsetRect
   bool unset = op->bounds.left() == SK_ScalarInfinity;
 
-  canvas->saveLayer(unset ? nullptr : &op->bounds, ToSkPaint(flags));
+  SkPaint paint = flags->ToSkPaint();
+  canvas->saveLayer(unset ? nullptr : &op->bounds, &paint);
 }
 
 void SaveLayerAlphaOp::Raster(const PaintOp* base_op,
@@ -1374,7 +1387,7 @@ int ClipPathOp::CountSlowPaths() const {
 }
 
 int DrawLineOp::CountSlowPaths() const {
-  if (const SkPathEffect* effect = flags.getPathEffect()) {
+  if (const SkPathEffect* effect = flags.getPathEffect().get()) {
     SkPathEffect::DashInfo info;
     SkPathEffect::DashType dashType = effect->asADash(&info);
     if (flags.getStrokeCap() != PaintFlags::kRound_Cap &&

cc/paint/paint_op_buffer_unittest.cc

@@ -18,11 +18,20 @@ using testing::Mock;
 
 namespace cc {
 namespace {
+
 void Playback(PaintOpBuffer* buffer,
               SkCanvas* canvas,
               const std::vector<size_t>& indices) {
   buffer->Playback(canvas, nullptr, &indices);
 }
+
+void ExpectPaintFlagsEqual(const PaintFlags& expected,
+                           const PaintFlags& actual) {
+  SkPaint expected_paint = expected.ToSkPaint();
+  SkPaint actual_paint = actual.ToSkPaint();
+  EXPECT_TRUE(expected_paint == actual_paint);
+}
+
 }  // namespace
 
 TEST(PaintOpBufferTest, Empty) {
@@ -68,7 +77,7 @@ class PaintOpAppendTest : public ::testing::Test {
     ASSERT_EQ(iter->GetType(), PaintOpType::SaveLayer);
     SaveLayerOp* save_op = static_cast<SaveLayerOp*>(*iter);
     EXPECT_EQ(save_op->bounds, rect_);
-    EXPECT_TRUE(save_op->flags == flags_);
+    ExpectPaintFlagsEqual(save_op->flags, flags_);
     ++iter;
 
     ASSERT_EQ(iter->GetType(), PaintOpType::Save);

cc/paint/paint_shader.cc

@@ -214,4 +214,9 @@ void PaintShader::SetFlagsAndFallback(uint32_t flags, SkColor fallback_color) {
   fallback_color_ = fallback_color;
 }
 
+bool PaintShader::IsOpaque() const {
+  // TODO(enne): don't create a shader to answer this.
+  return GetSkShader()->isOpaque();
+}
+
 }  // namespace cc

cc/paint/paint_shader.h

@@ -84,6 +84,8 @@ class CC_PAINT_EXPORT PaintShader : public SkRefCnt {
     return local_matrix_ ? *local_matrix_ : SkMatrix::I();
   }
 
+  bool IsOpaque() const;
+
  private:
   friend class PaintFlags;
 

cc/paint/record_paint_canvas.cc

@@ -56,7 +56,7 @@ int RecordPaintCanvas::saveLayer(const SkRect* bounds,
     // matrices affect transparent flags on SkCanvas layers, but it's not clear
     // whether those are actually needed and we could just skip ToSkPaint here.
     buffer_->push<SaveLayerOp>(bounds, flags);
-    const SkPaint& paint = ToSkPaint(*flags);
+    SkPaint paint = flags->ToSkPaint();
     return GetCanvas()->saveLayer(bounds, &paint);
   }
   buffer_->push<SaveLayerOp>(bounds, flags);
@@ -309,7 +309,9 @@ void RecordPaintCanvas::drawPosText(const void* text,
                                     size_t byte_length,
                                     const SkPoint pos[],
                                     const PaintFlags& flags) {
-  size_t count = ToSkPaint(flags).countText(text, byte_length);
+  // TODO(enne): implement countText in PaintFlags??
+  SkPaint paint = flags.ToSkPaint();
+  size_t count = paint.countText(text, byte_length);
   buffer_->push_with_array<DrawPosTextOp>(text, byte_length, pos, count, flags);
 }
 

cc/paint/skia_paint_canvas.cc

@@ -57,7 +57,10 @@ int SkiaPaintCanvas::save() {
 }
 
 int SkiaPaintCanvas::saveLayer(const SkRect* bounds, const PaintFlags* flags) {
-  return canvas_->saveLayer(bounds, ToSkPaint(flags));
+  if (!flags)
+    return canvas_->saveLayer(bounds, nullptr);
+  SkPaint paint = flags->ToSkPaint();
+  return canvas_->saveLayer(bounds, &paint);
 }
 
 int SkiaPaintCanvas::saveLayerAlpha(const SkRect* bounds,
@@ -158,36 +161,43 @@ void SkiaPaintCanvas::drawLine(SkScalar x0,
                                SkScalar x1,
                                SkScalar y1,
                                const PaintFlags& flags) {
-  SkiaPaintCanvas::canvas_->drawLine(x0, y0, x1, y1, ToSkPaint(flags));
+  SkPaint paint = flags.ToSkPaint();
+  SkiaPaintCanvas::canvas_->drawLine(x0, y0, x1, y1, paint);
 }
 
 void SkiaPaintCanvas::drawRect(const SkRect& rect, const PaintFlags& flags) {
-  canvas_->drawRect(rect, ToSkPaint(flags));
+  SkPaint paint = flags.ToSkPaint();
+  canvas_->drawRect(rect, paint);
 }
 
 void SkiaPaintCanvas::drawIRect(const SkIRect& rect, const PaintFlags& flags) {
-  canvas_->drawIRect(rect, ToSkPaint(flags));
+  SkPaint paint = flags.ToSkPaint();
+  canvas_->drawIRect(rect, paint);
 }
 
 void SkiaPaintCanvas::drawOval(const SkRect& oval, const PaintFlags& flags) {
-  canvas_->drawOval(oval, ToSkPaint(flags));
+  SkPaint paint = flags.ToSkPaint();
+  canvas_->drawOval(oval, paint);
 }
 
 void SkiaPaintCanvas::drawRRect(const SkRRect& rrect, const PaintFlags& flags) {
-  canvas_->drawRRect(rrect, ToSkPaint(flags));
+  SkPaint paint = flags.ToSkPaint();
+  canvas_->drawRRect(rrect, paint);
 }
 
 void SkiaPaintCanvas::drawDRRect(const SkRRect& outer,
                                  const SkRRect& inner,
                                  const PaintFlags& flags) {
-  canvas_->drawDRRect(outer, inner, ToSkPaint(flags));
+  SkPaint paint = flags.ToSkPaint();
+  canvas_->drawDRRect(outer, inner, paint);
 }
 
 void SkiaPaintCanvas::drawCircle(SkScalar cx,
                                  SkScalar cy,
                                  SkScalar radius,
                                  const PaintFlags& flags) {
-  canvas_->drawCircle(cx, cy, radius, ToSkPaint(flags));
+  SkPaint paint = flags.ToSkPaint();
+  canvas_->drawCircle(cx, cy, radius, paint);
 }
 
 void SkiaPaintCanvas::drawArc(const SkRect& oval,
@@ -195,26 +205,32 @@ void SkiaPaintCanvas::drawArc(const SkRect& oval,
                               SkScalar sweep_angle,
                               bool use_center,
                               const PaintFlags& flags) {
-  canvas_->drawArc(oval, start_angle, sweep_angle, use_center,
-                   ToSkPaint(flags));
+  SkPaint paint = flags.ToSkPaint();
+  canvas_->drawArc(oval, start_angle, sweep_angle, use_center, paint);
 }
 
 void SkiaPaintCanvas::drawRoundRect(const SkRect& rect,
                                     SkScalar rx,
                                     SkScalar ry,
                                     const PaintFlags& flags) {
-  canvas_->drawRoundRect(rect, rx, ry, ToSkPaint(flags));
+  SkPaint paint = flags.ToSkPaint();
+  canvas_->drawRoundRect(rect, rx, ry, paint);
 }
 
 void SkiaPaintCanvas::drawPath(const SkPath& path, const PaintFlags& flags) {
-  canvas_->drawPath(path, ToSkPaint(flags));
+  SkPaint paint = flags.ToSkPaint();
+  canvas_->drawPath(path, paint);
 }
 
 void SkiaPaintCanvas::drawImage(const PaintImage& image,
                                 SkScalar left,
                                 SkScalar top,
                                 const PaintFlags* flags) {
-  canvas_->drawImage(image.sk_image().get(), left, top, ToSkPaint(flags));
+  SkPaint paint;
+  if (flags)
+    paint = flags->ToSkPaint();
+  canvas_->drawImage(image.sk_image().get(), left, top,
+                     flags ? &paint : nullptr);
 }
 
 void SkiaPaintCanvas::drawImageRect(const PaintImage& image,
@@ -222,7 +238,11 @@ void SkiaPaintCanvas::drawImageRect(const PaintImage& image,
                                     const SkRect& dst,
                                     const PaintFlags* flags,
                                     SrcRectConstraint constraint) {
-  canvas_->drawImageRect(image.sk_image().get(), src, dst, ToSkPaint(flags),
+  SkPaint paint;
+  if (flags)
+    paint = flags->ToSkPaint();
+  canvas_->drawImageRect(image.sk_image().get(), src, dst,
+                         flags ? &paint : nullptr,
                          static_cast<SkCanvas::SrcRectConstraint>(constraint));
 }
 
@@ -230,7 +250,12 @@ void SkiaPaintCanvas::drawBitmap(const SkBitmap& bitmap,
                                  SkScalar left,
                                  SkScalar top,
                                  const PaintFlags* flags) {
-  canvas_->drawBitmap(bitmap, left, top, ToSkPaint(flags));
+  if (flags) {
+    SkPaint paint = flags->ToSkPaint();
+    canvas_->drawBitmap(bitmap, left, top, &paint);
+  } else {
+    canvas_->drawBitmap(bitmap, left, top, nullptr);
+  }
 }
 
 void SkiaPaintCanvas::drawText(const void* text,
@@ -238,21 +263,24 @@ void SkiaPaintCanvas::drawText(const void* text,
                                SkScalar x,
                                SkScalar y,
                                const PaintFlags& flags) {
-  canvas_->drawText(text, byte_length, x, y, ToSkPaint(flags));
+  SkPaint paint = flags.ToSkPaint();
+  canvas_->drawText(text, byte_length, x, y, paint);
 }
 
 void SkiaPaintCanvas::drawPosText(const void* text,
                                   size_t byte_length,
                                   const SkPoint pos[],
                                   const PaintFlags& flags) {
-  canvas_->drawPosText(text, byte_length, pos, ToSkPaint(flags));
+  SkPaint paint = flags.ToSkPaint();
+  canvas_->drawPosText(text, byte_length, pos, paint);
 }
 
 void SkiaPaintCanvas::drawTextBlob(sk_sp<SkTextBlob> blob,
                                    SkScalar x,
                                    SkScalar y,
                                    const PaintFlags& flags) {
-  canvas_->drawTextBlob(blob.get(), x, y, ToSkPaint(flags));
+  SkPaint paint = flags.ToSkPaint();
+  canvas_->drawTextBlob(blob.get(), x, y, paint);
 }
 
 void SkiaPaintCanvas::drawPicture(sk_sp<const PaintRecord> record) {

third_party/WebKit/Source/core/paint/ScrollableAreaPainter.cpp

@@ -107,7 +107,7 @@ void ScrollableAreaPainter::DrawPlatformResizerImage(
   line_path.lineTo(points[1].X(), points[1].Y());
   line_path.moveTo(points[2].X(), points[2].Y());
   line_path.lineTo(points[3].X(), points[3].Y());
-  paint_flags.setARGB(153, 0, 0, 0);
+  paint_flags.setColor(SkColorSetARGB(153, 0, 0, 0));
   context.DrawPath(line_path, paint_flags);
 
   // Draw a light line one pixel below the light line,
@@ -117,7 +117,7 @@ void ScrollableAreaPainter::DrawPlatformResizerImage(
   line_path.lineTo(points[1].X() + (on_left ? -1 : 1), points[1].Y());
   line_path.moveTo(points[2].X(), points[2].Y() + 1);
   line_path.lineTo(points[3].X() + (on_left ? -1 : 1), points[3].Y());
-  paint_flags.setARGB(153, 255, 255, 255);
+  paint_flags.setColor(SkColorSetARGB(153, 255, 255, 255));
   context.DrawPath(line_path, paint_flags);
 }
 

third_party/WebKit/Source/core/svg/graphics/SVGImage.cpp

@@ -412,7 +412,8 @@ sk_sp<SkImage> SVGImage::ImageForCurrentFrameForContainer(
 static bool DrawNeedsLayer(const PaintFlags& flags) {
   if (SkColorGetA(flags.getColor()) < 255)
     return true;
-  return !flags.isSrcOver();
+
+  return flags.getBlendMode() != SkBlendMode::kSrcOver;
 }
 
 bool SVGImage::ApplyShaderInternal(PaintFlags& flags,

third_party/WebKit/Source/modules/canvas2d/BaseRenderingContext2D.cpp

@@ -1063,7 +1063,7 @@ void BaseRenderingContext2D::DrawImageInternal(PaintCanvas* c,
     ctm.mapRect(&bounds);
     PaintFlags layer_flags;
     layer_flags.setBlendMode(flags->getBlendMode());
-    layer_flags.setImageFilter(flags->refImageFilter());
+    layer_flags.setImageFilter(flags->getImageFilter());
 
     c->saveLayer(&bounds, &layer_flags);
     c->concat(ctm);

third_party/WebKit/Source/modules/canvas2d/BaseRenderingContext2D.h

@@ -460,8 +460,8 @@ void BaseRenderingContext2D::CompositedDraw(
       PaintFlags foreground_flags =
           *GetState().GetFlags(paint_type, kDrawForegroundOnly, image_type);
       foreground_flags.setImageFilter(SkComposeImageFilter::Make(
-          SkComposeImageFilter::Make(foreground_flags.refImageFilter(),
-                                     shadow_flags.refImageFilter()),
+          SkComposeImageFilter::Make(foreground_flags.getImageFilter(),
+                                     shadow_flags.getImageFilter()),
           filter));
       c->setMatrix(ctm);
       draw_func(c, &foreground_flags);

third_party/WebKit/Source/platform/fonts/Font.cpp

@@ -307,7 +307,7 @@ void GetTextInterceptsInternal(const ShapeResultBloberizer::BlobBuffer& blobs,
   // Get the number of intervals, without copying the actual values by
   // specifying nullptr for the buffer, following the Skia allocation model for
   // retrieving text intercepts.
-  SkPaint paint(ToSkPaint(flags));
+  SkPaint paint = flags.ToSkPaint();
   unsigned num_intervals = InterceptsFromBlobs(blobs, paint, bounds, nullptr);
   if (!num_intervals)
     return;

third_party/WebKit/Source/platform/graphics/Gradient.cpp

@@ -168,8 +168,8 @@ sk_sp<PaintShader> Gradient::CreateShaderInternal(
 
 void Gradient::ApplyToFlags(PaintFlags& flags, const SkMatrix& local_matrix) {
   if (!cached_shader_ || local_matrix != cached_shader_->GetLocalMatrix() ||
-      flags.getColorFilter() != color_filter_.get()) {
-    color_filter_ = flags.refColorFilter();
+      flags.getColorFilter().get() != color_filter_.get()) {
+    color_filter_ = flags.getColorFilter();
     flags.setColorFilter(nullptr);
     cached_shader_ = CreateShaderInternal(local_matrix);
   }

third_party/WebKit/Source/platform/graphics/GraphicsContextState.h

@@ -87,7 +87,7 @@ class PLATFORM_EXPORT GraphicsContextState final {
   // Shadow. (This will need tweaking if we use draw loopers for other things.)
   SkDrawLooper* DrawLooper() const {
     DCHECK_EQ(fill_flags_.getLooper(), stroke_flags_.getLooper());
-    return fill_flags_.getLooper();
+    return fill_flags_.getLooper().get();
   }
   void SetDrawLooper(sk_sp<SkDrawLooper>);
 
@@ -99,7 +99,7 @@ class PLATFORM_EXPORT GraphicsContextState final {
 
   SkColorFilter* GetColorFilter() const {
     DCHECK_EQ(fill_flags_.getColorFilter(), stroke_flags_.getColorFilter());
-    return fill_flags_.getColorFilter();
+    return fill_flags_.getColorFilter().get();
   }
   void SetColorFilter(sk_sp<SkColorFilter>);
 

third_party/WebKit/Source/platform/graphics/filters/PaintFilterEffect.cpp

@@ -23,7 +23,8 @@ PaintFilterEffect* PaintFilterEffect::Create(Filter* filter,
 }
 
 sk_sp<SkImageFilter> PaintFilterEffect::CreateImageFilter() {
-  return SkPaintImageFilter::Make(ToSkPaint(flags_), nullptr);
+  SkPaint paint = flags_.ToSkPaint();
+  return SkPaintImageFilter::Make(paint, nullptr);
 }
 
 TextStream& PaintFilterEffect::ExternalRepresentation(TextStream& ts,

third_party/WebKit/Source/platform/graphics/paint/PaintFlags.h

@@ -9,7 +9,6 @@
 
 namespace blink {
 using cc::PaintFlags;
-using cc::ToSkPaint;
 }
 
 #endif  // PaintFlags_h

ui/app_list/BUILD.gn

@@ -74,6 +74,7 @@ component("app_list") {
     "//base",
     "//base:i18n",
     "//base/third_party/dynamic_annotations",
+    "//cc/paint",
     "//components/keyed_service/core",
     "//components/sync",
     "//components/wallpaper",

ui/gfx/harfbuzz_font_skia.cc

@@ -56,7 +56,7 @@ void GetGlyphWidthAndExtents(cc::PaintFlags* flags,
                              hb_codepoint_t codepoint,
                              hb_position_t* width,
                              hb_glyph_extents_t* extents) {
-  SkPaint paint(cc::ToSkPaint(*flags));
+  SkPaint paint = flags->ToSkPaint();
 
   DCHECK_LE(codepoint, std::numeric_limits<uint16_t>::max());
   paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
@@ -92,7 +92,7 @@ hb_bool_t GetGlyph(hb_font_t* font,
   bool exists = cache->count(unicode) != 0;
   if (!exists) {
     font_data->flags_.setTextEncoding(cc::PaintFlags::kUTF32_TextEncoding);
-    SkPaint paint(cc::ToSkPaint(font_data->flags_));
+    SkPaint paint = font_data->flags_.ToSkPaint();
     paint.textToGlyphs(&unicode, sizeof(hb_codepoint_t), &(*cache)[unicode]);
   }
   *glyph = (*cache)[unicode];
@@ -124,7 +124,7 @@ hb_bool_t GetGlyphHorizontalOrigin(hb_font_t* font,
 hb_position_t GetGlyphKerning(FontData* font_data,
                               hb_codepoint_t first_glyph,
                               hb_codepoint_t second_glyph) {
-  SkTypeface* typeface = font_data->flags_.getTypeface();
+  SkTypeface* typeface = font_data->flags_.getTypeface().get();
   const uint16_t glyphs[2] = { static_cast<uint16_t>(first_glyph),
                                static_cast<uint16_t>(second_glyph) };
   int32_t kerning_adjustments[1] = { 0 };