chromium/src
0
Fork 0
Code Activity

cc: Make RenderPass into a struct-like class.

Browse Source 
This follows the same pattern as DrawQuad and SharedQuadState. The Create()
method takes no parameters, allowing the IPC code to create an empty RenderPass.

Then we have SetNew() and SetAll() methods to set the the properties of the
RenderPass when creating a new one, or when recreating one via IPC,
respectively.

Covered by existing tests.

BUG=152337
TBR=aelias


Review URL: https://chromiumcodereview.appspot.com/11413106

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@168998 0039d316-1c4b-4281-b951-d872f2087c98
This commit is contained in:
danakj@chromium.org
2012-11-21 07:02:15 +00:00
parent 493227ba58
commit f57bbc063a
21 changed files with 663 additions and 538 deletions

32
cc/delegated_renderer_layer_impl.cc

@ -44,20 +44,18 @@ void DelegatedRendererLayerImpl::setRenderPasses(ScopedPtrVector<RenderPass>& re
{
gfx::RectF oldRootDamage;
if (!m_renderPassesInDrawOrder.isEmpty())
oldRootDamage = m_renderPassesInDrawOrder.last()->damageRect();
oldRootDamage = m_renderPassesInDrawOrder.last()->damage_rect;
clearRenderPasses();
for (size_t i = 0; i < renderPassesInDrawOrder.size(); ++i) {
m_renderPassesIndexById.insert(std::pair<RenderPass::Id, int>(renderPassesInDrawOrder[i]->id(), i));
m_renderPassesIndexById.insert(std::pair<RenderPass::Id, int>(renderPassesInDrawOrder[i]->id, i));
m_renderPassesInDrawOrder.append(renderPassesInDrawOrder.take(i));
}
renderPassesInDrawOrder.clear();
if (!m_renderPassesInDrawOrder.isEmpty()) {
gfx::RectF newRootDamage = m_renderPassesInDrawOrder.last()->damageRect();
m_renderPassesInDrawOrder.last()->setDamageRect(gfx::UnionRects(oldRootDamage, newRootDamage));
}
if (!m_renderPassesInDrawOrder.isEmpty())
m_renderPassesInDrawOrder.last()->damage_rect.Union(oldRootDamage);
}
void DelegatedRendererLayerImpl::clearRenderPasses()
@ -82,7 +80,7 @@ RenderPass::Id DelegatedRendererLayerImpl::firstContributingRenderPassId() const
RenderPass::Id DelegatedRendererLayerImpl::nextContributingRenderPassId(RenderPass::Id previous) const
{
return RenderPass::Id(previous.layerId, previous.index + 1);
return RenderPass::Id(previous.layer_id, previous.index + 1);
}
RenderPass::Id DelegatedRendererLayerImpl::convertDelegatedRenderPassId(RenderPass::Id delegatedRenderPassId) const
@ -98,12 +96,12 @@ void DelegatedRendererLayerImpl::appendContributingRenderPasses(RenderPassSink&
DCHECK(hasContributingDelegatedRenderPasses());
for (size_t i = 0; i < m_renderPassesInDrawOrder.size() - 1; ++i) {
RenderPass::Id outputRenderPassId = convertDelegatedRenderPassId(m_renderPassesInDrawOrder[i]->id());
RenderPass::Id outputRenderPassId = convertDelegatedRenderPassId(m_renderPassesInDrawOrder[i]->id);
// Don't clash with the RenderPass we generate if we own a RenderSurfaceImpl.
DCHECK(outputRenderPassId.index > 0);
renderPassSink.appendRenderPass(m_renderPassesInDrawOrder[i]->copy(outputRenderPassId));
renderPassSink.appendRenderPass(m_renderPassesInDrawOrder[i]->Copy(outputRenderPassId));
}
}
@ -121,31 +119,31 @@ void DelegatedRendererLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData
bool shouldMergeRootRenderPassWithTarget = !targetRenderPassId.index;
if (shouldMergeRootRenderPassWithTarget) {
// Verify that the renderPass we are appending to is created our renderTarget.
DCHECK(targetRenderPassId.layerId == renderTarget()->id());
DCHECK(targetRenderPassId.layer_id == renderTarget()->id());
RenderPass* rootDelegatedRenderPass = m_renderPassesInDrawOrder.last();
const RenderPass* rootDelegatedRenderPass = m_renderPassesInDrawOrder.last();
appendRenderPassQuads(quadSink, appendQuadsData, rootDelegatedRenderPass);
} else {
// Verify that the renderPass we are appending to was created by us.
DCHECK(targetRenderPassId.layerId == id());
DCHECK(targetRenderPassId.layer_id == id());
int renderPassIndex = idToIndex(targetRenderPassId.index);
RenderPass* delegatedRenderPass = m_renderPassesInDrawOrder[renderPassIndex];
const RenderPass* delegatedRenderPass = m_renderPassesInDrawOrder[renderPassIndex];
appendRenderPassQuads(quadSink, appendQuadsData, delegatedRenderPass);
}
}
void DelegatedRendererLayerImpl::appendRenderPassQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData, RenderPass* delegatedRenderPass) const
void DelegatedRendererLayerImpl::appendRenderPassQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData, const RenderPass* delegatedRenderPass) const
{
const SharedQuadState* currentSharedQuadState = 0;
SharedQuadState* copiedSharedQuadState = 0;
for (size_t i = 0; i < delegatedRenderPass->quadList().size(); ++i) {
const DrawQuad* quad = delegatedRenderPass->quadList()[i];
for (size_t i = 0; i < delegatedRenderPass->quad_list.size(); ++i) {
const DrawQuad* quad = delegatedRenderPass->quad_list[i];
if (quad->shared_quad_state != currentSharedQuadState) {
currentSharedQuadState = quad->shared_quad_state;
copiedSharedQuadState = quadSink.useSharedQuadState(currentSharedQuadState->Copy());
bool targetIsFromDelegatedRendererLayer = appendQuadsData.renderPassId.layerId == id();
bool targetIsFromDelegatedRendererLayer = appendQuadsData.renderPassId.layer_id == id();
if (!targetIsFromDelegatedRendererLayer) {
// Should be the root render pass.
DCHECK(delegatedRenderPass == m_renderPassesInDrawOrder.last());

2
cc/delegated_renderer_layer_impl.h

@ -36,7 +36,7 @@ private:
RenderPass::Id convertDelegatedRenderPassId(RenderPass::Id delegatedRenderPassId) const;
void appendRenderPassQuads(QuadSink&, AppendQuadsData&, RenderPass* fromDelegatedRenderPass) const;
void appendRenderPassQuads(QuadSink&, AppendQuadsData&, const RenderPass* fromDelegatedRenderPass) const;
virtual const char* layerTypeAsString() const OVERRIDE;

159
cc/delegated_renderer_layer_impl_unittest.cc

@ -68,7 +68,8 @@ protected:
static TestRenderPass* addRenderPass(ScopedPtrVector<RenderPass>& passList, RenderPass::Id id, gfx::Rect outputRect, WebTransformationMatrix rootTransform)
{
scoped_ptr<TestRenderPass> pass(TestRenderPass::create(id, outputRect, rootTransform));
scoped_ptr<TestRenderPass> pass(TestRenderPass::Create());
pass->SetNew(id, outputRect, outputRect, rootTransform);
TestRenderPass* saved = pass.get();
passList.append(pass.PassAs<RenderPass>());
return saved;
@ -76,8 +77,8 @@ static TestRenderPass* addRenderPass(ScopedPtrVector<RenderPass>& passList, Rend
static SolidColorDrawQuad* addQuad(TestRenderPass* pass, gfx::Rect rect, SkColor color)
{
MockQuadCuller quadSink(pass->quadList(), pass->sharedQuadStateList());
AppendQuadsData data(pass->id());
MockQuadCuller quadSink(pass->quad_list, pass->shared_quad_state_list);
AppendQuadsData data(pass->id);
SharedQuadState* sharedState = quadSink.useSharedQuadState(SharedQuadState::Create());
sharedState->SetAll(WebTransformationMatrix(), rect, rect, 1);
scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
@ -89,13 +90,13 @@ static SolidColorDrawQuad* addQuad(TestRenderPass* pass, gfx::Rect rect, SkColor
static void addRenderPassQuad(TestRenderPass* toPass, TestRenderPass* contributingPass)
{
MockQuadCuller quadSink(toPass->quadList(), toPass->sharedQuadStateList());
AppendQuadsData data(toPass->id());
gfx::Rect outputRect = contributingPass->outputRect();
MockQuadCuller quadSink(toPass->quad_list, toPass->shared_quad_state_list);
AppendQuadsData data(toPass->id);
gfx::Rect outputRect = contributingPass->output_rect;
SharedQuadState* sharedState = quadSink.useSharedQuadState(SharedQuadState::Create());
sharedState->SetAll(WebTransformationMatrix(), outputRect, outputRect, 1);
scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
quad->SetNew(sharedState, outputRect, contributingPass->id(), false, 0, outputRect, 0, 0, 0, 0);
quad->SetNew(sharedState, outputRect, contributingPass->id, false, 0, outputRect, 0, 0, 0, 0);
quadSink.append(quad.PassAs<DrawQuad>(), data);
}
@ -178,21 +179,21 @@ TEST_F(DelegatedRendererLayerImplTestSimple, AddsContributingRenderPasses)
ASSERT_EQ(5u, frame.renderPasses.size());
// The DelegatedRendererLayer should have added its contributing RenderPasses to the frame.
EXPECT_EQ(4, frame.renderPasses[1]->id().layerId);
EXPECT_EQ(1, frame.renderPasses[1]->id().index);
EXPECT_EQ(4, frame.renderPasses[2]->id().layerId);
EXPECT_EQ(2, frame.renderPasses[2]->id().index);
EXPECT_EQ(4, frame.renderPasses[1]->id.layer_id);
EXPECT_EQ(1, frame.renderPasses[1]->id.index);
EXPECT_EQ(4, frame.renderPasses[2]->id.layer_id);
EXPECT_EQ(2, frame.renderPasses[2]->id.index);
// And all other RenderPasses should be non-delegated.
EXPECT_NE(4, frame.renderPasses[0]->id().layerId);
EXPECT_EQ(0, frame.renderPasses[0]->id().index);
EXPECT_NE(4, frame.renderPasses[3]->id().layerId);
EXPECT_EQ(0, frame.renderPasses[3]->id().index);
EXPECT_NE(4, frame.renderPasses[4]->id().layerId);
EXPECT_EQ(0, frame.renderPasses[4]->id().index);
EXPECT_NE(4, frame.renderPasses[0]->id.layer_id);
EXPECT_EQ(0, frame.renderPasses[0]->id.index);
EXPECT_NE(4, frame.renderPasses[3]->id.layer_id);
EXPECT_EQ(0, frame.renderPasses[3]->id.index);
EXPECT_NE(4, frame.renderPasses[4]->id.layer_id);
EXPECT_EQ(0, frame.renderPasses[4]->id.index);
// The DelegatedRendererLayer should have added its RenderPasses to the frame in order.
EXPECT_RECT_EQ(gfx::Rect(6, 6, 6, 6), frame.renderPasses[1]->outputRect());
EXPECT_RECT_EQ(gfx::Rect(7, 7, 7, 7), frame.renderPasses[2]->outputRect());
EXPECT_RECT_EQ(gfx::Rect(6, 6, 6, 6), frame.renderPasses[1]->output_rect);
EXPECT_RECT_EQ(gfx::Rect(7, 7, 7, 7), frame.renderPasses[2]->output_rect);
}
TEST_F(DelegatedRendererLayerImplTestSimple, AddsQuadsToContributingRenderPasses)
@ -206,21 +207,21 @@ TEST_F(DelegatedRendererLayerImplTestSimple, AddsQuadsToContributingRenderPasses
ASSERT_EQ(5u, frame.renderPasses.size());
// The DelegatedRendererLayer should have added its contributing RenderPasses to the frame.
EXPECT_EQ(4, frame.renderPasses[1]->id().layerId);
EXPECT_EQ(1, frame.renderPasses[1]->id().index);
EXPECT_EQ(4, frame.renderPasses[2]->id().layerId);
EXPECT_EQ(2, frame.renderPasses[2]->id().index);
EXPECT_EQ(4, frame.renderPasses[1]->id.layer_id);
EXPECT_EQ(1, frame.renderPasses[1]->id.index);
EXPECT_EQ(4, frame.renderPasses[2]->id.layer_id);
EXPECT_EQ(2, frame.renderPasses[2]->id.index);
// The DelegatedRendererLayer should have added copies of its quads to contributing RenderPasses.
ASSERT_EQ(1u, frame.renderPasses[1]->quadList().size());
EXPECT_RECT_EQ(gfx::Rect(0, 0, 6, 6), frame.renderPasses[1]->quadList()[0]->rect);
ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
EXPECT_RECT_EQ(gfx::Rect(0, 0, 6, 6), frame.renderPasses[1]->quad_list[0]->rect);
// Verify it added the right quads.
ASSERT_EQ(2u, frame.renderPasses[2]->quadList().size());
EXPECT_RECT_EQ(gfx::Rect(0, 0, 7, 7), frame.renderPasses[2]->quadList()[0]->rect);
EXPECT_RECT_EQ(gfx::Rect(6, 6, 6, 6), frame.renderPasses[2]->quadList()[1]->rect);
ASSERT_EQ(1u, frame.renderPasses[1]->quadList().size());
EXPECT_RECT_EQ(gfx::Rect(0, 0, 6, 6), frame.renderPasses[1]->quadList()[0]->rect);
ASSERT_EQ(2u, frame.renderPasses[2]->quad_list.size());
EXPECT_RECT_EQ(gfx::Rect(0, 0, 7, 7), frame.renderPasses[2]->quad_list[0]->rect);
EXPECT_RECT_EQ(gfx::Rect(6, 6, 6, 6), frame.renderPasses[2]->quad_list[1]->rect);
ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
EXPECT_RECT_EQ(gfx::Rect(0, 0, 6, 6), frame.renderPasses[1]->quad_list[0]->rect);
}
TEST_F(DelegatedRendererLayerImplTestSimple, AddsQuadsToTargetRenderPass)
@ -234,17 +235,17 @@ TEST_F(DelegatedRendererLayerImplTestSimple, AddsQuadsToTargetRenderPass)
ASSERT_EQ(5u, frame.renderPasses.size());
// The layer's target is the RenderPass from m_layerAfter.
EXPECT_EQ(RenderPass::Id(3, 0), frame.renderPasses[3]->id());
EXPECT_EQ(RenderPass::Id(3, 0), frame.renderPasses[3]->id);
// The DelegatedRendererLayer should have added copies of quads in its root RenderPass to its target RenderPass.
// The m_layerAfter also adds one quad.
ASSERT_EQ(2u, frame.renderPasses[3]->quadList().size());
ASSERT_EQ(2u, frame.renderPasses[3]->quad_list.size());
// Verify it added the right quads.
EXPECT_RECT_EQ(gfx::Rect(7, 7, 7, 7), frame.renderPasses[3]->quadList()[0]->rect);
EXPECT_RECT_EQ(gfx::Rect(7, 7, 7, 7), frame.renderPasses[3]->quad_list[0]->rect);
// Its target layer should have a quad as well.
EXPECT_RECT_EQ(gfx::Rect(0, 0, 15, 15), frame.renderPasses[3]->quadList()[1]->rect);
EXPECT_RECT_EQ(gfx::Rect(0, 0, 15, 15), frame.renderPasses[3]->quad_list[1]->rect);
}
TEST_F(DelegatedRendererLayerImplTestSimple, QuadsFromRootRenderPassAreModifiedForTheTarget)
@ -261,14 +262,14 @@ TEST_F(DelegatedRendererLayerImplTestSimple, QuadsFromRootRenderPassAreModifiedF
// So its root RenderPass' quads should all be transformed by that combined amount.
WebTransformationMatrix transform;
transform.translate(4, 4);
EXPECT_TRANSFORMATION_MATRIX_EQ(transform, frame.renderPasses[3]->quadList()[0]->quadTransform());
EXPECT_TRANSFORMATION_MATRIX_EQ(transform, frame.renderPasses[3]->quad_list[0]->quadTransform());
// Quads from non-root RenderPasses should not be shifted though.
ASSERT_EQ(2u, frame.renderPasses[2]->quadList().size());
EXPECT_TRANSFORMATION_MATRIX_EQ(WebTransformationMatrix(), frame.renderPasses[2]->quadList()[0]->quadTransform());
EXPECT_TRANSFORMATION_MATRIX_EQ(WebTransformationMatrix(), frame.renderPasses[2]->quadList()[1]->quadTransform());
ASSERT_EQ(1u, frame.renderPasses[1]->quadList().size());
EXPECT_TRANSFORMATION_MATRIX_EQ(WebTransformationMatrix(), frame.renderPasses[1]->quadList()[0]->quadTransform());
ASSERT_EQ(2u, frame.renderPasses[2]->quad_list.size());
EXPECT_TRANSFORMATION_MATRIX_EQ(WebTransformationMatrix(), frame.renderPasses[2]->quad_list[0]->quadTransform());
EXPECT_TRANSFORMATION_MATRIX_EQ(WebTransformationMatrix(), frame.renderPasses[2]->quad_list[1]->quadTransform());
ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
EXPECT_TRANSFORMATION_MATRIX_EQ(WebTransformationMatrix(), frame.renderPasses[1]->quad_list[0]->quadTransform());
}
class DelegatedRendererLayerImplTestOwnSurface : public DelegatedRendererLayerImplTestSimple {
@ -291,24 +292,24 @@ TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsRenderPasses)
ASSERT_EQ(6u, frame.renderPasses.size());
// The DelegatedRendererLayer should have added its contributing RenderPasses to the frame.
EXPECT_EQ(4, frame.renderPasses[1]->id().layerId);
EXPECT_EQ(1, frame.renderPasses[1]->id().index);
EXPECT_EQ(4, frame.renderPasses[2]->id().layerId);
EXPECT_EQ(2, frame.renderPasses[2]->id().index);
EXPECT_EQ(4, frame.renderPasses[1]->id.layer_id);
EXPECT_EQ(1, frame.renderPasses[1]->id.index);
EXPECT_EQ(4, frame.renderPasses[2]->id.layer_id);
EXPECT_EQ(2, frame.renderPasses[2]->id.index);
// The DelegatedRendererLayer should have added a RenderPass for its surface to the frame.
EXPECT_EQ(4, frame.renderPasses[1]->id().layerId);
EXPECT_EQ(0, frame.renderPasses[3]->id().index);
EXPECT_EQ(4, frame.renderPasses[1]->id.layer_id);
EXPECT_EQ(0, frame.renderPasses[3]->id.index);
// And all other RenderPasses should be non-delegated.
EXPECT_NE(4, frame.renderPasses[0]->id().layerId);
EXPECT_EQ(0, frame.renderPasses[0]->id().index);
EXPECT_NE(4, frame.renderPasses[4]->id().layerId);
EXPECT_EQ(0, frame.renderPasses[4]->id().index);
EXPECT_NE(4, frame.renderPasses[5]->id().layerId);
EXPECT_EQ(0, frame.renderPasses[5]->id().index);
EXPECT_NE(4, frame.renderPasses[0]->id.layer_id);
EXPECT_EQ(0, frame.renderPasses[0]->id.index);
EXPECT_NE(4, frame.renderPasses[4]->id.layer_id);
EXPECT_EQ(0, frame.renderPasses[4]->id.index);
EXPECT_NE(4, frame.renderPasses[5]->id.layer_id);
EXPECT_EQ(0, frame.renderPasses[5]->id.index);
// The DelegatedRendererLayer should have added its RenderPasses to the frame in order.
EXPECT_RECT_EQ(gfx::Rect(6, 6, 6, 6), frame.renderPasses[1]->outputRect());
EXPECT_RECT_EQ(gfx::Rect(7, 7, 7, 7), frame.renderPasses[2]->outputRect());
EXPECT_RECT_EQ(gfx::Rect(6, 6, 6, 6), frame.renderPasses[1]->output_rect);
EXPECT_RECT_EQ(gfx::Rect(7, 7, 7, 7), frame.renderPasses[2]->output_rect);
}
TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsQuadsToContributingRenderPasses)
@ -322,21 +323,21 @@ TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsQuadsToContributingRenderPa
ASSERT_EQ(6u, frame.renderPasses.size());
// The DelegatedRendererLayer should have added its contributing RenderPasses to the frame.
EXPECT_EQ(4, frame.renderPasses[1]->id().layerId);
EXPECT_EQ(1, frame.renderPasses[1]->id().index);
EXPECT_EQ(4, frame.renderPasses[2]->id().layerId);
EXPECT_EQ(2, frame.renderPasses[2]->id().index);
EXPECT_EQ(4, frame.renderPasses[1]->id.layer_id);
EXPECT_EQ(1, frame.renderPasses[1]->id.index);
EXPECT_EQ(4, frame.renderPasses[2]->id.layer_id);
EXPECT_EQ(2, frame.renderPasses[2]->id.index);
// The DelegatedRendererLayer should have added copies of its quads to contributing RenderPasses.
ASSERT_EQ(1u, frame.renderPasses[1]->quadList().size());
EXPECT_RECT_EQ(gfx::Rect(0, 0, 6, 6), frame.renderPasses[1]->quadList()[0]->rect);
ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
EXPECT_RECT_EQ(gfx::Rect(0, 0, 6, 6), frame.renderPasses[1]->quad_list[0]->rect);
// Verify it added the right quads.
ASSERT_EQ(2u, frame.renderPasses[2]->quadList().size());
EXPECT_RECT_EQ(gfx::Rect(0, 0, 7, 7), frame.renderPasses[2]->quadList()[0]->rect);
EXPECT_RECT_EQ(gfx::Rect(6, 6, 6, 6), frame.renderPasses[2]->quadList()[1]->rect);
ASSERT_EQ(1u, frame.renderPasses[1]->quadList().size());
EXPECT_RECT_EQ(gfx::Rect(0, 0, 6, 6), frame.renderPasses[1]->quadList()[0]->rect);
ASSERT_EQ(2u, frame.renderPasses[2]->quad_list.size());
EXPECT_RECT_EQ(gfx::Rect(0, 0, 7, 7), frame.renderPasses[2]->quad_list[0]->rect);
EXPECT_RECT_EQ(gfx::Rect(6, 6, 6, 6), frame.renderPasses[2]->quad_list[1]->rect);
ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
EXPECT_RECT_EQ(gfx::Rect(0, 0, 6, 6), frame.renderPasses[1]->quad_list[0]->rect);
}
TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsQuadsToTargetRenderPass)
@ -350,14 +351,14 @@ TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsQuadsToTargetRenderPass)
ASSERT_EQ(6u, frame.renderPasses.size());
// The layer's target is the RenderPass owned by itself.
EXPECT_EQ(RenderPass::Id(4, 0), frame.renderPasses[3]->id());
EXPECT_EQ(RenderPass::Id(4, 0), frame.renderPasses[3]->id);
// The DelegatedRendererLayer should have added copies of quads in its root RenderPass to its target RenderPass.
// The m_layerAfter also adds one quad.
ASSERT_EQ(1u, frame.renderPasses[3]->quadList().size());
ASSERT_EQ(1u, frame.renderPasses[3]->quad_list.size());
// Verify it added the right quads.
EXPECT_RECT_EQ(gfx::Rect(7, 7, 7, 7), frame.renderPasses[3]->quadList()[0]->rect);
EXPECT_RECT_EQ(gfx::Rect(7, 7, 7, 7), frame.renderPasses[3]->quad_list[0]->rect);
}
TEST_F(DelegatedRendererLayerImplTestOwnSurface, QuadsFromRootRenderPassAreNotModifiedForTheTarget)
@ -372,14 +373,14 @@ TEST_F(DelegatedRendererLayerImplTestOwnSurface, QuadsFromRootRenderPassAreNotMo
// Because the DelegatedRendererLayer owns a RenderSurfaceImpl, its root RenderPass' quads do not need to be
// modified at all.
EXPECT_TRANSFORMATION_MATRIX_EQ(WebTransformationMatrix(), frame.renderPasses[3]->quadList()[0]->quadTransform());
EXPECT_TRANSFORMATION_MATRIX_EQ(WebTransformationMatrix(), frame.renderPasses[3]->quad_list[0]->quadTransform());
// Quads from non-root RenderPasses should not be shifted though.
ASSERT_EQ(2u, frame.renderPasses[2]->quadList().size());
EXPECT_TRANSFORMATION_MATRIX_EQ(WebTransformationMatrix(), frame.renderPasses[2]->quadList()[0]->quadTransform());
EXPECT_TRANSFORMATION_MATRIX_EQ(WebTransformationMatrix(), frame.renderPasses[2]->quadList()[1]->quadTransform());
ASSERT_EQ(1u, frame.renderPasses[1]->quadList().size());
EXPECT_TRANSFORMATION_MATRIX_EQ(WebTransformationMatrix(), frame.renderPasses[1]->quadList()[0]->quadTransform());
ASSERT_EQ(2u, frame.renderPasses[2]->quad_list.size());
EXPECT_TRANSFORMATION_MATRIX_EQ(WebTransformationMatrix(), frame.renderPasses[2]->quad_list[0]->quadTransform());
EXPECT_TRANSFORMATION_MATRIX_EQ(WebTransformationMatrix(), frame.renderPasses[2]->quad_list[1]->quadTransform());
ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
EXPECT_TRANSFORMATION_MATRIX_EQ(WebTransformationMatrix(), frame.renderPasses[1]->quad_list[0]->quadTransform());
}
class DelegatedRendererLayerImplTestSharedData : public DelegatedRendererLayerImplTest {
@ -404,8 +405,8 @@ public:
ScopedPtrVector<RenderPass> delegatedRenderPasses;
gfx::Rect passRect(0, 0, 50, 50);
TestRenderPass* pass = addRenderPass(delegatedRenderPasses, RenderPass::Id(9, 6), passRect, WebTransformationMatrix());
MockQuadCuller quadSink(pass->quadList(), pass->sharedQuadStateList());
AppendQuadsData data(pass->id());
MockQuadCuller quadSink(pass->quad_list, pass->shared_quad_state_list);
AppendQuadsData data(pass->id);
SharedQuadState* sharedState = quadSink.useSharedQuadState(SharedQuadState::Create());
sharedState->SetAll(WebTransformationMatrix(), passRect, passRect, 1);
scoped_ptr<SolidColorDrawQuad> colorQuad;
@ -452,10 +453,10 @@ TEST_F(DelegatedRendererLayerImplTestSharedData, SharedData)
m_hostImpl->didDrawAllLayers(frame);
ASSERT_EQ(1u, frame.renderPasses.size());
EXPECT_EQ(1, frame.renderPasses[0]->id().layerId);
EXPECT_EQ(0, frame.renderPasses[0]->id().index);
EXPECT_EQ(1, frame.renderPasses[0]->id.layer_id);
EXPECT_EQ(0, frame.renderPasses[0]->id.index);
const QuadList& quadList = frame.renderPasses[0]->quadList();
const QuadList& quadList = frame.renderPasses[0]->quad_list;
ASSERT_EQ(4u, quadList.size());
// All quads should share the same state.

34
cc/direct_renderer.cc

@ -95,7 +95,7 @@ gfx::Rect DirectRenderer::moveScissorToWindowSpace(const DrawingFrame& frame, gf
gfx::Rect scissorRectInCanvasSpace = gfx::ToEnclosingRect(scissorRect);
// The scissor coordinates must be supplied in viewport space so we need to offset
// by the relative position of the top left corner of the current render pass.
gfx::Rect framebufferOutputRect = frame.currentRenderPass->outputRect();
gfx::Rect framebufferOutputRect = frame.currentRenderPass->output_rect;
scissorRectInCanvasSpace.set_x(scissorRectInCanvasSpace.x() - framebufferOutputRect.x());
if (frame.flippedY && !frame.currentTexture)
scissorRectInCanvasSpace.set_y(framebufferOutputRect.height() - (scissorRectInCanvasSpace.bottom() - framebufferOutputRect.y()));
@ -118,7 +118,7 @@ void DirectRenderer::decideRenderPassAllocationsForFrame(const RenderPassList& r
{
base::hash_map<RenderPass::Id, const RenderPass*> renderPassesInFrame;
for (size_t i = 0; i < renderPassesInDrawOrder.size(); ++i)
renderPassesInFrame.insert(std::pair<RenderPass::Id, const RenderPass*>(renderPassesInDrawOrder[i]->id(), renderPassesInDrawOrder[i]));
renderPassesInFrame.insert(std::pair<RenderPass::Id, const RenderPass*>(renderPassesInDrawOrder[i]->id, renderPassesInDrawOrder[i]));
std::vector<RenderPass::Id> passesToDelete;
ScopedPtrHashMap<RenderPass::Id, CachedResource>::const_iterator passIterator;
@ -144,9 +144,9 @@ void DirectRenderer::decideRenderPassAllocationsForFrame(const RenderPassList& r
m_renderPassTextures.erase(passesToDelete[i]);
for (size_t i = 0; i < renderPassesInDrawOrder.size(); ++i) {
if (!m_renderPassTextures.contains(renderPassesInDrawOrder[i]->id())) {
if (!m_renderPassTextures.contains(renderPassesInDrawOrder[i]->id)) {
scoped_ptr<CachedResource> texture = CachedResource::create(m_resourceProvider);
m_renderPassTextures.set(renderPassesInDrawOrder[i]->id(), texture.Pass());
m_renderPassTextures.set(renderPassesInDrawOrder[i]->id, texture.Pass());
}
}
}
@ -160,7 +160,7 @@ void DirectRenderer::drawFrame(const RenderPassList& renderPassesInDrawOrder, co
DrawingFrame frame;
frame.renderPassesById = &renderPassesById;
frame.rootRenderPass = rootRenderPass;
frame.rootDamageRect = capabilities().usingPartialSwap ? rootRenderPass->damageRect() : rootRenderPass->outputRect();
frame.rootDamageRect = capabilities().usingPartialSwap ? rootRenderPass->damage_rect : rootRenderPass->output_rect;
frame.rootDamageRect.Intersect(gfx::Rect(gfx::Point(), viewportSize()));
beginDrawingFrame(frame);
@ -175,9 +175,9 @@ void DirectRenderer::drawRenderPass(DrawingFrame& frame, const RenderPass* rende
if (!useRenderPass(frame, renderPass))
return;
frame.scissorRectInRenderPassSpace = frame.currentRenderPass->outputRect();
if (frame.rootDamageRect != frame.rootRenderPass->outputRect()) {
WebTransformationMatrix inverseTransformToRoot = frame.currentRenderPass->transformToRootTarget().inverse();
frame.scissorRectInRenderPassSpace = frame.currentRenderPass->output_rect;
if (frame.rootDamageRect != frame.rootRenderPass->output_rect) {
WebTransformationMatrix inverseTransformToRoot = frame.currentRenderPass->transform_to_root_target.inverse();
gfx::RectF damageRectInRenderPassSpace = MathUtil::projectClippedRect(inverseTransformToRoot, frame.rootDamageRect);
frame.scissorRectInRenderPassSpace.Intersect(damageRectInRenderPassSpace);
}
@ -185,18 +185,18 @@ void DirectRenderer::drawRenderPass(DrawingFrame& frame, const RenderPass* rende
setScissorTestRect(moveScissorToWindowSpace(frame, frame.scissorRectInRenderPassSpace));
clearFramebuffer(frame);
const QuadList& quadList = renderPass->quadList();
const QuadList& quadList = renderPass->quad_list;
for (QuadList::constBackToFrontIterator it = quadList.backToFrontBegin(); it != quadList.backToFrontEnd(); ++it) {
gfx::RectF quadScissorRect = gfx::IntersectRects(frame.scissorRectInRenderPassSpace, (*it)->clippedRectInTarget());
gfx::RectF quadScissorRect = gfx::IntersectRects(frame.scissorRectInRenderPassSpace, (*it)->clippedRectInTarget());
if (!quadScissorRect.IsEmpty()) {
setScissorTestRect(moveScissorToWindowSpace(frame, quadScissorRect));
drawQuad(frame, *it);
}
}
CachedResource* texture = m_renderPassTextures.get(renderPass->id());
CachedResource* texture = m_renderPassTextures.get(renderPass->id);
if (texture)
texture->setIsComplete(!renderPass->hasOcclusionFromOutsideTargetSurface());
texture->setIsComplete(!renderPass->has_occlusion_from_outside_target_surface);
}
bool DirectRenderer::useRenderPass(DrawingFrame& frame, const RenderPass* renderPass)
@ -206,17 +206,17 @@ bool DirectRenderer::useRenderPass(DrawingFrame& frame, const RenderPass* render
if (renderPass == frame.rootRenderPass) {
bindFramebufferToOutputSurface(frame);
initializeMatrices(frame, renderPass->outputRect(), flippedFramebuffer());
setDrawViewportSize(renderPass->outputRect().size());
initializeMatrices(frame, renderPass->output_rect, flippedFramebuffer());
setDrawViewportSize(renderPass->output_rect.size());
return true;
}
CachedResource* texture = m_renderPassTextures.get(renderPass->id());
CachedResource* texture = m_renderPassTextures.get(renderPass->id);
DCHECK(texture);
if (!texture->id() && !texture->Allocate(Renderer::ImplPool, renderPassTextureSize(renderPass), renderPassTextureFormat(renderPass), ResourceProvider::TextureUsageFramebuffer))
return false;
return bindFramebufferToTexture(frame, texture, renderPass->outputRect());
return bindFramebufferToTexture(frame, texture, renderPass->output_rect);
}
bool DirectRenderer::haveCachedResourcesForRenderPassId(RenderPass::Id id) const
@ -228,7 +228,7 @@ bool DirectRenderer::haveCachedResourcesForRenderPassId(RenderPass::Id id) const
// static
gfx::Size DirectRenderer::renderPassTextureSize(const RenderPass* pass)
{
return pass->outputRect().size();
return pass->output_rect.size();
}
// static

16
cc/gl_renderer.cc

@ -201,13 +201,13 @@ void GLRenderer::viewportChanged()
void GLRenderer::clearFramebuffer(DrawingFrame& frame)
{
// On DEBUG builds, opaque render passes are cleared to blue to easily see regions that were not drawn on the screen.
if (frame.currentRenderPass->hasTransparentBackground())
if (frame.currentRenderPass->has_transparent_background)
GLC(m_context, m_context->clearColor(0, 0, 0, 0));
else
GLC(m_context, m_context->clearColor(0, 0, 1, 1));
#ifdef NDEBUG
if (frame.currentRenderPass->hasTransparentBackground())
if (frame.currentRenderPass->has_transparent_background)
#endif
m_context->clear(GL_COLOR_BUFFER_BIT);
}
@ -455,7 +455,7 @@ scoped_ptr<ScopedResource> GLRenderer::drawBackgroundFilters(
// FIXME: We only allow background filters on an opaque render surface because other surfaces may contain
// translucent pixels, and the contents behind those translucent pixels wouldn't have the filter applied.
if (frame.currentRenderPass->hasTransparentBackground())
if (frame.currentRenderPass->has_transparent_background)
return scoped_ptr<ScopedResource>();
DCHECK(!frame.currentTexture);
@ -466,7 +466,7 @@ scoped_ptr<ScopedResource> GLRenderer::drawBackgroundFilters(
filters.getOutsets(top, right, bottom, left);
deviceRect.Inset(-left, -top, -right, -bottom);
deviceRect.Intersect(frame.currentRenderPass->outputRect());
deviceRect.Intersect(frame.currentRenderPass->output_rect);
scoped_ptr<ScopedResource> deviceBackgroundTexture = ScopedResource::create(m_resourceProvider);
if (!getFramebufferTexture(deviceBackgroundTexture.get(), deviceRect))
@ -523,16 +523,16 @@ void GLRenderer::drawRenderPassQuad(DrawingFrame& frame, const RenderPassDrawQua
WebTransformationMatrix contentsDeviceTransformInverse = contentsDeviceTransform.inverse();
scoped_ptr<ScopedResource> backgroundTexture = drawBackgroundFilters(
frame, quad, renderPass->backgroundFilters(),
frame, quad, renderPass->background_filters,
contentsDeviceTransform, contentsDeviceTransformInverse);
// FIXME: Cache this value so that we don't have to do it for both the surface and its replica.
// Apply filters to the contents texture.
SkBitmap filterBitmap;
if (renderPass->filter()) {
filterBitmap = applyImageFilter(this, renderPass->filter(), contentsTexture, m_client->hasImplThread());
if (renderPass->filter) {
filterBitmap = applyImageFilter(this, renderPass->filter, contentsTexture, m_client->hasImplThread());
} else {
filterBitmap = applyFilters(this, renderPass->filters(), contentsTexture, m_client->hasImplThread());
filterBitmap = applyFilters(this, renderPass->filters, contentsTexture, m_client->hasImplThread());
}
scoped_ptr<ResourceProvider::ScopedReadLockGL> contentsResourceLock;
unsigned contentsTextureId = 0;

16
cc/gl_renderer_unittest.cc

@ -59,7 +59,8 @@ public:
{
m_rootLayer->createRenderSurface();
RenderPass::Id renderPassId = m_rootLayer->renderSurface()->renderPassId();
scoped_ptr<RenderPass> rootRenderPass = RenderPass::create(renderPassId, gfx::Rect(), WebTransformationMatrix());
scoped_ptr<RenderPass> rootRenderPass = RenderPass::Create();
rootRenderPass->SetNew(renderPassId, gfx::Rect(), gfx::Rect(), WebTransformationMatrix());
m_renderPassesInDrawOrder.push_back(rootRenderPass.get());
m_renderPasses.set(renderPassId, rootRenderPass.Pass());
}
@ -390,7 +391,7 @@ TEST(GLRendererTest2, opaqueBackground)
scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(outputSurface.get()));
FakeRendererGL renderer(&mockClient, resourceProvider.get());
mockClient.rootRenderPass()->setHasTransparentBackground(false);
mockClient.rootRenderPass()->has_transparent_background = false;
EXPECT_TRUE(renderer.initialize());
@ -413,7 +414,7 @@ TEST(GLRendererTest2, transparentBackground)
scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(outputSurface.get()));
FakeRendererGL renderer(&mockClient, resourceProvider.get());
mockClient.rootRenderPass()->setHasTransparentBackground(true);
mockClient.rootRenderPass()->has_transparent_background = true;
EXPECT_TRUE(renderer.initialize());
@ -529,8 +530,9 @@ TEST(GLRendererTest2, activeTextureState)
EXPECT_TRUE(renderer.initialize());
cc::RenderPass::Id id(1, 1);
scoped_ptr<TestRenderPass> pass = TestRenderPass::create(id, gfx::Rect(0, 0, 100, 100), WebTransformationMatrix());
pass->appendOneOfEveryQuadType(resourceProvider.get());
scoped_ptr<TestRenderPass> pass = TestRenderPass::Create();
pass->SetNew(id, gfx::Rect(0, 0, 100, 100), gfx::Rect(0, 0, 100, 100), WebTransformationMatrix());
pass->AppendOneOfEveryQuadType(resourceProvider.get());
context->setInDraw();
@ -538,8 +540,8 @@ TEST(GLRendererTest2, activeTextureState)
renderer.beginDrawingFrame(drawingFrame);
EXPECT_EQ(context->activeTexture(), GL_TEXTURE0);
for (cc::QuadList::backToFrontIterator it = pass->quadList().backToFrontBegin();
it != pass->quadList().backToFrontEnd(); ++it) {
for (cc::QuadList::backToFrontIterator it = pass->quad_list.backToFrontBegin();
it != pass->quad_list.backToFrontEnd(); ++it) {
renderer.drawQuad(drawingFrame, *it);
}
EXPECT_EQ(context->activeTexture(), GL_TEXTURE0);

118
cc/layer_tree_host_impl.cc

@ -23,12 +23,15 @@
#include "cc/overdraw_metrics.h"
#include "cc/page_scale_animation.h"
#include "cc/prioritized_resource_manager.h"
#include "cc/quad_culler.h"
#include "cc/render_pass_draw_quad.h"
#include "cc/rendering_stats.h"
#include "cc/scrollbar_animation_controller.h"
#include "cc/scrollbar_layer_impl.h"
#include "cc/shared_quad_state.h"
#include "cc/single_thread_proxy.h"
#include "cc/software_renderer.h"
#include "cc/solid_color_draw_quad.h"
#include "cc/texture_uploader.h"
#include "ui/gfx/size_conversions.h"
#include "ui/gfx/vector2d_conversions.h"
@ -380,7 +383,90 @@ void LayerTreeHostImpl::FrameData::appendRenderPass(scoped_ptr<RenderPass> rende
{
RenderPass* pass = renderPass.get();
renderPasses.push_back(pass);
renderPassesById.set(pass->id(), renderPass.Pass());
renderPassesById.set(pass->id, renderPass.Pass());
}
static void appendQuadsForLayer(RenderPass* targetRenderPass, LayerImpl* layer, OcclusionTrackerImpl& occlusionTracker, AppendQuadsData& appendQuadsData)
{
bool forSurface = false;
QuadCuller quadCuller(targetRenderPass->quad_list,
targetRenderPass->shared_quad_state_list,
layer,
occlusionTracker,
layer->showDebugBorders(),
forSurface);
layer->appendQuads(quadCuller, appendQuadsData);
}
static void appendQuadsForRenderSurfaceLayer(RenderPass* targetRenderPass, LayerImpl* layer, const RenderPass* contributingRenderPass, OcclusionTrackerImpl& occlusionTracker, AppendQuadsData& appendQuadsData)
{
bool forSurface = true;
QuadCuller quadCuller(targetRenderPass->quad_list,
targetRenderPass->shared_quad_state_list,
layer,
occlusionTracker,
layer->showDebugBorders(),
forSurface);
bool isReplica = false;
layer->renderSurface()->appendQuads(quadCuller,
appendQuadsData,
isReplica,
contributingRenderPass->id);
// Add replica after the surface so that it appears below the surface.
if (layer->hasReplica()) {
isReplica = true;
layer->renderSurface()->appendQuads(quadCuller,
appendQuadsData,
isReplica,
contributingRenderPass->id);
}
}
static void appendQuadsToFillScreen(RenderPass* targetRenderPass, LayerImpl* rootLayer, SkColor screenBackgroundColor, const OcclusionTrackerImpl& occlusionTracker)
{
if (!rootLayer || !SkColorGetA(screenBackgroundColor))
return;
Region fillRegion = occlusionTracker.computeVisibleRegionInScreen();
if (fillRegion.IsEmpty())
return;
bool forSurface = false;
QuadCuller quadCuller(targetRenderPass->quad_list,
targetRenderPass->shared_quad_state_list,
rootLayer,
occlusionTracker,
rootLayer->showDebugBorders(),
forSurface);
// Manually create the quad state for the gutter quads, as the root layer
// doesn't have any bounds and so can't generate this itself.
// FIXME: Make the gutter quads generated by the solid color layer (make it smarter about generating quads to fill unoccluded areas).
DCHECK(rootLayer->screenSpaceTransform().isInvertible());
gfx::Rect rootTargetRect = rootLayer->renderSurface()->contentRect();
float opacity = 1;
SharedQuadState* sharedQuadState = quadCuller.useSharedQuadState(SharedQuadState::Create());
sharedQuadState->SetAll(rootLayer->drawTransform(),
rootTargetRect,
rootTargetRect,
opacity);
AppendQuadsData appendQuadsData;
WebTransformationMatrix transformToLayerSpace = rootLayer->screenSpaceTransform().inverse();
for (Region::Iterator fillRects(fillRegion); fillRects.has_rect(); fillRects.next()) {
// The root layer transform is composed of translations and scales only,
// no perspective, so mapping is sufficient.
gfx::Rect layerRect = MathUtil::mapClippedRect(transformToLayerSpace, fillRects.rect());
// Skip the quad culler and just append the quads directly to avoid
// occlusion checks.
scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
quad->SetNew(sharedQuadState, layerRect, screenBackgroundColor);
quadCuller.append(quad.PassAs<DrawQuad>(), appendQuadsData);
}
}
bool LayerTreeHostImpl::calculateRenderPasses(FrameData& frame)
@ -421,12 +507,12 @@ bool LayerTreeHostImpl::calculateRenderPasses(FrameData& frame)
occlusionTracker.enterLayer(it);
AppendQuadsData appendQuadsData(targetRenderPass->id());
AppendQuadsData appendQuadsData(targetRenderPass->id);
if (it.representsContributingRenderSurface()) {
RenderPass::Id contributingRenderPassId = it->renderSurface()->renderPassId();
RenderPass* contributingRenderPass = frame.renderPassesById.get(contributingRenderPassId);
targetRenderPass->appendQuadsForRenderSurfaceLayer(*it, contributingRenderPass, &occlusionTracker, appendQuadsData);
appendQuadsForRenderSurfaceLayer(targetRenderPass, *it, contributingRenderPass, occlusionTracker, appendQuadsData);
} else if (it.representsItself() && !it->visibleContentRect().IsEmpty()) {
bool hasOcclusionFromOutsideTargetSurface;
bool implDrawTransformIsUnknown = false;
@ -441,19 +527,19 @@ bool LayerTreeHostImpl::calculateRenderPasses(FrameData& frame)
while (frame.renderPassesById.contains(contributingRenderPassId)) {
RenderPass* renderPass = frame.renderPassesById.get(contributingRenderPassId);
AppendQuadsData appendQuadsData(renderPass->id());
renderPass->appendQuadsForLayer(*it, &occlusionTracker, appendQuadsData);
AppendQuadsData appendQuadsData(renderPass->id);
appendQuadsForLayer(renderPass, *it, occlusionTracker, appendQuadsData);
contributingRenderPassId = it->nextContributingRenderPassId(contributingRenderPassId);
}
}
targetRenderPass->appendQuadsForLayer(*it, &occlusionTracker, appendQuadsData);
appendQuadsForLayer(targetRenderPass, *it, occlusionTracker, appendQuadsData);
}
}
if (appendQuadsData.hadOcclusionFromOutsideTargetSurface)
targetRenderPass->setHasOcclusionFromOutsideTargetSurface(true);
targetRenderPass->has_occlusion_from_outside_target_surface = true;
if (appendQuadsData.hadMissingTiles) {
bool layerHasAnimatingTransform = it->screenSpaceTransformIsAnimating() || it->drawTransformIsAnimating();
@ -466,15 +552,15 @@ bool LayerTreeHostImpl::calculateRenderPasses(FrameData& frame)
#ifndef NDEBUG
for (size_t i = 0; i < frame.renderPasses.size(); ++i) {
for (size_t j = 0; j < frame.renderPasses[i]->quadList().size(); ++j)
DCHECK(frame.renderPasses[i]->quadList()[j]->shared_quad_state);
DCHECK(frame.renderPassesById.contains(frame.renderPasses[i]->id()));
for (size_t j = 0; j < frame.renderPasses[i]->quad_list.size(); ++j)
DCHECK(frame.renderPasses[i]->quad_list[j]->shared_quad_state);
DCHECK(frame.renderPassesById.contains(frame.renderPasses[i]->id));
}
#endif
if (!m_hasTransparentBackground) {
frame.renderPasses.back()->setHasTransparentBackground(false);
frame.renderPasses.back()->appendQuadsToFillScreen(m_rootLayerImpl.get(), m_backgroundColor, occlusionTracker);
frame.renderPasses.back()->has_transparent_background = false;
appendQuadsToFillScreen(frame.renderPasses.back(), m_rootLayerImpl.get(), m_backgroundColor, occlusionTracker);
}
if (drawFrame)
@ -555,7 +641,7 @@ static void removeRenderPassesRecursive(RenderPass::Id removeRenderPassId, Layer
frame.renderPasses.erase(toRemove);
// Now follow up for all RenderPass quads and remove their RenderPasses recursively.
const QuadList& quadList = removedPass->quadList();
const QuadList& quadList = removedPass->quad_list;
QuadList::constBackToFrontIterator quadListIterator = quadList.backToFrontBegin();
for (; quadListIterator != quadList.backToFrontEnd(); ++quadListIterator) {
DrawQuad* currentQuad = (*quadListIterator);
@ -583,7 +669,7 @@ bool LayerTreeHostImpl::CullRenderPassesWithNoQuads::shouldRemoveRenderPass(cons
return false;
// If any quad or RenderPass draws into this RenderPass, then keep it.
const QuadList& quadList = (*foundPass)->quadList();
const QuadList& quadList = (*foundPass)->quad_list;
for (QuadList::constBackToFrontIterator quadListIterator = quadList.backToFrontBegin(); quadListIterator != quadList.backToFrontEnd(); ++quadListIterator) {
DrawQuad* currentQuad = *quadListIterator;
@ -608,7 +694,7 @@ void LayerTreeHostImpl::removeRenderPasses(RenderPassCuller culler, FrameData& f
{
for (size_t it = culler.renderPassListBegin(frame.renderPasses); it != culler.renderPassListEnd(frame.renderPasses); it = culler.renderPassListNext(it)) {
const RenderPass* currentPass = frame.renderPasses[it];
const QuadList& quadList = currentPass->quadList();
const QuadList& quadList = currentPass->quad_list;
QuadList::constBackToFrontIterator quadListIterator = quadList.backToFrontBegin();
for (; quadListIterator != quadList.backToFrontEnd(); ++quadListIterator) {
@ -721,7 +807,7 @@ void LayerTreeHostImpl::drawLayers(const FrameData& frame)
// Once a RenderPass has been drawn, its damage should be cleared in
// case the RenderPass will be reused next frame.
for (unsigned int i = 0; i < frame.renderPasses.size(); i++)
frame.renderPasses[i]->setDamageRect(gfx::RectF());
frame.renderPasses[i]->damage_rect = gfx::RectF();
// The next frame should start by assuming nothing has changed, and changes are noted as they occur.
for (unsigned int i = 0; i < frame.renderSurfaceLayerList->size(); i++)

263
cc/layer_tree_host_impl_unittest.cc

@ -1868,12 +1868,12 @@ TEST_P(LayerTreeHostImplTest, viewportCovered)
ASSERT_EQ(1u, frame.renderPasses.size());
size_t numGutterQuads = 0;
for (size_t i = 0; i < frame.renderPasses[0]->quadList().size(); ++i)
numGutterQuads += (frame.renderPasses[0]->quadList()[i]->material == DrawQuad::SOLID_COLOR) ? 1 : 0;
for (size_t i = 0; i < frame.renderPasses[0]->quad_list.size(); ++i)
numGutterQuads += (frame.renderPasses[0]->quad_list[i]->material == DrawQuad::SOLID_COLOR) ? 1 : 0;
EXPECT_EQ(0u, numGutterQuads);
EXPECT_EQ(1u, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(1u, frame.renderPasses[0]->quad_list.size());
verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quadList(), gfx::Rect(gfx::Point(), viewportSize));
verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quad_list, gfx::Rect(gfx::Point(), viewportSize));
m_hostImpl->didDrawAllLayers(frame);
}
@ -1892,12 +1892,12 @@ TEST_P(LayerTreeHostImplTest, viewportCovered)
m_hostImpl->didDrawAllLayers(frame);
size_t numGutterQuads = 0;
for (size_t i = 0; i < frame.renderPasses[0]->quadList().size(); ++i)
numGutterQuads += (frame.renderPasses[0]->quadList()[i]->material == DrawQuad::SOLID_COLOR) ? 1 : 0;
for (size_t i = 0; i < frame.renderPasses[0]->quad_list.size(); ++i)
numGutterQuads += (frame.renderPasses[0]->quad_list[i]->material == DrawQuad::SOLID_COLOR) ? 1 : 0;
EXPECT_EQ(1u, numGutterQuads);
EXPECT_EQ(1u, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(1u, frame.renderPasses[0]->quad_list.size());
verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quadList(), gfx::Rect(gfx::Point(), viewportSize));
verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quad_list, gfx::Rect(gfx::Point(), viewportSize));
m_hostImpl->didDrawAllLayers(frame);
}
@ -1915,12 +1915,12 @@ TEST_P(LayerTreeHostImplTest, viewportCovered)
ASSERT_EQ(1u, frame.renderPasses.size());
size_t numGutterQuads = 0;
for (size_t i = 0; i < frame.renderPasses[0]->quadList().size(); ++i)
numGutterQuads += (frame.renderPasses[0]->quadList()[i]->material == DrawQuad::SOLID_COLOR) ? 1 : 0;
for (size_t i = 0; i < frame.renderPasses[0]->quad_list.size(); ++i)
numGutterQuads += (frame.renderPasses[0]->quad_list[i]->material == DrawQuad::SOLID_COLOR) ? 1 : 0;
EXPECT_EQ(4u, numGutterQuads);
EXPECT_EQ(5u, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(5u, frame.renderPasses[0]->quad_list.size());
verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quadList(), gfx::Rect(gfx::Point(), viewportSize));
verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quad_list, gfx::Rect(gfx::Point(), viewportSize));
m_hostImpl->didDrawAllLayers(frame);
}
@ -2366,10 +2366,10 @@ TEST_P(LayerTreeHostImplTest, contributingLayerEmptyScissorPartialSwap)
// Verify all quads have been computed
ASSERT_EQ(2U, frame.renderPasses.size());
ASSERT_EQ(1U, frame.renderPasses[0]->quadList().size());
ASSERT_EQ(1U, frame.renderPasses[1]->quadList().size());
EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.renderPasses[0]->quadList()[0]->material);
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material);
ASSERT_EQ(1U, frame.renderPasses[0]->quad_list.size());
ASSERT_EQ(1U, frame.renderPasses[1]->quad_list.size());
EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.renderPasses[0]->quad_list[0]->material);
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
}
}
@ -2387,10 +2387,10 @@ TEST_P(LayerTreeHostImplTest, contributingLayerEmptyScissorNoPartialSwap)
// Verify all quads have been computed
ASSERT_EQ(2U, frame.renderPasses.size());
ASSERT_EQ(1U, frame.renderPasses[0]->quadList().size());
ASSERT_EQ(1U, frame.renderPasses[1]->quadList().size());
EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.renderPasses[0]->quadList()[0]->material);
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material);
ASSERT_EQ(1U, frame.renderPasses[0]->quad_list.size());
ASSERT_EQ(1U, frame.renderPasses[1]->quad_list.size());
EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.renderPasses[0]->quad_list[0]->material);
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
}
}
@ -2714,14 +2714,15 @@ static inline scoped_ptr<RenderPass> createRenderPassWithResource(ResourceProvid
{
ResourceProvider::ResourceId resourceId = provider->createResource(0, gfx::Size(1, 1), GL_RGBA, ResourceProvider::TextureUsageAny);
scoped_ptr<TestRenderPass> pass = TestRenderPass::create(RenderPass::Id(1, 1), gfx::Rect(0, 0, 1, 1), WebTransformationMatrix());
scoped_ptr<TestRenderPass> pass = TestRenderPass::Create();
pass->SetNew(RenderPass::Id(1, 1), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), WebTransformationMatrix());
scoped_ptr<SharedQuadState> sharedState = SharedQuadState::Create();
sharedState->SetAll(WebTransformationMatrix(), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), 1);
scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
quad->SetNew(sharedState.get(), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), resourceId, false, gfx::RectF(0, 0, 1, 1), false);
pass->appendSharedQuadState(sharedState.Pass());
pass->appendQuad(quad.PassAs<DrawQuad>());
pass->AppendSharedQuadState(sharedState.Pass());
pass->AppendQuad(quad.PassAs<DrawQuad>());
return pass.PassAs<RenderPass>();
}
@ -3148,21 +3149,21 @@ TEST_P(LayerTreeHostImplTest, textureCachingWithClipping)
// Must receive two render passes, each with one quad
ASSERT_EQ(2U, frame.renderPasses.size());
EXPECT_EQ(2U, frame.renderPasses[0]->quadList().size());
ASSERT_EQ(1U, frame.renderPasses[1]->quadList().size());
EXPECT_EQ(2U, frame.renderPasses[0]->quad_list.size());
ASSERT_EQ(1U, frame.renderPasses[1]->quad_list.size());
// Verify that the child layers are being clipped.
gfx::Rect quadVisibleRect = frame.renderPasses[0]->quadList()[0]->visible_rect;
gfx::Rect quadVisibleRect = frame.renderPasses[0]->quad_list[0]->visible_rect;
EXPECT_LT(quadVisibleRect.width(), 100);
quadVisibleRect = frame.renderPasses[0]->quadList()[1]->visible_rect;
quadVisibleRect = frame.renderPasses[0]->quad_list[1]->visible_rect;
EXPECT_LT(quadVisibleRect.width(), 100);
// Verify that the render surface texture is *not* clipped.
EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), frame.renderPasses[0]->outputRect());
EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), frame.renderPasses[0]->output_rect);
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]);
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quad_list[0]);
EXPECT_FALSE(quad->contents_changed_since_last_frame.IsEmpty());
myHostImpl->drawLayers(frame);
@ -3184,8 +3185,8 @@ TEST_P(LayerTreeHostImplTest, textureCachingWithClipping)
// Must receive two render passes, each with one quad
ASSERT_EQ(2U, frame.renderPasses.size());
EXPECT_EQ(2U, frame.renderPasses[0]->quadList().size());
ASSERT_EQ(1U, frame.renderPasses[1]->quadList().size());
EXPECT_EQ(2U, frame.renderPasses[0]->quad_list.size());
ASSERT_EQ(1U, frame.renderPasses[1]->quad_list.size());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -3254,9 +3255,9 @@ TEST_P(LayerTreeHostImplTest, textureCachingWithOcclusion)
// For Root, there are 2 quads; for S1, there are 2 quads (1 is occluded); for S2, there is 2 quads.
ASSERT_EQ(3U, frame.renderPasses.size());
EXPECT_EQ(2U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(2U, frame.renderPasses[1]->quadList().size());
EXPECT_EQ(2U, frame.renderPasses[2]->quadList().size());
EXPECT_EQ(2U, frame.renderPasses[0]->quad_list.size());
EXPECT_EQ(2U, frame.renderPasses[1]->quad_list.size());
EXPECT_EQ(2U, frame.renderPasses[2]->quad_list.size());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -3278,8 +3279,8 @@ TEST_P(LayerTreeHostImplTest, textureCachingWithOcclusion)
// For S2, there is no render pass
ASSERT_EQ(2U, frame.renderPasses.size());
EXPECT_GT(frame.renderPasses[0]->quadList().size(), 0U);
EXPECT_EQ(2U, frame.renderPasses[1]->quadList().size());
EXPECT_GT(frame.renderPasses[0]->quad_list.size(), 0U);
EXPECT_EQ(2U, frame.renderPasses[1]->quad_list.size());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -3298,7 +3299,7 @@ TEST_P(LayerTreeHostImplTest, textureCachingWithOcclusion)
// Must receive 1 render pass - for the root.
ASSERT_EQ(1U, frame.renderPasses.size());
EXPECT_EQ(2U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(2U, frame.renderPasses[0]->quad_list.size());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -3367,11 +3368,11 @@ TEST_P(LayerTreeHostImplTest, textureCachingWithOcclusionEarlyOut)
// For Root, there are 2 quads; for S1, there are 3 quads; for S2, there is 1 quad.
ASSERT_EQ(3U, frame.renderPasses.size());
EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
// L14 is culled, so only 3 quads.
EXPECT_EQ(3U, frame.renderPasses[1]->quadList().size());
EXPECT_EQ(2U, frame.renderPasses[2]->quadList().size());
EXPECT_EQ(3U, frame.renderPasses[1]->quad_list.size());
EXPECT_EQ(2U, frame.renderPasses[2]->quad_list.size());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -3393,8 +3394,8 @@ TEST_P(LayerTreeHostImplTest, textureCachingWithOcclusionEarlyOut)
// For S2, there is no render pass
ASSERT_EQ(2U, frame.renderPasses.size());
EXPECT_GT(frame.renderPasses[0]->quadList().size(), 0U);
EXPECT_EQ(2U, frame.renderPasses[1]->quadList().size());
EXPECT_GT(frame.renderPasses[0]->quad_list.size(), 0U);
EXPECT_EQ(2U, frame.renderPasses[1]->quad_list.size());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -3413,7 +3414,7 @@ TEST_P(LayerTreeHostImplTest, textureCachingWithOcclusionEarlyOut)
// Must receive 1 render pass - for the root.
ASSERT_EQ(1U, frame.renderPasses.size());
EXPECT_EQ(2U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(2U, frame.renderPasses[0]->quad_list.size());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -3475,9 +3476,9 @@ TEST_P(LayerTreeHostImplTest, textureCachingWithOcclusionExternalOverInternal)
// For Root, there are 2 quads; for S1, there are 3 quads; for S2, there is 1 quad.
ASSERT_EQ(3U, frame.renderPasses.size());
EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(3U, frame.renderPasses[1]->quadList().size());
EXPECT_EQ(2U, frame.renderPasses[2]->quadList().size());
EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
EXPECT_EQ(3U, frame.renderPasses[1]->quad_list.size());
EXPECT_EQ(2U, frame.renderPasses[2]->quad_list.size());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -3499,8 +3500,8 @@ TEST_P(LayerTreeHostImplTest, textureCachingWithOcclusionExternalOverInternal)
// For S2, there is no render pass
ASSERT_EQ(2U, frame.renderPasses.size());
EXPECT_GT(frame.renderPasses[0]->quadList().size(), 0U);
EXPECT_EQ(2U, frame.renderPasses[1]->quadList().size());
EXPECT_GT(frame.renderPasses[0]->quad_list.size(), 0U);
EXPECT_EQ(2U, frame.renderPasses[1]->quad_list.size());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -3556,8 +3557,8 @@ TEST_P(LayerTreeHostImplTest, textureCachingWithOcclusionExternalNotAligned)
// Must receive 2 render passes.
ASSERT_EQ(2U, frame.renderPasses.size());
EXPECT_EQ(2U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(1U, frame.renderPasses[1]->quadList().size());
EXPECT_EQ(2U, frame.renderPasses[0]->quad_list.size());
EXPECT_EQ(1U, frame.renderPasses[1]->quad_list.size());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -3572,7 +3573,7 @@ TEST_P(LayerTreeHostImplTest, textureCachingWithOcclusionExternalNotAligned)
// One render pass must be gone due to cached texture.
ASSERT_EQ(1U, frame.renderPasses.size());
EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -3642,9 +3643,9 @@ TEST_P(LayerTreeHostImplTest, textureCachingWithOcclusionPartialSwap)
// For Root, there are 2 quads; for S1, there are 2 quads (one is occluded); for S2, there is 2 quads.
ASSERT_EQ(3U, frame.renderPasses.size());
EXPECT_EQ(2U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(2U, frame.renderPasses[1]->quadList().size());
EXPECT_EQ(2U, frame.renderPasses[2]->quadList().size());
EXPECT_EQ(2U, frame.renderPasses[0]->quad_list.size());
EXPECT_EQ(2U, frame.renderPasses[1]->quad_list.size());
EXPECT_EQ(2U, frame.renderPasses[2]->quad_list.size());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -3666,8 +3667,8 @@ TEST_P(LayerTreeHostImplTest, textureCachingWithOcclusionPartialSwap)
// For S2, there is no render pass
ASSERT_EQ(2U, frame.renderPasses.size());
EXPECT_EQ(2U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(2U, frame.renderPasses[1]->quadList().size());
EXPECT_EQ(2U, frame.renderPasses[0]->quad_list.size());
EXPECT_EQ(2U, frame.renderPasses[1]->quad_list.size());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -3816,13 +3817,13 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching)
// Must receive two render passes, each with one quad
ASSERT_EQ(2U, frame.renderPasses.size());
EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(1U, frame.renderPasses[1]->quadList().size());
EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
EXPECT_EQ(1U, frame.renderPasses[1]->quad_list.size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]);
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quad_list[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_FALSE(targetPass->damageRect().IsEmpty());
EXPECT_FALSE(targetPass->damage_rect.IsEmpty());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -3836,11 +3837,11 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching)
// Must receive one render pass, as the other one should be culled
ASSERT_EQ(1U, frame.renderPasses.size());
EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]);
EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_TRUE(targetPass->damageRect().IsEmpty());
EXPECT_TRUE(targetPass->damage_rect.IsEmpty());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -3855,11 +3856,11 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching)
// Must receive one render pass, as the other one should be culled
ASSERT_EQ(1U, frame.renderPasses.size());
EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]);
EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_TRUE(targetPass->damageRect().IsEmpty());
EXPECT_TRUE(targetPass->damage_rect.IsEmpty());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -3874,13 +3875,13 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching)
// Must receive two render passes, each with one quad
ASSERT_EQ(2U, frame.renderPasses.size());
EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.renderPasses[0]->quadList()[0]->material);
EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.renderPasses[0]->quad_list[0]->material);
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]);
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quad_list[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_FALSE(targetPass->damageRect().IsEmpty());
EXPECT_FALSE(targetPass->damage_rect.IsEmpty());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -3901,16 +3902,16 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching)
// Even though not enough properties changed, the entire thing must be
// redrawn as we don't have cached textures
EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(1U, frame.renderPasses[1]->quadList().size());
EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
EXPECT_EQ(1U, frame.renderPasses[1]->quad_list.size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]);
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quad_list[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_TRUE(targetPass->damageRect().IsEmpty());
EXPECT_TRUE(targetPass->damage_rect.IsEmpty());
// Was our surface evicted?
EXPECT_FALSE(myHostImpl->renderer()->haveCachedResourcesForRenderPassId(targetPass->id()));
EXPECT_FALSE(myHostImpl->renderer()->haveCachedResourcesForRenderPassId(targetPass->id));
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -3924,11 +3925,11 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching)
// Must receive one render pass, as the other one should be culled
ASSERT_EQ(1U, frame.renderPasses.size());
EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]);
EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_TRUE(targetPass->damageRect().IsEmpty());
EXPECT_TRUE(targetPass->damage_rect.IsEmpty());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -3944,12 +3945,12 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching)
// Must receive one render pass, as the other one should be culled.
ASSERT_EQ(1U, frame.renderPasses.size());
EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]);
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_TRUE(targetPass->damageRect().IsEmpty());
EXPECT_TRUE(targetPass->damage_rect.IsEmpty());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -3975,19 +3976,19 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
// Must receive two render passes, each with one quad
ASSERT_EQ(2U, frame.renderPasses.size());
EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(1U, frame.renderPasses[1]->quadList().size());
EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
EXPECT_EQ(1U, frame.renderPasses[1]->quad_list.size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]);
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quad_list[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_FALSE(targetPass->damageRect().IsEmpty());
EXPECT_FALSE(targetPass->damage_rect.IsEmpty());
EXPECT_FALSE(frame.renderPasses[0]->damageRect().IsEmpty());
EXPECT_FALSE(frame.renderPasses[1]->damageRect().IsEmpty());
EXPECT_FALSE(frame.renderPasses[0]->damage_rect.IsEmpty());
EXPECT_FALSE(frame.renderPasses[1]->damage_rect.IsEmpty());
EXPECT_FALSE(frame.renderPasses[0]->hasOcclusionFromOutsideTargetSurface());
EXPECT_FALSE(frame.renderPasses[1]->hasOcclusionFromOutsideTargetSurface());
EXPECT_FALSE(frame.renderPasses[0]->has_occlusion_from_outside_target_surface);
EXPECT_FALSE(frame.renderPasses[1]->has_occlusion_from_outside_target_surface);
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -4002,9 +4003,9 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
// One of the passes should be culled as a result, since contents didn't change
// and we have cached texture.
ASSERT_EQ(1U, frame.renderPasses.size());
EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
EXPECT_TRUE(frame.renderPasses[0]->damageRect().IsEmpty());
EXPECT_TRUE(frame.renderPasses[0]->damage_rect.IsEmpty());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -4019,11 +4020,11 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
// Must receive one render pass, as the other one should be culled
ASSERT_EQ(1U, frame.renderPasses.size());
EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]);
EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_TRUE(targetPass->damageRect().IsEmpty());
EXPECT_TRUE(targetPass->damage_rect.IsEmpty());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -4038,13 +4039,13 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
// Must receive two render passes, each with one quad
ASSERT_EQ(2U, frame.renderPasses.size());
EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.renderPasses[0]->quadList()[0]->material);
EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.renderPasses[0]->quad_list[0]->material);
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]);
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quad_list[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_FALSE(targetPass->damageRect().IsEmpty());
EXPECT_FALSE(targetPass->damage_rect.IsEmpty());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -4065,16 +4066,16 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
// Even though not enough properties changed, the entire thing must be
// redrawn as we don't have cached textures
EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(1U, frame.renderPasses[1]->quadList().size());
EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
EXPECT_EQ(1U, frame.renderPasses[1]->quad_list.size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]);
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quad_list[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_TRUE(targetPass->damageRect().IsEmpty());
EXPECT_TRUE(targetPass->damage_rect.IsEmpty());
// Was our surface evicted?
EXPECT_FALSE(myHostImpl->renderer()->haveCachedResourcesForRenderPassId(targetPass->id()));
EXPECT_FALSE(myHostImpl->renderer()->haveCachedResourcesForRenderPassId(targetPass->id));
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -4089,7 +4090,7 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
// One of the passes should be culled as a result, since contents didn't change
// and we have cached texture.
ASSERT_EQ(1U, frame.renderPasses.size());
EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -4105,12 +4106,12 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
// Must receive one render pass, as the other one should be culled.
ASSERT_EQ(1U, frame.renderPasses.size());
EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]);
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_TRUE(targetPass->damageRect().IsEmpty());
EXPECT_TRUE(targetPass->damage_rect.IsEmpty());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -4197,7 +4198,9 @@ static void configureRenderPassTestData(const char* testScript, RenderPassRemova
// Pre-create root pass
RenderPass::Id rootRenderPassId = RenderPass::Id(testScript[0], testScript[1]);
testData.renderPassCache.add(rootRenderPassId, TestRenderPass::create(rootRenderPassId, gfx::Rect(), WebTransformationMatrix()));
scoped_ptr<TestRenderPass> pass = TestRenderPass::Create();
pass->SetNew(rootRenderPassId, gfx::Rect(), gfx::Rect(), WebTransformationMatrix());
testData.renderPassCache.add(rootRenderPassId, pass.Pass());
while (*currentChar) {
int layerId = *currentChar;
currentChar++;
@ -4220,7 +4223,7 @@ static void configureRenderPassTestData(const char* testScript, RenderPassRemova
scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
quad->SetNew(testData.sharedQuadState.get(), gfx::Rect(0, 0, 10, 10), SK_ColorWHITE);
renderPass->appendQuad(quad.PassAs<DrawQuad>());
renderPass->AppendQuad(quad.PassAs<DrawQuad>());
currentChar++;
} else if ((*currentChar >= 'A') && (*currentChar <= 'Z')) {
// RenderPass draw quad
@ -4255,14 +4258,16 @@ static void configureRenderPassTestData(const char* testScript, RenderPassRemova
if (hasTexture)
renderer->setHaveCachedResourcesForRenderPassId(newRenderPassId);
testData.renderPassCache.add(newRenderPassId, TestRenderPass::create(newRenderPassId, gfx::Rect(), WebTransformationMatrix()));
scoped_ptr<TestRenderPass> pass = TestRenderPass::Create();
pass->SetNew(newRenderPassId, gfx::Rect(), gfx::Rect(), WebTransformationMatrix());
testData.renderPassCache.add(newRenderPassId, pass.Pass());
}
gfx::Rect quadRect = gfx::Rect(0, 0, 1, 1);
gfx::Rect contentsChangedRect = contentsChanged ? quadRect : gfx::Rect();
scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
quad->SetNew(testData.sharedQuadState.get(), quadRect, newRenderPassId, isReplica, 1, contentsChangedRect, 1, 1, 0, 0);
renderPass->appendQuad(quad.PassAs<DrawQuad>());
renderPass->AppendQuad(quad.PassAs<DrawQuad>());
}
}
testData.renderPasses.insert(testData.renderPasses.begin(), renderPass.get());
@ -4277,13 +4282,13 @@ void dumpRenderPassTestData(const RenderPassRemovalTestData& testData, char* buf
char* pos = buffer;
for (RenderPassList::const_reverse_iterator it = testData.renderPasses.rbegin(); it != testData.renderPasses.rend(); ++it) {
const RenderPass* currentPass = *it;
*pos = currentPass->id().layerId;
*pos = currentPass->id.layer_id;
pos++;
*pos = currentPass->id().index;
*pos = currentPass->id.index;
pos++;
QuadList::const_iterator quadListIterator = currentPass->quadList().begin();
while (quadListIterator != currentPass->quadList().end()) {
QuadList::const_iterator quadListIterator = currentPass->quad_list.begin();
while (quadListIterator != currentPass->quad_list.end()) {
DrawQuad* currentQuad = *quadListIterator;
switch (currentQuad->material) {
case DrawQuad::SOLID_COLOR:
@ -4291,7 +4296,7 @@ void dumpRenderPassTestData(const RenderPassRemovalTestData& testData, char* buf
pos++;
break;
case DrawQuad::RENDER_PASS:
*pos = RenderPassDrawQuad::MaterialCast(currentQuad)->render_pass_id.layerId;
*pos = RenderPassDrawQuad::MaterialCast(currentQuad)->render_pass_id.layer_id;
pos++;
*pos = RenderPassDrawQuad::MaterialCast(currentQuad)->render_pass_id.index;
pos++;

8
cc/quad_culler.cc

@ -18,7 +18,7 @@ using namespace std;
namespace cc {
QuadCuller::QuadCuller(QuadList& quadList, SharedQuadStateList& sharedQuadStateList, const LayerImpl* layer, const OcclusionTrackerImpl* occlusionTracker, bool showCullingWithDebugBorderQuads, bool forSurface)
QuadCuller::QuadCuller(QuadList& quadList, SharedQuadStateList& sharedQuadStateList, const LayerImpl* layer, const OcclusionTrackerImpl& occlusionTracker, bool showCullingWithDebugBorderQuads, bool forSurface)
: m_quadList(quadList)
, m_sharedQuadStateList(sharedQuadStateList)
, m_currentSharedQuadState(0)
@ -73,13 +73,13 @@ bool QuadCuller::append(scoped_ptr<DrawQuad> drawQuad, AppendQuadsData& appendQu
bool implDrawTransformIsUnknown = false;
if (m_forSurface)
culledRect = m_occlusionTracker->unoccludedContributingSurfaceContentRect(m_layer, false, drawQuad->rect, &hasOcclusionFromOutsideTargetSurface);
culledRect = m_occlusionTracker.unoccludedContributingSurfaceContentRect(m_layer, false, drawQuad->rect, &hasOcclusionFromOutsideTargetSurface);
else
culledRect = m_occlusionTracker->unoccludedContentRect(m_layer->renderTarget(), drawQuad->rect, drawQuad->quadTransform(), implDrawTransformIsUnknown, drawQuad->clippedRectInTarget(), &hasOcclusionFromOutsideTargetSurface);
culledRect = m_occlusionTracker.unoccludedContentRect(m_layer->renderTarget(), drawQuad->rect, drawQuad->quadTransform(), implDrawTransformIsUnknown, drawQuad->clippedRectInTarget(), &hasOcclusionFromOutsideTargetSurface);
appendQuadsData.hadOcclusionFromOutsideTargetSurface |= hasOcclusionFromOutsideTargetSurface;
return appendQuadInternal(drawQuad.Pass(), culledRect, m_quadList, *m_occlusionTracker, m_layer, m_showCullingWithDebugBorderQuads);
return appendQuadInternal(drawQuad.Pass(), culledRect, m_quadList, m_occlusionTracker, m_layer, m_showCullingWithDebugBorderQuads);
}
} // namespace cc

7
cc/quad_culler.h

@ -17,7 +17,7 @@ class OcclusionTrackerBase;
class CC_EXPORT QuadCuller : public QuadSink {
public:
QuadCuller(QuadList&, SharedQuadStateList&, const LayerImpl*, const OcclusionTrackerBase<LayerImpl, RenderSurfaceImpl>*, bool showCullingWithDebugBorderQuads, bool forSurface);
QuadCuller(QuadList&, SharedQuadStateList&, const LayerImpl*, const OcclusionTrackerBase<LayerImpl, RenderSurfaceImpl>&, bool showCullingWithDebugBorderQuads, bool forSurface);
virtual ~QuadCuller() { }
// QuadSink implementation.
@ -27,9 +27,10 @@ public:
private:
QuadList& m_quadList;
SharedQuadStateList& m_sharedQuadStateList;
SharedQuadState* m_currentSharedQuadState;
const LayerImpl* m_layer;
const OcclusionTrackerBase<LayerImpl, RenderSurfaceImpl>* m_occlusionTracker;
const OcclusionTrackerBase<LayerImpl, RenderSurfaceImpl>& m_occlusionTracker;
SharedQuadState* m_currentSharedQuadState;
bool m_showCullingWithDebugBorderQuads;
bool m_forSurface;
};

2
cc/quad_culler_unittest.cc

@ -78,7 +78,7 @@ static scoped_ptr<TiledLayerImpl> makeLayer(TiledLayerImpl* parent, const WebTra
static void appendQuads(QuadList& quadList, SharedQuadStateList& sharedStateList, TiledLayerImpl* layer, LayerIteratorType& it, OcclusionTrackerImpl& occlusionTracker)
{
occlusionTracker.enterLayer(it);
QuadCuller quadCuller(quadList, sharedStateList, layer, &occlusionTracker, false, false);
QuadCuller quadCuller(quadList, sharedStateList, layer, occlusionTracker, false, false);
AppendQuadsData data;
layer->appendQuads(quadCuller, data);
occlusionTracker.leaveLayer(it);

145
cc/render_pass.cc

@ -4,113 +4,84 @@
#include "cc/render_pass.h"
#include "cc/layer_impl.h"
#include "cc/math_util.h"
#include "cc/occlusion_tracker.h"
#include "cc/quad_culler.h"
#include "cc/shared_quad_state.h"
#include "cc/solid_color_draw_quad.h"
#include "third_party/skia/include/core/SkImageFilter.h"
using WebKit::WebTransformationMatrix;
namespace cc {
scoped_ptr<RenderPass> RenderPass::create(Id id, gfx::Rect outputRect, const WebKit::WebTransformationMatrix& transformToRootTarget)
{
return make_scoped_ptr(new RenderPass(id, outputRect, transformToRootTarget));
scoped_ptr<RenderPass> RenderPass::Create() {
return make_scoped_ptr(new RenderPass);
}
RenderPass::RenderPass(Id id, gfx::Rect outputRect, const WebKit::WebTransformationMatrix& transformToRootTarget)
: m_id(id)
, m_transformToRootTarget(transformToRootTarget)
, m_outputRect(outputRect)
, m_hasTransparentBackground(true)
, m_hasOcclusionFromOutsideTargetSurface(false)
, m_filter(0)
{
DCHECK(id.layerId > 0);
DCHECK(id.index >= 0);
RenderPass::RenderPass()
: id(Id(-1, -1)),
has_transparent_background(true),
has_occlusion_from_outside_target_surface(false),
filter(NULL) {
}
RenderPass::~RenderPass()
{
SkSafeUnref(m_filter);
RenderPass::~RenderPass() {
SkSafeUnref(filter);
}
scoped_ptr<RenderPass> RenderPass::copy(Id newId) const
{
DCHECK(newId != m_id);
scoped_ptr<RenderPass> RenderPass::Copy(Id new_id) const {
DCHECK(new_id != id);
scoped_ptr<RenderPass> copyPass(create(newId, m_outputRect, m_transformToRootTarget));
copyPass->setDamageRect(m_damageRect);
copyPass->setHasTransparentBackground(m_hasTransparentBackground);
copyPass->setHasOcclusionFromOutsideTargetSurface(m_hasOcclusionFromOutsideTargetSurface);
copyPass->setFilters(m_filters);
copyPass->setBackgroundFilters(m_backgroundFilters);
copyPass->setFilter(m_filter);
return copyPass.Pass();
scoped_ptr<RenderPass> copy_pass(Create());
copy_pass->SetAll(new_id,
output_rect,
damage_rect,
transform_to_root_target,
has_transparent_background,
has_occlusion_from_outside_target_surface,
filters,
filter,
background_filters);
return copy_pass.Pass();
}
void RenderPass::appendQuadsForLayer(LayerImpl* layer, OcclusionTrackerImpl* occlusionTracker, AppendQuadsData& appendQuadsData)
{
bool forSurface = false;
QuadCuller quadCuller(m_quadList, m_sharedQuadStateList, layer, occlusionTracker, layer->showDebugBorders(), forSurface);
void RenderPass::SetNew(Id id,
gfx::Rect output_rect,
gfx::RectF damage_rect,
const WebKit::WebTransformationMatrix& transform_to_root_target) {
DCHECK_GT(id.layer_id, 0);
DCHECK_GE(id.index, 0);
layer->appendQuads(quadCuller, appendQuadsData);
this->id = id;
this->output_rect = output_rect;
this->damage_rect = damage_rect;
this->transform_to_root_target = transform_to_root_target;
DCHECK(quad_list.isEmpty());
DCHECK(shared_quad_state_list.isEmpty());
}
void RenderPass::appendQuadsForRenderSurfaceLayer(LayerImpl* layer, const RenderPass* contributingRenderPass, OcclusionTrackerImpl* occlusionTracker, AppendQuadsData& appendQuadsData)
{
bool forSurface = true;
QuadCuller quadCuller(m_quadList, m_sharedQuadStateList, layer, occlusionTracker, layer->showDebugBorders(), forSurface);
void RenderPass::SetAll(Id id,
gfx::Rect output_rect,
gfx::RectF damage_rect,
const WebKit::WebTransformationMatrix& transform_to_root_target,
bool has_transparent_background,
bool has_occlusion_from_outside_target_surface,
const WebKit::WebFilterOperations& filters,
SkImageFilter* filter,
const WebKit::WebFilterOperations& background_filters) {
DCHECK_GT(id.layer_id, 0);
DCHECK_GE(id.index, 0);
bool isReplica = false;
layer->renderSurface()->appendQuads(quadCuller, appendQuadsData, isReplica, contributingRenderPass->id());
this->id = id;
this->output_rect = output_rect;
this->damage_rect = damage_rect;
this->transform_to_root_target = transform_to_root_target;
this->has_transparent_background = has_transparent_background;
this->has_occlusion_from_outside_target_surface =
has_occlusion_from_outside_target_surface;
this->filters = filters;
SkRefCnt_SafeAssign(this->filter, filter);
this->background_filters = background_filters;
// Add replica after the surface so that it appears below the surface.
if (layer->hasReplica()) {
isReplica = true;
layer->renderSurface()->appendQuads(quadCuller, appendQuadsData, isReplica, contributingRenderPass->id());
}
}
void RenderPass::appendQuadsToFillScreen(LayerImpl* rootLayer, SkColor screenBackgroundColor, const OcclusionTrackerImpl& occlusionTracker)
{
if (!rootLayer || !screenBackgroundColor)
return;
Region fillRegion = occlusionTracker.computeVisibleRegionInScreen();
if (fillRegion.IsEmpty())
return;
bool forSurface = false;
QuadCuller quadCuller(m_quadList, m_sharedQuadStateList, rootLayer, &occlusionTracker, rootLayer->showDebugBorders(), forSurface);
// Manually create the quad state for the gutter quads, as the root layer
// doesn't have any bounds and so can't generate this itself.
// FIXME: Make the gutter quads generated by the solid color layer (make it smarter about generating quads to fill unoccluded areas).
DCHECK(rootLayer->screenSpaceTransform().isInvertible());
gfx::Rect rootTargetRect = rootLayer->renderSurface()->contentRect();
float opacity = 1;
SharedQuadState* sharedQuadState = quadCuller.useSharedQuadState(SharedQuadState::Create());
sharedQuadState->SetAll(rootLayer->drawTransform(), rootTargetRect, rootTargetRect, opacity);
WebTransformationMatrix transformToLayerSpace = rootLayer->screenSpaceTransform().inverse();
for (Region::Iterator fillRects(fillRegion); fillRects.has_rect(); fillRects.next()) {
// The root layer transform is composed of translations and scales only, no perspective, so mapping is sufficient.
gfx::Rect layerRect = MathUtil::mapClippedRect(transformToLayerSpace, fillRects.rect());
// Skip the quad culler and just append the quads directly to avoid occlusion checks.
scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
quad->SetNew(sharedQuadState, layerRect, screenBackgroundColor);
m_quadList.append(quad.PassAs<DrawQuad>());
}
}
void RenderPass::setFilter(SkImageFilter* filter) {
SkRefCnt_SafeAssign(m_filter, filter);
DCHECK(quad_list.isEmpty());
DCHECK(shared_quad_state_list.isEmpty());
}
} // namespace cc

146
cc/render_pass.h

@ -22,101 +22,97 @@ class SkImageFilter;
namespace cc {
class LayerImpl;
template<typename LayerType, typename SurfaceType>
class OcclusionTrackerBase;
class RenderSurfaceImpl;
struct AppendQuadsData;
typedef OcclusionTrackerBase<LayerImpl, RenderSurfaceImpl> OcclusionTrackerImpl;
// A list of DrawQuad objects, sorted internally in front-to-back order.
class QuadList : public ScopedPtrVector<DrawQuad> {
public:
typedef reverse_iterator backToFrontIterator;
typedef const_reverse_iterator constBackToFrontIterator;
public:
typedef reverse_iterator backToFrontIterator;
typedef const_reverse_iterator constBackToFrontIterator;
inline backToFrontIterator backToFrontBegin() { return rbegin(); }
inline backToFrontIterator backToFrontEnd() { return rend(); }
inline constBackToFrontIterator backToFrontBegin() const { return rbegin(); }
inline constBackToFrontIterator backToFrontEnd() const { return rend(); }
inline backToFrontIterator backToFrontBegin() { return rbegin(); }
inline backToFrontIterator backToFrontEnd() { return rend(); }
inline constBackToFrontIterator backToFrontBegin() const { return rbegin(); }
inline constBackToFrontIterator backToFrontEnd() const { return rend(); }
};
typedef ScopedPtrVector<SharedQuadState> SharedQuadStateList;
class CC_EXPORT RenderPass {
public:
~RenderPass();
public:
struct Id {
int layer_id;
int index;
struct Id {
int layerId;
int index;
Id(int layer_id, int index) : layer_id(layer_id), index(index) {}
Id(int layerId, int index)
: layerId(layerId)
, index(index)
{
}
bool operator==(const Id& other) const {
return layer_id == other.layer_id && index == other.index;
}
bool operator!=(const Id& other) const {
return !(*this == other);
}
bool operator<(const Id& other) const {
return layer_id < other.layer_id ||
(layer_id == other.layer_id && index < other.index);
}
};
bool operator==(const Id& other) const { return layerId == other.layerId && index == other.index; }
bool operator!=(const Id& other) const { return !(*this == other); }
bool operator<(const Id& other) const { return layerId < other.layerId || (layerId == other.layerId && index < other.index); }
};
~RenderPass();
static scoped_ptr<RenderPass> create(Id, gfx::Rect outputRect, const WebKit::WebTransformationMatrix& transformToRootTarget);
static scoped_ptr<RenderPass> Create();
// A shallow copy of the render pass, which does not include its quads.
scoped_ptr<RenderPass> copy(Id newId) const;
// A shallow copy of the render pass, which does not include its quads.
scoped_ptr<RenderPass> Copy(Id newId) const;
void appendQuadsForLayer(LayerImpl*, OcclusionTrackerImpl*, AppendQuadsData&);
void appendQuadsForRenderSurfaceLayer(LayerImpl*, const RenderPass* contributingRenderPass, OcclusionTrackerImpl*, AppendQuadsData&);
void appendQuadsToFillScreen(LayerImpl* rootLayer, SkColor screenBackgroundColor, const OcclusionTrackerImpl&);
void SetNew(Id id,
gfx::Rect output_rect,
gfx::RectF damage_rect,
const WebKit::WebTransformationMatrix& transform_to_root_target);
const QuadList& quadList() const { return m_quadList; }
void SetAll(Id id,
gfx::Rect output_rect,
gfx::RectF damage_rect,
const WebKit::WebTransformationMatrix& transform_to_root_target,
bool has_transparent_background,
bool has_occlusion_from_outside_target_surface,
const WebKit::WebFilterOperations& filters,
SkImageFilter* filter,
const WebKit::WebFilterOperations& background_filters);
Id id() const { return m_id; }
// Uniquely identifies the render pass in the compositor's current frame.
Id id;
// FIXME: Modify this transform when merging the RenderPass into a parent compositor.
// Transforms from quad's original content space to the root target's content space.
const WebKit::WebTransformationMatrix& transformToRootTarget() const { return m_transformToRootTarget; }
// These are in the space of the render pass' physical pixels.
gfx::Rect output_rect;
gfx::RectF damage_rect;
// This denotes the bounds in physical pixels of the output generated by this RenderPass.
const gfx::Rect& outputRect() const { return m_outputRect; }
// Transforms from the origin of the |output_rect| to the origin of the root
// render pass' |output_rect|.
WebKit::WebTransformationMatrix transform_to_root_target;
gfx::RectF damageRect() const { return m_damageRect; }
void setDamageRect(gfx::RectF rect) { m_damageRect = rect; }
// If false, the pixels in the render pass' texture are all opaque.
bool has_transparent_background;
const WebKit::WebFilterOperations& filters() const { return m_filters; }
void setFilters(const WebKit::WebFilterOperations& filters) { m_filters = filters; }
// If true, then there may be pixels in the render pass' texture that are not
// complete, since they are occluded.
bool has_occlusion_from_outside_target_surface;
const WebKit::WebFilterOperations& backgroundFilters() const { return m_backgroundFilters; }
void setBackgroundFilters(const WebKit::WebFilterOperations& filters) { m_backgroundFilters = filters; }
// Deprecated post-processing filters, applied to the pixels in the render
// pass' texture.
WebKit::WebFilterOperations filters;
// Post-processing filter applied to the pixels in the render pass' texture.
SkImageFilter* filter;
SkImageFilter* filter() const { return m_filter; }
void setFilter(SkImageFilter* filter);
// Post-processing filters, applied to the pixels showing through the
// background of the render pass, from behind it.
WebKit::WebFilterOperations background_filters;
bool hasTransparentBackground() const { return m_hasTransparentBackground; }
void setHasTransparentBackground(bool transparent) { m_hasTransparentBackground = transparent; }
QuadList quad_list;
SharedQuadStateList shared_quad_state_list;
bool hasOcclusionFromOutsideTargetSurface() const { return m_hasOcclusionFromOutsideTargetSurface; }
void setHasOcclusionFromOutsideTargetSurface(bool hasOcclusionFromOutsideTargetSurface) { m_hasOcclusionFromOutsideTargetSurface = hasOcclusionFromOutsideTargetSurface; }
protected:
RenderPass(Id, gfx::Rect outputRect, const WebKit::WebTransformationMatrix& transformToRootTarget);
protected:
RenderPass();
Id m_id;
QuadList m_quadList;
SharedQuadStateList m_sharedQuadStateList;
WebKit::WebTransformationMatrix m_transformToRootTarget;
gfx::Rect m_outputRect;
gfx::RectF m_damageRect;
bool m_hasTransparentBackground;
bool m_hasOcclusionFromOutsideTargetSurface;
WebKit::WebFilterOperations m_filters;
WebKit::WebFilterOperations m_backgroundFilters;
SkImageFilter* m_filter;
DISALLOW_COPY_AND_ASSIGN(RenderPass);
DISALLOW_COPY_AND_ASSIGN(RenderPass);
};
} // namespace cc
@ -125,14 +121,16 @@ namespace BASE_HASH_NAMESPACE {
#if defined(COMPILER_MSVC)
template<>
inline size_t hash_value<cc::RenderPass::Id>(const cc::RenderPass::Id& key) {
return hash_value<std::pair<int, int> >(std::pair<int, int>(key.layerId, key.index));
return hash_value<std::pair<int, int> >(
std::pair<int, int>(key.layer_id, key.index));
}
#elif defined(COMPILER_GCC)
template<>
struct hash<cc::RenderPass::Id> {
size_t operator()(cc::RenderPass::Id key) const {
return hash<std::pair<int, int> >()(std::pair<int, int>(key.layerId, key.index));
}
size_t operator()(cc::RenderPass::Id key) const {
return hash<std::pair<int, int> >()(
std::pair<int, int>(key.layer_id, key.index));
}
};
#else
#error define a hash function for your compiler

4
cc/render_pass_draw_quad.cc

@ -39,7 +39,7 @@ void RenderPassDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
float mask_tex_coord_scale_y,
float mask_tex_coord_offset_x,
float mask_tex_coord_offset_y) {
DCHECK(render_pass_id.layerId > 0);
DCHECK(render_pass_id.layer_id > 0);
DCHECK(render_pass_id.index >= 0);
gfx::Rect opaque_rect;
@ -70,7 +70,7 @@ void RenderPassDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
float mask_tex_coord_scale_y,
float mask_tex_coord_offset_x,
float mask_tex_coord_offset_y) {
DCHECK(render_pass_id.layerId > 0);
DCHECK(render_pass_id.layer_id > 0);
DCHECK(render_pass_id.index >= 0);
DrawQuad::SetAll(shared_quad_state, DrawQuad::RENDER_PASS, rect, opaque_rect,

47
cc/render_pass_unittest.cc

@ -40,9 +40,6 @@ TEST(RenderPassTest, copyShouldBeIdenticalExceptIdAndQuads)
RenderPass::Id id(3, 2);
gfx::Rect outputRect(45, 22, 120, 13);
WebTransformationMatrix transformToRoot(1, 0.5, 0.5, -0.5, -1, 0);
scoped_ptr<TestRenderPass> pass = TestRenderPass::create(id, outputRect, transformToRoot);
gfx::Rect damageRect(56, 123, 19, 43);
bool hasTransparentBackground = true;
bool hasOcclusionFromOutsideTargetSurface = true;
@ -53,35 +50,39 @@ TEST(RenderPassTest, copyShouldBeIdenticalExceptIdAndQuads)
backgroundFilters.append(WebFilterOperation::createInvertFilter(0.2f));
SkAutoTUnref<SkBlurImageFilter> filter(new SkBlurImageFilter(SK_Scalar1, SK_Scalar1));
pass->setDamageRect(damageRect);
pass->setHasTransparentBackground(hasTransparentBackground);
pass->setHasOcclusionFromOutsideTargetSurface(hasOcclusionFromOutsideTargetSurface);
pass->setFilters(filters);
pass->setBackgroundFilters(backgroundFilters);
pass->setFilter(filter);
scoped_ptr<TestRenderPass> pass = TestRenderPass::Create();
pass->SetAll(id,
outputRect,
damageRect,
transformToRoot,
hasTransparentBackground,
hasOcclusionFromOutsideTargetSurface,
filters,
filter,
backgroundFilters);
// Stick a quad in the pass, this should not get copied.
scoped_ptr<SharedQuadState> sharedState = SharedQuadState::Create();
sharedState->SetAll(WebTransformationMatrix(), gfx::Rect(), gfx::Rect(), 1);
pass->sharedQuadStateList().append(sharedState.Pass());
pass->AppendSharedQuadState(sharedState.Pass());
scoped_ptr<CheckerboardDrawQuad> checkerboardQuad = CheckerboardDrawQuad::Create();
checkerboardQuad->SetNew(pass->sharedQuadStateList().last(), gfx::Rect(), SkColor());
pass->quadList().append(checkerboardQuad.PassAs<DrawQuad>());
checkerboardQuad->SetNew(pass->shared_quad_state_list.last(), gfx::Rect(), SkColor());
pass->quad_list.append(checkerboardQuad.PassAs<DrawQuad>());
RenderPass::Id newId(63, 4);
scoped_ptr<RenderPass> copy = pass->copy(newId);
EXPECT_EQ(newId, copy->id());
EXPECT_RECT_EQ(pass->outputRect(), copy->outputRect());
EXPECT_EQ(pass->transformToRootTarget(), copy->transformToRootTarget());
EXPECT_RECT_EQ(pass->damageRect(), copy->damageRect());
EXPECT_EQ(pass->hasTransparentBackground(), copy->hasTransparentBackground());
EXPECT_EQ(pass->hasOcclusionFromOutsideTargetSurface(), copy->hasOcclusionFromOutsideTargetSurface());
EXPECT_EQ(pass->filters(), copy->filters());
EXPECT_EQ(pass->backgroundFilters(), copy->backgroundFilters());
EXPECT_EQ(pass->filter(), copy->filter());
EXPECT_EQ(0u, copy->quadList().size());
scoped_ptr<RenderPass> copy = pass->Copy(newId);
EXPECT_EQ(newId, copy->id);
EXPECT_RECT_EQ(pass->output_rect, copy->output_rect);
EXPECT_EQ(pass->transform_to_root_target, copy->transform_to_root_target);
EXPECT_RECT_EQ(pass->damage_rect, copy->damage_rect);
EXPECT_EQ(pass->has_transparent_background, copy->has_transparent_background);
EXPECT_EQ(pass->has_occlusion_from_outside_target_surface, copy->has_occlusion_from_outside_target_surface);
EXPECT_EQ(pass->filters, copy->filters);
EXPECT_EQ(pass->filter, copy->filter);
EXPECT_EQ(pass->background_filters, copy->background_filters);
EXPECT_EQ(0u, copy->quad_list.size());
EXPECT_EQ(sizeof(RenderPassSize), sizeof(RenderPass));
}

10
cc/render_surface_impl.cc

@ -184,11 +184,11 @@ void RenderSurfaceImpl::appendRenderPasses(RenderPassSink& passSink)
for (size_t i = 0; i < m_contributingDelegatedRenderPassLayerList.size(); ++i)
m_contributingDelegatedRenderPassLayerList[i]->appendContributingRenderPasses(passSink);
scoped_ptr<RenderPass> pass = RenderPass::create(renderPassId(), m_contentRect, m_screenSpaceTransform);
pass->setDamageRect(m_damageTracker->currentDamageRect());
pass->setFilters(m_owningLayer->filters());
pass->setFilter(m_owningLayer->filter());
pass->setBackgroundFilters(m_owningLayer->backgroundFilters());
scoped_ptr<RenderPass> pass = RenderPass::Create();
pass->SetNew(renderPassId(), m_contentRect, m_damageTracker->currentDamageRect(), m_screenSpaceTransform);
pass->filters = m_owningLayer->filters();
pass->filter = m_owningLayer->filter();
pass->background_filters = m_owningLayer->backgroundFilters();
passSink.appendRenderPass(pass.Pass());
}

6
cc/render_surface_unittest.cc

@ -145,9 +145,9 @@ TEST(RenderSurfaceTest, sanityCheckSurfaceCreatesCorrectRenderPass)
ASSERT_EQ(1u, passSink.renderPasses().size());
RenderPass* pass = passSink.renderPasses()[0];
EXPECT_EQ(RenderPass::Id(2, 0), pass->id());
EXPECT_RECT_EQ(contentRect, pass->outputRect());
EXPECT_EQ(origin, pass->transformToRootTarget());
EXPECT_EQ(RenderPass::Id(2, 0), pass->id);
EXPECT_RECT_EQ(contentRect, pass->output_rect);
EXPECT_EQ(origin, pass->transform_to_root_target);
}
} // namespace

4
cc/software_renderer.cc

@ -137,7 +137,7 @@ void SoftwareRenderer::setScissorTestRect(const gfx::Rect& scissorRect)
void SoftwareRenderer::clearFramebuffer(DrawingFrame& frame)
{
if (frame.currentRenderPass->hasTransparentBackground()) {
if (frame.currentRenderPass->has_transparent_background) {
m_skCurrentCanvas->clear(SkColorSetARGB(0, 0, 0, 0));
} else {
#ifndef NDEBUG
@ -295,7 +295,7 @@ void SoftwareRenderer::drawRenderPassQuad(const DrawingFrame& frame, const Rende
shader->setLocalMatrix(contentMat);
m_skCurrentPaint.setShader(shader);
SkImageFilter* filter = renderPass->filter();
SkImageFilter* filter = renderPass->filter;
if (filter)
m_skCurrentPaint.setImageFilter(filter);

14
cc/software_renderer_unittest.cc

@ -69,13 +69,14 @@ TEST_F(SoftwareRendererTest, solidColorQuad)
scoped_ptr<SharedQuadState> sharedQuadState = SharedQuadState::Create();
sharedQuadState->SetAll(WebTransformationMatrix(), outerRect, outerRect, 1.0);
RenderPass::Id rootRenderPassId = RenderPass::Id(1, 1);
scoped_ptr<TestRenderPass> rootRenderPass = TestRenderPass::create(rootRenderPassId, outerRect, WebTransformationMatrix());
scoped_ptr<TestRenderPass> rootRenderPass = TestRenderPass::Create();
rootRenderPass->SetNew(rootRenderPassId, outerRect, gfx::Rect(), WebTransformationMatrix());
scoped_ptr<SolidColorDrawQuad> outerQuad = SolidColorDrawQuad::Create();
outerQuad->SetNew(sharedQuadState.get(), outerRect, SK_ColorYELLOW);
scoped_ptr<SolidColorDrawQuad> innerQuad = SolidColorDrawQuad::Create();
innerQuad->SetNew(sharedQuadState.get(), innerRect, SK_ColorCYAN);
rootRenderPass->appendQuad(innerQuad.PassAs<DrawQuad>());
rootRenderPass->appendQuad(outerQuad.PassAs<DrawQuad>());
rootRenderPass->AppendQuad(innerQuad.PassAs<DrawQuad>());
rootRenderPass->AppendQuad(outerQuad.PassAs<DrawQuad>());
RenderPassList list;
RenderPassIdHashMap hashmap;
@ -129,13 +130,14 @@ TEST_F(SoftwareRendererTest, tileQuad)
scoped_ptr<SharedQuadState> sharedQuadState = SharedQuadState::Create();
sharedQuadState->SetAll(WebTransformationMatrix(), outerRect, outerRect, 1.0);
RenderPass::Id rootRenderPassId = RenderPass::Id(1, 1);
scoped_ptr<TestRenderPass> rootRenderPass = TestRenderPass::create(rootRenderPassId, gfx::Rect(gfx::Point(), deviceViewportSize()), WebTransformationMatrix());
scoped_ptr<TestRenderPass> rootRenderPass = TestRenderPass::Create();
rootRenderPass->SetNew(rootRenderPassId, gfx::Rect(gfx::Point(), deviceViewportSize()), gfx::Rect(), WebTransformationMatrix());
scoped_ptr<TileDrawQuad> outerQuad = TileDrawQuad::Create();
outerQuad->SetNew(sharedQuadState.get(), outerRect, outerRect, resourceYellow, gfx::RectF(gfx::PointF(), outerSize), outerSize, false, false, false, false, false);
scoped_ptr<TileDrawQuad> innerQuad = TileDrawQuad::Create();
innerQuad->SetNew(sharedQuadState.get(), innerRect, innerRect, resourceCyan, gfx::RectF(gfx::PointF(), innerSize), innerSize, false, false, false, false, false);
rootRenderPass->appendQuad(innerQuad.PassAs<DrawQuad>());
rootRenderPass->appendQuad(outerQuad.PassAs<DrawQuad>());
rootRenderPass->AppendQuad(innerQuad.PassAs<DrawQuad>());
rootRenderPass->AppendQuad(outerQuad.PassAs<DrawQuad>());
RenderPassList list;
RenderPassIdHashMap hashmap;

142
cc/test/render_pass_test_common.cc

@ -22,57 +22,117 @@ namespace WebKitTests {
using cc::DrawQuad;
using WebKit::WebTransformationMatrix;
void TestRenderPass::appendOneOfEveryQuadType(cc::ResourceProvider* resourceProvider)
{
gfx::Rect rect(0, 0, 100, 100);
gfx::Rect opaqueRect(10, 10, 80, 80);
cc::ResourceProvider::ResourceId textureResource = resourceProvider->createResourceFromExternalTexture(1);
scoped_ptr<cc::SharedQuadState> sharedState = cc::SharedQuadState::Create();
sharedState->SetAll(WebTransformationMatrix(), rect, rect, 1);
void TestRenderPass::AppendOneOfEveryQuadType(cc::ResourceProvider* resourceProvider) {
gfx::Rect rect(0, 0, 100, 100);
gfx::Rect opaque_rect(10, 10, 80, 80);
cc::ResourceProvider::ResourceId texture_resource =
resourceProvider->createResourceFromExternalTexture(1);
scoped_ptr<cc::SharedQuadState> shared_state = cc::SharedQuadState::Create();
shared_state->SetAll(WebTransformationMatrix(),
rect,
rect,
1);
scoped_ptr<cc::CheckerboardDrawQuad> checkerboardQuad = cc::CheckerboardDrawQuad::Create();
checkerboardQuad->SetNew(sharedState.get(), rect, SK_ColorRED);
appendQuad(checkerboardQuad.PassAs<DrawQuad>());
scoped_ptr<cc::CheckerboardDrawQuad> checkerboard_quad =
cc::CheckerboardDrawQuad::Create();
checkerboard_quad->SetNew(shared_state.get(),
rect,
SK_ColorRED);
AppendQuad(checkerboard_quad.PassAs<DrawQuad>());
scoped_ptr<cc::DebugBorderDrawQuad> debugBorderQuad = cc::DebugBorderDrawQuad::Create();
debugBorderQuad->SetNew(sharedState.get(), rect, SK_ColorRED, 1);
appendQuad(debugBorderQuad.PassAs<DrawQuad>());
scoped_ptr<cc::DebugBorderDrawQuad> debug_border_quad =
cc::DebugBorderDrawQuad::Create();
debug_border_quad->SetNew(shared_state.get(),
rect,
SK_ColorRED,
1);
AppendQuad(debug_border_quad.PassAs<DrawQuad>());
scoped_ptr<cc::IOSurfaceDrawQuad> ioSurfaceQuad = cc::IOSurfaceDrawQuad::Create();
ioSurfaceQuad->SetNew(sharedState.get(), rect, opaqueRect, gfx::Size(50, 50), 1, cc::IOSurfaceDrawQuad::FLIPPED);
appendQuad(ioSurfaceQuad.PassAs<DrawQuad>());
scoped_ptr<cc::IOSurfaceDrawQuad> io_surface_quad =
cc::IOSurfaceDrawQuad::Create();
io_surface_quad->SetNew(shared_state.get(),
rect,
opaque_rect,
gfx::Size(50, 50),
1,
cc::IOSurfaceDrawQuad::FLIPPED);
AppendQuad(io_surface_quad.PassAs<DrawQuad>());
scoped_ptr<cc::RenderPassDrawQuad> renderPassQuad = cc::RenderPassDrawQuad::Create();
renderPassQuad->SetNew(sharedState.get(), rect, cc::RenderPass::Id(1, 1), false, 0, rect, 0, 0, 0, 0);
appendQuad(renderPassQuad.PassAs<DrawQuad>());
scoped_ptr<cc::RenderPassDrawQuad> render_pass_quad =
cc::RenderPassDrawQuad::Create();
render_pass_quad->SetNew(shared_state.get(),
rect,
cc::RenderPass::Id(1, 1),
false,
0,
rect,
0,
0,
0,
0);
AppendQuad(render_pass_quad.PassAs<DrawQuad>());
scoped_ptr<cc::SolidColorDrawQuad> solidColorQuad = cc::SolidColorDrawQuad::Create();
solidColorQuad->SetNew(sharedState.get(), rect, SK_ColorRED);
appendQuad(solidColorQuad.PassAs<DrawQuad>());
scoped_ptr<cc::SolidColorDrawQuad> solid_color_quad =
cc::SolidColorDrawQuad::Create();
solid_color_quad->SetNew(shared_state.get(),
rect,
SK_ColorRED);
AppendQuad(solid_color_quad.PassAs<DrawQuad>());
scoped_ptr<cc::StreamVideoDrawQuad> streamVideoQuad = cc::StreamVideoDrawQuad::Create();
streamVideoQuad->SetNew(sharedState.get(), rect, opaqueRect, 1, WebKit::WebTransformationMatrix());
appendQuad(streamVideoQuad.PassAs<DrawQuad>());
scoped_ptr<cc::StreamVideoDrawQuad> stream_video_quad =
cc::StreamVideoDrawQuad::Create();
stream_video_quad->SetNew(shared_state.get(),
rect,
opaque_rect,
1,
WebKit::WebTransformationMatrix());
AppendQuad(stream_video_quad.PassAs<DrawQuad>());
scoped_ptr<cc::TextureDrawQuad> textureQuad = cc::TextureDrawQuad::Create();
textureQuad->SetNew(sharedState.get(), rect, opaqueRect, textureResource, false, rect, false);
appendQuad(textureQuad.PassAs<DrawQuad>());
scoped_ptr<cc::TextureDrawQuad> texture_quad =
cc::TextureDrawQuad::Create();
texture_quad->SetNew(shared_state.get(),
rect,
opaque_rect,
texture_resource,
false,
rect,
false);
AppendQuad(texture_quad.PassAs<DrawQuad>());
scoped_ptr<cc::TileDrawQuad> tileQuad = cc::TileDrawQuad::Create();
tileQuad->SetNew(sharedState.get(), rect, opaqueRect, textureResource, gfx::RectF(0, 0, 100, 100), gfx::Size(100, 100), false, false, false, false, false);
appendQuad(tileQuad.PassAs<DrawQuad>());
scoped_ptr<cc::TileDrawQuad> tile_quad =
cc::TileDrawQuad::Create();
tile_quad->SetNew(shared_state.get(),
rect,
opaque_rect,
texture_resource,
gfx::RectF(0, 0, 100, 100),
gfx::Size(100, 100),
false,
false,
false,
false,
false);
AppendQuad(tile_quad.PassAs<DrawQuad>());
cc::VideoLayerImpl::FramePlane planes[3];
for (int i = 0; i < 3; ++i) {
planes[i].resourceId = resourceProvider->createResourceFromExternalTexture(1);
planes[i].size = gfx::Size(100, 100);
planes[i].format = GL_LUMINANCE;
}
scoped_ptr<cc::YUVVideoDrawQuad> yuvQuad = cc::YUVVideoDrawQuad::Create();
yuvQuad->SetNew(sharedState.get(), rect, opaqueRect, gfx::Size(100, 100), planes[0], planes[1], planes[2]);
appendQuad(yuvQuad.PassAs<DrawQuad>());
cc::VideoLayerImpl::FramePlane planes[3];
for (int i = 0; i < 3; ++i) {
planes[i].resourceId =
resourceProvider->createResourceFromExternalTexture(1);
planes[i].size = gfx::Size(100, 100);
planes[i].format = GL_LUMINANCE;
}
scoped_ptr<cc::YUVVideoDrawQuad> yuv_quad =
cc::YUVVideoDrawQuad::Create();
yuv_quad->SetNew(shared_state.get(),
rect,
opaque_rect,
gfx::Size(100, 100),
planes[0],
planes[1],
planes[2]);
AppendQuad(yuv_quad.PassAs<DrawQuad>());
appendSharedQuadState(sharedState.Pass());
AppendSharedQuadState(shared_state.Pass());
}
} // namespace WebKitTests

26
cc/test/render_pass_test_common.h

@ -14,22 +14,22 @@ class ResourceProvider;
namespace WebKitTests {
class TestRenderPass : public cc::RenderPass {
public:
static scoped_ptr<TestRenderPass> create(Id id, gfx::Rect outputRect, const WebKit::WebTransformationMatrix& transformToRootTarget) {
return make_scoped_ptr(new TestRenderPass(id, outputRect, transformToRootTarget));
}
public:
static scoped_ptr<TestRenderPass> Create() {
return make_scoped_ptr(new TestRenderPass);
}
cc::QuadList& quadList() { return m_quadList; }
cc::SharedQuadStateList& sharedQuadStateList() { return m_sharedQuadStateList; }
void AppendQuad(scoped_ptr<cc::DrawQuad> quad) {
quad_list.append(quad.Pass());
}
void AppendSharedQuadState(scoped_ptr<cc::SharedQuadState> state) {
shared_quad_state_list.append(state.Pass());
}
void appendQuad(scoped_ptr<cc::DrawQuad> quad) { m_quadList.append(quad.Pass()); }
void appendSharedQuadState(scoped_ptr<cc::SharedQuadState> state) { m_sharedQuadStateList.append(state.Pass()); }
void AppendOneOfEveryQuadType(cc::ResourceProvider*);
void appendOneOfEveryQuadType(cc::ResourceProvider*);
protected:
TestRenderPass(Id id, gfx::Rect outputRect, const WebKit::WebTransformationMatrix& transformToRootTarget)
: RenderPass(id, outputRect, transformToRootTarget) { }
protected:
TestRenderPass() : RenderPass() {}
};
} // namespace WebKitTests