Remove Dart_GetField from Paint marshalling (#2753)

This should make almost every Canvas call significantly faster.

flutter/lib/ui/BUILD.gn

@@ -4,8 +4,6 @@
 
 source_set("ui") {
   sources = [
-    "painting/color_filter.cc",
-    "painting/color_filter.h",
     "painting/gradient.cc",
     "painting/gradient.h",
     "painting/image.cc",
@@ -18,6 +16,8 @@ source_set("ui") {
     "painting/mask_filter.h",
     "painting/matrix.cc",
     "painting/matrix.h",
+    "painting/paint.cc",
+    "painting/paint.h",
     "painting/path.cc",
     "painting/path.h",
     "painting/picture.cc",

flutter/lib/ui/painting/color_filter.cc

-// Copyright 2015 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 "flutter/lib/ui/painting/color_filter.h"
-
-#include "flutter/tonic/dart_args.h"
-#include "flutter/tonic/dart_binding_macros.h"
-#include "flutter/tonic/dart_converter.h"
-#include "flutter/tonic/dart_library_natives.h"
-
-namespace blink {
-
-static void ColorFilter_constructor(Dart_NativeArguments args) {
-  DartCallConstructor(&ColorFilter::Create, args);
-}
-
-IMPLEMENT_WRAPPERTYPEINFO(ui, ColorFilter);
-
-void ColorFilter::RegisterNatives(DartLibraryNatives* natives) {
-  natives->Register({
-    { "ColorFilter_constructor", ColorFilter_constructor, 3, true },
-  });
-}
-
-scoped_refptr<ColorFilter> ColorFilter::Create(int color,
-                                               int transfer_mode) {
-  return new ColorFilter(SkColorFilter::MakeModeFilter(
-      static_cast<SkColor>(color),
-      static_cast<SkXfermode::Mode>(transfer_mode)));
-}
-
-ColorFilter::ColorFilter(sk_sp<SkColorFilter> filter)
-    : filter_(std::move(filter)) {
-}
-
-ColorFilter::~ColorFilter() {
-}
-
-} // namespace blink

flutter/lib/ui/painting/color_filter.h

-// Copyright 2015 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 FLUTTER_LIB_UI_PAINTING_COLOR_FILTER_H_
-#define FLUTTER_LIB_UI_PAINTING_COLOR_FILTER_H_
-
-#include "base/memory/ref_counted.h"
-#include "flutter/tonic/dart_wrappable.h"
-#include "third_party/skia/include/core/SkColorFilter.h"
-
-namespace blink {
-class DartLibraryNatives;
-
-class ColorFilter : public base::RefCountedThreadSafe<ColorFilter>, public DartWrappable {
-  DEFINE_WRAPPERTYPEINFO();
- public:
-  ~ColorFilter() override;
-  static scoped_refptr<ColorFilter> Create(int color, int transfer_mode);
-
-  const sk_sp<SkColorFilter>& filter() { return filter_; }
-
-  static void RegisterNatives(DartLibraryNatives* natives);
-
- private:
-  ColorFilter(sk_sp<SkColorFilter> filter);
-
-  sk_sp<SkColorFilter> filter_;
-};
-
-} // namespace blink
-
-#endif  // FLUTTER_LIB_UI_PAINTING_COLOR_FILTER_H_

flutter/lib/ui/painting/paint.cc

+// Copyright 2015 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 "flutter/lib/ui/painting/paint.h"
+
+#include "flutter/lib/ui/painting/mask_filter.h"
+#include "flutter/lib/ui/painting/shader.h"
+#include "flutter/tonic/dart_byte_data.h"
+#include "third_party/skia/include/core/SkColorFilter.h"
+#include "third_party/skia/include/core/SkMaskFilter.h"
+#include "third_party/skia/include/core/SkShader.h"
+#include "third_party/skia/include/core/SkString.h"
+
+namespace blink {
+
+static const int kIsAntiAliasIndex = 0;
+static const int kColorIndex = 1;
+static const int kTransferModeIndex = 2;
+static const int kStyleIndex = 3;
+static const int kStrokeWidthIndex = 4;
+static const int kStrokeCapIndex = 5;
+static const int kFilterQualityIndex = 6;
+static const int kColorFilterIndex = 7;
+static const int kColorFilterColorIndex = 8;
+static const int kColorFilterTransferModeIndex = 9;
+static const size_t kDataByteCount = 40;
+
+static const int kMaskFilterIndex = 0;
+static const int kShaderIndex = 1;
+static const int kObjectCount = 2;  // Must be one larger than the largest index
+
+Paint DartConverter<Paint>::FromArguments(Dart_NativeArguments args,
+                                          int index,
+                                          Dart_Handle& exception) {
+  Dart_Handle paint_objects = Dart_GetNativeArgument(args, index);
+  DCHECK(!LogIfError(paint_objects));
+
+  Dart_Handle paint_data = Dart_GetNativeArgument(args, index + 1);
+  DCHECK(!LogIfError(paint_data));
+
+  Paint result;
+  SkPaint& paint = result.paint_;
+
+  if (!Dart_IsNull(paint_objects)) {
+    DCHECK(Dart_IsList(paint_objects));
+    intptr_t length = 0;
+    Dart_ListLength(paint_objects, &length);
+
+    CHECK_EQ(length, kObjectCount);
+    Dart_Handle values[kObjectCount];
+    if (Dart_IsError(Dart_ListGetRange(paint_objects, 0, kObjectCount, values)))
+      return result;
+
+    Dart_Handle mask_filter = values[kMaskFilterIndex];
+    if (!Dart_IsNull(mask_filter)) {
+      MaskFilter* decoded = DartConverter<MaskFilter*>::FromDart(mask_filter);
+      paint.setMaskFilter(decoded->filter());
+    }
+
+    Dart_Handle shader = values[kShaderIndex];
+    if (!Dart_IsNull(shader)) {
+      Shader* decoded = DartConverter<Shader*>::FromDart(shader);
+      paint.setShader(decoded->shader());
+    }
+  }
+
+  DartByteData byte_data(paint_data);
+  CHECK_EQ(byte_data.length_in_bytes(), kDataByteCount);
+
+  const uint32_t* uint_data = static_cast<const uint32_t*>(byte_data.data());
+  const float* float_data = static_cast<const float*>(byte_data.data());
+
+  paint.setAntiAlias(uint_data[kIsAntiAliasIndex] == 0);
+
+  uint32_t encoded_color = uint_data[kColorIndex];
+  if (encoded_color) {
+    SkColor color = encoded_color ^ 0xFF000000;
+    paint.setColor(color);
+  }
+
+  uint32_t encoded_transfer_mode = uint_data[kTransferModeIndex];
+  if (encoded_transfer_mode) {
+    uint32_t transfer_mode = encoded_transfer_mode ^ SkXfermode::kSrcOver_Mode;
+    paint.setXfermodeMode(static_cast<SkXfermode::Mode>(transfer_mode));
+  }
+
+  uint32_t style = uint_data[kStyleIndex];
+  if (style)
+    paint.setStyle(static_cast<SkPaint::Style>(style));
+
+  float stroke_width = float_data[kStrokeWidthIndex];
+  if (stroke_width != 0.0)
+    paint.setStrokeWidth(stroke_width);
+
+  uint32_t stroke_cap = uint_data[kStrokeCapIndex];
+  if (stroke_cap)
+    paint.setStrokeCap(static_cast<SkPaint::Cap>(stroke_cap));
+
+  uint32_t filter_quality = uint_data[kFilterQualityIndex];
+  if (filter_quality)
+    paint.setFilterQuality(static_cast<SkFilterQuality>(filter_quality));
+
+  if (uint_data[kColorFilterIndex]) {
+    SkColor color = uint_data[kColorFilterColorIndex];
+    SkXfermode::Mode transfer_mode =
+        static_cast<SkXfermode::Mode>(uint_data[kColorFilterTransferModeIndex]);
+    paint.setColorFilter(SkColorFilter::MakeModeFilter(color, transfer_mode));
+  }
+
+  result.is_null_ = false;
+  return result;
+}
+
+PaintData DartConverter<PaintData>::FromArguments(Dart_NativeArguments args,
+                                                  int index,
+                                                  Dart_Handle& exception) {
+  return PaintData();
+}
+
+}  // namespace blink

sky/engine/core/painting/Paint.h → flutter/lib/ui/painting/paint.h

@@ -2,30 +2,50 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef SKY_ENGINE_CORE_PAINTING_PAINT_H_
-#define SKY_ENGINE_CORE_PAINTING_PAINT_H_
+#ifndef FLUTTER_LIB_UI_PAINTING_PAINT_H_
+#define FLUTTER_LIB_UI_PAINTING_PAINT_H_
 
-#include "flutter/tonic/dart_wrappable.h"
+#include "flutter/tonic/dart_converter.h"
 #include "third_party/skia/include/core/SkPaint.h"
 
 namespace blink {
 
+template <>
+struct DartConverter<SkXfermode::Mode>
+    : public DartConverterInteger<SkXfermode::Mode> {};
+
 class Paint {
  public:
-  SkPaint sk_paint;
-  bool is_null;
+  const SkPaint* paint() const { return is_null_ ? nullptr : &paint_; }
+
+ private:
+  friend struct DartConverter<Paint>;
+
+  SkPaint paint_;
+  bool is_null_;
+};
 
-  const SkPaint* paint() const { return is_null ? nullptr : &sk_paint; }
+class PaintData {
 };
 
 template <>
 struct DartConverter<Paint> {
-  static Paint FromDart(Dart_Handle handle);
   static Paint FromArguments(Dart_NativeArguments args,
                              int index,
                              Dart_Handle& exception);
 };
 
+// The PaintData argument is a placeholder to receive encoded data for Paint
+// objects. The data is actually processed by DartConverter<Paint>, which reads
+// both at the given index and at the next index (which it assumes is a byte
+// data for a Paint object).
+template <>
+struct DartConverter<PaintData> {
+  static PaintData FromArguments(Dart_NativeArguments args,
+                                 int index,
+                                 Dart_Handle& exception);
+};
+
 }  // namespace blink
 
-#endif  // SKY_ENGINE_CORE_PAINTING_PAINT_H_
+#endif  // FLUTTER_LIB_UI_PAINTING_PAINT_H_

flutter/tonic/BUILD.gn

@@ -7,6 +7,8 @@ source_set("tonic") {
     "dart_api_scope.h",
     "dart_args.h",
     "dart_binding_macros.h",
+    "dart_byte_data.cc",
+    "dart_byte_data.h",
     "dart_class_library.cc",
     "dart_class_library.h",
     "dart_class_provider.cc",

flutter/tonic/dart_byte_data.cc

+// Copyright 2015 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 "flutter/tonic/dart_byte_data.h"
+
+#include "flutter/tonic/dart_error.h"
+
+namespace blink {
+
+DartByteData::DartByteData()
+    : data_(nullptr), length_in_bytes_(0), dart_handle_(nullptr) {}
+
+DartByteData::DartByteData(Dart_Handle list)
+    : data_(nullptr), length_in_bytes_(0), dart_handle_(list) {
+  if (Dart_IsNull(list))
+    return;
+
+  Dart_TypedData_Type type;
+  Dart_TypedDataAcquireData(list, &type, &data_, &length_in_bytes_);
+  DCHECK(!LogIfError(list));
+  DCHECK(type == Dart_TypedData_kByteData);
+}
+
+DartByteData::DartByteData(DartByteData&& other)
+    : data_(other.data_),
+      length_in_bytes_(other.length_in_bytes_),
+      dart_handle_(other.dart_handle_) {
+  other.data_ = nullptr;
+  other.dart_handle_ = nullptr;
+}
+
+DartByteData::~DartByteData() {
+  Release();
+}
+
+std::vector<char> DartByteData::Copy() const {
+  const char* ptr = static_cast<const char*>(data_);
+  return std::vector<char>(ptr, ptr + length_in_bytes_);
+}
+
+void DartByteData::Release() const {
+  if (data_) {
+    Dart_TypedDataReleaseData(dart_handle_);
+    data_ = nullptr;
+  }
+}
+
+DartByteData DartConverter<DartByteData>::FromArguments(
+    Dart_NativeArguments args,
+    int index,
+    Dart_Handle& exception) {
+  Dart_Handle data = Dart_GetNativeArgument(args, index);
+  DCHECK(!LogIfError(data));
+  return DartByteData(data);
+}
+
+void DartConverter<DartByteData>::SetReturnValue(Dart_NativeArguments args,
+                                                 DartByteData val) {
+  Dart_SetReturnValue(args, val.dart_handle());
+}
+
+} // namespace blink

flutter/tonic/dart_byte_data.h

+// Copyright 2016 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 FLUTTER_TONIC_DART_BYTE_DATA_H_
+#define FLUTTER_TONIC_DART_BYTE_DATA_H_
+
+#include <vector>
+
+#include "dart/runtime/include/dart_api.h"
+#include "flutter/tonic/dart_converter.h"
+
+namespace blink {
+
+class DartByteData {
+ public:
+  explicit DartByteData(Dart_Handle list);
+  DartByteData(DartByteData&& other);
+  DartByteData();
+  ~DartByteData();
+
+  const void* data() const { return data_; }
+  size_t length_in_bytes() const { return length_in_bytes_; }
+  Dart_Handle dart_handle() const { return dart_handle_; }
+
+  std::vector<char> Copy() const;
+  void Release() const;
+
+ private:
+  mutable void* data_;
+  intptr_t length_in_bytes_;
+  Dart_Handle dart_handle_;
+
+  DartByteData(const DartByteData& other) = delete;
+};
+
+template <>
+struct DartConverter<DartByteData> {
+  static void SetReturnValue(Dart_NativeArguments args, DartByteData val);
+  static DartByteData FromArguments(Dart_NativeArguments args,
+                                    int index,
+                                    Dart_Handle& exception);
+};
+
+} // namespace blink
+
+#endif  // FLUTTER_TONIC_DART_BYTE_DATA_H_

flutter/tonic/dart_invoke.cc

@@ -13,14 +13,12 @@ namespace blink {
 bool DartInvokeField(Dart_Handle target,
                      const char* name,
                      std::initializer_list<Dart_Handle> args) {
-  TRACE_EVENT1("flutter", "DartInvokeField", "name", name);
   Dart_Handle field = Dart_NewStringFromCString(name);
   return LogIfError(Dart_Invoke(
       target, field, args.size(), const_cast<Dart_Handle*>(args.begin())));
 }
 
 void DartInvoke(Dart_Handle closure, std::initializer_list<Dart_Handle> args) {
-  TRACE_EVENT0("flutter", "DartInvoke");
   int argc = args.size();
   Dart_Handle* argv = const_cast<Dart_Handle*>(args.begin());
   Dart_Handle handle = Dart_InvokeClosure(closure, argc, argv);
@@ -28,7 +26,6 @@ void DartInvoke(Dart_Handle closure, std::initializer_list<Dart_Handle> args) {
 }
 
 void DartInvokeVoid(Dart_Handle closure) {
-  TRACE_EVENT0("flutter", "DartInvokeVoid");
   Dart_Handle handle = Dart_InvokeClosure(closure, 0, nullptr);
   LogIfError(handle);
 }

flutter/tonic/float32_list.cc

@@ -2,9 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "flutter/tonic/dart_error.h"
 #include "flutter/tonic/float32_list.h"
 
+#include "flutter/tonic/dart_error.h"
+
 namespace blink {
 
 Float32List::Float32List()
@@ -41,9 +42,7 @@ Float32List DartConverter<Float32List>::FromArguments(
     Dart_Handle& exception) {
   Dart_Handle list = Dart_GetNativeArgument(args, index);
   DCHECK(!LogIfError(list));
-
-  Float32List result(list);
-  return result;
+  return Float32List(list);
 }
 
 void DartConverter<Float32List>::SetReturnValue(Dart_NativeArguments args,

flutter/tonic/float64_list.cc

@@ -2,9 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "flutter/tonic/dart_error.h"
 #include "flutter/tonic/float64_list.h"
 
+#include "flutter/tonic/dart_error.h"
+
 namespace blink {
 
 Float64List::Float64List()
@@ -41,9 +42,7 @@ Float64List DartConverter<Float64List>::FromArguments(
     Dart_Handle& exception) {
   Dart_Handle list = Dart_GetNativeArgument(args, index);
   DCHECK(!LogIfError(list));
-
-  Float64List result(list);
-  return result;
+  return Float64List(list);
 }
 
 void DartConverter<Float64List>::SetReturnValue(Dart_NativeArguments args,

flutter/tonic/int32_list.cc

@@ -2,9 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "flutter/tonic/dart_error.h"
 #include "flutter/tonic/int32_list.h"
 
+#include "flutter/tonic/dart_error.h"
+
 namespace blink {
 
 Int32List::Int32List()
@@ -48,9 +49,7 @@ Int32List DartConverter<Int32List>::FromArguments(
     Dart_Handle& exception) {
   Dart_Handle list = Dart_GetNativeArgument(args, index);
   DCHECK(!LogIfError(list));
-
-  Int32List result(list);
-  return result;
+  return Int32List(list);
 }
 
 void DartConverter<Int32List>::SetReturnValue(Dart_NativeArguments args,

flutter/tonic/uint8_list.cc

@@ -2,9 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "flutter/tonic/dart_error.h"
 #include "flutter/tonic/uint8_list.h"
 
+#include "flutter/tonic/dart_error.h"
+
 namespace blink {
 
 Uint8List::Uint8List()
@@ -41,9 +42,7 @@ Uint8List DartConverter<Uint8List>::FromArguments(
     Dart_Handle& exception) {
   Dart_Handle list = Dart_GetNativeArgument(args, index);
   DCHECK(!LogIfError(list));
-
-  Uint8List result(list);
-  return result;
+  return Uint8List(list);
 }
 
 void DartConverter<Uint8List>::SetReturnValue(Dart_NativeArguments args,

sky/engine/bindings/dart_ui.cc

@@ -4,7 +4,6 @@
 
 #include "sky/engine/bindings/dart_ui.h"
 
-#include "flutter/lib/ui/painting/color_filter.h"
 #include "flutter/lib/ui/painting/gradient.h"
 #include "flutter/lib/ui/painting/image.h"
 #include "flutter/lib/ui/painting/image_filter.h"
@@ -49,7 +48,6 @@ void DartUI::InitForGlobal() {
     CanvasGradient::RegisterNatives(g_natives);
     CanvasImage::RegisterNatives(g_natives);
     CanvasPath::RegisterNatives(g_natives);
-    ColorFilter::RegisterNatives(g_natives);
     DartRuntimeHooks::RegisterNatives(g_natives);
     ImageFilter::RegisterNatives(g_natives);
     ImageShader::RegisterNatives(g_natives);

sky/engine/core/compositing/SceneBuilder.h

@@ -18,7 +18,6 @@
 #include "flutter/tonic/dart_wrappable.h"
 #include "flutter/tonic/float64_list.h"
 #include "sky/engine/core/compositing/Scene.h"
-#include "sky/engine/core/painting/Paint.h"
 
 namespace blink {
 

sky/engine/core/core.gni

@@ -20,8 +20,6 @@ sky_core_files = [
   "editing/PositionWithAffinity.h",
   "painting/Canvas.cpp",
   "painting/Canvas.h",
-  "painting/Paint.cpp",
-  "painting/Paint.h",
   "painting/painting.cc",
   "painting/painting.h",
   "painting/PictureRecorder.cpp",

sky/engine/core/painting/Canvas.cpp

@@ -95,7 +95,8 @@ void Canvas::save()
     m_canvas->save();
 }
 
-void Canvas::saveLayerWithoutBounds(const Paint& paint) {
+void Canvas::saveLayerWithoutBounds(const Paint& paint,
+                                    const PaintData& paint_data) {
     if (!m_canvas)
         return;
     m_canvas->saveLayer(nullptr, paint.paint());
@@ -105,7 +106,8 @@ void Canvas::saveLayer(double left,
                        double top,
                        double right,
                        double bottom,
-                       const Paint& paint)
+                       const Paint& paint,
+                       const PaintData& paint_data)
 {
     if (!m_canvas)
         return;
@@ -193,80 +195,101 @@ void Canvas::clipPath(const CanvasPath* path)
     m_canvas->clipPath(path->path(), SkRegion::kIntersect_Op);
 }
 
-void Canvas::drawColor(int color, int transferMode)
+void Canvas::drawColor(SkColor color, SkXfermode::Mode transferMode)
 {
     if (!m_canvas)
         return;
-    m_canvas->drawColor(static_cast<SkColor>(color),
-                        static_cast<SkXfermode::Mode>(transferMode));
+    m_canvas->drawColor(color, transferMode);
 }
 
-void Canvas::drawLine(double x1, double y1, double x2, double y2, const Paint& paint)
+void Canvas::drawLine(double x1,
+                      double y1,
+                      double x2,
+                      double y2,
+                      const Paint& paint,
+                      const PaintData& paint_data)
 {
     if (!m_canvas)
         return;
-    m_canvas->drawLine(x1, y1, x2, y2, paint.sk_paint);
+    m_canvas->drawLine(x1, y1, x2, y2, *paint.paint());
 }
 
-void Canvas::drawPaint(const Paint& paint)
+void Canvas::drawPaint(const Paint& paint, const PaintData& paint_data)
 {
     if (!m_canvas)
         return;
-    m_canvas->drawPaint(paint.sk_paint);
+    m_canvas->drawPaint(*paint.paint());
 }
 
 void Canvas::drawRect(double left,
                       double top,
                       double right,
                       double bottom,
-                      const Paint& paint)
+                      const Paint& paint,
+                      const PaintData& paint_data)
 {
     if (!m_canvas)
         return;
-    m_canvas->drawRect(SkRect::MakeLTRB(left, top, right, bottom), paint.sk_paint);
+    m_canvas->drawRect(SkRect::MakeLTRB(left, top, right, bottom), *paint.paint());
 }
 
-void Canvas::drawRRect(const RRect& rrect, const Paint& paint)
+void Canvas::drawRRect(const RRect& rrect,
+                       const Paint& paint,
+                      const PaintData& paint_data)
 {
     if (!m_canvas)
         return;
-    m_canvas->drawRRect(rrect.sk_rrect, paint.sk_paint);
+    m_canvas->drawRRect(rrect.sk_rrect, *paint.paint());
 }
 
-void Canvas::drawDRRect(const RRect& outer, const RRect& inner, const Paint& paint)
+void Canvas::drawDRRect(const RRect& outer,
+                        const RRect& inner,
+                        const Paint& paint,
+                        const PaintData& paint_data)
 {
     if (!m_canvas)
         return;
-    m_canvas->drawDRRect(outer.sk_rrect, inner.sk_rrect, paint.sk_paint);
+    m_canvas->drawDRRect(outer.sk_rrect, inner.sk_rrect, *paint.paint());
 }
 
 void Canvas::drawOval(double left,
                       double top,
                       double right,
                       double bottom,
-                      const Paint& paint)
+                      const Paint& paint,
+                      const PaintData& paint_data)
 {
     if (!m_canvas)
         return;
-    m_canvas->drawOval(SkRect::MakeLTRB(left, top, right, bottom), paint.sk_paint);
+    m_canvas->drawOval(SkRect::MakeLTRB(left, top, right, bottom), *paint.paint());
 }
 
-void Canvas::drawCircle(double x, double y, double radius, const Paint& paint)
+void Canvas::drawCircle(double x,
+                        double y,
+                        double radius,
+                        const Paint& paint,
+                        const PaintData& paint_data)
 {
     if (!m_canvas)
         return;
-    m_canvas->drawCircle(x, y, radius, paint.sk_paint);
+    m_canvas->drawCircle(x, y, radius, *paint.paint());
 }
 
-void Canvas::drawPath(const CanvasPath* path, const Paint& paint)
+void Canvas::drawPath(const CanvasPath* path,
+                      const Paint& paint,
+                      const PaintData& paint_data)
 {
     if (!m_canvas)
         return;
     DCHECK(path);
-    m_canvas->drawPath(path->path(), paint.sk_paint);
+    m_canvas->drawPath(path->path(), *paint.paint());
 }
 
-void Canvas::drawImage(const CanvasImage* image, double x, double y, const Paint& paint) {
+void Canvas::drawImage(const CanvasImage* image,
+                       double x,
+                       double y,
+                       const Paint& paint,
+                       const PaintData& paint_data) {
     if (!m_canvas)
         return;
     DCHECK(image);
@@ -282,7 +305,8 @@ void Canvas::drawImageRect(const CanvasImage* image,
                            double dstTop,
                            double dstRight,
                            double dstBottom,
-                           const Paint& paint) {
+                           const Paint& paint,
+                           const PaintData& paint_data) {
     if (!m_canvas)
         return;
     DCHECK(image);
@@ -302,7 +326,8 @@ void Canvas::drawImageNine(const CanvasImage* image,
                            double dstTop,
                            double dstRight,
                            double dstBottom,
-                           const Paint& paint) {
+                           const Paint& paint,
+                           const PaintData& paint_data) {
     if (!m_canvas)
         return;
     DCHECK(image);
@@ -331,6 +356,7 @@ void Canvas::drawParagraph(Paragraph* paragraph, double x, double y) {
 }
 
 void Canvas::drawPoints(const Paint& paint,
+                        const PaintData& paint_data,
                         SkCanvas::PointMode pointMode,
                         const Float32List& points) {
   if (!m_canvas)
@@ -348,17 +374,17 @@ void Canvas::drawPoints(const Paint& paint,
 
 void Canvas::drawVertices(
     const Paint& paint,
+    const PaintData& paint_data,
     SkCanvas::VertexMode vertexMode,
     const Float32List& vertices,
     const Float32List& textureCoordinates,
     const Int32List& colors,
-    int transferMode,
+    SkXfermode::Mode transferMode,
     const Int32List& indices) {
   if (!m_canvas)
     return;
 
-  sk_sp<SkXfermode> transferModePtr = SkXfermode::Make(
-    static_cast<SkXfermode::Mode>(transferMode));
+  sk_sp<SkXfermode> transferModePtr = SkXfermode::Make(transferMode);
 
   std::vector<uint16_t> indices16;
   indices16.reserve(indices.num_elements());
@@ -383,11 +409,12 @@ void Canvas::drawVertices(
 
 void Canvas::drawAtlas(
     const Paint& paint,
+    const PaintData& paint_data,
     CanvasImage* atlas,
     const Float32List& transforms,
     const Float32List& rects,
     const Int32List& colors,
-    int transferMode,
+    SkXfermode::Mode transferMode,
     const Float32List& cullRect) {
   if (!m_canvas)
     return;
@@ -403,7 +430,7 @@ void Canvas::drawAtlas(
     reinterpret_cast<const SkRect*>(rects.data()),
     reinterpret_cast<const SkColor*>(colors.data()),
     rects.num_elements() / 4,  // SkRect have four floats.
-    static_cast<SkXfermode::Mode>(transferMode),
+    transferMode,
     reinterpret_cast<const SkRect*>(cullRect.data()),
     paint.paint()
   );

sky/engine/core/painting/Canvas.h

@@ -6,6 +6,7 @@
 #define SKY_ENGINE_CORE_PAINTING_CANVAS_H_
 
 #include "base/memory/ref_counted.h"
+#include "flutter/lib/ui/painting/paint.h"
 #include "flutter/lib/ui/painting/path.h"
 #include "flutter/lib/ui/painting/picture.h"
 #include "flutter/lib/ui/painting/rrect.h"
@@ -13,7 +14,6 @@
 #include "flutter/tonic/float32_list.h"
 #include "flutter/tonic/float64_list.h"
 #include "flutter/tonic/int32_list.h"
-#include "sky/engine/core/painting/Paint.h"
 #include "sky/engine/core/painting/PictureRecorder.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 
@@ -23,10 +23,12 @@ class DartLibraryNatives;
 class Paragraph;
 
 template <>
-struct DartConverter<SkCanvas::PointMode> : public DartConverterInteger<SkCanvas::PointMode> {};
+struct DartConverter<SkCanvas::PointMode>
+    : public DartConverterInteger<SkCanvas::PointMode> {};
 
 template <>
-struct DartConverter<SkCanvas::VertexMode> : public DartConverterInteger<SkCanvas::VertexMode> {};
+struct DartConverter<SkCanvas::VertexMode>
+    : public DartConverterInteger<SkCanvas::VertexMode> {};
 
 class Canvas : public base::RefCountedThreadSafe<Canvas>, public DartWrappable {
     DEFINE_WRAPPERTYPEINFO();
@@ -40,12 +42,14 @@ public:
     ~Canvas() override;
 
     void save();
-    void saveLayerWithoutBounds(const Paint& paint);
+    void saveLayerWithoutBounds(const Paint& paint,
+                                const PaintData& paint_data);
     void saveLayer(double left,
                    double top,
                    double right,
                    double bottom,
-                   const Paint& paint);
+                   const Paint& paint,
+                   const PaintData& paint_data);
     void restore();
     int getSaveCount();
 
@@ -63,24 +67,47 @@ public:
     void clipRRect(const RRect& rrect);
     void clipPath(const CanvasPath* path);
 
-    void drawColor(int color, int transferMode);
-    void drawLine(double x1, double y1, double x2, double y2, const Paint& paint);
-    void drawPaint(const Paint& paint);
+    void drawColor(SkColor color, SkXfermode::Mode transferMode);
+    void drawLine(double x1,
+                  double y1,
+                  double x2,
+                  double y2,
+                  const Paint& paint,
+                  const PaintData& paint_data);
+    void drawPaint(const Paint& paint,
+                   const PaintData& paint_data);
     void drawRect(double left,
                   double top,
                   double right,
                   double bottom,
-                  const Paint& paint);
-    void drawRRect(const RRect& rrect, const Paint& paint);
-    void drawDRRect(const RRect& outer, const RRect& inner, const Paint& paint);
+                  const Paint& paint,
+                  const PaintData& paint_data);
+    void drawRRect(const RRect& rrect,
+                   const Paint& paint,
+                   const PaintData& paint_data);
+    void drawDRRect(const RRect& outer,
+                    const RRect& inner,
+                    const Paint& paint,
+                    const PaintData& paint_data);
     void drawOval(double left,
                   double top,
                   double right,
                   double bottom,
-                  const Paint& paint);
-    void drawCircle(double x, double y, double radius, const Paint& paint);
-    void drawPath(const CanvasPath* path, const Paint& paint);
-    void drawImage(const CanvasImage* image, double x, double y, const Paint& paint);
+                  const Paint& paint,
+                  const PaintData& paint_data);
+    void drawCircle(double x,
+                    double y,
+                    double radius,
+                    const Paint& paint,
+                    const PaintData& paint_data);
+    void drawPath(const CanvasPath* path,
+                  const Paint& paint,
+                  const PaintData& paint_data);
+    void drawImage(const CanvasImage* image,
+                   double x,
+                   double y,
+                   const Paint& paint,
+                   const PaintData& paint_data);
     void drawImageRect(const CanvasImage* image,
                        double srcLeft,
                        double srcTop,
@@ -90,7 +117,8 @@ public:
                        double dstTop,
                        double dstRight,
                        double dstBottom,
-                       const Paint& paint);
+                       const Paint& paint,
+                       const PaintData& paint_data);
     void drawImageNine(const CanvasImage* image,
                        double centerLeft,
                        double centerTop,
@@ -100,36 +128,37 @@ public:
                        double dstTop,
                        double dstRight,
                        double dstBottom,
-                       const Paint& paint);
+                       const Paint& paint,
+                       const PaintData& paint_data);
     void drawPicture(Picture* picture);
     void drawParagraph(Paragraph* paragraph, double x, double y);
 
     // The paint argument is first for the following functions because Paint
-    // still uses Dart_GetField to extract data from the DartVM. Once we create
-    // a view unto a Float32List, we cannot re-enter the VM to call
-    // Dart_GetField. That means we either need to process the paint argument
-    // first or remove the Dart_GetField from marshalling the paint argument.
-    //
-    // TODO(abarth): Remove the Dart_GetField from marshalling the paint argument.
+    // unwraps a number of C++ objects. Once we create a view unto a
+    // Float32List, we cannot re-enter the VM to unwrap objects. That means we
+    // either need to process the paint argument first.
 
     void drawPoints(const Paint& paint,
+                    const PaintData& paint_data,
                     SkCanvas::PointMode pointMode,
                     const Float32List& points);
 
     void drawVertices(const Paint& paint,
+                      const PaintData& paint_data,
                       SkCanvas::VertexMode vertexMode,
                       const Float32List& vertices,
                       const Float32List& textureCoordinates,
                       const Int32List& colors,
-                      int transferMode,
+                      SkXfermode::Mode transferMode,
                       const Int32List& indices);
 
     void drawAtlas(const Paint& paint,
+                   const PaintData& paint_data,
                    CanvasImage* atlas,
                    const Float32List& transforms,
                    const Float32List& rects,
                    const Int32List& colors,
-                   int transferMode,
+                   SkXfermode::Mode transferMode,
                    const Float32List& cullRect);
 
     SkCanvas* skCanvas() { return m_canvas; }

sky/engine/core/painting/Paint.cpp

-// Copyright 2015 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 "sky/engine/core/painting/Paint.h"
-
-#include "flutter/lib/ui/painting/color_filter.h"
-#include "flutter/lib/ui/painting/mask_filter.h"
-#include "flutter/lib/ui/painting/shader.h"
-#include "sky/engine/core/script/ui_dart_state.h"
-#include "third_party/skia/include/core/SkColorFilter.h"
-#include "third_party/skia/include/core/SkMaskFilter.h"
-#include "third_party/skia/include/core/SkShader.h"
-#include "third_party/skia/include/core/SkString.h"
-
-#include <iostream>
-
-namespace blink {
-namespace {
-
-// Must match Paint._value getter in Paint.dart.
-enum PaintFields {
-  kStyle,
-  kStrokeWidth,
-  kStrokeCap,
-  kIsAntiAlias,
-  kColor,
-  kTransferMode,
-  kColorFilter,
-  kMaskFilter,
-  kFilterQuality,
-  kShader,
-
-  // kNumberOfPaintFields must be last.
-  kNumberOfPaintFields,
-};
-
-}
-
-Paint DartConverter<Paint>::FromDart(Dart_Handle dart_paint) {
-  Paint result;
-  result.is_null = true;
-  if (Dart_IsNull(dart_paint))
-    return result;
-
-  Dart_Handle value_handle = UIDartState::Current()->value_handle();
-  Dart_Handle data = Dart_GetField(dart_paint, value_handle);
-
-  if (Dart_IsInteger(data)) {
-    // This is a simple Paint object that just contains a color with
-    // anti-aliasing enabled. The data is the color, represented as an
-    // int in the same format as SkColor.
-    result.sk_paint.setColor(DartConverter<SkColor>::FromDart(data));
-    result.sk_paint.setAntiAlias(true);
-    result.is_null = false;
-    return result;
-  }
-
-  DCHECK(Dart_IsList(data));
-
-  intptr_t length;
-  Dart_ListLength(data, &length);
-
-  CHECK_EQ(length, kNumberOfPaintFields);
-  Dart_Handle values[kNumberOfPaintFields];
-  Dart_Handle range_result = Dart_ListGetRange(data, 0, kNumberOfPaintFields,
-					       values);
-  if (Dart_IsError(range_result)) {
-    return result;
-  }
-
-  SkPaint& paint = result.sk_paint;
-
-  if (!Dart_IsNull(values[kStyle]))
-    paint.setStyle(static_cast<SkPaint::Style>(DartConverter<int>::FromDart(values[kStyle])));
-  if (!Dart_IsNull(values[kStrokeWidth]))
-    paint.setStrokeWidth(DartConverter<SkScalar>::FromDart(values[kStrokeWidth]));
-  if (!Dart_IsNull(values[kStrokeCap]))
-    paint.setStrokeCap(static_cast<SkPaint::Cap>(DartConverter<int>::FromDart(values[kStrokeCap])));
-  if (!Dart_IsNull(values[kIsAntiAlias]))
-    paint.setAntiAlias(DartConverter<bool>::FromDart(values[kIsAntiAlias]));
-  if (!Dart_IsNull(values[kColor]))
-    paint.setColor(static_cast<SkColor>(DartConverter<int>::FromDart(values[kColor])));
-  if (!Dart_IsNull(values[kTransferMode]))
-    paint.setXfermodeMode(static_cast<SkXfermode::Mode>(DartConverter<int>::FromDart(values[kTransferMode])));
-  if (!Dart_IsNull(values[kColorFilter]))
-    paint.setColorFilter(DartConverter<ColorFilter*>::FromDart(values[kColorFilter])->filter());
-  if (!Dart_IsNull(values[kMaskFilter]))
-    paint.setMaskFilter(DartConverter<MaskFilter*>::FromDart(values[kMaskFilter])->filter());
-  if (!Dart_IsNull(values[kFilterQuality]))
-    paint.setFilterQuality(static_cast<SkFilterQuality>(DartConverter<int>::FromDart(values[kFilterQuality])));
-  if (!Dart_IsNull(values[kShader]))
-    paint.setShader(DartConverter<Shader*>::FromDart(values[kShader])->shader());
-
-  result.is_null = false;
-  return result;
-}
-
-Paint DartConverter<Paint>::FromArguments(Dart_NativeArguments args,
-                                          int index,
-                                          Dart_Handle& exception) {
-  Dart_Handle dart_rect = Dart_GetNativeArgument(args, index);
-  DCHECK(!LogIfError(dart_rect));
-  return FromDart(dart_rect);
-}
-
-}  // namespace blink