Inheritance diagram for flutter::testing::DisplayListNopTest:

Protected Member Functions
	DisplayListNopTest ()

std::unique_ptr< RenderResult >	get_output (int w, int h, bool snapshot, const std::function< void(SkCanvas *)> &renderer)

int	check_color_result (DlColor dst_color, DlColor result_color, const sk_sp< DisplayList > &dl, const std::string &desc)

int	check_image_result (const std::unique_ptr< RenderResult > &dst_data, const std::unique_ptr< RenderResult > &result_data, const sk_sp< DisplayList > &dl, const std::string &desc)

void	report_results (int all_flags, const sk_sp< DisplayList > &dl, const std::string &desc)

void	test_mode_color_via_filter (DlBlendMode mode, DlColor color)

void	test_mode_color_via_rendering (DlBlendMode mode, DlColor color)

void	test_attributes_image (DlBlendMode mode, DlColor color, DlColorFilter color_filter, DlImageFilter image_filter)

Protected Attributes
std::vector< DlColor >	test_src_colors

std::vector< DlColor >	test_dst_colors

std::shared_ptr< DlColorFilter >	color_filter_nomtb

std::shared_ptr< DlColorFilter >	color_filter_mtb

std::unique_ptr< RenderResult >	test_data

std::unique_ptr< RenderResult >	test_image_dst_data

std::unique_ptr< RenderResult >	test_image_src_data

Static Protected Attributes
static constexpr int	kWasNotNop = 0x1

static constexpr int	kWasMTB = 0x2

Static Protected Attributes inherited from flutter::DisplayListOpFlags
static constexpr DisplayListAttributeFlags	kSaveLayerFlags

static constexpr DisplayListAttributeFlags	kSaveLayerWithPaintFlags

static constexpr DisplayListAttributeFlags	kDrawColorFlags

static constexpr DisplayListAttributeFlags	kDrawPaintFlags

static constexpr DisplayListAttributeFlags	kDrawHVLineFlags

static constexpr DisplayListAttributeFlags	kDrawLineFlags

static constexpr DisplayListAttributeFlags	kDrawRectFlags

static constexpr DisplayListAttributeFlags	kDrawOvalFlags

static constexpr DisplayListAttributeFlags	kDrawCircleFlags

static constexpr DisplayListAttributeFlags	kDrawRRectFlags

static constexpr DisplayListAttributeFlags	kDrawDRRectFlags

static constexpr DisplayListAttributeFlags	kDrawPathFlags

static constexpr DisplayListAttributeFlags	kDrawArcNoCenterFlags

static constexpr DisplayListAttributeFlags	kDrawArcWithCenterFlags

static constexpr DisplayListAttributeFlags	kDrawPointsAsPointsFlags

static constexpr DisplayListAttributeFlags	kDrawPointsAsLinesFlags

static constexpr DisplayListAttributeFlags	kDrawPointsAsPolygonFlags

static constexpr DisplayListAttributeFlags	kDrawVerticesFlags

static constexpr DisplayListAttributeFlags	kDrawImageFlags

static constexpr DisplayListAttributeFlags	kDrawImageWithPaintFlags

static constexpr DisplayListAttributeFlags	kDrawImageRectFlags

static constexpr DisplayListAttributeFlags	kDrawImageRectWithPaintFlags

static constexpr DisplayListAttributeFlags	kDrawImageNineFlags

static constexpr DisplayListAttributeFlags	kDrawImageNineWithPaintFlags

static constexpr DisplayListAttributeFlags	kDrawAtlasFlags

static constexpr DisplayListAttributeFlags	kDrawAtlasWithPaintFlags

static constexpr DisplayListAttributeFlags	kDrawDisplayListFlags

static constexpr DisplayListAttributeFlags	kDrawTextBlobFlags

static constexpr DisplayListAttributeFlags	kDrawShadowFlags

Additional Inherited Members
Public Member Functions inherited from flutter::testing::DisplayListRenderingTestBase< BaseT >
	DisplayListRenderingTestBase ()=default

Static Public Member Functions inherited from flutter::testing::DisplayListRenderingTestBase< BaseT >
static bool	StartsWith (std::string str, std::string prefix)

static void	SetUpTestSuite ()

static void	TearDownTestSuite ()

Detailed Description

Definition at line 4337 of file dl_rendering_unittests.cc.

Constructor & Destructor Documentation

◆ DisplayListNopTest()

flutter::testing::DisplayListNopTest::DisplayListNopTest ( )

inlineprotected

