libs/hwui/tests/unit/RenderNodeTests.cpp - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <VectorDrawable.h>
 #include <gtest/gtest.h>

 #include "AnimationContext.h"
 #include "DamageAccumulator.h"
 #include "IContextFactory.h"
 #include "RenderNode.h"
 #include "TreeInfo.h"
 #include "renderthread/CanvasContext.h"
 #include "tests/common/TestUtils.h"
 #include "utils/Color.h"

 using namespace android;
 using namespace android::uirenderer;
 using namespace android::uirenderer::renderthread;

 class ContextFactory : public android::uirenderer::IContextFactory {
 public:
     android::uirenderer::AnimationContext* createAnimationContext(
             android::uirenderer::renderthread::TimeLord& clock) override {
         return new android::uirenderer::AnimationContext(clock);
     }
 };

 TEST(RenderNode, hasParents) {
     auto child = TestUtils::createNode(0, 0, 200, 400, [](RenderProperties& props, Canvas& canvas) {
         canvas.drawColor(Color::Red_500, SkBlendMode::kSrcOver);
     });
     auto parent = TestUtils::createNode(0, 0, 200, 400,
                                         [&child](RenderProperties& props, Canvas& canvas) {
                                             canvas.drawRenderNode(child.get());
                                         });

     TestUtils::syncHierarchyPropertiesAndDisplayList(parent);

     EXPECT_TRUE(child->hasParents()) << "Child node has no parent";
     EXPECT_FALSE(parent->hasParents()) << "Root node shouldn't have any parents";

     TestUtils::recordNode(*parent, [](Canvas& canvas) {
         canvas.drawColor(Color::Amber_500, SkBlendMode::kSrcOver);
     });

     EXPECT_TRUE(child->hasParents()) << "Child should still have a parent";
     EXPECT_FALSE(parent->hasParents()) << "Root node shouldn't have any parents";

     TestUtils::syncHierarchyPropertiesAndDisplayList(parent);

     EXPECT_FALSE(child->hasParents()) << "Child should be removed";
     EXPECT_FALSE(parent->hasParents()) << "Root node shouldn't have any parents";
 }

 TEST(RenderNode, validity) {
     auto child = TestUtils::createNode(0, 0, 200, 400, [](RenderProperties& props, Canvas& canvas) {
         canvas.drawColor(Color::Red_500, SkBlendMode::kSrcOver);
     });
     auto parent = TestUtils::createNode(0, 0, 200, 400,
                                         [&child](RenderProperties& props, Canvas& canvas) {
                                             canvas.drawRenderNode(child.get());
                                         });

     EXPECT_TRUE(child->isValid());
     EXPECT_TRUE(parent->isValid());
     EXPECT_TRUE(child->nothingToDraw());
     EXPECT_TRUE(parent->nothingToDraw());

     TestUtils::syncHierarchyPropertiesAndDisplayList(parent);

     EXPECT_TRUE(child->isValid());
     EXPECT_TRUE(parent->isValid());
     EXPECT_FALSE(child->nothingToDraw());
     EXPECT_FALSE(parent->nothingToDraw());

     TestUtils::recordNode(*parent, [](Canvas& canvas) {
         canvas.drawColor(Color::Amber_500, SkBlendMode::kSrcOver);
     });

     EXPECT_TRUE(child->isValid());
     EXPECT_TRUE(parent->isValid());
     EXPECT_FALSE(child->nothingToDraw());
     EXPECT_FALSE(parent->nothingToDraw());

     TestUtils::syncHierarchyPropertiesAndDisplayList(parent);

     EXPECT_FALSE(child->isValid());
     EXPECT_TRUE(parent->isValid());
     EXPECT_TRUE(child->nothingToDraw());
     EXPECT_FALSE(parent->nothingToDraw());

     TestUtils::recordNode(*child, [](Canvas& canvas) {
         canvas.drawColor(Color::Amber_500, SkBlendMode::kSrcOver);
     });

     EXPECT_TRUE(child->isValid());
     EXPECT_TRUE(child->nothingToDraw());

     TestUtils::recordNode(*parent,
                           [&child](Canvas& canvas) { canvas.drawRenderNode(child.get()); });

     TestUtils::syncHierarchyPropertiesAndDisplayList(parent);

     EXPECT_TRUE(child->isValid());
     EXPECT_TRUE(parent->isValid());
     EXPECT_FALSE(child->nothingToDraw());
     EXPECT_FALSE(parent->nothingToDraw());

     parent->destroyHardwareResources();

     EXPECT_FALSE(child->isValid());
     EXPECT_FALSE(parent->isValid());
     EXPECT_TRUE(child->nothingToDraw());
     EXPECT_TRUE(parent->nothingToDraw());
 }

 TEST(RenderNode, multiTreeValidity) {
     auto child = TestUtils::createNode(0, 0, 200, 400, [](RenderProperties& props, Canvas& canvas) {
         canvas.drawColor(Color::Red_500, SkBlendMode::kSrcOver);
     });
     auto parent1 = TestUtils::createNode(0, 0, 200, 400,
                                          [&child](RenderProperties& props, Canvas& canvas) {
                                              canvas.drawRenderNode(child.get());
                                          });
     auto parent2 = TestUtils::createNode(0, 0, 200, 400,
                                          [&child](RenderProperties& props, Canvas& canvas) {
                                              canvas.drawRenderNode(child.get());
                                          });

     EXPECT_TRUE(child->isValid());
     EXPECT_TRUE(parent1->isValid());
     EXPECT_TRUE(parent2->isValid());
     EXPECT_TRUE(child->nothingToDraw());
     EXPECT_TRUE(parent1->nothingToDraw());
     EXPECT_TRUE(parent2->nothingToDraw());

     TestUtils::syncHierarchyPropertiesAndDisplayList(parent1);

     EXPECT_TRUE(child->isValid());
     EXPECT_TRUE(parent1->isValid());
     EXPECT_TRUE(parent2->isValid());
     EXPECT_FALSE(child->nothingToDraw());
     EXPECT_FALSE(parent1->nothingToDraw());
     EXPECT_TRUE(parent2->nothingToDraw());

     TestUtils::syncHierarchyPropertiesAndDisplayList(parent2);

     EXPECT_TRUE(child->isValid());
     EXPECT_TRUE(parent1->isValid());
     EXPECT_TRUE(parent2->isValid());
     EXPECT_FALSE(child->nothingToDraw());
     EXPECT_FALSE(parent1->nothingToDraw());
     EXPECT_FALSE(parent2->nothingToDraw());

     TestUtils::recordNode(*parent1, [](Canvas& canvas) {
         canvas.drawColor(Color::Amber_500, SkBlendMode::kSrcOver);
     });

     TestUtils::syncHierarchyPropertiesAndDisplayList(parent1);

     EXPECT_TRUE(child->isValid());
     EXPECT_TRUE(parent1->isValid());
     EXPECT_TRUE(parent2->isValid());
     EXPECT_FALSE(child->nothingToDraw());
     EXPECT_FALSE(parent1->nothingToDraw());
     EXPECT_FALSE(parent2->nothingToDraw());

     TestUtils::recordNode(*parent2, [](Canvas& canvas) {
         canvas.drawColor(Color::Amber_500, SkBlendMode::kSrcOver);
     });

     TestUtils::syncHierarchyPropertiesAndDisplayList(parent2);

     EXPECT_FALSE(child->isValid());
     EXPECT_TRUE(parent1->isValid());
     EXPECT_TRUE(parent2->isValid());
     EXPECT_TRUE(child->nothingToDraw());
     EXPECT_FALSE(parent1->nothingToDraw());
     EXPECT_FALSE(parent2->nothingToDraw());

     TestUtils::recordNode(*child, [](Canvas& canvas) {
         canvas.drawColor(Color::Red_500, SkBlendMode::kSrcOver);
     });
     TestUtils::syncHierarchyPropertiesAndDisplayList(child);

     TestUtils::recordNode(*parent1,
                           [&child](Canvas& canvas) { canvas.drawRenderNode(child.get()); });
     TestUtils::syncHierarchyPropertiesAndDisplayList(parent1);

     TestUtils::recordNode(*parent2,
                           [&child](Canvas& canvas) { canvas.drawRenderNode(child.get()); });
     TestUtils::syncHierarchyPropertiesAndDisplayList(parent2);

     EXPECT_TRUE(child->isValid());
     EXPECT_TRUE(parent1->isValid());
     EXPECT_TRUE(parent2->isValid());
     EXPECT_FALSE(child->nothingToDraw());
     EXPECT_FALSE(parent1->nothingToDraw());
     EXPECT_FALSE(parent2->nothingToDraw());

     parent1->destroyHardwareResources();

     EXPECT_TRUE(child->isValid());
     EXPECT_FALSE(parent1->isValid());
     EXPECT_TRUE(parent2->isValid());
     EXPECT_FALSE(child->nothingToDraw());
     EXPECT_TRUE(parent1->nothingToDraw());
     EXPECT_FALSE(parent2->nothingToDraw());

     parent2->destroyHardwareResources();

     EXPECT_FALSE(child->isValid());
     EXPECT_FALSE(parent1->isValid());
     EXPECT_FALSE(parent2->isValid());
     EXPECT_TRUE(child->nothingToDraw());
     EXPECT_TRUE(parent1->nothingToDraw());
     EXPECT_TRUE(parent2->nothingToDraw());
 }

 TEST(RenderNode, releasedCallback) {
     int functor = TestUtils::createMockFunctor();

     auto node = TestUtils::createNode(0, 0, 200, 400, [&](RenderProperties& props, Canvas& canvas) {
         canvas.drawWebViewFunctor(functor);
     });
     TestUtils::runOnRenderThreadUnmanaged([&] (RenderThread&) {
         TestUtils::syncHierarchyPropertiesAndDisplayList(node);
     });
     auto& counts = TestUtils::countsForFunctor(functor);
     EXPECT_EQ(1, counts.sync);
     EXPECT_EQ(0, counts.destroyed);

     TestUtils::recordNode(*node, [&](Canvas& canvas) {
         canvas.drawWebViewFunctor(functor);
     });
     EXPECT_EQ(1, counts.sync);
     EXPECT_EQ(0, counts.destroyed);

     TestUtils::runOnRenderThreadUnmanaged([&] (RenderThread&) {
         TestUtils::syncHierarchyPropertiesAndDisplayList(node);
     });
     EXPECT_EQ(2, counts.sync);
     EXPECT_EQ(0, counts.destroyed);

     WebViewFunctor_release(functor);
     EXPECT_EQ(2, counts.sync);
     EXPECT_EQ(0, counts.destroyed);

     TestUtils::recordNode(*node, [](Canvas& canvas) {});
     TestUtils::runOnRenderThreadUnmanaged([&] (RenderThread&) {
         TestUtils::syncHierarchyPropertiesAndDisplayList(node);
     });
     // Fence on any remaining post'd work
     TestUtils::runOnRenderThreadUnmanaged([] (RenderThread&) {});
     EXPECT_EQ(2, counts.sync);
     EXPECT_EQ(1, counts.destroyed);
 }

 RENDERTHREAD_TEST(RenderNode, prepareTree_nullableDisplayList) {
     auto rootNode = TestUtils::createNode(0, 0, 200, 400, nullptr);
     ContextFactory contextFactory;
     std::unique_ptr<CanvasContext> canvasContext(
             CanvasContext::create(renderThread, false, rootNode.get(), &contextFactory, 0, 0));
     TreeInfo info(TreeInfo::MODE_RT_ONLY, *canvasContext.get());
     DamageAccumulator damageAccumulator;
     info.damageAccumulator = &damageAccumulator;

     {
         auto nonNullDLNode =
                 TestUtils::createNode(0, 0, 200, 400, [](RenderProperties& props, Canvas& canvas) {
                     canvas.drawColor(Color::Red_500, SkBlendMode::kSrcOver);
                 });
         TestUtils::syncHierarchyPropertiesAndDisplayList(nonNullDLNode);
         EXPECT_TRUE(nonNullDLNode->getDisplayList());
         nonNullDLNode->prepareTree(info);
     }

     {
         auto nullDLNode = TestUtils::createNode(0, 0, 200, 400, nullptr);
         TestUtils::syncHierarchyPropertiesAndDisplayList(nullDLNode);
         EXPECT_FALSE(nullDLNode->getDisplayList());
         nullDLNode->prepareTree(info);
     }

     canvasContext->destroy();
 }

 // TODO: Is this supposed to work in SkiaGL/SkiaVK?
 RENDERTHREAD_TEST(DISABLED_RenderNode, prepareTree_HwLayer_AVD_enqueueDamage) {
     VectorDrawable::Group* group = new VectorDrawable::Group();
     sp<VectorDrawableRoot> vectorDrawable(new VectorDrawableRoot(group));

     auto rootNode =
             TestUtils::createNode(0, 0, 200, 400, [&](RenderProperties& props, Canvas& canvas) {
                 canvas.drawVectorDrawable(vectorDrawable.get());
             });
     ContextFactory contextFactory;
     std::unique_ptr<CanvasContext> canvasContext(
             CanvasContext::create(renderThread, false, rootNode.get(), &contextFactory, 0, 0));
     canvasContext->setSurface(nullptr);
     TreeInfo info(TreeInfo::MODE_RT_ONLY, *canvasContext.get());
     DamageAccumulator damageAccumulator;
     LayerUpdateQueue layerUpdateQueue;
     info.damageAccumulator = &damageAccumulator;
     info.layerUpdateQueue = &layerUpdateQueue;

     // Put node on HW layer
     rootNode->mutateStagingProperties().mutateLayerProperties().setType(LayerType::RenderLayer);

     TestUtils::syncHierarchyPropertiesAndDisplayList(rootNode);
     rootNode->prepareTree(info);

     // Check that the VD is in the dislay list, and the layer update queue contains the correct
     // damage rect.
     EXPECT_TRUE(rootNode->getDisplayList().hasVectorDrawables());
     ASSERT_FALSE(info.layerUpdateQueue->entries().empty());
     EXPECT_EQ(rootNode.get(), info.layerUpdateQueue->entries().at(0).renderNode.get());
     EXPECT_EQ(uirenderer::Rect(0, 0, 200, 400), info.layerUpdateQueue->entries().at(0).damage);
     canvasContext->destroy();
 }

 TEST(RenderNode, hasNoFill) {
     auto rootNode =
             TestUtils::createNode(0, 0, 200, 400, [](RenderProperties& props, Canvas& canvas) {
                 Paint paint;
                 paint.setStyle(SkPaint::Style::kStroke_Style);
                 canvas.drawRect(10, 10, 100, 100, paint);
             });

     TestUtils::syncHierarchyPropertiesAndDisplayList(rootNode);

     EXPECT_FALSE(rootNode.get()->getDisplayList().hasFill());
     EXPECT_FALSE(rootNode.get()->getDisplayList().hasText());
 }

 TEST(RenderNode, hasFill) {
     auto rootNode =
             TestUtils::createNode(0, 0, 200, 400, [](RenderProperties& props, Canvas& canvas) {
                 Paint paint;
                 paint.setStyle(SkPaint::kStrokeAndFill_Style);
                 canvas.drawRect(10, 10, 100, 100, paint);
             });

     TestUtils::syncHierarchyPropertiesAndDisplayList(rootNode);

     EXPECT_TRUE(rootNode.get()->getDisplayList().hasFill());
     EXPECT_FALSE(rootNode.get()->getDisplayList().hasText());
 }
	/*
	* Copyright (C) 2016 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <VectorDrawable.h>
	#include <gtest/gtest.h>

	#include "AnimationContext.h"
	#include "DamageAccumulator.h"
	#include "IContextFactory.h"
	#include "RenderNode.h"
	#include "TreeInfo.h"
	#include "renderthread/CanvasContext.h"
	#include "tests/common/TestUtils.h"
	#include "utils/Color.h"

	using namespace android;
	using namespace android::uirenderer;
	using namespace android::uirenderer::renderthread;

	class ContextFactory : public android::uirenderer::IContextFactory {
	public:
	android::uirenderer::AnimationContext* createAnimationContext(
	android::uirenderer::renderthread::TimeLord& clock) override {
	return new android::uirenderer::AnimationContext(clock);
	}
	};

	TEST(RenderNode, hasParents) {
	auto child = TestUtils::createNode(0, 0, 200, 400, [](RenderProperties& props, Canvas& canvas) {
	canvas.drawColor(Color::Red_500, SkBlendMode::kSrcOver);
	});
	auto parent = TestUtils::createNode(0, 0, 200, 400,
	[&child](RenderProperties& props, Canvas& canvas) {
	canvas.drawRenderNode(child.get());
	});

	TestUtils::syncHierarchyPropertiesAndDisplayList(parent);

	EXPECT_TRUE(child->hasParents()) << "Child node has no parent";
	EXPECT_FALSE(parent->hasParents()) << "Root node shouldn't have any parents";

	TestUtils::recordNode(*parent, [](Canvas& canvas) {
	canvas.drawColor(Color::Amber_500, SkBlendMode::kSrcOver);
	});

	EXPECT_TRUE(child->hasParents()) << "Child should still have a parent";
	EXPECT_FALSE(parent->hasParents()) << "Root node shouldn't have any parents";

	TestUtils::syncHierarchyPropertiesAndDisplayList(parent);

	EXPECT_FALSE(child->hasParents()) << "Child should be removed";
	EXPECT_FALSE(parent->hasParents()) << "Root node shouldn't have any parents";
	}

	TEST(RenderNode, validity) {
	auto child = TestUtils::createNode(0, 0, 200, 400, [](RenderProperties& props, Canvas& canvas) {
	canvas.drawColor(Color::Red_500, SkBlendMode::kSrcOver);
	});
	auto parent = TestUtils::createNode(0, 0, 200, 400,
	[&child](RenderProperties& props, Canvas& canvas) {
	canvas.drawRenderNode(child.get());
	});

	EXPECT_TRUE(child->isValid());
	EXPECT_TRUE(parent->isValid());
	EXPECT_TRUE(child->nothingToDraw());
	EXPECT_TRUE(parent->nothingToDraw());

	TestUtils::syncHierarchyPropertiesAndDisplayList(parent);

	EXPECT_TRUE(child->isValid());
	EXPECT_TRUE(parent->isValid());
	EXPECT_FALSE(child->nothingToDraw());
	EXPECT_FALSE(parent->nothingToDraw());

	TestUtils::recordNode(*parent, [](Canvas& canvas) {
	canvas.drawColor(Color::Amber_500, SkBlendMode::kSrcOver);
	});

	EXPECT_TRUE(child->isValid());
	EXPECT_TRUE(parent->isValid());
	EXPECT_FALSE(child->nothingToDraw());
	EXPECT_FALSE(parent->nothingToDraw());

	TestUtils::syncHierarchyPropertiesAndDisplayList(parent);

	EXPECT_FALSE(child->isValid());
	EXPECT_TRUE(parent->isValid());
	EXPECT_TRUE(child->nothingToDraw());
	EXPECT_FALSE(parent->nothingToDraw());

	TestUtils::recordNode(*child, [](Canvas& canvas) {
	canvas.drawColor(Color::Amber_500, SkBlendMode::kSrcOver);
	});

	EXPECT_TRUE(child->isValid());
	EXPECT_TRUE(child->nothingToDraw());

	TestUtils::recordNode(*parent,
	[&child](Canvas& canvas) { canvas.drawRenderNode(child.get()); });

	TestUtils::syncHierarchyPropertiesAndDisplayList(parent);

	EXPECT_TRUE(child->isValid());
	EXPECT_TRUE(parent->isValid());
	EXPECT_FALSE(child->nothingToDraw());
	EXPECT_FALSE(parent->nothingToDraw());

	parent->destroyHardwareResources();

	EXPECT_FALSE(child->isValid());
	EXPECT_FALSE(parent->isValid());
	EXPECT_TRUE(child->nothingToDraw());
	EXPECT_TRUE(parent->nothingToDraw());
	}

	TEST(RenderNode, multiTreeValidity) {
	auto child = TestUtils::createNode(0, 0, 200, 400, [](RenderProperties& props, Canvas& canvas) {
	canvas.drawColor(Color::Red_500, SkBlendMode::kSrcOver);
	});
	auto parent1 = TestUtils::createNode(0, 0, 200, 400,
	[&child](RenderProperties& props, Canvas& canvas) {
	canvas.drawRenderNode(child.get());
	});
	auto parent2 = TestUtils::createNode(0, 0, 200, 400,
	[&child](RenderProperties& props, Canvas& canvas) {
	canvas.drawRenderNode(child.get());
	});

	EXPECT_TRUE(child->isValid());
	EXPECT_TRUE(parent1->isValid());
	EXPECT_TRUE(parent2->isValid());
	EXPECT_TRUE(child->nothingToDraw());
	EXPECT_TRUE(parent1->nothingToDraw());
	EXPECT_TRUE(parent2->nothingToDraw());

	TestUtils::syncHierarchyPropertiesAndDisplayList(parent1);

	EXPECT_TRUE(child->isValid());
	EXPECT_TRUE(parent1->isValid());
	EXPECT_TRUE(parent2->isValid());
	EXPECT_FALSE(child->nothingToDraw());
	EXPECT_FALSE(parent1->nothingToDraw());
	EXPECT_TRUE(parent2->nothingToDraw());

	TestUtils::syncHierarchyPropertiesAndDisplayList(parent2);

	EXPECT_TRUE(child->isValid());
	EXPECT_TRUE(parent1->isValid());
	EXPECT_TRUE(parent2->isValid());
	EXPECT_FALSE(child->nothingToDraw());
	EXPECT_FALSE(parent1->nothingToDraw());
	EXPECT_FALSE(parent2->nothingToDraw());

	TestUtils::recordNode(*parent1, [](Canvas& canvas) {
	canvas.drawColor(Color::Amber_500, SkBlendMode::kSrcOver);
	});

	TestUtils::syncHierarchyPropertiesAndDisplayList(parent1);

	EXPECT_TRUE(child->isValid());
	EXPECT_TRUE(parent1->isValid());
	EXPECT_TRUE(parent2->isValid());
	EXPECT_FALSE(child->nothingToDraw());
	EXPECT_FALSE(parent1->nothingToDraw());
	EXPECT_FALSE(parent2->nothingToDraw());

	TestUtils::recordNode(*parent2, [](Canvas& canvas) {
	canvas.drawColor(Color::Amber_500, SkBlendMode::kSrcOver);
	});

	TestUtils::syncHierarchyPropertiesAndDisplayList(parent2);

	EXPECT_FALSE(child->isValid());
	EXPECT_TRUE(parent1->isValid());
	EXPECT_TRUE(parent2->isValid());
	EXPECT_TRUE(child->nothingToDraw());
	EXPECT_FALSE(parent1->nothingToDraw());
	EXPECT_FALSE(parent2->nothingToDraw());

	TestUtils::recordNode(*child, [](Canvas& canvas) {
	canvas.drawColor(Color::Red_500, SkBlendMode::kSrcOver);
	});
	TestUtils::syncHierarchyPropertiesAndDisplayList(child);

	TestUtils::recordNode(*parent1,
	[&child](Canvas& canvas) { canvas.drawRenderNode(child.get()); });
	TestUtils::syncHierarchyPropertiesAndDisplayList(parent1);

	TestUtils::recordNode(*parent2,
	[&child](Canvas& canvas) { canvas.drawRenderNode(child.get()); });
	TestUtils::syncHierarchyPropertiesAndDisplayList(parent2);

	EXPECT_TRUE(child->isValid());
	EXPECT_TRUE(parent1->isValid());
	EXPECT_TRUE(parent2->isValid());
	EXPECT_FALSE(child->nothingToDraw());
	EXPECT_FALSE(parent1->nothingToDraw());
	EXPECT_FALSE(parent2->nothingToDraw());

	parent1->destroyHardwareResources();

	EXPECT_TRUE(child->isValid());
	EXPECT_FALSE(parent1->isValid());
	EXPECT_TRUE(parent2->isValid());
	EXPECT_FALSE(child->nothingToDraw());
	EXPECT_TRUE(parent1->nothingToDraw());
	EXPECT_FALSE(parent2->nothingToDraw());

	parent2->destroyHardwareResources();

	EXPECT_FALSE(child->isValid());
	EXPECT_FALSE(parent1->isValid());
	EXPECT_FALSE(parent2->isValid());
	EXPECT_TRUE(child->nothingToDraw());
	EXPECT_TRUE(parent1->nothingToDraw());
	EXPECT_TRUE(parent2->nothingToDraw());
	}

	TEST(RenderNode, releasedCallback) {
	int functor = TestUtils::createMockFunctor();

	auto node = TestUtils::createNode(0, 0, 200, 400, [&](RenderProperties& props, Canvas& canvas) {
	canvas.drawWebViewFunctor(functor);
	});
	TestUtils::runOnRenderThreadUnmanaged([&] (RenderThread&) {
	TestUtils::syncHierarchyPropertiesAndDisplayList(node);
	});
	auto& counts = TestUtils::countsForFunctor(functor);
	EXPECT_EQ(1, counts.sync);
	EXPECT_EQ(0, counts.destroyed);

	TestUtils::recordNode(*node, [&](Canvas& canvas) {
	canvas.drawWebViewFunctor(functor);
	});
	EXPECT_EQ(1, counts.sync);
	EXPECT_EQ(0, counts.destroyed);

	TestUtils::runOnRenderThreadUnmanaged([&] (RenderThread&) {
	TestUtils::syncHierarchyPropertiesAndDisplayList(node);
	});
	EXPECT_EQ(2, counts.sync);
	EXPECT_EQ(0, counts.destroyed);

	WebViewFunctor_release(functor);
	EXPECT_EQ(2, counts.sync);
	EXPECT_EQ(0, counts.destroyed);

	TestUtils::recordNode(*node, [](Canvas& canvas) {});
	TestUtils::runOnRenderThreadUnmanaged([&] (RenderThread&) {
	TestUtils::syncHierarchyPropertiesAndDisplayList(node);
	});
	// Fence on any remaining post'd work
	TestUtils::runOnRenderThreadUnmanaged([] (RenderThread&) {});
	EXPECT_EQ(2, counts.sync);
	EXPECT_EQ(1, counts.destroyed);
	}

	RENDERTHREAD_TEST(RenderNode, prepareTree_nullableDisplayList) {
	auto rootNode = TestUtils::createNode(0, 0, 200, 400, nullptr);
	ContextFactory contextFactory;
	std::unique_ptr<CanvasContext> canvasContext(
	CanvasContext::create(renderThread, false, rootNode.get(), &contextFactory, 0, 0));
	TreeInfo info(TreeInfo::MODE_RT_ONLY, *canvasContext.get());
	DamageAccumulator damageAccumulator;
	info.damageAccumulator = &damageAccumulator;

	{
	auto nonNullDLNode =
	TestUtils::createNode(0, 0, 200, 400, [](RenderProperties& props, Canvas& canvas) {
	canvas.drawColor(Color::Red_500, SkBlendMode::kSrcOver);
	});
	TestUtils::syncHierarchyPropertiesAndDisplayList(nonNullDLNode);
	EXPECT_TRUE(nonNullDLNode->getDisplayList());
	nonNullDLNode->prepareTree(info);
	}

	{
	auto nullDLNode = TestUtils::createNode(0, 0, 200, 400, nullptr);
	TestUtils::syncHierarchyPropertiesAndDisplayList(nullDLNode);
	EXPECT_FALSE(nullDLNode->getDisplayList());
	nullDLNode->prepareTree(info);
	}

	canvasContext->destroy();
	}

	// TODO: Is this supposed to work in SkiaGL/SkiaVK?
	RENDERTHREAD_TEST(DISABLED_RenderNode, prepareTree_HwLayer_AVD_enqueueDamage) {
	VectorDrawable::Group* group = new VectorDrawable::Group();
	sp<VectorDrawableRoot> vectorDrawable(new VectorDrawableRoot(group));

	auto rootNode =
	TestUtils::createNode(0, 0, 200, 400, [&](RenderProperties& props, Canvas& canvas) {
	canvas.drawVectorDrawable(vectorDrawable.get());
	});
	ContextFactory contextFactory;
	std::unique_ptr<CanvasContext> canvasContext(
	CanvasContext::create(renderThread, false, rootNode.get(), &contextFactory, 0, 0));
	canvasContext->setSurface(nullptr);
	TreeInfo info(TreeInfo::MODE_RT_ONLY, *canvasContext.get());
	DamageAccumulator damageAccumulator;
	LayerUpdateQueue layerUpdateQueue;
	info.damageAccumulator = &damageAccumulator;
	info.layerUpdateQueue = &layerUpdateQueue;

	// Put node on HW layer
	rootNode->mutateStagingProperties().mutateLayerProperties().setType(LayerType::RenderLayer);

	TestUtils::syncHierarchyPropertiesAndDisplayList(rootNode);
	rootNode->prepareTree(info);

	// Check that the VD is in the dislay list, and the layer update queue contains the correct
	// damage rect.
	EXPECT_TRUE(rootNode->getDisplayList().hasVectorDrawables());
	ASSERT_FALSE(info.layerUpdateQueue->entries().empty());
	EXPECT_EQ(rootNode.get(), info.layerUpdateQueue->entries().at(0).renderNode.get());
	EXPECT_EQ(uirenderer::Rect(0, 0, 200, 400), info.layerUpdateQueue->entries().at(0).damage);
	canvasContext->destroy();
	}

	TEST(RenderNode, hasNoFill) {
	auto rootNode =
	TestUtils::createNode(0, 0, 200, 400, [](RenderProperties& props, Canvas& canvas) {
	Paint paint;
	paint.setStyle(SkPaint::Style::kStroke_Style);
	canvas.drawRect(10, 10, 100, 100, paint);
	});

	TestUtils::syncHierarchyPropertiesAndDisplayList(rootNode);

	EXPECT_FALSE(rootNode.get()->getDisplayList().hasFill());
	EXPECT_FALSE(rootNode.get()->getDisplayList().hasText());
	}

	TEST(RenderNode, hasFill) {
	auto rootNode =
	TestUtils::createNode(0, 0, 200, 400, [](RenderProperties& props, Canvas& canvas) {
	Paint paint;
	paint.setStyle(SkPaint::kStrokeAndFill_Style);
	canvas.drawRect(10, 10, 100, 100, paint);
	});

	TestUtils::syncHierarchyPropertiesAndDisplayList(rootNode);

	EXPECT_TRUE(rootNode.get()->getDisplayList().hasFill());
	EXPECT_FALSE(rootNode.get()->getDisplayList().hasText());
	}