started sending down the wider colors in paint

Author: gaaclarke

lib/ui/painting.dart

@@ -1185,22 +1185,31 @@ final class Paint {
   @pragma('vm:entry-point')
   final ByteData _data = ByteData(_kDataByteCount);
 
+  // Must match //lib/ui/painting/paint.cc.
   static const int _kIsAntiAliasIndex = 0;
-  static const int _kColorIndex = 1;
-  static const int _kBlendModeIndex = 2;
-  static const int _kStyleIndex = 3;
-  static const int _kStrokeWidthIndex = 4;
-  static const int _kStrokeCapIndex = 5;
-  static const int _kStrokeJoinIndex = 6;
-  static const int _kStrokeMiterLimitIndex = 7;
-  static const int _kFilterQualityIndex = 8;
-  static const int _kMaskFilterIndex = 9;
-  static const int _kMaskFilterBlurStyleIndex = 10;
-  static const int _kMaskFilterSigmaIndex = 11;
-  static const int _kInvertColorIndex = 12;
+  static const int _kColorRedIndex = 1;
+  static const int _kColorGreenIndex = 2;
+  static const int _kColorBlueIndex = 3;
+  static const int _kColorAlphaIndex = 4;
+  static const int _kColorSpaceIndex = 5;
+  static const int _kBlendModeIndex = 6;
+  static const int _kStyleIndex = 7;
+  static const int _kStrokeWidthIndex = 8;
+  static const int _kStrokeCapIndex = 9;
+  static const int _kStrokeJoinIndex = 10;
+  static const int _kStrokeMiterLimitIndex = 11;
+  static const int _kFilterQualityIndex = 12;
+  static const int _kMaskFilterIndex = 13;
+  static const int _kMaskFilterBlurStyleIndex = 14;
+  static const int _kMaskFilterSigmaIndex = 15;
+  static const int _kInvertColorIndex = 16;
 
   static const int _kIsAntiAliasOffset = _kIsAntiAliasIndex << 2;
-  static const int _kColorOffset = _kColorIndex << 2;
+  static const int _kColorRedOffset = _kColorRedIndex << 2;
+  static const int _kColorGreenOffset = _kColorGreenIndex << 2;
+  static const int _kColorBlueOffset = _kColorBlueIndex << 2;
+  static const int _kColorAlphaOffset = _kColorAlphaIndex << 2;
+  static const int _kColorSpaceOffset = _kColorSpaceIndex << 2;
   static const int _kBlendModeOffset = _kBlendModeIndex << 2;
   static const int _kStyleOffset = _kStyleIndex << 2;
   static const int _kStrokeWidthOffset = _kStrokeWidthIndex << 2;
@@ -1214,7 +1223,7 @@ final class Paint {
   static const int _kInvertColorOffset = _kInvertColorIndex << 2;
 
   // If you add more fields, remember to update _kDataByteCount.
-  static const int _kDataByteCount = 52; // 4 * (last index + 1).
+  static const int _kDataByteCount = 68; // 4 * (last index + 1).
 
   // Binary format must match the deserialization code in paint.cc.
   // C++ unit tests access this.
@@ -1260,12 +1269,28 @@ final class Paint {
   /// This color is not used when compositing. To colorize a layer, use
   /// [colorFilter].
   Color get color {
-    final int encoded = _data.getInt32(_kColorOffset, _kFakeHostEndian);
-    return Color(encoded ^ _kColorDefault);
+    final double red = _data.getFloat32(_kColorRedOffset, _kFakeHostEndian);
+    final double green = _data.getFloat32(_kColorGreenOffset, _kFakeHostEndian);
+    final double blue = _data.getFloat32(_kColorBlueOffset, _kFakeHostEndian);
+    final double alpha =
+        1.0 - _data.getFloat32(_kColorAlphaOffset, _kFakeHostEndian);
+    final ColorSpace colorSpace = _indexToColorSpace(
+        _data.getInt32(_kColorSpaceOffset, _kFakeHostEndian));
+    return Color.from(
+        alpha: alpha,
+        red: red,
+        green: green,
+        blue: blue,
+        colorSpace: colorSpace);
   }
+
   set color(Color value) {
-    final int encoded = value.value ^ _kColorDefault;
-    _data.setInt32(_kColorOffset, encoded, _kFakeHostEndian);
+    _data.setFloat32(_kColorRedOffset, value.r, _kFakeHostEndian);
+    _data.setFloat32(_kColorGreenOffset, value.g, _kFakeHostEndian);
+    _data.setFloat32(_kColorBlueOffset, value.b, _kFakeHostEndian);
+    _data.setFloat32(_kColorAlphaOffset, 1.0 - value.a, _kFakeHostEndian);
+    _data.setInt32(_kColorSpaceOffset, _colorSpaceToIndex(value.colorSpace),
+        _kFakeHostEndian);
   }
 
   // Must be kept in sync with the default in paint.cc.
@@ -1642,6 +1667,30 @@ enum ColorSpace {
   displayP3,
 }
 
+int _colorSpaceToIndex(ColorSpace colorSpace) {
+  switch (colorSpace) {
+    case ColorSpace.sRGB:
+      return 0;
+    case ColorSpace.extendedSRGB:
+      return 1;
+    case ColorSpace.displayP3:
+      return 2;
+  }
+}
+
+ColorSpace _indexToColorSpace(int index) {
+  switch(index) {
+    case 0:
+      return ColorSpace.sRGB;
+    case 1:
+      return ColorSpace.extendedSRGB;
+    case 2:
+      return ColorSpace.displayP3;
+    default:
+      throw ArgumentError('Unknown color space: $index');
+  }
+}
+
 /// The format in which image bytes should be returned when using
 /// [Image.toByteData].
 // We do not expect to add more encoding formats to the ImageByteFormat enum,

lib/ui/painting/paint.cc

@@ -21,20 +21,25 @@
 namespace flutter {
 
 // Indices for 32bit values.
+// Must match //lib/ui/painting.dart.
 constexpr int kIsAntiAliasIndex = 0;
-constexpr int kColorIndex = 1;
-constexpr int kBlendModeIndex = 2;
-constexpr int kStyleIndex = 3;
-constexpr int kStrokeWidthIndex = 4;
-constexpr int kStrokeCapIndex = 5;
-constexpr int kStrokeJoinIndex = 6;
-constexpr int kStrokeMiterLimitIndex = 7;
-constexpr int kFilterQualityIndex = 8;
-constexpr int kMaskFilterIndex = 9;
-constexpr int kMaskFilterBlurStyleIndex = 10;
-constexpr int kMaskFilterSigmaIndex = 11;
-constexpr int kInvertColorIndex = 12;
-constexpr size_t kDataByteCount = 52;  // 4 * (last index + 1)
+constexpr int kColorRedIndex = 1;
+constexpr int kColorGreenIndex = 2;
+constexpr int kColorBlueIndex = 3;
+constexpr int kColorAlphaIndex = 4;
+constexpr int kColorSpaceIndex = 5;
+constexpr int kBlendModeIndex = 6;
+constexpr int kStyleIndex = 7;
+constexpr int kStrokeWidthIndex = 8;
+constexpr int kStrokeCapIndex = 9;
+constexpr int kStrokeJoinIndex = 10;
+constexpr int kStrokeMiterLimitIndex = 11;
+constexpr int kFilterQualityIndex = 12;
+constexpr int kMaskFilterIndex = 13;
+constexpr int kMaskFilterBlurStyleIndex = 14;
+constexpr int kMaskFilterSigmaIndex = 15;
+constexpr int kInvertColorIndex = 16;
+constexpr size_t kDataByteCount = 68;  // 4 * (last index + 1)
 static_assert(kDataByteCount == sizeof(uint32_t) * (kInvertColorIndex + 1),
               "kDataByteCount must match the size of the data array.");
 
@@ -44,9 +49,6 @@ constexpr int kColorFilterIndex = 1;
 constexpr int kImageFilterIndex = 2;
 constexpr int kObjectCount = 3;  // One larger than largest object index.
 
-// Must be kept in sync with the default in painting.dart.
-constexpr uint32_t kColorDefault = 0xFF000000;
-
 // Must be kept in sync with the default in painting.dart.
 constexpr uint32_t kBlendModeDefault =
     static_cast<uint32_t>(SkBlendMode::kSrcOver);
@@ -58,6 +60,27 @@ constexpr float kStrokeMiterLimitDefault = 4.0f;
 // Must be kept in sync with the MaskFilter private constants in painting.dart.
 enum MaskFilterType { kNull, kBlur };
 
+namespace {
+DlColor ReadColor(const tonic::DartByteData& byte_data) {
+  const uint32_t* uint_data = static_cast<const uint32_t*>(byte_data.data());
+  const float* float_data = static_cast<const float*>(byte_data.data());
+
+  float red = float_data[kColorRedIndex];
+  float green = float_data[kColorGreenIndex];
+  float blue = float_data[kColorBlueIndex];
+  // Invert alpha so 0 initialized buffer has default value;
+  float alpha = 1.f - float_data[kColorAlphaIndex];
+  uint32_t colorspace = uint_data[kColorSpaceIndex];
+  (void)colorspace;
+  uint32_t encoded_color = static_cast<uint8_t>(alpha * 255.f) << 24 |  //
+                           static_cast<uint8_t>(red * 255.f) << 16 |    //
+                           static_cast<uint8_t>(green * 255.f) << 8 |   //
+                           static_cast<uint8_t>(blue * 255.f) << 0;
+  // TODO(gaaclarke): Pass down color info to DlColor.
+  return DlColor(encoded_color);
+}
+}  // namespace
+
 Paint::Paint(Dart_Handle paint_objects, Dart_Handle paint_data)
     : paint_objects_(paint_objects), paint_data_(paint_data) {}
 
@@ -137,8 +160,7 @@ const DlPaint* Paint::paint(DlPaint& paint,
   }
 
   if (flags.applies_alpha_or_color()) {
-    uint32_t encoded_color = uint_data[kColorIndex];
-    paint.setColor(DlColor(encoded_color ^ kColorDefault));
+    paint.setColor(ReadColor(byte_data));
   }
 
   if (flags.applies_blend()) {
@@ -238,8 +260,7 @@ void Paint::toDlPaint(DlPaint& paint) const {
 
   paint.setAntiAlias(uint_data[kIsAntiAliasIndex] == 0);
 
-  uint32_t encoded_color = uint_data[kColorIndex];
-  paint.setColor(DlColor(encoded_color ^ kColorDefault));
+  paint.setColor(ReadColor(byte_data));
 
   uint32_t encoded_blend_mode = uint_data[kBlendModeIndex];
   uint32_t blend_mode = encoded_blend_mode ^ kBlendModeDefault;