Definition at line 4341 of file dl_rendering_unittests.cc.

                       : DisplayListRendering() {
    test_src_colors = {
        DlColor::kBlack().withAlpha(0),     // transparent black
        DlColor::kBlack().withAlpha(0x7f),  // half transparent black
        DlColor::kWhite().withAlpha(0x7f),  // half transparent white
        DlColor::kBlack(),                  // opaque black
        DlColor::kWhite(),                  // opaque white
        DlColor::kRed(),                    // opaque red
        DlColor::kGreen(),                  // opaque green
        DlColor::kBlue(),                   // opaque blue
        DlColor::kDarkGrey(),               // dark grey
        DlColor::kLightGrey(),              // light grey
    };
 
    // We test against a color cube of 3x3x3 colors [55,aa,ff]
    // plus transparency as the first color/pixel
    test_dst_colors.push_back(DlColor::kTransparent());
    const int step = 0x55;
    static_assert(step * 3 == 255);
    for (int a = step; a < 256; a += step) {
      for (int r = step; r < 256; r += step) {
        for (int g = step; g < 256; g += step) {
          for (int b = step; b < 256; b += step) {
            test_dst_colors.push_back(DlColor(a << 24 | r << 16 | g << 8 | b));
          }
        }
      }
    }
 
    static constexpr float color_filter_matrix_nomtb[] = {
        0.0001, 0.0001, 0.0001, 0.9997, 0.0,  //
        0.0001, 0.0001, 0.0001, 0.9997, 0.0,  //
        0.0001, 0.0001, 0.0001, 0.9997, 0.0,  //
        0.0001, 0.0001, 0.0001, 0.9997, 0.0,  //
    };
    static constexpr float color_filter_matrix_mtb[] = {
        0.0001, 0.0001, 0.0001, 0.9997, 0.0,  //
        0.0001, 0.0001, 0.0001, 0.9997, 0.0,  //
        0.0001, 0.0001, 0.0001, 0.9997, 0.0,  //
        0.0001, 0.0001, 0.0001, 0.9997, 0.1,  //
    };
    color_filter_nomtb = DlMatrixColorFilter::Make(color_filter_matrix_nomtb);
    color_filter_mtb = DlMatrixColorFilter::Make(color_filter_matrix_mtb);
    EXPECT_FALSE(color_filter_nomtb->modifies_transparent_black());
    EXPECT_TRUE(color_filter_mtb->modifies_transparent_black());
 
    test_data =
        get_output(test_dst_colors.size(), 1, true, [this](SkCanvas* canvas) {
          int x = 0;
          for (DlColor color : test_dst_colors) {
            SkPaint paint;
            paint.setColor(ToSk(color));
            paint.setBlendMode(SkBlendMode::kSrc);
            canvas->drawRect(SkRect::MakeXYWH(x, 0, 1, 1), paint);
            x++;
          }
        });
 
    // For image-on-image tests, the src and dest images will have repeated
    // rows/columns that have every color, but laid out at right angles to
    // each other so we see an interaction with every test color against
    // every other test color.
    int data_count = test_data->image()->width();
    test_image_dst_data = get_output(
        data_count, data_count, true, [this, data_count](SkCanvas* canvas) {
          ASSERT_EQ(test_data->width(), data_count);
          ASSERT_EQ(test_data->height(), 1);
          for (int y = 0; y < data_count; y++) {
            canvas->drawImage(test_data->image().get(), 0, y);
          }
        });
    test_image_src_data = get_output(
        data_count, data_count, true, [this, data_count](SkCanvas* canvas) {
          ASSERT_EQ(test_data->width(), data_count);
          ASSERT_EQ(test_data->height(), 1);
          canvas->translate(data_count, 0);
          canvas->rotate(90);
          for (int y = 0; y < data_count; y++) {
            canvas->drawImage(test_data->image().get(), 0, y);
          }
        });
    // Double check that the pixel data is laid out in orthogonal stripes
    for (int y = 0; y < data_count; y++) {
      for (int x = 0; x < data_count; x++) {
        EXPECT_EQ(*test_image_dst_data->addr32(x, y), *test_data->addr32(x, 0));
        EXPECT_EQ(*test_image_src_data->addr32(x, y), *test_data->addr32(y, 0));
      }
    }
  }

Member Function Documentation

◆ check_color_result()

int flutter::testing::DisplayListNopTest::check_color_result	(	DlColor	dst_color,
		DlColor	result_color,
		const sk_sp< DisplayList > &	dl,
		const std::string &	desc
	)

inlineprotected

Definition at line 4462 of file dl_rendering_unittests.cc.

                                                {
    int ret = 0;
    bool is_error = false;
    if (dst_color.isTransparent() && !result_color.isTransparent()) {
      ret |= kWasMTB;
      is_error = !dl->modifies_transparent_black();
    }
    if (result_color != dst_color) {
      ret |= kWasNotNop;
      is_error = (dl->op_count() == 0u);
    }
    if (is_error) {
      FML_LOG(ERROR) << std::hex << dst_color << " filters to " << result_color
                     << desc;
    }
    return ret;
  }

◆ check_image_result()

