Reflect vertex buffer size in pictures

Author: dnfield

lib/ui/painting/canvas.cc

@@ -293,7 +293,7 @@ void Canvas::drawImage(const CanvasImage* image,
   if (!image)
     Dart_ThrowException(
         ToDart("Canvas.drawImage called with non-genuine Image."));
-  image_allocation_size_ += image->GetAllocationSize();
+  external_allocation_size_ += image->GetAllocationSize();
   canvas_->drawImage(image->image(), x, y, paint.paint());
 }
 
@@ -315,7 +315,7 @@ void Canvas::drawImageRect(const CanvasImage* image,
         ToDart("Canvas.drawImageRect called with non-genuine Image."));
   SkRect src = SkRect::MakeLTRB(src_left, src_top, src_right, src_bottom);
   SkRect dst = SkRect::MakeLTRB(dst_left, dst_top, dst_right, dst_bottom);
-  image_allocation_size_ += image->GetAllocationSize();
+  external_allocation_size_ += image->GetAllocationSize();
   canvas_->drawImageRect(image->image(), src, dst, paint.paint(),
                          SkCanvas::kFast_SrcRectConstraint);
 }
@@ -341,7 +341,7 @@ void Canvas::drawImageNine(const CanvasImage* image,
   SkIRect icenter;
   center.round(&icenter);
   SkRect dst = SkRect::MakeLTRB(dst_left, dst_top, dst_right, dst_bottom);
-  image_allocation_size_ += image->GetAllocationSize();
+  external_allocation_size_ += image->GetAllocationSize();
   canvas_->drawImageNine(image->image(), icenter, dst, paint.paint());
 }
 
@@ -351,7 +351,7 @@ void Canvas::drawPicture(Picture* picture) {
   if (!picture)
     Dart_ThrowException(
         ToDart("Canvas.drawPicture called with non-genuine Picture."));
-  image_allocation_size_ += picture->GetAllocationSize();
+  external_allocation_size_ += picture->GetAllocationSize();
   canvas_->drawPicture(picture->picture().get());
 }
 
@@ -380,7 +380,7 @@ void Canvas::drawVertices(const Vertices* vertices,
   if (!vertices)
     Dart_ThrowException(
         ToDart("Canvas.drawVertices called with non-genuine Vertices."));
-
+  external_allocation_size_ += vertices->GetAllocationSize();
   canvas_->drawVertices(vertices->vertices(), blend_mode, *paint.paint());
 }
 
