Merge pull request #2 from Mairramer/master

DEPS

@@ -15,7 +15,7 @@ vars = {
   'flutter_git': 'https://flutter.googlesource.com',
   'skia_git': 'https://skia.googlesource.com',
   'llvm_git': 'https://llvm.googlesource.com',
-  'skia_revision': 'e61cc6d073fd3dd217b52e7b91d21151aad61478',
+  'skia_revision': 'deb0153719ddf8895c9c1448a9a6959610785947',
 
   # WARNING: DO NOT EDIT canvaskit_cipd_instance MANUALLY
   # See `lib/web_ui/README.md` for how to roll CanvasKit to a new version.
@@ -59,7 +59,7 @@ vars = {
   # updated revision list of existing dependencies. You will need to
   # gclient sync before and after update deps to ensure all deps are updated.
   # updated revision list of existing dependencies.
-  'dart_revision': '077062c5e5154cee4ffb1d72532428eaa79bc0fa',
+  'dart_revision': 'dbcb567e2432c7cf8401ca4d9365a3f040aa5deb',
 
   # WARNING: DO NOT EDIT MANUALLY
   # The lines between blank lines above and below are generated by a script. See create_updated_flutter_deps.py
@@ -77,7 +77,7 @@ vars = {
   'dart_protobuf_rev': '9e30258e0aa6a6430ee36c84b75308a9702fde42',
   'dart_pub_rev': 'b297f1f5e42f2569f15a98548f44b4b9a48487c1',
   'dart_sync_http_rev': '6666fff944221891182e1f80bf56569338164d72',
-  'dart_tools_rev': 'd03c394b24829f662098e590a2c812a076b01199',
+  'dart_tools_rev': '97014f33a2aad59385df73f25baf9c304ca5c866',
   'dart_vector_math_rev': '70a9a2cb610d040b247f3ca2cd70a94c1c6f6f23',
   'dart_web_rev': '35fc98dd8f9da175ed0a2dcf246299e922e1e1e2',
   'dart_webdev_rev': '234e44c2ba0aa6cee5a36026538ca89457bf0d55',
@@ -810,7 +810,7 @@ deps = {
      'packages': [
        {
         'package': 'fuchsia/sdk/core/linux-amd64',
-        'version': 'u5vxWTRT0HlxOP5_rIPOkUJXTun41aPDWjrw0MQdakkC'
+        'version': 'QssSL8DkxIbMvf89CsxO9AsjjFWhqAZd7XoYRjQxeP8C'
        }
      ],
      'condition': 'download_fuchsia_deps and not download_fuchsia_sdk',

engine/src/flutter/fml/string_conversion.cc

@@ -44,4 +44,9 @@ std::u16string Utf8ToUtf16(const std::string_view string) {
   return converter.from_bytes(string.data());
 }
 
+std::string PathToUtf8(const std::filesystem::path& path) {
+  const std::u8string path_u8 = path.u8string();
+  return std::string(path_u8.begin(), path_u8.end());
+}
+
 }  // namespace fml

engine/src/flutter/fml/string_conversion.h

@@ -5,6 +5,7 @@
 #ifndef FLUTTER_FML_STRING_CONVERSION_H_
 #define FLUTTER_FML_STRING_CONVERSION_H_
 
+#include <filesystem>
 #include <string>
 #include <vector>
 
@@ -19,6 +20,9 @@ std::string Utf16ToUtf8(const std::u16string_view string);
 // Returns a UTF-16 encoded equivalent of a UTF-8 encoded input string.
 std::u16string Utf8ToUtf16(const std::string_view string);
 
+// Returns the pathname encoded in UTF-8.
+std::string PathToUtf8(const std::filesystem::path& path);
+
 }  // namespace fml
 
 #endif  // FLUTTER_FML_STRING_CONVERSION_H_

engine/src/flutter/fml/string_conversion_unittests.cc

@@ -33,5 +33,10 @@ TEST(StringConversion, Utf16ToUtf8Unicode) {
   EXPECT_EQ(Utf16ToUtf8(u"\x2603"), "\xe2\x98\x83");
 }
 
+TEST(StringConversion, PathToUtf8) {
+  EXPECT_EQ(PathToUtf8(std::filesystem::path("abc")), "abc");
+  EXPECT_EQ(PathToUtf8(std::filesystem::path(u"\x2603")), "\xe2\x98\x83");
+}
+
 }  // namespace testing
 }  // namespace fml

engine/src/flutter/impeller/display_list/aiks_dl_basic_unittests.cc

@@ -852,6 +852,25 @@ void RenderArcFarm(DisplayListBuilder& builder,
   }
   builder.Restore();
 }
