Tools/TestWebKitAPI/Tests/WebCore/DisplayListTests.cpp - WebKit - Git at Google

 /*
  * Copyright (C) 2020-2021 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include "config.h"

 #include <WebCore/DisplayList.h>
 #include <WebCore/DisplayListItems.h>
 #include <WebCore/DisplayListIterator.h>
 #include <WebCore/Filter.h>
 #include <WebCore/Gradient.h>
 #include <WebCore/InMemoryDisplayList.h>

 namespace TestWebKitAPI {
 using namespace WebCore;
 using DisplayList::DisplayList;
 using namespace DisplayList;

 constexpr size_t globalItemBufferCapacity = 1 << 12;
 static uint8_t globalItemBuffer[globalItemBufferCapacity];

 static Ref<Gradient> createGradient()
 {
     auto gradient = Gradient::create(Gradient::ConicData { { 0., 0. }, 1.25 }, { ColorInterpolationMethod::SRGB { }, AlphaPremultiplication::Unpremultiplied });
     gradient->addColorStop({ 0.1, Color::red });
     gradient->addColorStop({ 0.5, Color::green });
     gradient->addColorStop({ 0.9, Color::blue });
     return gradient;
 }

 static Path createComplexPath()
 {
     Path path;
     path.moveTo({ 10., 10. });
     path.addLineTo({ 50., 50. });
     path.addQuadCurveTo({ 100., 100. }, { 0., 200. });
     path.addLineTo({ 10., 10. });
     return path;
 }

 TEST(DisplayListTests, AppendItems)
 {
     InMemoryDisplayList list;

     EXPECT_TRUE(list.isEmpty());

     auto gradient = createGradient();
     auto path = createComplexPath();

     for (int i = 0; i < 50; ++i) {
         list.append<SetStrokeThickness>(1.5);
         list.append<FillPath>(path);
         list.append<FillRectWithGradient>(FloatRect { 1., 1., 10., 10. }, gradient);
         list.append<SetInlineFillColor>(Color::red);
 #if ENABLE(INLINE_PATH_DATA)
         list.append<StrokeLine>(LineData {{ 0., 0. }, { 10., 15. }});
 #endif
     }

     EXPECT_FALSE(list.isEmpty());

     bool observedUnexpectedItem = false;
     for (auto displayListItem : list) {
         auto handle = displayListItem->item;
         switch (handle.type()) {
         case ItemType::SetStrokeThickness: {
             EXPECT_FALSE(handle.isDrawingItem());
             EXPECT_TRUE(handle.is<SetStrokeThickness>());
             auto& item = handle.get<SetStrokeThickness>();
             EXPECT_EQ(item.thickness(), 1.5);
             break;
         }
         case ItemType::FillPath: {
             EXPECT_TRUE(handle.isDrawingItem());
             EXPECT_TRUE(handle.is<FillPath>());
             auto& item = handle.get<FillPath>();
             EXPECT_EQ(item.path().platformPath(), path.platformPath());
             break;
         }
         case ItemType::FillRectWithGradient: {
             EXPECT_TRUE(handle.isDrawingItem());
             EXPECT_TRUE(handle.is<FillRectWithGradient>());
             auto& item = handle.get<FillRectWithGradient>();
             EXPECT_EQ(item.rect(), FloatRect(1., 1., 10., 10.));
             EXPECT_EQ(&item.gradient(), gradient.ptr());
             break;
         }
         case ItemType::SetInlineFillColor: {
             EXPECT_FALSE(handle.isDrawingItem());
             EXPECT_TRUE(handle.is<SetInlineFillColor>());
             auto& item = handle.get<SetInlineFillColor>();
             EXPECT_EQ(item.color(), Color::red);
             break;
         }
 #if ENABLE(INLINE_PATH_DATA)
         case ItemType::StrokeLine: {
             EXPECT_TRUE(handle.isDrawingItem());
             EXPECT_TRUE(handle.is<StrokeLine>());
             auto& item = handle.get<StrokeLine>();
             EXPECT_EQ(item.start(), FloatPoint(0, 0));
             EXPECT_EQ(item.end(), FloatPoint(10., 15.));
             break;
         }
 #endif
         default: {
             observedUnexpectedItem = true;
             break;
         }
         }
     }

     EXPECT_FALSE(observedUnexpectedItem);
     EXPECT_GT(list.sizeInBytes(), 0U);

     list.clear();

     observedUnexpectedItem = false;
     for (auto itemAndExtent : list) {
         UNUSED_PARAM(itemAndExtent);
         observedUnexpectedItem = true;
     }

     EXPECT_TRUE(list.isEmpty());
     EXPECT_EQ(list.sizeInBytes(), 0U);
     EXPECT_FALSE(observedUnexpectedItem);

     list.append<FillRectWithColor>(FloatRect { 0, 0, 100, 100 }, Color::black);

     for (auto displayListItem : list) {
         auto handle = displayListItem->item;
         EXPECT_EQ(handle.type(), ItemType::FillRectWithColor);
         EXPECT_TRUE(handle.is<FillRectWithColor>());

         auto& item = handle.get<FillRectWithColor>();
         EXPECT_EQ(*item.color().tryGetAsSRGBABytes(), Color::black);
         EXPECT_EQ(item.rect(), FloatRect(0, 0, 100, 100));
     }

     EXPECT_FALSE(list.isEmpty());
     EXPECT_GT(list.sizeInBytes(), 0U);
 }

 TEST(DisplayListTests, ItemBufferClient)
 {
     Vector<StrokePath> strokePathItems;
     static ItemBufferIdentifier globalBufferIdentifier = ItemBufferIdentifier::generate();

     class StrokePathReader : public ItemBufferReadingClient {
     public:
         StrokePathReader(const Vector<StrokePath>& items)
             : m_items(items)
         {
         }

     private:
         std::optional<ItemHandle> WARN_UNUSED_RETURN decodeItem(const uint8_t* data, size_t dataLength, ItemType type, uint8_t* handleLocation) final
         {
             EXPECT_EQ(type, ItemType::StrokePath);
             EXPECT_EQ(dataLength, sizeof(size_t));
             new (handleLocation + sizeof(uint64_t)) StrokePath(m_items[*reinterpret_cast<const size_t*>(data)]);
             return {{ handleLocation }};
         }

         const Vector<StrokePath>& m_items;
     };

     class StrokePathWriter : public ItemBufferWritingClient {
     public:
         StrokePathWriter(Vector<StrokePath>& items)
             : m_items(items)
         {
         }

     private:
         ItemBufferHandle createItemBuffer(size_t capacity) final
         {
             EXPECT_LT(capacity, globalItemBufferCapacity);
             return { globalBufferIdentifier, globalItemBuffer, globalItemBufferCapacity };
         }

         RefPtr<FragmentedSharedBuffer> encodeItemOutOfLine(const DisplayListItem& displayListItem) const final
         {
             auto index = m_items.size();
             m_items.append(std::get<StrokePath>(displayListItem));
             return SharedBuffer::create(reinterpret_cast<uint8_t*>(&index), sizeof(size_t));
         }

         Vector<StrokePath>& m_items;
     };

     DisplayList list;
     StrokePathWriter writer { strokePathItems };
     list.setItemBufferWritingClient(&writer);

     auto path = createComplexPath();
     list.append<SetInlineStrokeColor>(Color::blue);
     list.append<StrokePath>(path);
     list.append<SetInlineStrokeColor>(Color::red);
     list.append<StrokePath>(path);

     DisplayList shallowCopy {{ ItemBufferHandle { globalBufferIdentifier, globalItemBuffer, list.sizeInBytes() } }};
     StrokePathReader reader { strokePathItems };
     shallowCopy.setItemBufferReadingClient(&reader);

     Vector<ItemType> itemTypes;
     for (auto displayListItem : shallowCopy)
         itemTypes.append(displayListItem->item.type());

     EXPECT_FALSE(shallowCopy.isEmpty());
     EXPECT_EQ(itemTypes.size(), 4U);
     EXPECT_EQ(itemTypes[0], ItemType::SetInlineStrokeColor);
     EXPECT_EQ(itemTypes[1], ItemType::StrokePath);
     EXPECT_EQ(itemTypes[2], ItemType::SetInlineStrokeColor);
     EXPECT_EQ(itemTypes[3], ItemType::StrokePath);
 }

 } // namespace TestWebKitAPI
	/*
	* Copyright (C) 2020-2021 Apple Inc. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
	* THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include "config.h"

	#include <WebCore/DisplayList.h>
	#include <WebCore/DisplayListItems.h>
	#include <WebCore/DisplayListIterator.h>
	#include <WebCore/Filter.h>
	#include <WebCore/Gradient.h>
	#include <WebCore/InMemoryDisplayList.h>

	namespace TestWebKitAPI {
	using namespace WebCore;
	using DisplayList::DisplayList;
	using namespace DisplayList;

	constexpr size_t globalItemBufferCapacity = 1 << 12;
	static uint8_t globalItemBuffer[globalItemBufferCapacity];

	static Ref<Gradient> createGradient()
	{
	auto gradient = Gradient::create(Gradient::ConicData { { 0., 0. }, 1.25 }, { ColorInterpolationMethod::SRGB { }, AlphaPremultiplication::Unpremultiplied });
	gradient->addColorStop({ 0.1, Color::red });
	gradient->addColorStop({ 0.5, Color::green });
	gradient->addColorStop({ 0.9, Color::blue });
	return gradient;
	}

	static Path createComplexPath()
	{
	Path path;
	path.moveTo({ 10., 10. });
	path.addLineTo({ 50., 50. });
	path.addQuadCurveTo({ 100., 100. }, { 0., 200. });
	path.addLineTo({ 10., 10. });
	return path;
	}

	TEST(DisplayListTests, AppendItems)
	{
	InMemoryDisplayList list;

	EXPECT_TRUE(list.isEmpty());

	auto gradient = createGradient();
	auto path = createComplexPath();

	for (int i = 0; i < 50; ++i) {
	list.append<SetStrokeThickness>(1.5);
	list.append<FillPath>(path);
	list.append<FillRectWithGradient>(FloatRect { 1., 1., 10., 10. }, gradient);
	list.append<SetInlineFillColor>(Color::red);
	#if ENABLE(INLINE_PATH_DATA)
	list.append<StrokeLine>(LineData {{ 0., 0. }, { 10., 15. }});
	#endif
	}

	EXPECT_FALSE(list.isEmpty());

	bool observedUnexpectedItem = false;
	for (auto displayListItem : list) {
	auto handle = displayListItem->item;
	switch (handle.type()) {
	case ItemType::SetStrokeThickness: {
	EXPECT_FALSE(handle.isDrawingItem());
	EXPECT_TRUE(handle.is<SetStrokeThickness>());
	auto& item = handle.get<SetStrokeThickness>();
	EXPECT_EQ(item.thickness(), 1.5);
	break;
	}
	case ItemType::FillPath: {
	EXPECT_TRUE(handle.isDrawingItem());
	EXPECT_TRUE(handle.is<FillPath>());
	auto& item = handle.get<FillPath>();
	EXPECT_EQ(item.path().platformPath(), path.platformPath());
	break;
	}
	case ItemType::FillRectWithGradient: {
	EXPECT_TRUE(handle.isDrawingItem());
	EXPECT_TRUE(handle.is<FillRectWithGradient>());
	auto& item = handle.get<FillRectWithGradient>();
	EXPECT_EQ(item.rect(), FloatRect(1., 1., 10., 10.));
	EXPECT_EQ(&item.gradient(), gradient.ptr());
	break;
	}
	case ItemType::SetInlineFillColor: {
	EXPECT_FALSE(handle.isDrawingItem());
	EXPECT_TRUE(handle.is<SetInlineFillColor>());
	auto& item = handle.get<SetInlineFillColor>();
	EXPECT_EQ(item.color(), Color::red);
	break;
	}
	#if ENABLE(INLINE_PATH_DATA)
	case ItemType::StrokeLine: {
	EXPECT_TRUE(handle.isDrawingItem());
	EXPECT_TRUE(handle.is<StrokeLine>());
	auto& item = handle.get<StrokeLine>();
	EXPECT_EQ(item.start(), FloatPoint(0, 0));
	EXPECT_EQ(item.end(), FloatPoint(10., 15.));
	break;
	}
	#endif
	default: {
	observedUnexpectedItem = true;
	break;
	}
	}
	}

	EXPECT_FALSE(observedUnexpectedItem);
	EXPECT_GT(list.sizeInBytes(), 0U);

	list.clear();

	observedUnexpectedItem = false;
	for (auto itemAndExtent : list) {
	UNUSED_PARAM(itemAndExtent);
	observedUnexpectedItem = true;
	}

	EXPECT_TRUE(list.isEmpty());
	EXPECT_EQ(list.sizeInBytes(), 0U);
	EXPECT_FALSE(observedUnexpectedItem);

	list.append<FillRectWithColor>(FloatRect { 0, 0, 100, 100 }, Color::black);

	for (auto displayListItem : list) {
	auto handle = displayListItem->item;
	EXPECT_EQ(handle.type(), ItemType::FillRectWithColor);
	EXPECT_TRUE(handle.is<FillRectWithColor>());

	auto& item = handle.get<FillRectWithColor>();
	EXPECT_EQ(*item.color().tryGetAsSRGBABytes(), Color::black);
	EXPECT_EQ(item.rect(), FloatRect(0, 0, 100, 100));
	}

	EXPECT_FALSE(list.isEmpty());
	EXPECT_GT(list.sizeInBytes(), 0U);
	}

	TEST(DisplayListTests, ItemBufferClient)
	{
	Vector<StrokePath> strokePathItems;
	static ItemBufferIdentifier globalBufferIdentifier = ItemBufferIdentifier::generate();

	class StrokePathReader : public ItemBufferReadingClient {
	public:
	StrokePathReader(const Vector<StrokePath>& items)
	: m_items(items)
	{
	}

	private:
	std::optional<ItemHandle> WARN_UNUSED_RETURN decodeItem(const uint8_t* data, size_t dataLength, ItemType type, uint8_t* handleLocation) final
	{
	EXPECT_EQ(type, ItemType::StrokePath);
	EXPECT_EQ(dataLength, sizeof(size_t));
	new (handleLocation + sizeof(uint64_t)) StrokePath(m_items[reinterpret_cast<const size_t>(data)]);
	return {{ handleLocation }};
	}

	const Vector<StrokePath>& m_items;
	};

	class StrokePathWriter : public ItemBufferWritingClient {
	public:
	StrokePathWriter(Vector<StrokePath>& items)
	: m_items(items)
	{
	}

	private:
	ItemBufferHandle createItemBuffer(size_t capacity) final
	{
	EXPECT_LT(capacity, globalItemBufferCapacity);
	return { globalBufferIdentifier, globalItemBuffer, globalItemBufferCapacity };
	}

	RefPtr<FragmentedSharedBuffer> encodeItemOutOfLine(const DisplayListItem& displayListItem) const final
	{
	auto index = m_items.size();
	m_items.append(std::get<StrokePath>(displayListItem));
	return SharedBuffer::create(reinterpret_cast<uint8_t*>(&index), sizeof(size_t));
	}

	Vector<StrokePath>& m_items;
	};

	DisplayList list;
	StrokePathWriter writer { strokePathItems };
	list.setItemBufferWritingClient(&writer);

	auto path = createComplexPath();
	list.append<SetInlineStrokeColor>(Color::blue);
	list.append<StrokePath>(path);
	list.append<SetInlineStrokeColor>(Color::red);
	list.append<StrokePath>(path);

	DisplayList shallowCopy {{ ItemBufferHandle { globalBufferIdentifier, globalItemBuffer, list.sizeInBytes() } }};
	StrokePathReader reader { strokePathItems };
	shallowCopy.setItemBufferReadingClient(&reader);

	Vector<ItemType> itemTypes;
	for (auto displayListItem : shallowCopy)
	itemTypes.append(displayListItem->item.type());

	EXPECT_FALSE(shallowCopy.isEmpty());
	EXPECT_EQ(itemTypes.size(), 4U);
	EXPECT_EQ(itemTypes[0], ItemType::SetInlineStrokeColor);
	EXPECT_EQ(itemTypes[1], ItemType::StrokePath);
	EXPECT_EQ(itemTypes[2], ItemType::SetInlineStrokeColor);
	EXPECT_EQ(itemTypes[3], ItemType::StrokePath);
	}

	} // namespace TestWebKitAPI