int flutter::testing::DisplayListNopTest::check_image_result	(	const std::unique_ptr< RenderResult > &	dst_data,
		const std::unique_ptr< RenderResult > &	result_data,
		const sk_sp< DisplayList > &	dl,
		const std::string &	desc
	)

inlineprotected

Definition at line 4483 of file dl_rendering_unittests.cc.

                                                {
    EXPECT_EQ(dst_data->width(), result_data->width());
    EXPECT_EQ(dst_data->height(), result_data->height());
    int all_flags = 0;
    for (int y = 0; y < dst_data->height(); y++) {
      const uint32_t* dst_pixels = dst_data->addr32(0, y);
      const uint32_t* result_pixels = result_data->addr32(0, y);
      for (int x = 0; x < dst_data->width(); x++) {
        all_flags |= check_color_result(DlColor(dst_pixels[x]),
                                        DlColor(result_pixels[x]), dl, desc);
      }
    }
    return all_flags;
  }

◆ get_output()

std::unique_ptr< RenderResult > flutter::testing::DisplayListNopTest::get_output	(	int	w,
		int	h,
		bool	snapshot,
		const std::function< void(SkCanvas *)> &	renderer
	)

inlineprotected

Definition at line 4451 of file dl_rendering_unittests.cc.

                                                    {
    auto surface = SkSurfaces::Raster(SkImageInfo::MakeN32Premul(w, h));
    SkCanvas* canvas = surface->getCanvas();
    renderer(canvas);
    return std::make_unique<SkRenderResult>(surface, snapshot);
  }

◆ report_results()

void flutter::testing::DisplayListNopTest::report_results	(	int	all_flags,
		const sk_sp< DisplayList > &	dl,
		const std::string &	desc
	)

inlineprotected

Definition at line 4501 of file dl_rendering_unittests.cc.

                                             {
    if (!dl->modifies_transparent_black()) {
      EXPECT_TRUE((all_flags & kWasMTB) == 0);
    } else if ((all_flags & kWasMTB) == 0) {
      FML_LOG(INFO) << "combination does not affect transparency: " << desc;
    }
    if (dl->op_count() == 0u) {
      EXPECT_TRUE((all_flags & kWasNotNop) == 0);
    } else if ((all_flags & kWasNotNop) == 0) {
      FML_LOG(INFO) << "combination could be classified as a nop: " << desc;
    }
  };

◆ test_attributes_image()

void flutter::testing::DisplayListNopTest::test_attributes_image	(	DlBlendMode	mode,
		DlColor	color,
		DlColorFilter *	color_filter,
		DlImageFilter *	image_filter
	)

inlineprotected

Definition at line 4593 of file dl_rendering_unittests.cc.

                                                          {
    // if (true) { return; }
    std::stringstream desc_stream;
    desc_stream << " rendering with: ";
    desc_stream << BlendModeToString(mode);
    desc_stream << "/" << color;
    std::string cf_mtb = color_filter
                             ? color_filter->modifies_transparent_black()
                                   ? "modifies transparency"
                                   : "preserves transparency"
                             : "no filter";
    desc_stream << ", CF: " << cf_mtb;
    std::string if_mtb = image_filter
                             ? image_filter->modifies_transparent_black()
                                   ? "modifies transparency"
                                   : "preserves transparency"
                             : "no filter";
    desc_stream << ", IF: " << if_mtb;
    std::string desc = desc_stream.str();
 
    DisplayListBuilder builder({0.0f, 0.0f, 100.0f, 100.0f});
    DlPaint paint = DlPaint(color)                     //
                        .setBlendMode(mode)            //
                        .setColorFilter(color_filter)  //
                        .setImageFilter(image_filter);
    builder.DrawImage(DlImage::Make(test_image_src_data->image()), {0, 0},
                      DlImageSampling::kNearestNeighbor, &paint);
    auto dl = builder.Build();
 
    int w = test_image_src_data->width();
    int h = test_image_src_data->height();
    auto sk_mode = static_cast<SkBlendMode>(mode);
    SkPaint sk_paint;
    sk_paint.setBlendMode(sk_mode);
    sk_paint.setColor(ToSk(color));
    sk_paint.setColorFilter(ToSk(color_filter));
    sk_paint.setImageFilter(ToSk(image_filter));
    for (auto& back_end : CanvasCompareTester::TestBackends) {
      auto provider = CanvasCompareTester::GetProvider(back_end);
      auto result_surface = provider->MakeOffscreenSurface(
          w, h, DlSurfaceProvider::kN32PremulPixelFormat);
      SkCanvas* result_canvas = result_surface->sk_surface()->getCanvas();
      result_canvas->clear(SK_ColorTRANSPARENT);
      result_canvas->drawImage(test_image_dst_data->image(), 0, 0);
      result_canvas->drawImage(test_image_src_data->image(), 0, 0,
                               SkSamplingOptions(), &sk_paint);
      if (GrDirectContext* direct_context = GrAsDirectContext(
              result_surface->sk_surface()->recordingContext())) {
        direct_context->flushAndSubmit();
        direct_context->flushAndSubmit(result_surface->sk_surface().get(),
                                       GrSyncCpu::kYes);
      }
      std::unique_ptr<RenderResult> result_pixels =
          std::make_unique<SkRenderResult>(result_surface->sk_surface());
 
      int all_flags =
          check_image_result(test_image_dst_data, result_pixels, dl, desc);
      report_results(all_flags, dl, desc);
    }
  };

