Revert "Set SkPath::setIsVolatile based on whether the path survives at least two frames (flutter#22620)" (flutter#23044)

This reverts commit 2efc7c1.

Author: dnfield

ci/licenses_golden/licenses_flutter

@@ -361,7 +361,6 @@ FILE: ../../../flutter/lib/ui/painting/path.cc
 FILE: ../../../flutter/lib/ui/painting/path.h
 FILE: ../../../flutter/lib/ui/painting/path_measure.cc
 FILE: ../../../flutter/lib/ui/painting/path_measure.h
-FILE: ../../../flutter/lib/ui/painting/path_unittests.cc
 FILE: ../../../flutter/lib/ui/painting/picture.cc
 FILE: ../../../flutter/lib/ui/painting/picture.h
 FILE: ../../../flutter/lib/ui/painting/picture_recorder.cc
@@ -405,8 +404,6 @@ FILE: ../../../flutter/lib/ui/ui.dart
 FILE: ../../../flutter/lib/ui/ui_benchmarks.cc
 FILE: ../../../flutter/lib/ui/ui_dart_state.cc
 FILE: ../../../flutter/lib/ui/ui_dart_state.h
-FILE: ../../../flutter/lib/ui/volatile_path_tracker.cc
-FILE: ../../../flutter/lib/ui/volatile_path_tracker.h
 FILE: ../../../flutter/lib/ui/window.dart
 FILE: ../../../flutter/lib/ui/window/platform_configuration.cc
 FILE: ../../../flutter/lib/ui/window/platform_configuration.h

lib/ui/BUILD.gn

@@ -91,8 +91,6 @@ source_set("ui") {
     "text/text_box.h",
     "ui_dart_state.cc",
     "ui_dart_state.h",
-    "volatile_path_tracker.cc",
-    "volatile_path_tracker.h",
     "window/platform_configuration.cc",
     "window/platform_configuration.h",
     "window/platform_message.cc",
@@ -190,7 +188,6 @@ if (enable_unittests) {
     sources = [
       "painting/image_dispose_unittests.cc",
       "painting/image_encoding_unittests.cc",
-      "painting/path_unittests.cc",
       "painting/vertices_unittests.cc",
       "window/platform_configuration_unittests.cc",
       "window/pointer_data_packet_converter_unittests.cc",

lib/ui/fixtures/ui_test.dart

@@ -35,19 +35,8 @@ void createVertices() {
   );
   _validateVertices(vertices);
 }
-void _validateVertices(Vertices vertices) native 'ValidateVertices';
 
-@pragma('vm:entry-point')
-void createPath() {
-  final Path path = Path()..lineTo(10, 10);
-  _validatePath(path);
-  // Arbitrarily hold a reference to the path to make sure it does not get
-  // garbage collected.
-  Future<void>.delayed(const Duration(days: 100)).then((_) {
-    path.lineTo(100, 100);
-  });
-}
-void _validatePath(Path path) native 'ValidatePath';
+void _validateVertices(Vertices vertices) native 'ValidateVertices';
 
 @pragma('vm:entry-point')
 void frameCallback(FrameInfo info) {

lib/ui/painting/path.cc

@@ -67,69 +67,43 @@ void CanvasPath::RegisterNatives(tonic::DartLibraryNatives* natives) {
                      FOR_EACH_BINDING(DART_REGISTER_NATIVE)});
 }
 
-CanvasPath::CanvasPath()
-    : path_tracker_(UIDartState::Current()->GetVolatilePathTracker()),
-      tracked_path_(std::make_shared<VolatilePathTracker::TrackedPath>()) {
-  FML_DCHECK(path_tracker_);
-  resetVolatility();
-}
-
-CanvasPath::~CanvasPath() = default;
-
-void CanvasPath::resetVolatility() {
-  if (!tracked_path_->tracking_volatility) {
-    mutable_path().setIsVolatile(true);
-    tracked_path_->frame_count = 0;
-    tracked_path_->tracking_volatility = true;
-    path_tracker_->Insert(tracked_path_);
-  }
-}
+CanvasPath::CanvasPath() {}
 
-void CanvasPath::ReleaseDartWrappableReference() const {
-  FML_DCHECK(path_tracker_);
-  path_tracker_->Erase(tracked_path_);
-}
+CanvasPath::~CanvasPath() {}
 
 int CanvasPath::getFillType() {
-  return static_cast<int>(path().getFillType());
+  return static_cast<int>(path_.getFillType());
 }
 
 void CanvasPath::setFillType(int fill_type) {
-  mutable_path().setFillType(static_cast<SkPathFillType>(fill_type));
-  resetVolatility();
+  path_.setFillType(static_cast<SkPathFillType>(fill_type));
 }
 
 void CanvasPath::moveTo(float x, float y) {
-  mutable_path().moveTo(x, y);
-  resetVolatility();
+  path_.moveTo(x, y);
 }
 
 void CanvasPath::relativeMoveTo(float x, float y) {
-  mutable_path().rMoveTo(x, y);
-  resetVolatility();
+  path_.rMoveTo(x, y);
 }
 
 void CanvasPath::lineTo(float x, float y) {
-  mutable_path().lineTo(x, y);
-  resetVolatility();
+  path_.lineTo(x, y);
 }
 
 void CanvasPath::relativeLineTo(float x, float y) {
-  mutable_path().rLineTo(x, y);
-  resetVolatility();
+  path_.rLineTo(x, y);
 }
 
 void CanvasPath::quadraticBezierTo(float x1, float y1, float x2, float y2) {
-  mutable_path().quadTo(x1, y1, x2, y2);
-  resetVolatility();
+  path_.quadTo(x1, y1, x2, y2);
 }
 
 void CanvasPath::relativeQuadraticBezierTo(float x1,
                                            float y1,
                                            float x2,
                                            float y2) {
-  mutable_path().rQuadTo(x1, y1, x2, y2);
-  resetVolatility();
+  path_.rQuadTo(x1, y1, x2, y2);
 }
 
 void CanvasPath::cubicTo(float x1,
@@ -138,8 +112,7 @@ void CanvasPath::cubicTo(float x1,
                          float y2,
                          float x3,
                          float y3) {
-  mutable_path().cubicTo(x1, y1, x2, y2, x3, y3);
-  resetVolatility();
+  path_.cubicTo(x1, y1, x2, y2, x3, y3);
 }
 
 void CanvasPath::relativeCubicTo(float x1,
@@ -148,22 +121,19 @@ void CanvasPath::relativeCubicTo(float x1,
                                  float y2,
                                  float x3,
                                  float y3) {
-  mutable_path().rCubicTo(x1, y1, x2, y2, x3, y3);
-  resetVolatility();
+  path_.rCubicTo(x1, y1, x2, y2, x3, y3);
 }
 
 void CanvasPath::conicTo(float x1, float y1, float x2, float y2, float w) {
-  mutable_path().conicTo(x1, y1, x2, y2, w);
-  resetVolatility();
+  path_.conicTo(x1, y1, x2, y2, w);
 }
 
 void CanvasPath::relativeConicTo(float x1,
                                  float y1,
                                  float x2,
                                  float y2,
                                  float w) {
-  mutable_path().rConicTo(x1, y1, x2, y2, w);
-  resetVolatility();
+  path_.rConicTo(x1, y1, x2, y2, w);
 }
 
 void CanvasPath::arcTo(float left,
@@ -173,10 +143,9 @@ void CanvasPath::arcTo(float left,
                        float startAngle,
                        float sweepAngle,
                        bool forceMoveTo) {
-  mutable_path().arcTo(SkRect::MakeLTRB(left, top, right, bottom),
-                       startAngle * 180.0 / M_PI, sweepAngle * 180.0 / M_PI,
-                       forceMoveTo);
-  resetVolatility();
+  path_.arcTo(SkRect::MakeLTRB(left, top, right, bottom),
+              startAngle * 180.0 / M_PI, sweepAngle * 180.0 / M_PI,
+              forceMoveTo);
 }
 
 void CanvasPath::arcToPoint(float arcEndX,
@@ -191,9 +160,8 @@ void CanvasPath::arcToPoint(float arcEndX,
   const auto direction =
       isClockwiseDirection ? SkPathDirection::kCW : SkPathDirection::kCCW;
 
-  mutable_path().arcTo(radiusX, radiusY, xAxisRotation, arcSize, direction,
-                       arcEndX, arcEndY);
-  resetVolatility();
+  path_.arcTo(radiusX, radiusY, xAxisRotation, arcSize, direction, arcEndX,
+              arcEndY);
 }
 
 void CanvasPath::relativeArcToPoint(float arcEndDeltaX,
@@ -207,19 +175,16 @@ void CanvasPath::relativeArcToPoint(float arcEndDeltaX,
                                   : SkPath::ArcSize::kSmall_ArcSize;
   const auto direction =
       isClockwiseDirection ? SkPathDirection::kCW : SkPathDirection::kCCW;
-  mutable_path().rArcTo(radiusX, radiusY, xAxisRotation, arcSize, direction,
-                        arcEndDeltaX, arcEndDeltaY);
-  resetVolatility();
+  path_.rArcTo(radiusX, radiusY, xAxisRotation, arcSize, direction,
+               arcEndDeltaX, arcEndDeltaY);
 }
 
 void CanvasPath::addRect(float left, float top, float right, float bottom) {
-  mutable_path().addRect(SkRect::MakeLTRB(left, top, right, bottom));
-  resetVolatility();
+  path_.addRect(SkRect::MakeLTRB(left, top, right, bottom));
 }
 
 void CanvasPath::addOval(float left, float top, float right, float bottom) {
-  mutable_path().addOval(SkRect::MakeLTRB(left, top, right, bottom));
-  resetVolatility();
+  path_.addOval(SkRect::MakeLTRB(left, top, right, bottom));
 }
 
 void CanvasPath::addArc(float left,
@@ -228,29 +193,25 @@ void CanvasPath::addArc(float left,
                         float bottom,
                         float startAngle,
                         float sweepAngle) {
-  mutable_path().addArc(SkRect::MakeLTRB(left, top, right, bottom),
-                        startAngle * 180.0 / M_PI, sweepAngle * 180.0 / M_PI);
-  resetVolatility();
+  path_.addArc(SkRect::MakeLTRB(left, top, right, bottom),
+               startAngle * 180.0 / M_PI, sweepAngle * 180.0 / M_PI);
 }
 
 void CanvasPath::addPolygon(const tonic::Float32List& points, bool close) {
-  mutable_path().addPoly(reinterpret_cast<const SkPoint*>(points.data()),
-                         points.num_elements() / 2, close);
-  resetVolatility();
+  path_.addPoly(reinterpret_cast<const SkPoint*>(points.data()),
+                points.num_elements() / 2, close);
 }
 
 void CanvasPath::addRRect(const RRect& rrect) {
-  mutable_path().addRRect(rrect.sk_rrect);
-  resetVolatility();
+  path_.addRRect(rrect.sk_rrect);
 }
 
 void CanvasPath::addPath(CanvasPath* path, double dx, double dy) {
   if (!path) {
     Dart_ThrowException(ToDart("Path.addPath called with non-genuine Path."));
     return;
   }
-  mutable_path().addPath(path->path(), dx, dy, SkPath::kAppend_AddPathMode);
-  resetVolatility();
+  path_.addPath(path->path(), dx, dy, SkPath::kAppend_AddPathMode);
 }
 
 void CanvasPath::addPathWithMatrix(CanvasPath* path,
@@ -266,9 +227,8 @@ void CanvasPath::addPathWithMatrix(CanvasPath* path,
   SkMatrix matrix = ToSkMatrix(matrix4);
   matrix.setTranslateX(matrix.getTranslateX() + dx);
   matrix.setTranslateY(matrix.getTranslateY() + dy);
-  mutable_path().addPath(path->path(), matrix, SkPath::kAppend_AddPathMode);
+  path_.addPath(path->path(), matrix, SkPath::kAppend_AddPathMode);
   matrix4.Release();
-  resetVolatility();
 }
 
 void CanvasPath::extendWithPath(CanvasPath* path, double dx, double dy) {
@@ -277,8 +237,7 @@ void CanvasPath::extendWithPath(CanvasPath* path, double dx, double dy) {
         ToDart("Path.extendWithPath called with non-genuine Path."));
     return;
   }
-  mutable_path().addPath(path->path(), dx, dy, SkPath::kExtend_AddPathMode);
-  resetVolatility();
+  path_.addPath(path->path(), dx, dy, SkPath::kExtend_AddPathMode);
 }
 
 void CanvasPath::extendWithPathAndMatrix(CanvasPath* path,
@@ -294,43 +253,37 @@ void CanvasPath::extendWithPathAndMatrix(CanvasPath* path,
   SkMatrix matrix = ToSkMatrix(matrix4);
   matrix.setTranslateX(matrix.getTranslateX() + dx);
   matrix.setTranslateY(matrix.getTranslateY() + dy);
-  mutable_path().addPath(path->path(), matrix, SkPath::kExtend_AddPathMode);
+  path_.addPath(path->path(), matrix, SkPath::kExtend_AddPathMode);
   matrix4.Release();
-  resetVolatility();
 }
 
 void CanvasPath::close() {
-  mutable_path().close();
-  resetVolatility();
+  path_.close();
 }
 
 void CanvasPath::reset() {
-  mutable_path().reset();
-  resetVolatility();
+  path_.reset();
 }
 
 bool CanvasPath::contains(double x, double y) {
-  return path().contains(x, y);
+  return path_.contains(x, y);
 }
 
 void CanvasPath::shift(Dart_Handle path_handle, double dx, double dy) {
   fml::RefPtr<CanvasPath> path = CanvasPath::Create(path_handle);
-  auto& other_mutable_path = path->mutable_path();
-  mutable_path().offset(dx, dy, &other_mutable_path);
-  resetVolatility();
+  path_.offset(dx, dy, &path->path_);
 }
 
 void CanvasPath::transform(Dart_Handle path_handle,
                            tonic::Float64List& matrix4) {
   fml::RefPtr<CanvasPath> path = CanvasPath::Create(path_handle);
-  auto& other_mutable_path = path->mutable_path();
-  mutable_path().transform(ToSkMatrix(matrix4), &other_mutable_path);
+  path_.transform(ToSkMatrix(matrix4), &path->path_);
   matrix4.Release();
 }
 
 tonic::Float32List CanvasPath::getBounds() {
   tonic::Float32List rect(Dart_NewTypedData(Dart_TypedData_kFloat32, 4));
-  const SkRect& bounds = path().getBounds();
+  const SkRect& bounds = path_.getBounds();
   rect[0] = bounds.left();
   rect[1] = bounds.top();
   rect[2] = bounds.right();
@@ -340,22 +293,21 @@ tonic::Float32List CanvasPath::getBounds() {
 
 bool CanvasPath::op(CanvasPath* path1, CanvasPath* path2, int operation) {
   return Op(path1->path(), path2->path(), static_cast<SkPathOp>(operation),
-            &tracked_path_->path);
-  resetVolatility();
+            &path_);
 }
 
 void CanvasPath::clone(Dart_Handle path_handle) {
   fml::RefPtr<CanvasPath> path = CanvasPath::Create(path_handle);
   // per Skia docs, this will create a fast copy
   // data is shared until the source path or dest path are mutated
-  path->mutable_path() = this->path();
+  path->path_ = path_;
 }
 
 // This is doomed to be called too early, since Paths are mutable.
 // However, it can help for some of the clone/shift/transform type methods
 // where the resultant path will initially have a meaningful size.
 size_t CanvasPath::GetAllocationSize() const {
-  return sizeof(CanvasPath) + path().approximateBytesUsed();
+  return sizeof(CanvasPath) + path_.approximateBytesUsed();
 }
 
 }  // namespace flutter

lib/ui/painting/path.h

@@ -7,7 +7,6 @@
 
 #include "flutter/lib/ui/dart_wrapper.h"
 #include "flutter/lib/ui/painting/rrect.h"
-#include "flutter/lib/ui/volatile_path_tracker.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/pathops/SkPathOps.h"
 #include "third_party/tonic/typed_data/typed_list.h"
@@ -37,7 +36,7 @@ class CanvasPath : public RefCountedDartWrappable<CanvasPath> {
   static fml::RefPtr<CanvasPath> CreateFrom(Dart_Handle path_handle,
                                             const SkPath& src) {
     fml::RefPtr<CanvasPath> path = CanvasPath::Create(path_handle);
-    path->tracked_path_->path = src;
+    path->path_ = src;
     return path;
   }
 
@@ -109,24 +108,16 @@ class CanvasPath : public RefCountedDartWrappable<CanvasPath> {
   bool op(CanvasPath* path1, CanvasPath* path2, int operation);
   void clone(Dart_Handle path_handle);
 
-  const SkPath& path() const { return tracked_path_->path; }
+  const SkPath& path() const { return path_; }
 
   size_t GetAllocationSize() const override;
 
   static void RegisterNatives(tonic::DartLibraryNatives* natives);
 
-  virtual void ReleaseDartWrappableReference() const override;
-
  private:
   CanvasPath();
 
-  std::shared_ptr<VolatilePathTracker> path_tracker_;
-  std::shared_ptr<VolatilePathTracker::TrackedPath> tracked_path_;
-
-  // Must be called whenever the path is created or mutated.
-  void resetVolatility();
-
-  SkPath& mutable_path() { return tracked_path_->path; }
+  SkPath path_;
 };
 
 }  // namespace flutter