@@ -406,7 +406,7 @@ void Canvas::drawAtlas(const Paint& paint,
   static_assert(sizeof(SkRect) == sizeof(float) * 4,
                 "SkRect doesn't use floats.");
 
-  image_allocation_size_ += atlas->GetAllocationSize();
+  external_allocation_size_ += atlas->GetAllocationSize();
   canvas_->drawAtlas(
       skImage.get(), reinterpret_cast<const SkRSXform*>(transforms.data()),
       reinterpret_cast<const SkRect*>(rects.data()),

lib/ui/painting/canvas.h

@@ -170,7 +170,7 @@ class Canvas : public RefCountedDartWrappable<Canvas> {
 
   static void RegisterNatives(tonic::DartLibraryNatives* natives);
 
-  size_t image_allocation_size() const { return image_allocation_size_; }
+  size_t external_allocation_size() const { return external_allocation_size_; }
 
  private:
   explicit Canvas(SkCanvas* canvas);
@@ -179,7 +179,7 @@ class Canvas : public RefCountedDartWrappable<Canvas> {
   // which does not transfer ownership.  For this reason, we hold a raw
   // pointer and manually set to null in Clear.
   SkCanvas* canvas_;
-  size_t image_allocation_size_ = 0;
+  size_t external_allocation_size_ = 0;
 };
 
 }  // namespace flutter

lib/ui/painting/picture.cc

@@ -28,18 +28,18 @@ DART_BIND_ALL(Picture, FOR_EACH_BINDING)
 
 fml::RefPtr<Picture> Picture::Create(Dart_Handle dart_handle,
                                      flutter::SkiaGPUObject<SkPicture> picture,
-                                     size_t image_allocation_size) {
+                                     size_t external_allocation_size) {
   auto canvas_picture =
-      fml::MakeRefCounted<Picture>(std::move(picture), image_allocation_size);
+      fml::MakeRefCounted<Picture>(std::move(picture), external_allocation_size);
 
   canvas_picture->AssociateWithDartWrapper(dart_handle);
   return canvas_picture;
 }
 
 Picture::Picture(flutter::SkiaGPUObject<SkPicture> picture,
-                 size_t image_allocation_size)
+                 size_t external_allocation_size)
     : picture_(std::move(picture)),
-      image_allocation_size_(image_allocation_size) {}
+      external_allocation_size_(external_allocation_size) {}
 
 Picture::~Picture() = default;
 
@@ -61,7 +61,7 @@ void Picture::dispose() {
 size_t Picture::GetAllocationSize() const {
   if (auto picture = picture_.get()) {
     return picture->approximateBytesUsed() + sizeof(Picture) +
-           image_allocation_size_;
+           external_allocation_size_;
   } else {
     return sizeof(Picture);
   }

lib/ui/painting/picture.h

@@ -26,7 +26,7 @@ class Picture : public RefCountedDartWrappable<Picture> {
   ~Picture() override;
   static fml::RefPtr<Picture> Create(Dart_Handle dart_handle,
                                      flutter::SkiaGPUObject<SkPicture> picture,
-                                     size_t image_allocation_size);
+                                     size_t external_allocation_size);
 
   sk_sp<SkPicture> picture() const { return picture_.get(); }
 
@@ -45,14 +45,14 @@ class Picture : public RefCountedDartWrappable<Picture> {
                                       uint32_t height,
                                       Dart_Handle raw_image_callback);
 
-  size_t image_allocation_size() const { return image_allocation_size_; }
+  size_t external_allocation_size() const { return external_allocation_size_; }
 
  private:
   Picture(flutter::SkiaGPUObject<SkPicture> picture,
-          size_t image_allocation_size_);
+          size_t external_allocation_size_);
 
   flutter::SkiaGPUObject<SkPicture> picture_;
-  size_t image_allocation_size_;
+  size_t external_allocation_size_;
 };
 
 }  // namespace flutter

lib/ui/painting/picture_recorder.cc

@@ -56,7 +56,7 @@ fml::RefPtr<Picture> PictureRecorder::endRecording(Dart_Handle dart_picture) {
       Picture::Create(dart_picture,
                       UIDartState::CreateGPUObject(
                           picture_recorder_.finishRecordingAsPicture()),
-                      canvas_->image_allocation_size());
+                      canvas_->external_allocation_size());
 
   canvas_->Clear();
   canvas_->ClearDartWrapper();

testing/dart/canvas_test.dart

@@ -245,4 +245,46 @@ void main() {
 
     expect(picture2.approximateBytesUsed, greaterThan(minimumExpected));
   });
+
+  test('Vertex buffer size reflected in picture size for drawVertices', () async {
+    final Image image = await createImage(100, 100);
+    final PictureRecorder recorder = PictureRecorder();
+    final Canvas canvas = Canvas(recorder);
+
+    const int uint16max = 65535;
+
+    final Int32List colors = Int32List(uint16max);
+    final Float32List coords = Float32List(uint16max * 2);
+    final Uint16List indices = Uint16List(uint16max);
+    final Float32List positions = Float32List(uint16max * 2);
+    colors[0] = const Color(0xFFFF0000).value;
+    colors[1] = const Color(0xFF00FF00).value;
+    colors[2] = const Color(0xFF0000FF).value;
+    colors[3] = const Color(0xFF00FFFF).value;
+    indices[1] = indices[3] = 1;
+    indices[2] = indices[5] = 3;
+    indices[4] = 2;
+    positions[2] = positions[4] = positions[5] = positions[7] = 250.0;
+
+    final Vertices vertices = Vertices.raw(
+      VertexMode.triangles,
+      positions,
+      textureCoordinates: coords,
+      colors: colors,
+      indices: indices,
+    );
+    canvas.drawVertices(vertices, BlendMode.src, Paint());
+    final Picture picture = recorder.endRecording();
+
+
+    const int minimumExpected = uint16max * 4;
+    expect(picture.approximateBytesUsed, greaterThan(minimumExpected));
+
+    final PictureRecorder recorder2 = PictureRecorder();
+    final Canvas canvas2 = Canvas(recorder2);
+    canvas2.drawPicture(picture);
+    final Picture picture2 = recorder2.endRecording();
+
+    expect(picture2.approximateBytesUsed, greaterThan(minimumExpected));
+  });
 }