◆ test_mode_color_via_filter()

void flutter::testing::DisplayListNopTest::test_mode_color_via_filter	(	DlBlendMode	mode,
		DlColor	color
	)

inlineprotected

Definition at line 4516 of file dl_rendering_unittests.cc.

                                                                   {
    std::stringstream desc_stream;
    desc_stream << " using SkColorFilter::filterColor() with: ";
    desc_stream << BlendModeToString(mode);
    desc_stream << "/" << color;
    std::string desc = desc_stream.str();
    DisplayListBuilder builder({0.0f, 0.0f, 100.0f, 100.0f});
    DlPaint paint = DlPaint(color).setBlendMode(mode);
    builder.DrawRect({0.0f, 0.0f, 10.0f, 10.0f}, paint);
    auto dl = builder.Build();
    if (dl->modifies_transparent_black()) {
      ASSERT_TRUE(dl->op_count() != 0u);
    }
 
    auto sk_mode = static_cast<SkBlendMode>(mode);
    auto sk_color_filter = SkColorFilters::Blend(ToSk(color), sk_mode);
    auto srgb = SkColorSpace::MakeSRGB();
    int all_flags = 0;
    if (sk_color_filter) {
      for (DlColor dst_color : test_dst_colors) {
        SkColor4f dst_color_f = SkColor4f::FromColor(ToSk(dst_color));
        DlColor result = DlColor(
            sk_color_filter->filterColor4f(dst_color_f, srgb.get(), srgb.get())
                .toSkColor());
        all_flags |= check_color_result(dst_color, result, dl, desc);
      }
      if ((all_flags & kWasMTB) != 0) {
        EXPECT_FALSE(sk_color_filter->isAlphaUnchanged());
      }
    }
    report_results(all_flags, dl, desc);
  };

◆ test_mode_color_via_rendering()

void flutter::testing::DisplayListNopTest::test_mode_color_via_rendering	(	DlBlendMode	mode,
		DlColor	color
	)

inlineprotected

Definition at line 4549 of file dl_rendering_unittests.cc.

                                                                      {
    std::stringstream desc_stream;
    desc_stream << " rendering with: ";
    desc_stream << BlendModeToString(mode);
    desc_stream << "/" << color;
    std::string desc = desc_stream.str();
    auto test_image = test_data->image();
    SkRect test_bounds =
        SkRect::MakeWH(test_image->width(), test_image->height());
    DisplayListBuilder builder(test_bounds);
    DlPaint dl_paint = DlPaint(color).setBlendMode(mode);
    builder.DrawRect(test_bounds, dl_paint);
    auto dl = builder.Build();
    bool dl_is_elided = dl->op_count() == 0u;
    bool dl_affects_transparent_pixels = dl->modifies_transparent_black();
    ASSERT_TRUE(!dl_is_elided || !dl_affects_transparent_pixels);
 
    auto sk_mode = static_cast<SkBlendMode>(mode);
    SkPaint sk_paint;
    sk_paint.setBlendMode(sk_mode);
    sk_paint.setColor(ToSk(color));
    for (auto& back_end : CanvasCompareTester::TestBackends) {
      auto provider = CanvasCompareTester::GetProvider(back_end);
      auto result_surface = provider->MakeOffscreenSurface(
          test_image->width(), test_image->height(),
          DlSurfaceProvider::kN32PremulPixelFormat);
      SkCanvas* result_canvas = result_surface->sk_surface()->getCanvas();
      result_canvas->clear(SK_ColorTRANSPARENT);
      result_canvas->drawImage(test_image.get(), 0, 0);
      result_canvas->drawRect(test_bounds, sk_paint);
      if (GrDirectContext* direct_context = GrAsDirectContext(
              result_surface->sk_surface()->recordingContext())) {
        direct_context->flushAndSubmit();
        direct_context->flushAndSubmit(result_surface->sk_surface().get(),
                                       GrSyncCpu::kYes);
      }
      const std::unique_ptr<RenderResult> result_pixels =
          std::make_unique<SkRenderResult>(result_surface->sk_surface());
 
      int all_flags = check_image_result(test_data, result_pixels, dl, desc);
      report_results(all_flags, dl, desc);
    }
  };