Public Types
enum class	DirectoryStatus { kExisted , kCreated , kFailed }

Static Public Member Functions
static std::unique_ptr< DlSurfaceProvider >	GetProvider (BackendType type)

static void	ClearProviders ()

static bool	AddProvider (BackendType type)

static void	RenderAll (const TestParameters &params, const BoundsTolerance &tolerance=DefaultTolerance)

static void	RenderWithSaveRestore (const TestParameters &testP, const RenderEnvironment &env, const BoundsTolerance &tolerance)

static void	RenderWithAttributes (const TestParameters &testP, const RenderEnvironment &env, const BoundsTolerance &tolerance)

static void	RenderWithStrokes (const TestParameters &testP, const RenderEnvironment &env, const BoundsTolerance &tolerance_in)

static void	RenderWithTransforms (const TestParameters &testP, const RenderEnvironment &env, const BoundsTolerance &tolerance)

static void	RenderWithClips (const TestParameters &testP, const RenderEnvironment &env, const BoundsTolerance &diff_tolerance)

static DirectoryStatus	CheckDir (const std::string &dir)

static void	SetupImpellerFailureImageDirectory ()

static void	save_to_png (const RenderResult *result, const std::string &op_desc, const std::string &reason)

static void	RenderWith (const TestParameters &testP, const RenderEnvironment &env, const BoundsTolerance &tolerance_in, const CaseParameters &caseP)

static bool	fuzzyCompare (uint32_t pixel_a, uint32_t pixel_b, int fudge)

static int	groupOpacityFudgeFactor (const RenderEnvironment &env)

static void	checkGroupOpacity (const RenderEnvironment &env, const sk_sp< DisplayList > &display_list, const RenderResult *ref_result, const std::string &info, DlColor bg)

static bool	checkPixels (const RenderResult *ref_result, const DlRect ref_bounds, const std::string &info, const DlColor bg=DlColor::kTransparent())

static int	countModifiedTransparentPixels (const RenderResult ref_result, const RenderResult test_result)

static void	quickCompareToReference (const RenderEnvironment &env, const std::string &info)

static bool	quickCompareToReference (const RenderResult ref_result, const RenderResult test_result, bool should_match, const std::string &info)

static void	compareToReference (const RenderResult test_result, const RenderResult ref_result, const std::string &info, const DlRect bounds, const BoundsTolerance tolerance, const DlColor bg, bool fuzzyCompares=false, int width=kTestWidth, int height=kTestHeight, bool printMismatches=false)

static void	showBoundsOverflow (const std::string &info, DlIRect &bounds, const BoundsTolerance *tolerance, int pixLeft, int pixTop, int pixRight, int pixBottom)

static sk_sp< SkTextBlob >	MakeTextBlob (const std::string &string, DlScalar font_height)

Static Public Attributes
static std::vector< BackendType >	TestBackends

static std::string	ImpellerFailureImageDirectory = ""

static bool	SaveImpellerFailureImages = false

static std::vector< std::string >	ImpellerFailureImages

static bool	ImpellerSupported = false

static BoundsTolerance	DefaultTolerance

Detailed Description

Definition at line 1107 of file dl_rendering_unittests.cc.

Member Enumeration Documentation

◆ DirectoryStatus

enum class flutter::testing::CanvasCompareTester::DirectoryStatus

strong

Enumerator
kExisted
kCreated
kFailed

Definition at line 2270 of file dl_rendering_unittests.cc.

                             {
    kExisted,
    kCreated,
    kFailed,
  };

Member Function Documentation

◆ AddProvider()

static bool flutter::testing::CanvasCompareTester::AddProvider ( BackendType type )

inlinestatic

Definition at line 1129 of file dl_rendering_unittests.cc.

                                            {
    auto provider = GetProvider(type);
    if (!provider) {
      return false;
    }
    if (provider->supports_impeller()) {
      ImpellerSupported = true;
    }
    TestBackends.push_back(type);
    return true;
  }

References GetProvider(), ImpellerSupported, TestBackends, and type.

Referenced by flutter::testing::DisplayListRenderingTestBase< BaseT >::SetUpTestSuite().

◆ CheckDir()

static DirectoryStatus flutter::testing::CanvasCompareTester::CheckDir ( const std::string & dir )

inlinestatic

Definition at line 2276 of file dl_rendering_unittests.cc.

                                                        {
    auto ret =
        fml::OpenDirectory(dir.c_str(), false, fml::FilePermission::kRead);
    if (ret.is_valid()) {
      return DirectoryStatus::kExisted;
    }
    ret =
        fml::OpenDirectory(dir.c_str(), true, fml::FilePermission::kReadWrite);
    if (ret.is_valid()) {
      return DirectoryStatus::kCreated;
    }
    FML_LOG(ERROR) << "Could not create directory (" << dir
                   << ") for impeller failure images" << ", ret = " << ret.get()
                   << ", errno = " << errno;
    return DirectoryStatus::kFailed;
  }

References FML_LOG, kCreated, kExisted, kFailed, fml::kRead, fml::kReadWrite, and fml::OpenDirectory().

Referenced by SetupImpellerFailureImageDirectory().

◆ checkGroupOpacity()

static void flutter::testing::CanvasCompareTester::checkGroupOpacity	(	const RenderEnvironment &	env,
		const sk_sp< DisplayList > &	display_list,
		const RenderResult *	ref_result,
		const std::string &	info,
		DlColor	bg
	)

inlinestatic

Definition at line 2548 of file dl_rendering_unittests.cc.

                                            {
    DlScalar opacity = 128.0 / 255.0;
 
    DisplayListJobRenderer opacity_job(display_list);
    RenderJobInfo opacity_info = {
        .bg = bg,
        .opacity = opacity,
    };
    auto group_opacity_result = env.getResult(opacity_info, opacity_job);
 
    ASSERT_EQ(group_opacity_result->width(), kTestWidth) << info;
    ASSERT_EQ(group_opacity_result->height(), kTestHeight) << info;
 
    ASSERT_EQ(ref_result->width(), kTestWidth) << info;
    ASSERT_EQ(ref_result->height(), kTestHeight) << info;
 
    int pixels_touched = 0;
    int pixels_different = 0;
    int max_diff = 0;
    // We need to allow some slight differences per component due to the
    // fact that rearranging discrete calculations can compound round off
    // errors. Off-by-2 is enough for 8 bit components, but for the 565
    // tests we allow at least 9 which is the maximum distance between
    // samples when converted to 8 bits. (You might think it would be a
    // max step of 8 converting 5 bits to 8 bits, but it is really
    // converting 31 steps to 255 steps with an average step size of
    // 8.23 - 24 of the steps are by 8, but 7 of them are by 9.)
    int fudge = groupOpacityFudgeFactor(env);
    for (int y = 0; y < kTestHeight; y++) {
      const uint32_t* ref_row = ref_result->addr32(0, y);
      const uint32_t* test_row = group_opacity_result->addr32(0, y);
      for (int x = 0; x < kTestWidth; x++) {
        uint32_t ref_pixel = ref_row[x];
        uint32_t test_pixel = test_row[x];
        if (ref_pixel != bg.argb() || test_pixel != bg.argb()) {
          pixels_touched++;
          for (int i = 0; i < 32; i += 8) {
            int ref_comp = (ref_pixel >> i) & 0xff;
            int bg_comp = (bg.argb() >> i) & 0xff;
            DlScalar faded_comp = bg_comp + (ref_comp - bg_comp) * opacity;
            int test_comp = (test_pixel >> i) & 0xff;
            if (std::abs(faded_comp - test_comp) > fudge) {
              int diff = std::abs(faded_comp - test_comp);
              if (max_diff < diff) {
                max_diff = diff;
              }
              pixels_different++;
              break;
            }
          }
        }
      }
    }
    ASSERT_GT(pixels_touched, 20) << info;
    if (pixels_different > 1) {
      FML_LOG(ERROR) << "max diff == " << max_diff << " for " << info;
    }
    ASSERT_LE(pixels_different, 1) << info;
  }

References flutter::testing::RenderResult::addr32(), flutter::DlColor::argb(), flutter::testing::RenderJobInfo::bg, FML_LOG, flutter::testing::RenderEnvironment::getResult(), groupOpacityFudgeFactor(), flutter::testing::RenderResult::height(), i, flutter::testing::kTestHeight, flutter::testing::kTestWidth, flutter::testing::RenderResult::width(), x, and y.

Referenced by RenderWith().

◆ checkPixels()

static bool flutter::testing::CanvasCompareTester::checkPixels	(	const RenderResult *	ref_result,
		const DlRect	ref_bounds,
		const std::string &	info,
		const DlColor	bg = `DlColor::kTransparent()`
	)

inlinestatic

Definition at line 2612 of file dl_rendering_unittests.cc.

                                                                    {
    uint32_t untouched = PremultipliedArgb(bg);
    int pixels_touched = 0;
    int pixels_oob = 0;
    DlIRect i_bounds = DlIRect::RoundOut(ref_bounds);
    EXPECT_EQ(ref_result->width(), kTestWidth) << info;
    EXPECT_EQ(ref_result->height(), kTestWidth) << info;
    for (int y = 0; y < kTestHeight; y++) {
      const uint32_t* ref_row = ref_result->addr32(0, y);
      for (int x = 0; x < kTestWidth; x++) {
        if (ref_row[x] != untouched) {
          pixels_touched++;
          if (!i_bounds.Contains({x, y})) {
            pixels_oob++;
          }
        }
      }
    }
    EXPECT_EQ(pixels_oob, 0) << info;
    EXPECT_GT(pixels_touched, 0) << info;
    return pixels_oob == 0 && pixels_touched > 0;
  }

References flutter::testing::RenderResult::addr32(), impeller::TRect< T >::Contains(), flutter::testing::RenderResult::height(), flutter::testing::kTestHeight, flutter::testing::kTestWidth, impeller::TRect< T >::RoundOut(), flutter::testing::RenderResult::width(), x, and y.

Referenced by RenderAll(), and RenderWith().

◆ ClearProviders()

static void flutter::testing::CanvasCompareTester::ClearProviders ( )

inlinestatic

Definition at line 1127 of file dl_rendering_unittests.cc.

1127{ TestBackends.clear(); }

References TestBackends.

Referenced by flutter::testing::DisplayListRenderingTestBase< BaseT >::SetUpTestSuite().

◆ compareToReference()

static void flutter::testing::CanvasCompareTester::compareToReference	(	const RenderResult *	test_result,
		const RenderResult *	ref_result,
		const std::string &	info,
		const DlRect *	bounds,
		const BoundsTolerance *	tolerance,
		const DlColor	bg,
		bool	fuzzyCompares = `false`,
		int	width = `kTestWidth`,
		int	height = `kTestHeight`,
		bool	printMismatches = `false`
	)