+
+void RenderArcFarmForOverlappingCapsTest(DisplayListBuilder& builder,
+                                         const DlPaint& paint) {
+  builder.Save();
+  builder.Translate(40, 30);
+  const Rect arc_bounds = Rect::MakeLTRB(0, 0, 40, 40);
+  for (int stroke_width = 10; stroke_width <= 40; stroke_width += 3) {
+    DlPaint modified_paint = DlPaint(paint);
+    modified_paint.setStrokeWidth(stroke_width);
+    builder.Save();
+    for (int sweep = 160; sweep <= 360; sweep += 20) {
+      builder.DrawArc(arc_bounds, 0, sweep, false, modified_paint);
+      builder.Translate(84, 0);
+    }
+    builder.Restore();
+    builder.Translate(0, 44 + stroke_width);
+  }
+  builder.Restore();
+}
 }  // namespace
 
 TEST_P(AiksTest, FilledArcsRenderCorrectly) {
@@ -981,6 +1000,21 @@ TEST_P(AiksTest, StrokedArcsRenderCorrectlyWithSquareEnds) {
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }
 
+TEST_P(AiksTest, StrokedArcsRenderCorrectlyWithTranslucencyAndSquareEnds) {
+  DisplayListBuilder builder;
+  builder.Scale(GetContentScale().x, GetContentScale().y);
+  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
+
+  DlPaint paint;
+  paint.setDrawStyle(DlDrawStyle::kStroke);
+  paint.setStrokeCap(DlStrokeCap::kSquare);
+  paint.setColor(DlColor::kBlue().modulateOpacity(0.5));
+
+  RenderArcFarmForOverlappingCapsTest(builder, paint);
+
+  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
+}
+
 TEST_P(AiksTest, StrokedArcsRenderCorrectlyWithRoundEnds) {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);
@@ -1001,6 +1035,21 @@ TEST_P(AiksTest, StrokedArcsRenderCorrectlyWithRoundEnds) {
   ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
 }
 
+TEST_P(AiksTest, StrokedArcsRenderCorrectlyWithTranslucencyAndRoundEnds) {
+  DisplayListBuilder builder;
+  builder.Scale(GetContentScale().x, GetContentScale().y);
+  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
+
+  DlPaint paint;
+  paint.setDrawStyle(DlDrawStyle::kStroke);
+  paint.setStrokeCap(DlStrokeCap::kRound);
+  paint.setColor(DlColor::kBlue().modulateOpacity(0.5));
+
+  RenderArcFarmForOverlappingCapsTest(builder, paint);
+
+  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
+}
+
 TEST_P(AiksTest, StrokedArcsRenderCorrectlyWithBevelJoinsAndCenter) {
   DisplayListBuilder builder;
   builder.Scale(GetContentScale().x, GetContentScale().y);

engine/src/flutter/impeller/entity/entity_unittests.cc

@@ -2313,6 +2313,117 @@ TEST_P(EntityTest, FillPathGeometryGetPositionBufferReturnsExpectedMode) {
   }
 }
 
+TEST_P(EntityTest, StrokeArcGeometryGetPositionBufferReturnsExpectedMode) {
+  RenderTarget target;
+  testing::MockRenderPass mock_pass(GetContext(), target);
+  Rect oval_bounds = Rect::MakeLTRB(100, 100, 200, 200);
+
+  // Butt caps never overlap
+  {
+    StrokeParameters stroke = {.width = 50.0f, .cap = Cap::kButt};
+    for (auto start = 0; start < 360; start += 60) {
+      for (auto sweep = 0; sweep < 360; sweep += 12) {
+        auto geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
+                                                 Degrees(sweep), stroke);
+
+        GeometryResult result =
+            geometry->GetPositionBuffer(*GetContentContext(), {}, mock_pass);
+
+        EXPECT_EQ(result.mode, GeometryResult::Mode::kNormal)
+            << "start: " << start << " sweep: " << sweep;
+      }
+    }
+  }
+
+  // Round caps with 10 stroke width overlap starting at 348.6 degrees
+  {
+    StrokeParameters stroke = {.width = 10.0f, .cap = Cap::kRound};
+    for (auto start = 0; start < 360; start += 60) {
+      for (auto sweep = 0; sweep < 360; sweep += 12) {
+        auto geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
+                                                 Degrees(sweep), stroke);
+
+        GeometryResult result =
+            geometry->GetPositionBuffer(*GetContentContext(), {}, mock_pass);
+
+        if (sweep < 348.6) {
+          EXPECT_EQ(result.mode, GeometryResult::Mode::kNormal)
+              << "start: " << start << " sweep: " << sweep;
+        } else {
+          EXPECT_EQ(result.mode, GeometryResult::Mode::kPreventOverdraw)
+              << "start: " << start << " sweep: " << sweep;
+        }
+      }
+    }
+  }
+
+  // Round caps with 50 stroke width overlap starting at 300.1 degrees
+  {
+    StrokeParameters stroke = {.width = 50.0f, .cap = Cap::kRound};
+    for (auto start = 0; start < 360; start += 60) {
+      for (auto sweep = 0; sweep < 360; sweep += 12) {
+        auto geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
+                                                 Degrees(sweep), stroke);
+
+        GeometryResult result =
+            geometry->GetPositionBuffer(*GetContentContext(), {}, mock_pass);
+
+        if (sweep < 300.0) {
+          EXPECT_EQ(result.mode, GeometryResult::Mode::kNormal)
+              << "start: " << start << " sweep: " << sweep;
+        } else {
+          EXPECT_EQ(result.mode, GeometryResult::Mode::kPreventOverdraw)
+              << "start: " << start << " sweep: " << sweep;
+        }
+      }
+    }
+  }
+
+  // Square caps with 10 stroke width overlap starting at 347.4 degrees
+  {
+    StrokeParameters stroke = {.width = 10.0f, .cap = Cap::kSquare};
+    for (auto start = 0; start < 360; start += 60) {
+      for (auto sweep = 0; sweep < 360; sweep += 12) {
+        auto geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
+                                                 Degrees(sweep), stroke);
+
+        GeometryResult result =
+            geometry->GetPositionBuffer(*GetContentContext(), {}, mock_pass);
+
+        if (sweep < 347.4) {
+          EXPECT_EQ(result.mode, GeometryResult::Mode::kNormal)
+              << "start: " << start << " sweep: " << sweep;
+        } else {
+          EXPECT_EQ(result.mode, GeometryResult::Mode::kPreventOverdraw)
+              << "start: " << start << " sweep: " << sweep;
+        }
+      }
+    }
+  }
+
+  // Square caps with 50 stroke width overlap starting at 270.1 degrees
+  {
+    StrokeParameters stroke = {.width = 50.0f, .cap = Cap::kSquare};
+    for (auto start = 0; start < 360; start += 60) {
+      for (auto sweep = 0; sweep < 360; sweep += 12) {
+        auto geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
+                                                 Degrees(sweep), stroke);
+
+        GeometryResult result =
+            geometry->GetPositionBuffer(*GetContentContext(), {}, mock_pass);
+
+        if (sweep < 270.1) {
+          EXPECT_EQ(result.mode, GeometryResult::Mode::kNormal)
+              << "start: " << start << " sweep: " << sweep;
+        } else {
+          EXPECT_EQ(result.mode, GeometryResult::Mode::kPreventOverdraw)
+              << "start: " << start << " sweep: " << sweep;
+        }
+      }
+    }
+  }
+}
+
 TEST_P(EntityTest, FailOnValidationError) {
   if (GetParam() != PlaygroundBackend::kVulkan) {
     GTEST_SKIP() << "Validation is only fatal on Vulkan backend.";

engine/src/flutter/impeller/entity/geometry/arc_geometry.cc

@@ -5,6 +5,7 @@
 #include "flutter/impeller/entity/geometry/arc_geometry.h"
 
 #include "flutter/impeller/entity/geometry/line_geometry.h"
+#include "fml/logging.h"
 
 namespace impeller {
 
@@ -47,7 +48,11 @@ GeometryResult ArcGeometry::GetPositionBuffer(const ContentContext& renderer,
     auto generator =
         renderer.GetTessellator().StrokedArc(transform, arc_, cap_, half_width);
 
-    return ComputePositionGeometry(renderer, generator, entity, pass);
+    auto result = ComputePositionGeometry(renderer, generator, entity, pass);
+    if (CapsOverlap()) {
+      result.mode = GeometryResult::Mode::kPreventOverdraw;
+    }
+    return result;
   }
 }
 
@@ -80,4 +85,53 @@ bool ArcGeometry::IsAxisAlignedRect() const {
   return false;
 }
 
+bool ArcGeometry::CapsOverlap() const {
+  FML_DCHECK(arc_.GetSweep().degrees >= 0.0f);
+  FML_DCHECK(arc_.GetSweep().degrees <= 360.0f);
+
+  if (stroke_width_ < 0 || cap_ == Cap::kButt ||
+      arc_.GetSweep().degrees <= 180) {
+    return false;
+  }
+
+  switch (cap_) {
+    case Cap::kSquare: {
+      // Square caps overlap if the inner corner of the ending cap extends
+      // inside the inner edge of the start cap. For a visualization of when
+      // this occurs, see
+      // https://github.com/flutter/flutter/issues/178746#issuecomment-3554526727
+      // Note that testing for overlap is completely independent of the arc's
+      // start angle. To simplify the overlap test, we treat the arc as if its
+      // start angle is 0. This allows the test to only require checking the x
+      // coordinate of the ending cap, rather than needing to calculate overlap
+      // based on both x and y positions of both caps.
+      auto radius = arc_.GetOvalSize().width * 0.5f;
+      auto half_width = stroke_width_ * 0.5f;
+      auto inner_radius = radius - half_width;
+      auto inner_arc_end_x =
+          cos(Radians(arc_.GetSweep()).radians) * inner_radius;
+      auto inner_square_cap_end_x =
+          inner_arc_end_x +
+          cos(Radians(arc_.GetSweep() + Degrees(90)).radians) * half_width;
+      return inner_square_cap_end_x > inner_radius;
+    }
+    case Cap::kRound: {
+      // Round caps overlap if the distance between the arc's start and end
+      // points is less than the stroke width.
+      // https://github.com/flutter/flutter/issues/178746#issuecomment-3554526727
+      // Note that testing for overlap is completely independent of the arc's
+      // start angle. To simplify the overlap test, we treat the arc as if its
+      // start angle is 0.
+      auto radius = arc_.GetOvalSize().width / 2.0f;
+      auto start_point = Point(radius, 0);
+      auto sweep_radians = Radians(arc_.GetSweep()).radians;
+      auto end_point = Point(cos(sweep_radians), sin(sweep_radians)) * radius;
+      return start_point.GetDistanceSquared(end_point) <
+             stroke_width_ * stroke_width_;
+    }
+    case Cap::kButt:
+      FML_UNREACHABLE()
+  }
+}
+
 }  // namespace impeller

engine/src/flutter/impeller/entity/geometry/arc_geometry.h

@@ -40,6 +40,9 @@ class ArcGeometry final : public Geometry {
   // |Geometry|
   std::optional<Rect> GetCoverage(const Matrix& transform) const override;
 
+  // Whether the arc has overlapping stroke caps
+  bool CapsOverlap() const;
+
   Arc arc_;
   Scalar stroke_width_;
   Cap cap_;

engine/src/flutter/shell/platform/windows/flutter_project_bundle.cc

@@ -7,6 +7,7 @@
 #include <filesystem>
 
 #include "flutter/fml/logging.h"
+#include "flutter/fml/string_conversion.h"
 #include "flutter/shell/platform/common/engine_switches.h"  // nogncheck
 #include "flutter/shell/platform/common/path_utils.h"
 
@@ -73,7 +74,7 @@ UniqueAotDataPtr FlutterProjectBundle::LoadAotData(
                    << "; no such file.";
     return UniqueAotDataPtr(nullptr, nullptr);
   }
-  std::string path_string = aot_library_path_.string();
+  std::string path_string = fml::PathToUtf8(aot_library_path_);
   FlutterEngineAOTDataSource source = {};
   source.type = kFlutterEngineAOTDataSourceTypeElfPath;
   source.elf_path = path_string.c_str();

engine/src/flutter/shell/platform/windows/flutter_windows_engine.cc

@@ -274,8 +274,8 @@ bool FlutterWindowsEngine::Run(std::string_view entrypoint) {
     FML_LOG(ERROR) << "Missing or unresolvable paths to assets.";
     return false;
   }
-  std::string assets_path_string = project_->assets_path().string();
-  std::string icu_path_string = project_->icu_path().string();
+  std::string assets_path_string = fml::PathToUtf8(project_->assets_path());
+  std::string icu_path_string = fml::PathToUtf8(project_->icu_path());
   if (embedder_api_.RunsAOTCompiledDartCode()) {
     aot_data_ = project_->LoadAotData(embedder_api_);
     if (!aot_data_) {

engine/src/flutter/tools/templater/templater_main.cc

@@ -12,6 +12,7 @@
 #include "flutter/fml/file.h"
 #include "flutter/fml/logging.h"
 #include "flutter/fml/mapping.h"
+#include "flutter/fml/string_conversion.h"
 #include "inja/inja.hpp"
 
 namespace flutter {
@@ -50,9 +51,9 @@ bool TemplaterMain(const fml::CommandLine& command_line) {
       reinterpret_cast<const uint8_t*>(rendered_template.data()),
       rendered_template.size()};
 
-  auto current_dir =
-      fml::OpenDirectory(std::filesystem::current_path().string().c_str(),
-                         false, fml::FilePermission::kReadWrite);
+  auto current_dir = fml::OpenDirectory(
+      fml::PathToUtf8(std::filesystem::current_path()).c_str(), false,
+      fml::FilePermission::kReadWrite);
   if (!current_dir.is_valid()) {
     FML_LOG(ERROR) << "Could not open current directory.";
     return false;