inlinestatic

Definition at line 2691 of file dl_rendering_unittests.cc.

                                                               {
    uint32_t untouched = PremultipliedArgb(bg);
    ASSERT_EQ(test_result->width(), width) << info;
    ASSERT_EQ(test_result->height(), height) << info;
    DlIRect i_bounds =
        bounds ? DlIRect::RoundOut(*bounds) : DlIRect::MakeWH(width, height);
 
    int pixels_different = 0;
    int pixels_oob = 0;
    int min_x = width;
    int min_y = height;
    int max_x = 0;
    int max_y = 0;
    for (int y = 0; y < height; y++) {
      const uint32_t* ref_row = ref_result->addr32(0, y);
      const uint32_t* test_row = test_result->addr32(0, y);
      for (int x = 0; x < width; x++) {
        if (bounds && test_row[x] != untouched) {
          if (min_x > x) {
            min_x = x;
          }
          if (min_y > y) {
            min_y = y;
          }
          if (max_x <= x) {
            max_x = x + 1;
          }
          if (max_y <= y) {
            max_y = y + 1;
          }
          if (!i_bounds.Contains({x, y})) {
            pixels_oob++;
          }
        }
        bool match = fuzzyCompares ? fuzzyCompare(test_row[x], ref_row[x], 1)
                                   : test_row[x] == ref_row[x];
        if (!match) {
          if (printMismatches && pixels_different < 5) {
            FML_LOG(ERROR) << "pix[" << x << ", " << y
                           << "] mismatch: " << std::hex << test_row[x]
                           << "(test) != (ref)" << ref_row[x] << std::dec;
          }
          pixels_different++;
        }
      }
    }
    if (pixels_oob > 0) {
      FML_LOG(ERROR) << "pix bounds["
                     << DlIRect::MakeLTRB(min_x, min_y, max_x, max_y)  //
                     << "]";
      FML_LOG(ERROR) << "dl_bounds[" << bounds << "]";
    } else if (bounds) {
      showBoundsOverflow(info, i_bounds, tolerance, min_x, min_y, max_x, max_y);
    }
    ASSERT_EQ(pixels_oob, 0) << info;
    ASSERT_EQ(pixels_different, 0) << info;
  }

References flutter::testing::RenderResult::addr32(), impeller::TRect< T >::Contains(), FML_LOG, fuzzyCompare(), flutter::testing::RenderResult::height(), height, impeller::TRect< T >::MakeLTRB(), impeller::TRect< T >::MakeWH(), impeller::TRect< T >::RoundOut(), showBoundsOverflow(), flutter::testing::RenderResult::width(), width, x, and y.

Referenced by RenderWith(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

◆ countModifiedTransparentPixels()

static int flutter::testing::CanvasCompareTester::countModifiedTransparentPixels	(	const RenderResult *	ref_result,
		const RenderResult *	test_result
	)

inlinestatic

Definition at line 2638 of file dl_rendering_unittests.cc.

                                                                             {
    int count = 0;
    for (int y = 0; y < kTestHeight; y++) {
      const uint32_t* ref_row = ref_result->addr32(0, y);
      const uint32_t* test_row = test_result->addr32(0, y);
      for (int x = 0; x < kTestWidth; x++) {
        if (ref_row[x] != test_row[x]) {
          if (ref_row[x] == 0) {
            count++;
          }
        }
      }
    }
    return count;
  }

References flutter::testing::RenderResult::addr32(), flutter::testing::kTestHeight, flutter::testing::kTestWidth, x, and y.

Referenced by flutter::testing::TEST_F(), and flutter::testing::TEST_F().

◆ fuzzyCompare()

static bool flutter::testing::CanvasCompareTester::fuzzyCompare	(	uint32_t	pixel_a,
		uint32_t	pixel_b,
		int	fudge
	)

inlinestatic

Definition at line 2526 of file dl_rendering_unittests.cc.

                                                                          {
    for (int i = 0; i < 32; i += 8) {
      int comp_a = (pixel_a >> i) & 0xff;
      int comp_b = (pixel_b >> i) & 0xff;
      if (std::abs(comp_a - comp_b) > fudge) {
        return false;
      }
    }
    return true;
  }

References i.

Referenced by compareToReference().

◆ GetProvider()

static std::unique_ptr< DlSurfaceProvider > flutter::testing::CanvasCompareTester::GetProvider ( BackendType type )

inlinestatic

Definition at line 1115 of file dl_rendering_unittests.cc.

                                                                        {
    auto provider = DlSurfaceProvider::Create(type);
    if (provider == nullptr) {
      FML_LOG(ERROR) << "provider " << DlSurfaceProvider::BackendName(type)
                     << " not supported (ignoring)";
      return nullptr;
    }
    provider->InitializeSurface(kTestWidth, kTestHeight,
                                PixelFormat::kN32PremulPixelFormat);
    return provider;
  }

References flutter::testing::DlSurfaceProvider::BackendName(), flutter::testing::DlSurfaceProvider::Create(), FML_LOG, flutter::testing::kTestHeight, flutter::testing::kTestWidth, and type.

Referenced by AddProvider(), RenderAll(), flutter::testing::DisplayListNopTest::test_attributes_image(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::DisplayListNopTest::test_mode_color_via_rendering().

◆ groupOpacityFudgeFactor()

static int flutter::testing::CanvasCompareTester::groupOpacityFudgeFactor ( const RenderEnvironment & env )

inlinestatic

Definition at line 2537 of file dl_rendering_unittests.cc.

                                                                   {
    if (env.format() == PixelFormat::k565PixelFormat) {
      return 9;
    }
    if (env.provider()->backend_type() == BackendType::kOpenGlBackend) {
      // OpenGL gets a little fuzzy at times. Still, "within 5" (aka +/-4)
      // for byte samples is not bad, though the other backends give +/-1
      return 5;
    }
    return 2;
  }

References flutter::testing::DlSurfaceProvider::backend_type(), flutter::testing::RenderEnvironment::format(), and flutter::testing::RenderEnvironment::provider().

Referenced by checkGroupOpacity().

◆ MakeTextBlob()

static sk_sp< SkTextBlob > flutter::testing::CanvasCompareTester::MakeTextBlob	(	const std::string &	string,
		DlScalar	font_height
	)

inlinestatic

Definition at line 2796 of file dl_rendering_unittests.cc.

                                                              {
    SkFont font = CreateTestFontOfSize(font_height);
    sk_sp<SkTypeface> face = font.refTypeface();
    FML_CHECK(face);
    FML_CHECK(face->countGlyphs() > 0) << "No glyphs in font";
    return SkTextBlob::MakeFromText(string.c_str(), string.size(), font,
                                    SkTextEncoding::kUTF8);
  }

References flutter::testing::CreateTestFontOfSize(), FML_CHECK, and flutter::size.

Referenced by flutter::testing::TEST_F().

◆ quickCompareToReference() [1/2]

static void flutter::testing::CanvasCompareTester::quickCompareToReference	(	const RenderEnvironment &	env,
		const std::string &	info
	)

inlinestatic

Definition at line 2655 of file dl_rendering_unittests.cc.

                                                             {
    quickCompareToReference(env.ref_sk_result(), env.ref_dl_result(), true,
                            info + " reference rendering");
  }

References quickCompareToReference(), flutter::testing::RenderEnvironment::ref_dl_result(), and flutter::testing::RenderEnvironment::ref_sk_result().

Referenced by quickCompareToReference(), RenderAll(), RenderWith(), RenderWithAttributes(), RenderWithSaveRestore(), RenderWithStrokes(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

◆ quickCompareToReference() [2/2]

static bool flutter::testing::CanvasCompareTester::quickCompareToReference	(	const RenderResult *	ref_result,
		const RenderResult *	test_result,
		bool	should_match,
		const std::string &	info
	)

inlinestatic

Definition at line 2661 of file dl_rendering_unittests.cc.

                                                             {
    int w = test_result->width();
    int h = test_result->height();
    EXPECT_EQ(w, ref_result->width()) << info;
    EXPECT_EQ(h, ref_result->height()) << info;
    int pixels_different = 0;
    for (int y = 0; y < h; y++) {
      const uint32_t* ref_row = ref_result->addr32(0, y);
      const uint32_t* test_row = test_result->addr32(0, y);
      for (int x = 0; x < w; x++) {
        if (ref_row[x] != test_row[x]) {
          if (should_match && pixels_different < 5) {
            FML_LOG(ERROR) << std::hex << ref_row[x] << " != " << test_row[x];
          }
          pixels_different++;
        }
      }
    }
    if (should_match) {
      EXPECT_EQ(pixels_different, 0) << info;
      return pixels_different == 0;
    } else {
      EXPECT_NE(pixels_different, 0) << info;
      return pixels_different != 0;
    }
  }

References flutter::testing::RenderResult::addr32(), FML_LOG, flutter::h, flutter::testing::RenderResult::height(), flutter::testing::RenderResult::width(), x, and y.

◆ RenderAll()

static void flutter::testing::CanvasCompareTester::RenderAll	(	const TestParameters &	params,
		const BoundsTolerance &	tolerance = `DefaultTolerance`
	)

inlinestatic

Definition at line 1143 of file dl_rendering_unittests.cc.

                                                                             {
    for (auto& back_end : TestBackends) {
      auto provider = GetProvider(back_end);
      RenderEnvironment env = RenderEnvironment::MakeN32(provider.get());
      env.init_ref(kEmptySkSetup, params.sk_renderer(),  //
                   kEmptyDlSetup, params.dl_renderer(), params.imp_renderer());
      quickCompareToReference(env, "default");
      if (env.supports_impeller()) {
        auto impeller_result = env.ref_impeller_result();
        if (!checkPixels(impeller_result, impeller_result->render_bounds(),
                         "Impeller reference")) {
          std::string test_name =
              ::testing::UnitTest::GetInstance()->current_test_info()->name();
          save_to_png(impeller_result, test_name + " (Impeller reference)",
                      "base rendering was blank or out of bounds");
        }
      } else {
        static OncePerBackendWarning warnings("No Impeller output tests");
        warnings.warn(env.backend_name());
      }
 
      RenderWithTransforms(params, env, tolerance);
      RenderWithClips(params, env, tolerance);
      RenderWithSaveRestore(params, env, tolerance);
      // Only test attributes if the canvas version uses the paint object
      if (params.uses_paint()) {
        RenderWithAttributes(params, env, tolerance);
      }
    }
  }

References flutter::testing::RenderEnvironment::backend_name(), checkPixels(), GetProvider(), flutter::testing::RenderEnvironment::init_ref(), flutter::testing::kEmptyDlSetup, flutter::testing::kEmptySkSetup, flutter::testing::RenderEnvironment::MakeN32(), params, quickCompareToReference(), flutter::testing::RenderEnvironment::ref_impeller_result(), RenderWithAttributes(), RenderWithClips(), RenderWithSaveRestore(), RenderWithTransforms(), save_to_png(), flutter::testing::RenderEnvironment::supports_impeller(), TestBackends, and flutter::testing::OncePerBackendWarning::warn().

◆ RenderWith()

static void flutter::testing::CanvasCompareTester::RenderWith	(	const TestParameters &	testP,
		const RenderEnvironment &	env,
		const BoundsTolerance &	tolerance_in,
		const CaseParameters &	caseP
	)

inlinestatic

Definition at line 2341 of file dl_rendering_unittests.cc.

                                                      {
    std::string test_name =
        ::testing::UnitTest::GetInstance()->current_test_info()->name();
    const std::string info =
        env.backend_name() + ": " + test_name + " (" + caseP.info() + ")";
    const DlColor bg = caseP.bg();
    RenderJobInfo base_info = {
        .bg = bg,
    };
 
    // sk_result is a direct rendering via SkCanvas to SkSurface
    // DisplayList mechanisms are not involved in this operation
    SkJobRenderer sk_job(caseP.sk_setup(),     //
                         testP.sk_renderer(),  //
                         caseP.sk_restore(),   //
                         env.sk_image());
    auto sk_result = env.getResult(base_info, sk_job);
 
    DlJobRenderer dl_job(caseP.dl_setup(),     //
                         testP.dl_renderer(),  //
                         caseP.dl_restore(),   //
                         env.dl_image());
    auto dl_result = env.getResult(base_info, dl_job);
 
    if (sk_job.setup_matrix() != dl_job.setup_matrix()) {
      EXPECT_EQ(sk_job.setup_matrix(), dl_job.setup_matrix());
    }
    EXPECT_EQ(sk_job.setup_clip_bounds(), dl_job.setup_clip_bounds());
    ASSERT_EQ(sk_result->width(), kTestWidth) << info;
    ASSERT_EQ(sk_result->height(), kTestHeight) << info;
    ASSERT_EQ(dl_result->width(), kTestWidth) << info;
    ASSERT_EQ(dl_result->height(), kTestHeight) << info;
 
    const BoundsTolerance tolerance =
        testP.adjust(tolerance_in, dl_job.setup_paint(), dl_job.setup_matrix());
    const sk_sp<SkPicture> sk_picture = sk_job.MakePicture(base_info);
    const sk_sp<DisplayList> display_list = dl_job.MakeDisplayList(base_info);
 
    DlRect sk_bounds = ToDlRect(sk_picture->cullRect());
    checkPixels(sk_result.get(), sk_bounds, info + " (Skia reference)", bg);
 
    if (testP.should_match(env, caseP, dl_job.setup_paint(), dl_job)) {
      quickCompareToReference(env.ref_sk_result(), sk_result.get(), true,
                              info + " (attribute should not have effect)");
    } else {
      quickCompareToReference(env.ref_sk_result(), sk_result.get(), false,
                              info + " (attribute should affect rendering)");
    }
 
    // If either the reference setup or the test setup contain attributes
    // that Impeller doesn't support, we skip the Impeller testing. This
    // is mostly stroked or patterned text which is vectored through drawPath
    // for Impeller.
    if (env.supports_impeller() &&
        testP.impeller_compatible(dl_job.setup_paint()) &&
        testP.impeller_compatible(env.ref_dl_paint())) {
      DlJobRenderer imp_job(caseP.dl_setup(),      //
                            testP.imp_renderer(),  //
                            caseP.dl_restore(),    //
                            env.impeller_image());
      auto imp_result = env.getImpellerResult(base_info, imp_job);
      std::string imp_info = info + " (Impeller)";
      bool success = checkPixels(imp_result.get(), imp_result->render_bounds(),
                                 imp_info, bg);
      if (testP.should_match(env, caseP, imp_job.setup_paint(), imp_job)) {
        success = success &&                //
                  quickCompareToReference(  //
                      env.ref_impeller_result(), imp_result.get(), true,
                      imp_info + " (attribute should not have effect)");
      } else {
        success = success &&                //
                  quickCompareToReference(  //
                      env.ref_impeller_result(), imp_result.get(), false,
                      imp_info + " (attribute should affect rendering)");
      }
      if (SaveImpellerFailureImages && !success) {
        FML_LOG(ERROR) << "Impeller issue encountered for: "
                       << *imp_job.MakeDisplayList(base_info);
        save_to_png(imp_result.get(), info + " (Impeller Result)",
                    "output saved in");
        save_to_png(env.ref_impeller_result(), info + " (Impeller Reference)",
                    "compare to reference without attributes");
        save_to_png(sk_result.get(), info + " (Skia Result)",
                    "and to Skia reference with attributes");
        save_to_png(env.ref_sk_result(), info + " (Skia Reference)",
                    "and to Skia reference without attributes");
      }
    }
 
    quickCompareToReference(sk_result.get(), dl_result.get(), true,
                            info + " (DlCanvas output matches SkCanvas)");
 
    {
      DlRect dl_bounds = display_list->GetBounds();
      DlRect sk_padded_bounds = DlRect::RoundOut(sk_bounds);
      if (!sk_padded_bounds.Contains(dl_bounds)) {
        FML_LOG(ERROR) << "For " << info;
        FML_LOG(ERROR) << "sk ref: " << sk_bounds;
        FML_LOG(ERROR) << "dl: " << dl_bounds;
        if (!dl_bounds.Contains(sk_bounds)) {
          FML_LOG(ERROR) << "DisplayList bounds are too small!";
        }
        if (!dl_bounds.IsEmpty() &&
            !sk_padded_bounds.Contains(DlRect::RoundOut(dl_bounds))) {
          FML_LOG(ERROR) << "###### DisplayList bounds larger than reference!";
        }
      }
 
      // This EXPECT sometimes triggers, but when it triggers and I examine
      // the ref_bounds, they are always unnecessarily large and since the
      // pixel OOB tests in the compare method do not trigger, we will trust
      // the DL bounds.
      // EXPECT_TRUE(dl_bounds.contains(ref_bounds)) << info;
 
      // When we are drawing a DisplayList, the display_list built above
      // will contain just a single drawDisplayList call plus the case
      // attribute. The sk_picture will, however, contain a list of all
      // of the embedded calls in the display list and so the op counts
      // will not be equal between the two.
      if (!testP.is_draw_display_list()) {
        EXPECT_EQ(static_cast<int>(display_list->op_count()),
                  sk_picture->approximateOpCount())
            << info;
        EXPECT_EQ(static_cast<int>(display_list->op_count()),
                  sk_picture->approximateOpCount())
            << info;
      }
 
      DisplayListJobRenderer dl_builder_job(display_list);
      auto dl_builder_result = env.getResult(base_info, dl_builder_job);
      if (caseP.fuzzy_compare_components()) {
        compareToReference(
            dl_builder_result.get(), dl_result.get(),
            info + " (DlCanvas DL output close to Builder Dl output)",
            &dl_bounds, &tolerance, bg, true);
      } else {
        quickCompareToReference(
            dl_builder_result.get(), dl_result.get(), true,
            info + " (DlCanvas DL output matches Builder Dl output)");
      }
 
      compareToReference(dl_result.get(), sk_result.get(),
                         info + " (DisplayList built directly -> surface)",
                         &dl_bounds, &tolerance, bg,
                         caseP.fuzzy_compare_components());
 
      if (display_list->can_apply_group_opacity()) {
        checkGroupOpacity(env, display_list, dl_result.get(),
                          info + " with Group Opacity", bg);
      }
    }
 
    {
      // This sequence uses an SkPicture generated previously from the SkCanvas
      // calls and a DisplayList generated previously from the DlCanvas calls
      // and renders both back under a transform (scale(2x)) to see if their
      // rendering is affected differently by a change of matrix between
      // recording time and rendering time.
      const int test_width_2 = kTestWidth * 2;
      const int test_height_2 = kTestHeight * 2;
      const DlScalar test_scale = 2.0;
 
      SkPictureJobRenderer sk_job_x2(sk_picture);
      RenderJobInfo info_2x = {
          .width = test_width_2,
          .height = test_height_2,
          .bg = bg,
          .scale = test_scale,
      };
      auto ref_x2_result = env.getResult(info_2x, sk_job_x2);
      ASSERT_EQ(ref_x2_result->width(), test_width_2) << info;
      ASSERT_EQ(ref_x2_result->height(), test_height_2) << info;
 
      DisplayListJobRenderer dl_job_x2(display_list);
      auto test_x2_result = env.getResult(info_2x, dl_job_x2);
      compareToReference(test_x2_result.get(), ref_x2_result.get(),
                         info + " (Both rendered scaled 2x)", nullptr, nullptr,
                         bg, caseP.fuzzy_compare_components(),  //
                         test_width_2, test_height_2, false);
    }
  }

Referenced by RenderWithAttributes(), RenderWithClips(), RenderWithSaveRestore(), RenderWithStrokes(), RenderWithTransforms(), and flutter::testing::TEST_F().

◆ RenderWithAttributes()

static void flutter::testing::CanvasCompareTester::RenderWithAttributes	(	const TestParameters &	testP,
		const RenderEnvironment &	env,
		const BoundsTolerance &	tolerance
	)

inlinestatic

Definition at line 1487 of file dl_rendering_unittests.cc.

                                                                     {
    RenderWith(testP, env, tolerance, CaseParameters("Defaults Test"));
 
    {
      // CPU renderer with default line width of 0 does not show antialiasing
      // for stroked primitives, so we make a new reference with a non-trivial
      // stroke width to demonstrate the differences
      RenderEnvironment aa_env = RenderEnvironment::MakeN32(env.provider());
      // Tweak the bounds tolerance for the displacement of 1/10 of a pixel
      const BoundsTolerance aa_tolerance = tolerance.addBoundsPadding(1, 1);
      auto sk_aa_setup = [=](SkSetupContext ctx, bool is_aa) {
        ctx.canvas->translate(0.1, 0.1);
        ctx.paint.setAntiAlias(is_aa);
        ctx.paint.setStrokeWidth(5.0);
      };
      auto dl_aa_setup = [=](DlSetupContext ctx, bool is_aa) {
        ctx.canvas->Translate(0.1, 0.1);
        ctx.paint.setAntiAlias(is_aa);
        ctx.paint.setStrokeWidth(5.0);
      };
      aa_env.init_ref(
          [=](const SkSetupContext& ctx) { sk_aa_setup(ctx, false); },
          testP.sk_renderer(),
          [=](const DlSetupContext& ctx) { dl_aa_setup(ctx, false); },
          testP.dl_renderer(), testP.imp_renderer());
      quickCompareToReference(aa_env, "AntiAlias");
      RenderWith(
          testP, aa_env, aa_tolerance,
          CaseParameters(
              "AntiAlias == True",
              [=](const SkSetupContext& ctx) { sk_aa_setup(ctx, true); },
              [=](const DlSetupContext& ctx) { dl_aa_setup(ctx, true); }));
      RenderWith(
          testP, aa_env, aa_tolerance,
          CaseParameters(
              "AntiAlias == False",
              [=](const SkSetupContext& ctx) { sk_aa_setup(ctx, false); },
              [=](const DlSetupContext& ctx) { dl_aa_setup(ctx, false); }));
    }
 
    RenderWith(  //
        testP, env, tolerance,
        CaseParameters(
            "Color == Blue",
            [=](const SkSetupContext& ctx) {
              ctx.paint.setColor(SK_ColorBLUE);
            },
            [=](const DlSetupContext& ctx) {
              ctx.paint.setColor(DlColor::kBlue());
            }));
    RenderWith(  //
        testP, env, tolerance,
        CaseParameters(
            "Color == Green",
            [=](const SkSetupContext& ctx) {
              ctx.paint.setColor(SK_ColorGREEN);
            },
            [=](const DlSetupContext& ctx) {
              ctx.paint.setColor(DlColor::kGreen());
            }));
 
    RenderWithStrokes(testP, env, tolerance);
 
    {
      // half opaque cyan
      DlColor blendable_color = DlColor::kCyan().withAlpha(0x7f);
      DlColor bg = DlColor::kWhite();
 
      RenderWith(testP, env, tolerance,
                 CaseParameters(
                     "Blend == SrcIn",
                     [=](const SkSetupContext& ctx) {
                       ctx.paint.setBlendMode(SkBlendMode::kSrcIn);
                       ctx.paint.setColor(blendable_color.argb());
                     },
                     [=](const DlSetupContext& ctx) {
                       ctx.paint.setBlendMode(DlBlendMode::kSrcIn);
                       ctx.paint.setColor(blendable_color);
                     })
                     .with_bg(bg));
      RenderWith(testP, env, tolerance,
                 CaseParameters(
                     "Blend == DstIn",
                     [=](const SkSetupContext& ctx) {
                       ctx.paint.setBlendMode(SkBlendMode::kDstIn);
                       ctx.paint.setColor(blendable_color.argb());
                     },
                     [=](const DlSetupContext& ctx) {
                       ctx.paint.setBlendMode(DlBlendMode::kDstIn);
                       ctx.paint.setColor(blendable_color);
                     })
                     .with_bg(bg));
    }
 
    {
      // Being able to see a blur requires some non-default attributes,
      // like a non-trivial stroke width and a shader rather than a color
      // (for drawPaint) so we create a new environment for these tests.
      RenderEnvironment blur_env = RenderEnvironment::MakeN32(env.provider());
      SkSetup sk_blur_setup = [=](const SkSetupContext& ctx) {
        ctx.paint.setShader(MakeColorSource(ctx.image));
        ctx.paint.setStrokeWidth(5.0);
      };
      DlSetup dl_blur_setup = [=](const DlSetupContext& ctx) {
        ctx.paint.setColorSource(MakeColorSource(ctx.image));
        ctx.paint.setStrokeWidth(5.0);
      };
      blur_env.init_ref(sk_blur_setup, testP.sk_renderer(),  //
                        dl_blur_setup, testP.dl_renderer(),
                        testP.imp_renderer());
      quickCompareToReference(blur_env, "blur");
      DlBlurImageFilter dl_filter_decal_5(5.0, 5.0, DlTileMode::kDecal);
      auto sk_filter_decal_5 =
          SkImageFilters::Blur(5.0, 5.0, SkTileMode::kDecal, nullptr);
      BoundsTolerance blur_5_tolerance = tolerance.addBoundsPadding(4, 4);
      {
        RenderWith(testP, blur_env, blur_5_tolerance,
                   CaseParameters(
                       "ImageFilter == Decal Blur 5",
                       [=](const SkSetupContext& ctx) {
                         sk_blur_setup(ctx);
                         ctx.paint.setImageFilter(sk_filter_decal_5);
                       },
                       [=](const DlSetupContext& ctx) {
                         dl_blur_setup(ctx);
                         ctx.paint.setImageFilter(&dl_filter_decal_5);
                       }));
      }
      DlBlurImageFilter dl_filter_clamp_5(5.0, 5.0, DlTileMode::kClamp);
      auto sk_filter_clamp_5 =
          SkImageFilters::Blur(5.0, 5.0, SkTileMode::kClamp, nullptr);
      {
        RenderWith(testP, blur_env, blur_5_tolerance,
                   CaseParameters(
                       "ImageFilter == Clamp Blur 5",
                       [=](const SkSetupContext& ctx) {
                         sk_blur_setup(ctx);
                         ctx.paint.setImageFilter(sk_filter_clamp_5);
                       },
                       [=](const DlSetupContext& ctx) {
                         dl_blur_setup(ctx);
                         ctx.paint.setImageFilter(&dl_filter_clamp_5);
                       }));
      }
    }
 
    {
      // Being able to see a dilate requires some non-default attributes,
      // like a non-trivial stroke width and a shader rather than a color
      // (for drawPaint) so we create a new environment for these tests.
      RenderEnvironment dilate_env = RenderEnvironment::MakeN32(env.provider());
      SkSetup sk_dilate_setup = [=](const SkSetupContext& ctx) {
        ctx.paint.setShader(MakeColorSource(ctx.image));
        ctx.paint.setStrokeWidth(5.0);
      };
      DlSetup dl_dilate_setup = [=](const DlSetupContext& ctx) {
        ctx.paint.setColorSource(MakeColorSource(ctx.image));
        ctx.paint.setStrokeWidth(5.0);
      };
      dilate_env.init_ref(sk_dilate_setup, testP.sk_renderer(),  //
                          dl_dilate_setup, testP.dl_renderer(),
                          testP.imp_renderer());
      quickCompareToReference(dilate_env, "dilate");
      DlDilateImageFilter dl_dilate_filter_5(5.0, 5.0);
      auto sk_dilate_filter_5 = SkImageFilters::Dilate(5.0, 5.0, nullptr);
      RenderWith(testP, dilate_env, tolerance,
                 CaseParameters(
                     "ImageFilter == Dilate 5",
                     [=](const SkSetupContext& ctx) {
                       sk_dilate_setup(ctx);
                       ctx.paint.setImageFilter(sk_dilate_filter_5);
                     },
                     [=](const DlSetupContext& ctx) {
                       dl_dilate_setup(ctx);
                       ctx.paint.setImageFilter(&dl_dilate_filter_5);
                     }));
    }
 
    {
      // Being able to see an erode requires some non-default attributes,
      // like a non-trivial stroke width and a shader rather than a color
      // (for drawPaint) so we create a new environment for these tests.
      RenderEnvironment erode_env = RenderEnvironment::MakeN32(env.provider());
      SkSetup sk_erode_setup = [=](const SkSetupContext& ctx) {
        ctx.paint.setShader(MakeColorSource(ctx.image));
        ctx.paint.setStrokeWidth(6.0);
      };
      DlSetup dl_erode_setup = [=](const DlSetupContext& ctx) {
        ctx.paint.setColorSource(MakeColorSource(ctx.image));
        ctx.paint.setStrokeWidth(6.0);
      };
      erode_env.init_ref(sk_erode_setup, testP.sk_renderer(),  //
                         dl_erode_setup, testP.dl_renderer(),
                         testP.imp_renderer());
      quickCompareToReference(erode_env, "erode");
      // do not erode too much, because some tests assert there are enough
      // pixels that are changed.
      DlErodeImageFilter dl_erode_filter_1(1.0, 1.0);
      auto sk_erode_filter_1 = SkImageFilters::Erode(1.0, 1.0, nullptr);
      RenderWith(testP, erode_env, tolerance,
                 CaseParameters(
                     "ImageFilter == Erode 1",
                     [=](const SkSetupContext& ctx) {
                       sk_erode_setup(ctx);
                       ctx.paint.setImageFilter(sk_erode_filter_1);
                     },
                     [=](const DlSetupContext& ctx) {
                       dl_erode_setup(ctx);
                       ctx.paint.setImageFilter(&dl_erode_filter_1);
                     }));
    }
 
    {
      // clang-format off
      constexpr float rotate_color_matrix[20] = {
          0, 1, 0, 0, 0,
          0, 0, 1, 0, 0,
          1, 0, 0, 0, 0,
          0, 0, 0, 1, 0,
      };
      constexpr float invert_color_matrix[20] = {
        -1.0,    0,    0, 1.0,   0,
           0, -1.0,    0, 1.0,   0,
           0,    0, -1.0, 1.0,   0,
         1.0,  1.0,  1.0, 1.0,   0,
      };
      // clang-format on
      auto dl_color_filter = DlColorFilter::MakeMatrix(rotate_color_matrix);
      auto sk_color_filter = SkColorFilters::Matrix(rotate_color_matrix);
      {
        DlColor bg = DlColor::kWhite();
        RenderWith(testP, env, tolerance,
                   CaseParameters(
                       "ColorFilter == RotateRGB",
                       [=](const SkSetupContext& ctx) {
                         ctx.paint.setColor(SK_ColorYELLOW);
                         ctx.paint.setColorFilter(sk_color_filter);
                       },
                       [=](const DlSetupContext& ctx) {
                         ctx.paint.setColor(DlColor::kYellow());
                         ctx.paint.setColorFilter(dl_color_filter);
                       })
                       .with_bg(bg));
      }
      {
        DlColor bg = DlColor::kWhite();
        RenderWith(testP, env, tolerance,
                   CaseParameters(
                       "ColorFilter == Invert",
                       [=](const SkSetupContext& ctx) {
                         ctx.paint.setColor(SK_ColorYELLOW);
                         ctx.paint.setColorFilter(
                             SkColorFilters::Matrix(invert_color_matrix));
                       },
                       [=](const DlSetupContext& ctx) {
                         ctx.paint.setColor(DlColor::kYellow());
                         ctx.paint.setInvertColors(true);
                       })
                       .with_bg(bg));
      }
    }
 
    {
      const DlBlurMaskFilter dl_mask_filter(DlBlurStyle::kNormal, 5.0);
      auto sk_mask_filter = SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, 5.0);
      BoundsTolerance blur_5_tolerance = tolerance.addBoundsPadding(4, 4);
      {
        // Stroked primitives need some non-trivial stroke size to be blurred
        RenderWith(testP, env, blur_5_tolerance,
                   CaseParameters(
                       "MaskFilter == Blur 5",
                       [=](const SkSetupContext& ctx) {
                         ctx.paint.setStrokeWidth(5.0);
                         ctx.paint.setMaskFilter(sk_mask_filter);
                       },
                       [=](const DlSetupContext& ctx) {
                         ctx.paint.setStrokeWidth(5.0);
                         ctx.paint.setMaskFilter(&dl_mask_filter);
                       }));
      }
    }
 
    {
      DlPoint dl_end_points[] = {
          kRenderBounds.GetLeftTop(),
          kRenderBounds.GetRightBottom(),
      };
      DlColor dl_colors[] = {
          DlColor::kGreen(),
          DlColor::kYellow().withAlpha(0x7f),
          DlColor::kBlue(),
      };
      SkColor sk_colors[] = {
          SK_ColorGREEN,
          SkColorSetA(SK_ColorYELLOW, 0x7f),
          SK_ColorBLUE,
      };
      float stops[] = {
          0.0,
          0.5,
          1.0,
      };
      auto dl_gradient =
          DlColorSource::MakeLinear(dl_end_points[0], dl_end_points[1], 3,
                                    dl_colors, stops, DlTileMode::kMirror);
      auto sk_gradient = SkGradientShader::MakeLinear(
          ToSkPoints(dl_end_points), sk_colors, stops, 3, SkTileMode::kMirror,
          0, nullptr);
      {
        RenderWith(testP, env, tolerance,
                   CaseParameters(
                       "LinearGradient GYB",
                       [=](const SkSetupContext& ctx) {
                         ctx.paint.setShader(sk_gradient);
                         ctx.paint.setDither(testP.uses_gradient());
                       },
                       [=](const DlSetupContext& ctx) {
                         ctx.paint.setColorSource(dl_gradient);
                       }));
      }
    }
  }

Referenced by RenderAll().

◆ RenderWithClips()

static void flutter::testing::CanvasCompareTester::RenderWithClips	(	const TestParameters &	testP,
		const RenderEnvironment &	env,
		const BoundsTolerance &	diff_tolerance
	)

inlinestatic

Definition at line 2110 of file dl_rendering_unittests.cc.

                                                                     {
    // We used to use an inset of 15.5 pixels here, but since Skia's rounding
    // behavior at the center of pixels does not match between HW and SW, we
    // ended up with some clips including different pixels between the two
    // destinations and this interacted poorly with the carefully chosen
    // geometry in some of the tests which was designed to have just the
    // right features fully filling the clips based on the SW rounding. By
    // moving to a 15.4 inset, the edge of the clip is never on the "rounding
    // edge" of a pixel.
    DlRect r_clip = kRenderBounds.Expand(-15.4, -15.4);
    BoundsTolerance intersect_tolerance = diff_tolerance.clip(r_clip);
    intersect_tolerance = intersect_tolerance.addPostClipPadding(1, 1);
    RenderWith(testP, env, intersect_tolerance,
               CaseParameters(
                   "Hard ClipRect inset by 15.4",
                   [=](const SkSetupContext& ctx) {
                     ctx.canvas->clipRect(ToSkRect(r_clip),
                                          SkClipOp::kIntersect, false);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipRect(r_clip, DlClipOp::kIntersect, false);
                   }));
    RenderWith(testP, env, intersect_tolerance,
               CaseParameters(
                   "AntiAlias ClipRect inset by 15.4",
                   [=](const SkSetupContext& ctx) {
                     ctx.canvas->clipRect(ToSkRect(r_clip),
                                          SkClipOp::kIntersect, true);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipRect(r_clip, DlClipOp::kIntersect, true);
                   }));
    RenderWith(testP, env, diff_tolerance,
               CaseParameters(
                   "Hard ClipRect Diff, inset by 15.4",
                   [=](const SkSetupContext& ctx) {
                     ctx.canvas->clipRect(ToSkRect(r_clip),
                                          SkClipOp::kDifference, false);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipRect(r_clip, DlClipOp::kDifference, false);
                   })
                   .with_diff_clip());
    RenderWith(testP, env, intersect_tolerance,
               CaseParameters(
                   "Hard ClipOval",
                   [=](const SkSetupContext& ctx) {
                     // Skia lacks clipOval so we use an oval SkRRect
                     ctx.canvas->clipRRect(SkRRect::MakeOval(ToSkRect(r_clip)),
                                           SkClipOp::kIntersect, false);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipOval(r_clip, DlClipOp::kIntersect, false);
                   }));
    RenderWith(testP, env, intersect_tolerance,
               CaseParameters(
                   "AntiAlias ClipOval",
                   [=](const SkSetupContext& ctx) {
                     // Skia lacks clipOval so we use an oval SkRRect
                     ctx.canvas->clipRRect(SkRRect::MakeOval(ToSkRect(r_clip)),
                                           SkClipOp::kIntersect, true);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipOval(r_clip, DlClipOp::kIntersect, true);
                   }));
    RenderWith(testP, env, diff_tolerance,
               CaseParameters(
                   "Hard ClipOval Diff",
                   [=](const SkSetupContext& ctx) {
                     // Skia lacks clipOval so we use an oval SkRRect
                     ctx.canvas->clipRRect(SkRRect::MakeOval(ToSkRect(r_clip)),
                                           SkClipOp::kDifference, false);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipOval(r_clip, DlClipOp::kDifference, false);
                   })
                   .with_diff_clip());
    // This test RR clip used to use very small radii, but due to
    // optimizations in the HW rrect rasterization, this caused small
    // bulges in the corners of the RRect which were interpreted as
    // "clip overruns" by the clip OOB pixel testing code. Using less
    // abusively small radii fixes the problem.
    DlRoundRect rr_clip = DlRoundRect::MakeRectXY(r_clip, 9, 9);
    RenderWith(testP, env, intersect_tolerance,
               CaseParameters(
                   "Hard ClipRRect with radius of 9",
                   [=](const SkSetupContext& ctx) {
                     ctx.canvas->clipRRect(ToSkRRect(rr_clip),
                                           SkClipOp::kIntersect, false);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipRoundRect(rr_clip, DlClipOp::kIntersect,
                                               false);
                   }));
    RenderWith(testP, env, intersect_tolerance,
               CaseParameters(
                   "AntiAlias ClipRRect with radius of 9",
                   [=](const SkSetupContext& ctx) {
                     ctx.canvas->clipRRect(ToSkRRect(rr_clip),
                                           SkClipOp::kIntersect, true);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipRoundRect(rr_clip, DlClipOp::kIntersect,
                                               true);
                   }));
    RenderWith(testP, env, diff_tolerance,
               CaseParameters(
                   "Hard ClipRRect Diff, with radius of 9",
                   [=](const SkSetupContext& ctx) {
                     ctx.canvas->clipRRect(ToSkRRect(rr_clip),
                                           SkClipOp::kDifference, false);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipRoundRect(rr_clip, DlClipOp::kDifference,
                                               false);
                   })
                   .with_diff_clip());
    DlPathBuilder path_builder;
    path_builder.SetFillType(DlPathFillType::kOdd);
    path_builder.AddRect(r_clip);
    path_builder.AddCircle(DlPoint(kRenderCenterX, kRenderCenterY), 1.0f);
    DlPath path_clip = path_builder.TakePath();
    RenderWith(testP, env, intersect_tolerance,
               CaseParameters(
                   "Hard ClipPath inset by 15.4",
                   [=](const SkSetupContext& ctx) {
                     ctx.canvas->clipPath(path_clip.GetSkPath(),
                                          SkClipOp::kIntersect, false);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipPath(path_clip, DlClipOp::kIntersect,
                                          false);
                   }));
    RenderWith(testP, env, intersect_tolerance,
               CaseParameters(
                   "AntiAlias ClipPath inset by 15.4",
                   [=](const SkSetupContext& ctx) {
                     ctx.canvas->clipPath(path_clip.GetSkPath(),
                                          SkClipOp::kIntersect, true);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipPath(path_clip, DlClipOp::kIntersect,
                                          true);
                   }));
    RenderWith(testP, env, diff_tolerance,
               CaseParameters(
                   "Hard ClipPath Diff, inset by 15.4",
                   [=](const SkSetupContext& ctx) {
                     ctx.canvas->clipPath(path_clip.GetSkPath(),
                                          SkClipOp::kDifference, false);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipPath(path_clip, DlClipOp::kDifference,
                                          false);
                   })
                   .with_diff_clip());
  }

References flutter::DlPathBuilder::AddCircle(), flutter::testing::BoundsTolerance::addPostClipPadding(), flutter::DlPathBuilder::AddRect(), flutter::testing::BoundsTolerance::clip(), impeller::TRect< T >::Expand(), flutter::DlPath::GetSkPath(), flutter::kDifference, flutter::kIntersect, flutter::testing::kRenderBounds, flutter::testing::kRenderCenterX, flutter::testing::kRenderCenterY, impeller::RoundRect::MakeRectXY(), RenderWith(), flutter::DlPathBuilder::SetFillType(), flutter::ToSkRect(), and flutter::ToSkRRect().

Referenced by RenderAll().

◆ RenderWithSaveRestore()

static void flutter::testing::CanvasCompareTester::RenderWithSaveRestore	(	const TestParameters &	testP,
		const RenderEnvironment &	env,
		const BoundsTolerance &	tolerance
	)

inlinestatic

Definition at line 1175 of file dl_rendering_unittests.cc.

                                                                      {
    DlRect clip =
        DlRect::MakeXYWH(kRenderCenterX - 1, kRenderCenterY - 1, 2, 2);
    DlRect rect = DlRect::MakeXYWH(kRenderCenterX, kRenderCenterY, 10, 10);
    DlColor alpha_layer_color = DlColor::kCyan().withAlpha(0x7f);
    SkRenderer sk_safe_restore = [=](const SkRenderContext& ctx) {
      // Draw another primitive to disable peephole optimizations
      ctx.canvas->drawRect(ToSkRect(kRenderBounds).makeOffset(500, 500),
                           SkPaint());
      ctx.canvas->restore();
    };
    DlRenderer dl_safe_restore = [=](const DlRenderContext& ctx) {
      // Draw another primitive to disable peephole optimizations
      // As the rendering op rejection in the DisplayList Builder
      // gets smarter and smarter, this operation has had to get
      // sneakier and sneakier about specifying an operation that
      // won't practically show up in the output, but technically
      // can't be culled.
      ctx.canvas->DrawRect(
          DlRect::MakeXYWH(kRenderCenterX, kRenderCenterY, 0.0001, 0.0001),
          DlPaint());
      ctx.canvas->Restore();
    };
    SkRenderer sk_opt_restore = [=](const SkRenderContext& ctx) {
      // Just a simple restore to allow peephole optimizations to occur
      ctx.canvas->restore();
    };
    DlRenderer dl_opt_restore = [=](const DlRenderContext& ctx) {
      // Just a simple restore to allow peephole optimizations to occur
      ctx.canvas->Restore();
    };
    DlRect layer_bounds = kRenderBounds.Expand(-15, -15);
    RenderWith(testP, env, tolerance,
               CaseParameters(
                   "With prior save/clip/restore",
                   [=](const SkSetupContext& ctx) {
                     ctx.canvas->save();
                     ctx.canvas->clipRect(ToSkRect(clip), SkClipOp::kIntersect,
                                          false);
                     SkPaint p2;
                     ctx.canvas->drawRect(ToSkRect(rect), p2);
                     p2.setBlendMode(SkBlendMode::kClear);
                     ctx.canvas->drawRect(ToSkRect(rect), p2);
                     ctx.canvas->restore();
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->Save();
                     ctx.canvas->ClipRect(clip, DlClipOp::kIntersect, false);
                     DlPaint p2;
                     ctx.canvas->DrawRect(rect, p2);
                     p2.setBlendMode(DlBlendMode::kClear);
                     ctx.canvas->DrawRect(rect, p2);
                     ctx.canvas->Restore();
                   }));
    RenderWith(testP, env, tolerance,
               CaseParameters(
                   "saveLayer no paint, no bounds",
                   [=](const SkSetupContext& ctx) {
                     ctx.canvas->saveLayer(nullptr, nullptr);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->SaveLayer(std::nullopt, nullptr);
                   })
                   .with_restore(sk_safe_restore, dl_safe_restore, false));
    RenderWith(testP, env, tolerance,
               CaseParameters(
                   "saveLayer no paint, with bounds",
                   [=](const SkSetupContext& ctx) {
                     ctx.canvas->saveLayer(ToSkRect(layer_bounds), nullptr);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->SaveLayer(layer_bounds, nullptr);
                   })
                   .with_restore(sk_safe_restore, dl_safe_restore, true));
    RenderWith(testP, env, tolerance,
               CaseParameters(
                   "saveLayer with alpha, no bounds",
                   [=](const SkSetupContext& ctx) {
                     SkPaint save_p;
                     save_p.setColor(ToSkColor4f(alpha_layer_color));
                     ctx.canvas->saveLayer(nullptr, &save_p);
                   },
                   [=](const DlSetupContext& ctx) {
                     DlPaint save_p;
                     save_p.setColor(alpha_layer_color);
                     ctx.canvas->SaveLayer(std::nullopt, &save_p);
                   })
                   .with_restore(sk_safe_restore, dl_safe_restore, true));
    RenderWith(testP, env, tolerance,
               CaseParameters(
                   "saveLayer with peephole alpha, no bounds",
                   [=](const SkSetupContext& ctx) {
                     SkPaint save_p;
                     save_p.setColor(ToSkColor4f(alpha_layer_color));
                     ctx.canvas->saveLayer(nullptr, &save_p);
                   },
                   [=](const DlSetupContext& ctx) {
                     DlPaint save_p;
                     save_p.setColor(alpha_layer_color);
                     ctx.canvas->SaveLayer(std::nullopt, &save_p);
                   })
                   .with_restore(sk_opt_restore, dl_opt_restore, true, true));
    RenderWith(testP, env, tolerance,
               CaseParameters(
                   "saveLayer with alpha and bounds",
                   [=](const SkSetupContext& ctx) {
                     SkPaint save_p;
                     save_p.setColor(ToSkColor4f(alpha_layer_color));
                     ctx.canvas->saveLayer(ToSkRect(layer_bounds), &save_p);
                   },
                   [=](const DlSetupContext& ctx) {
                     DlPaint save_p;
                     save_p.setColor(alpha_layer_color);
                     ctx.canvas->SaveLayer(layer_bounds, &save_p);
                   })
                   .with_restore(sk_safe_restore, dl_safe_restore, true));
    {
      // Being able to see a backdrop blur requires a non-default background
      // so we create a new environment for these tests that has a checkerboard
      // background that can be blurred by the backdrop filter. We also want
      // to avoid the rendered primitive from obscuring the blurred background
      // so we set an alpha value which works for all primitives except for
      // drawColor which can override the alpha with its color, but it now uses
      // a non-opaque color to avoid that problem.
      RenderEnvironment backdrop_env =
          RenderEnvironment::MakeN32(env.provider());
      SkSetup sk_backdrop_setup = [=](const SkSetupContext& ctx) {
        SkPaint setup_p;
        setup_p.setShader(MakeColorSource(ctx.image));
        ctx.canvas->drawPaint(setup_p);
      };
      DlSetup dl_backdrop_setup = [=](const DlSetupContext& ctx) {
        DlPaint setup_p;
        setup_p.setColorSource(MakeColorSource(ctx.image));
        ctx.canvas->DrawPaint(setup_p);
      };
      SkSetup sk_content_setup = [=](const SkSetupContext& ctx) {
        ctx.paint.setAlpha(ctx.paint.getAlpha() / 2);
      };
      DlSetup dl_content_setup = [=](const DlSetupContext& ctx) {
        ctx.paint.setAlpha(ctx.paint.getAlpha() / 2);
      };
      backdrop_env.init_ref(sk_backdrop_setup, testP.sk_renderer(),
                            dl_backdrop_setup, testP.dl_renderer(),
                            testP.imp_renderer());
      quickCompareToReference(backdrop_env, "backdrop");
 
      DlBlurImageFilter dl_backdrop(5, 5, DlTileMode::kDecal);
      auto sk_backdrop =
          SkImageFilters::Blur(5, 5, SkTileMode::kDecal, nullptr);
      RenderWith(
          testP, backdrop_env, tolerance,
          CaseParameters(
              "saveLayer with backdrop",
              [=](const SkSetupContext& ctx) {
                sk_backdrop_setup(ctx);
                ctx.canvas->saveLayer(
                    SkCanvas::SaveLayerRec(nullptr, nullptr, sk_backdrop.get(),
                                           SkTileMode::kDecal, nullptr, 0));
                sk_content_setup(ctx);
              },
              [=](const DlSetupContext& ctx) {
                dl_backdrop_setup(ctx);
                ctx.canvas->SaveLayer(std::nullopt, nullptr, &dl_backdrop);
                dl_content_setup(ctx);
              })
              .with_restore(sk_safe_restore, dl_safe_restore, true));
      RenderWith(testP, backdrop_env, tolerance,
                 CaseParameters(
                     "saveLayer with bounds and backdrop",
                     [=](const SkSetupContext& ctx) {
                       sk_backdrop_setup(ctx);
                       ctx.canvas->saveLayer(SkCanvas::SaveLayerRec(
                           &ToSkRect(layer_bounds), nullptr, sk_backdrop.get(),
                           SkTileMode::kDecal, nullptr, 0));
                       sk_content_setup(ctx);
                     },
                     [=](const DlSetupContext& ctx) {
                       dl_backdrop_setup(ctx);
                       ctx.canvas->SaveLayer(layer_bounds, nullptr,
                                             &dl_backdrop);
                       dl_content_setup(ctx);
                     })
                     .with_restore(sk_safe_restore, dl_safe_restore, true));
      RenderWith(
          testP, backdrop_env, tolerance,
          CaseParameters(
              "clipped saveLayer with backdrop",
              [=](const SkSetupContext& ctx) {
                sk_backdrop_setup(ctx);
                ctx.canvas->clipRect(ToSkRect(layer_bounds));
                ctx.canvas->saveLayer(
                    SkCanvas::SaveLayerRec(nullptr, nullptr, sk_backdrop.get(),
                                           SkTileMode::kDecal, nullptr, 0));
                sk_content_setup(ctx);
              },
              [=](const DlSetupContext& ctx) {
                dl_backdrop_setup(ctx);
                ctx.canvas->ClipRect(layer_bounds);
                ctx.canvas->SaveLayer(std::nullopt, nullptr, &dl_backdrop);
                dl_content_setup(ctx);
              })
              .with_restore(sk_safe_restore, dl_safe_restore, true));
    }
 
    {
      // clang-format off
      constexpr float rotate_alpha_color_matrix[20] = {
          0, 1, 0,  0 , 0,
          0, 0, 1,  0 , 0,
          1, 0, 0,  0 , 0,
          0, 0, 0, 0.5, 0,
      };
      // clang-format on
      auto dl_alpha_rotate_filter =
          DlColorFilter::MakeMatrix(rotate_alpha_color_matrix);
      auto sk_alpha_rotate_filter =
          SkColorFilters::Matrix(rotate_alpha_color_matrix);
      {
        RenderWith(testP, env, tolerance,
                   CaseParameters(
                       "saveLayer ColorFilter, no bounds",
                       [=](const SkSetupContext& ctx) {
                         SkPaint save_p;
                         save_p.setColorFilter(sk_alpha_rotate_filter);
                         ctx.canvas->saveLayer(nullptr, &save_p);
                         ctx.paint.setStrokeWidth(5.0);
                       },
                       [=](const DlSetupContext& ctx) {
                         DlPaint save_p;
                         save_p.setColorFilter(dl_alpha_rotate_filter);
                         ctx.canvas->SaveLayer(std::nullopt, &save_p);
                         ctx.paint.setStrokeWidth(5.0);
                       })
                       .with_restore(sk_safe_restore, dl_safe_restore, true));
      }
      {
        RenderWith(testP, env, tolerance,
                   CaseParameters(
                       "saveLayer ColorFilter and bounds",
                       [=](const SkSetupContext& ctx) {
                         SkPaint save_p;
                         save_p.setColorFilter(sk_alpha_rotate_filter);
                         ctx.canvas->saveLayer(ToSkRect(kRenderBounds),
                                               &save_p);
                         ctx.paint.setStrokeWidth(5.0);
                       },
                       [=](const DlSetupContext& ctx) {
                         DlPaint save_p;
                         save_p.setColorFilter(dl_alpha_rotate_filter);
                         ctx.canvas->SaveLayer(kRenderBounds, &save_p);
                         ctx.paint.setStrokeWidth(5.0);
                       })
                       .with_restore(sk_safe_restore, dl_safe_restore, true));
      }
    }
 
    {
      // clang-format off
      constexpr float color_matrix[20] = {
          0.5, 0, 0, 0, 0.5,
          0, 0.5, 0, 0, 0.5,
          0, 0, 0.5, 0, 0.5,
          0, 0, 0, 1, 0,
      };
      // clang-format on
      auto dl_color_filter = DlColorFilter::MakeMatrix(color_matrix);
      auto dl_cf_image_filter = DlImageFilter::MakeColorFilter(dl_color_filter);
      auto sk_cf_image_filter = SkImageFilters::ColorFilter(
          SkColorFilters::Matrix(color_matrix), nullptr);
      {
        RenderWith(testP, env, tolerance,
                   CaseParameters(
                       "saveLayer ImageFilter, no bounds",
                       [=](const SkSetupContext& ctx) {
                         SkPaint save_p;
                         save_p.setImageFilter(sk_cf_image_filter);
                         ctx.canvas->saveLayer(nullptr, &save_p);
                         ctx.paint.setStrokeWidth(5.0);
                       },
                       [=](const DlSetupContext& ctx) {
                         DlPaint save_p;
                         save_p.setImageFilter(dl_cf_image_filter);
                         ctx.canvas->SaveLayer(std::nullopt, &save_p);
                         ctx.paint.setStrokeWidth(5.0);
                       })
                       .with_restore(sk_safe_restore, dl_safe_restore, true));
      }
      {
        RenderWith(testP, env, tolerance,
                   CaseParameters(
                       "saveLayer ImageFilter and bounds",
                       [=](const SkSetupContext& ctx) {
                         SkPaint save_p;
                         save_p.setImageFilter(sk_cf_image_filter);
                         ctx.canvas->saveLayer(ToSkRect(kRenderBounds),
                                               &save_p);
                         ctx.paint.setStrokeWidth(5.0);
                       },
                       [=](const DlSetupContext& ctx) {
                         DlPaint save_p;
                         save_p.setImageFilter(dl_cf_image_filter);
                         ctx.canvas->SaveLayer(kRenderBounds, &save_p);
                         ctx.paint.setStrokeWidth(5.0);
                       })
                       .with_restore(sk_safe_restore, dl_safe_restore, true));
      }
    }
  }

References flutter::testing::TestParameters::dl_renderer(), impeller::TRect< T >::Expand(), flutter::testing::TestParameters::imp_renderer(), flutter::testing::RenderEnvironment::init_ref(), flutter::DlColor::kCyan(), flutter::kDecal, flutter::kIntersect, flutter::testing::kRenderBounds, flutter::testing::kRenderCenterX, flutter::testing::kRenderCenterY, flutter::DlImageFilter::MakeColorFilter(), flutter::testing::MakeColorSource(), flutter::DlColorFilter::MakeMatrix(), flutter::testing::RenderEnvironment::MakeN32(), impeller::TRect< Scalar >::MakeXYWH(), flutter::testing::RenderEnvironment::provider(), quickCompareToReference(), RenderWith(), flutter::DlPaint::setAlpha(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorFilter(), flutter::DlPaint::setColorSource(), flutter::DlPaint::setImageFilter(), flutter::DlPaint::setStrokeWidth(), flutter::testing::TestParameters::sk_renderer(), flutter::ToSkColor4f(), flutter::ToSkRect(), and flutter::DlColor::withAlpha().

Referenced by RenderAll().

◆ RenderWithStrokes()

static void flutter::testing::CanvasCompareTester::RenderWithStrokes	(	const TestParameters &	testP,
		const RenderEnvironment &	env,
		const BoundsTolerance &	tolerance_in
	)

inlinestatic

Definition at line 1812 of file dl_rendering_unittests.cc.

                                                                     {
    // The test cases were generated with geometry that will try to fill
    // out the various miter limits used for testing, but they can be off
    // by a couple of pixels so we will relax bounds testing for strokes by
    // a couple of pixels.
    BoundsTolerance tolerance = tolerance_in.addBoundsPadding(2, 2);
    RenderWith(testP, env, tolerance,
               CaseParameters(
                   "Fill",
                   [=](const SkSetupContext& ctx) {
                     ctx.paint.setStyle(SkPaint::kFill_Style);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.paint.setDrawStyle(DlDrawStyle::kFill);
                   }));
    // Skia on HW produces a strong miter consistent with width=1.0
    // for any width less than a pixel, but the bounds computations of
    // both DL and SkPicture do not account for this. We will get
    // OOB pixel errors for the highly mitered drawPath geometry if
    // we don't set stroke width to 1.0 for that test on HW.
    // See https://bugs.chromium.org/p/skia/issues/detail?id=14046
    bool no_hairlines =
        testP.is_draw_path() &&
        env.provider()->backend_type() != BackendType::kSoftwareBackend;
    RenderWith(testP, env, tolerance,
               CaseParameters(
                   "Stroke + defaults",
                   [=](const SkSetupContext& ctx) {
                     if (no_hairlines) {
                       ctx.paint.setStrokeWidth(1.0);
                     }
                     ctx.paint.setStyle(SkPaint::kStroke_Style);
                   },
                   [=](const DlSetupContext& ctx) {
                     if (no_hairlines) {
                       ctx.paint.setStrokeWidth(1.0);
                     }
                     ctx.paint.setDrawStyle(DlDrawStyle::kStroke);
                   }));
 
    RenderWith(testP, env, tolerance,
               CaseParameters(
                   "Fill + unnecessary StrokeWidth 10",
                   [=](const SkSetupContext& ctx) {
                     ctx.paint.setStyle(SkPaint::kFill_Style);
                     ctx.paint.setStrokeWidth(10.0);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.paint.setDrawStyle(DlDrawStyle::kFill);
                     ctx.paint.setStrokeWidth(10.0);
                   }));
 
    RenderEnvironment stroke_base_env =
        RenderEnvironment::MakeN32(env.provider());
    SkSetup sk_stroke_setup = [=](const SkSetupContext& ctx) {
      ctx.paint.setStyle(SkPaint::kStroke_Style);
      ctx.paint.setStrokeWidth(5.0);
    };
    DlSetup dl_stroke_setup = [=](const DlSetupContext& ctx) {
      ctx.paint.setDrawStyle(DlDrawStyle::kStroke);
      ctx.paint.setStrokeWidth(5.0);
    };
    stroke_base_env.init_ref(sk_stroke_setup, testP.sk_renderer(),
                             dl_stroke_setup, testP.dl_renderer(),
                             testP.imp_renderer());
    quickCompareToReference(stroke_base_env, "stroke");
 
    RenderWith(testP, stroke_base_env, tolerance,
               CaseParameters(
                   "Stroke Width 10",
                   [=](const SkSetupContext& ctx) {
                     ctx.paint.setStyle(SkPaint::kStroke_Style);
                     ctx.paint.setStrokeWidth(10.0);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.paint.setDrawStyle(DlDrawStyle::kStroke);
                     ctx.paint.setStrokeWidth(10.0);
                   }));
    RenderWith(testP, stroke_base_env, tolerance,
               CaseParameters(
                   "Stroke Width 5",
                   [=](const SkSetupContext& ctx) {
                     ctx.paint.setStyle(SkPaint::kStroke_Style);
                     ctx.paint.setStrokeWidth(5.0);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.paint.setDrawStyle(DlDrawStyle::kStroke);
                     ctx.paint.setStrokeWidth(5.0);
                   }));
 
    RenderWith(testP, stroke_base_env, tolerance,
               CaseParameters(
                   "Stroke Width 5, Square Cap",
                   [=](const SkSetupContext& ctx) {
                     ctx.paint.setStyle(SkPaint::kStroke_Style);
                     ctx.paint.setStrokeWidth(5.0);
                     ctx.paint.setStrokeCap(SkPaint::kSquare_Cap);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.paint.setDrawStyle(DlDrawStyle::kStroke);
                     ctx.paint.setStrokeWidth(5.0);
                     ctx.paint.setStrokeCap(DlStrokeCap::kSquare);
                   }));
    RenderWith(testP, stroke_base_env, tolerance,
               CaseParameters(
                   "Stroke Width 5, Round Cap",
                   [=](const SkSetupContext& ctx) {
                     ctx.paint.setStyle(SkPaint::kStroke_Style);
                     ctx.paint.setStrokeWidth(5.0);
                     ctx.paint.setStrokeCap(SkPaint::kRound_Cap);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.paint.setDrawStyle(DlDrawStyle::kStroke);
                     ctx.paint.setStrokeWidth(5.0);
                     ctx.paint.setStrokeCap(DlStrokeCap::kRound);
                   }));
 
    RenderWith(testP, stroke_base_env, tolerance,
               CaseParameters(
                   "Stroke Width 5, Bevel Join",
                   [=](const SkSetupContext& ctx) {
                     ctx.paint.setStyle(SkPaint::kStroke_Style);
                     ctx.paint.setStrokeWidth(5.0);
                     ctx.paint.setStrokeJoin(SkPaint::kBevel_Join);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.paint.setDrawStyle(DlDrawStyle::kStroke);
                     ctx.paint.setStrokeWidth(5.0);
                     ctx.paint.setStrokeJoin(DlStrokeJoin::kBevel);
                   }));
    RenderWith(testP, stroke_base_env, tolerance,
               CaseParameters(
                   "Stroke Width 5, Round Join",
                   [=](const SkSetupContext& ctx) {
                     ctx.paint.setStyle(SkPaint::kStroke_Style);
                     ctx.paint.setStrokeWidth(5.0);
                     ctx.paint.setStrokeJoin(SkPaint::kRound_Join);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.paint.setDrawStyle(DlDrawStyle::kStroke);
                     ctx.paint.setStrokeWidth(5.0);
                     ctx.paint.setStrokeJoin(DlStrokeJoin::kRound);
                   }));
 
    RenderWith(testP, stroke_base_env, tolerance,
               CaseParameters(
                   "Stroke Width 5, Miter 10",
                   [=](const SkSetupContext& ctx) {
                     ctx.paint.setStyle(SkPaint::kStroke_Style);
                     ctx.paint.setStrokeWidth(5.0);
                     ctx.paint.setStrokeMiter(10.0);
                     ctx.paint.setStrokeJoin(SkPaint::kMiter_Join);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.paint.setDrawStyle(DlDrawStyle::kStroke);
                     ctx.paint.setStrokeWidth(5.0);
                     ctx.paint.setStrokeMiter(10.0);
                     ctx.paint.setStrokeJoin(DlStrokeJoin::kMiter);
                   }));
 
    RenderWith(testP, stroke_base_env, tolerance,
               CaseParameters(
                   "Stroke Width 5, Miter 0",
                   [=](const SkSetupContext& ctx) {
                     ctx.paint.setStyle(SkPaint::kStroke_Style);
                     ctx.paint.setStrokeWidth(5.0);
                     ctx.paint.setStrokeMiter(0.0);
                     ctx.paint.setStrokeJoin(SkPaint::kMiter_Join);
                   },
                   [=](const DlSetupContext& ctx) {
                     ctx.paint.setDrawStyle(DlDrawStyle::kStroke);
                     ctx.paint.setStrokeWidth(5.0);
                     ctx.paint.setStrokeMiter(0.0);
                     ctx.paint.setStrokeJoin(DlStrokeJoin::kMiter);
                   }));
  }

References flutter::testing::BoundsTolerance::addBoundsPadding(), flutter::testing::DlSurfaceProvider::backend_type(), flutter::testing::TestParameters::dl_renderer(), flutter::testing::TestParameters::imp_renderer(), flutter::testing::RenderEnvironment::init_ref(), flutter::testing::TestParameters::is_draw_path(), flutter::kBevel, flutter::kFill, flutter::kMiter, flutter::kRound, flutter::kSquare, flutter::kStroke, flutter::testing::RenderEnvironment::MakeN32(), flutter::testing::RenderEnvironment::provider(), quickCompareToReference(), RenderWith(), and flutter::testing::TestParameters::sk_renderer().

Referenced by RenderWithAttributes().

◆ RenderWithTransforms()

static void flutter::testing::CanvasCompareTester::RenderWithTransforms	(	const TestParameters &	testP,
		const RenderEnvironment &	env,
		const BoundsTolerance &	tolerance
	)

inlinestatic

Definition at line 1991 of file dl_rendering_unittests.cc.

                                                                     {
    // If the rendering method does not fill the corners of the original
    // bounds, then the estimate under rotation or skewing will be off
    // so we scale the padding by about 5% to compensate.
    BoundsTolerance skewed_tolerance = tolerance.mulScale(1.05, 1.05);
    RenderWith(  //
        testP, env, tolerance,
        CaseParameters(
            "Translate 5, 10",  //
            [=](const SkSetupContext& ctx) { ctx.canvas->translate(5, 10); },
            [=](const DlSetupContext& ctx) { ctx.canvas->Translate(5, 10); }));
    RenderWith(  //
        testP, env, tolerance,
        CaseParameters(
            "Scale +5%",  //
            [=](const SkSetupContext& ctx) { ctx.canvas->scale(1.05, 1.05); },
            [=](const DlSetupContext& ctx) { ctx.canvas->Scale(1.05, 1.05); }));
    RenderWith(  //
        testP, env, skewed_tolerance,
        CaseParameters(
            "Rotate 5 degrees",  //
            [=](const SkSetupContext& ctx) { ctx.canvas->rotate(5); },
            [=](const DlSetupContext& ctx) { ctx.canvas->Rotate(5); }));
    RenderWith(  //
        testP, env, skewed_tolerance,
        CaseParameters(
            "Skew 5%",  //
            [=](const SkSetupContext& ctx) { ctx.canvas->skew(0.05, 0.05); },
            [=](const DlSetupContext& ctx) { ctx.canvas->Skew(0.05, 0.05); }));
    {
      // This rather odd transform can cause slight differences in
      // computing in-bounds samples depending on which base rendering
      // routine Skia uses. Making sure our matrix values are powers
      // of 2 reduces, but does not eliminate, these slight differences
      // in calculation when we are comparing rendering with an alpha
      // to rendering opaque colors in the group opacity tests, for
      // example.
      DlScalar tweak = 1.0 / 16.0;
      DlMatrix matrix = DlMatrix::MakeRow(
          // clang-format off
          1.0 + tweak, tweak,       0, 5,
          tweak,       1.0 + tweak, 0, 10,
          0, 0, 1, 0,
          0, 0, 0, 1
          // clang-format on
      );
      RenderWith(  //
          testP, env, skewed_tolerance,
          CaseParameters(
              "Transform 2D Affine Matrix",
              [=](const SkSetupContext& ctx) {
                ctx.canvas->concat(ToSkMatrix(matrix));
              },
              [=](const DlSetupContext& ctx) {
                ctx.canvas->Transform(matrix);
              }));
      RenderWith(  //
          testP, env, skewed_tolerance,
          CaseParameters(
              "Transform 2D Affine inline",
              [=](const SkSetupContext& ctx) {
                ctx.canvas->concat(SkMatrix::MakeAll(1.0 + tweak, tweak, 5,   //
                                                     tweak, 1.0 + tweak, 10,  //
                                                     0, 0, 1));
              },
              [=](const DlSetupContext& ctx) {
                ctx.canvas->Transform2DAffine(1.0 + tweak, tweak, 5,  //
                                              tweak, 1.0 + tweak, 10);
              }));
    }
    {
      DlMatrix matrix = DlMatrix::MakeRow(1.0f, 0.0f, 0.0f, kRenderCenterX,  //
                                          0.0f, 1.0f, 0.0f, kRenderCenterY,  //
                                          0.0f, 0.0f, 1.0f, 0.0f,            //
                                          0.0f, 0.0f, .001f, 1.0f);
      matrix = matrix * DlMatrix::MakeRotationX(DlDegrees(3));
      matrix = matrix * DlMatrix::MakeRotationY(DlDegrees(4));
      matrix = matrix.Translate({-kRenderCenterX, -kRenderCenterY, 0.0f});
      RenderWith(  //
          testP, env, skewed_tolerance,
          CaseParameters(
              "Transform Full Perspective Matrix",
              [=](const SkSetupContext& ctx) {
                ctx.canvas->concat(ToSkM44(matrix));
              },
              [=](const DlSetupContext& ctx) {
                ctx.canvas->Transform(matrix);
              }));
      RenderWith(  //
          testP, env, skewed_tolerance,
          CaseParameters(
              "Transform Full Perspective inline",
              [=](const SkSetupContext& ctx) {
                ctx.canvas->concat(SkM44(
                    // These values match what ends up in matrix above
                    // clang-format off
                     0.997564,   0.000000,   0.069756,   0.243591,
                     0.003651,   0.998630,  -0.052208,  -0.228027,
                    -0.069661,   0.052336,   0.996197,   1.732491,
                    -0.000070,   0.000052,   0.000996,   1.001732
                    // clang-format on
                    ));
              },
              [=](const DlSetupContext& ctx) {
                ctx.canvas->TransformFullPerspective(
                    // These values match what ends up in matrix above
                    // clang-format off
                     0.997564,   0.000000,   0.069756,   0.243591,
                     0.003651,   0.998630,  -0.052208,  -0.228027,
                    -0.069661,   0.052336,   0.996197,   1.732491,
                    -0.000070,   0.000052,   0.000996,   1.001732
                    // clang-format on
                );
              }));
    }
  }

References flutter::testing::kRenderCenterX, flutter::testing::kRenderCenterY, impeller::Matrix::MakeRotationX(), impeller::Matrix::MakeRotationY(), impeller::Matrix::MakeRow(), flutter::testing::BoundsTolerance::mulScale(), RenderWith(), flutter::ToSkM44(), flutter::ToSkMatrix(), and impeller::Matrix::Translate().

Referenced by RenderAll().

◆ save_to_png()

static void flutter::testing::CanvasCompareTester::save_to_png	(	const RenderResult *	result,
		const std::string &	op_desc,
		const std::string &	reason
	)

inlinestatic

Definition at line 2317 of file dl_rendering_unittests.cc.

                                                   {
    if (!SaveImpellerFailureImages) {
      return;
    }
    if (ImpellerFailureImageDirectory.length() == 0) {
      SetupImpellerFailureImageDirectory();
      if (ImpellerFailureImageDirectory.length() == 0) {
        SaveImpellerFailureImages = false;
        return;
      }
    }
 
    std::string filename = ImpellerFailureImageDirectory + "/";
    for (const char& ch : op_desc) {
      filename += (ch == ':' || ch == ' ') ? '_' : ch;
    }
    filename = filename + ".png";
    result->write(filename);
    ImpellerFailureImages.push_back(filename);
    FML_LOG(ERROR) << reason << ": " << filename;
  }

References FML_LOG, ImpellerFailureImageDirectory, ImpellerFailureImages, SaveImpellerFailureImages, SetupImpellerFailureImageDirectory(), and flutter::testing::RenderResult::write().

Referenced by RenderAll(), and RenderWith().

◆ SetupImpellerFailureImageDirectory()

static void flutter::testing::CanvasCompareTester::SetupImpellerFailureImageDirectory ( )

inlinestatic

Definition at line 2293 of file dl_rendering_unittests.cc.

                                                   {
    std::string base_dir = "./impeller_failure_images";
    if (CheckDir(base_dir) == DirectoryStatus::kFailed) {
      return;
    }
    for (int i = 0; i < 10000; i++) {
      std::string sub_dir = std::to_string(i);
      while (sub_dir.length() < 4) {
        sub_dir = "0" + sub_dir;
      }
      std::string try_dir = base_dir + "/" + sub_dir;
      switch (CheckDir(try_dir)) {
        case DirectoryStatus::kExisted:
          break;
        case DirectoryStatus::kCreated:
          ImpellerFailureImageDirectory = try_dir;
          return;
        case DirectoryStatus::kFailed:
          return;
      }
    }
    FML_LOG(ERROR) << "Too many output directories for Impeller failure images";
  }

References CheckDir(), FML_LOG, i, ImpellerFailureImageDirectory, kCreated, kExisted, and kFailed.

Referenced by save_to_png().

◆ showBoundsOverflow()

static void flutter::testing::CanvasCompareTester::showBoundsOverflow	(	const std::string &	info,
		DlIRect &	bounds,
		const BoundsTolerance *	tolerance,
		int	pixLeft,
		int	pixTop,
		int	pixRight,
		int	pixBottom
	)

inlinestatic

Definition at line 2758 of file dl_rendering_unittests.cc.

                                                {
    int pad_left = std::max(0, pixLeft - bounds.GetLeft());
    int pad_top = std::max(0, pixTop - bounds.GetTop());
    int pad_right = std::max(0, bounds.GetRight() - pixRight);
    int pad_bottom = std::max(0, bounds.GetBottom() - pixBottom);
    DlIRect pix_bounds =
        DlIRect::MakeLTRB(pixLeft, pixTop, pixRight, pixBottom);
    DlISize pix_size = pix_bounds.GetSize();
    int pix_width = pix_size.width;
    int pix_height = pix_size.height;
    int worst_pad_x = std::max(pad_left, pad_right);
    int worst_pad_y = std::max(pad_top, pad_bottom);
    if (tolerance->overflows(pix_bounds, worst_pad_x, worst_pad_y)) {
      FML_LOG(ERROR) << "Computed bounds for " << info;
      FML_LOG(ERROR) << "pix bounds["                        //
                     << pixLeft << ", " << pixTop << " => "  //
                     << pixRight << ", " << pixBottom        //
                     << "]";
      FML_LOG(ERROR) << "dl_bounds[" << bounds << "]";
      FML_LOG(ERROR) << "Bounds overly conservative by up to "     //
                     << worst_pad_x << ", " << worst_pad_y         //
                     << " (" << (worst_pad_x * 100.0 / pix_width)  //
                     << "%, " << (worst_pad_y * 100.0 / pix_height) << "%)";
      int pix_area = pix_size.Area();
      int dl_area = bounds.Area();
      FML_LOG(ERROR) << "Total overflow area: " << (dl_area - pix_area)  //
                     << " (+" << (dl_area * 100.0 / pix_area - 100.0)    //
                     << "% larger)";
      FML_LOG(ERROR);
    }
  }