summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--cc/delegated_renderer_layer_impl.cc32
-rw-r--r--cc/delegated_renderer_layer_impl.h2
-rw-r--r--cc/delegated_renderer_layer_impl_unittest.cc159
-rw-r--r--cc/direct_renderer.cc34
-rw-r--r--cc/gl_renderer.cc16
-rw-r--r--cc/gl_renderer_unittest.cc16
-rw-r--r--cc/layer_tree_host_impl.cc118
-rw-r--r--cc/layer_tree_host_impl_unittest.cc263
-rw-r--r--cc/quad_culler.cc8
-rw-r--r--cc/quad_culler.h7
-rw-r--r--cc/quad_culler_unittest.cc2
-rw-r--r--cc/render_pass.cc149
-rw-r--r--cc/render_pass.h148
-rw-r--r--cc/render_pass_draw_quad.cc4
-rw-r--r--cc/render_pass_unittest.cc47
-rw-r--r--cc/render_surface_impl.cc10
-rw-r--r--cc/render_surface_unittest.cc6
-rw-r--r--cc/software_renderer.cc4
-rw-r--r--cc/software_renderer_unittest.cc14
-rw-r--r--cc/test/render_pass_test_common.cc162
-rw-r--r--cc/test/render_pass_test_common.h32
21 files changed, 679 insertions, 554 deletions
diff --git a/cc/delegated_renderer_layer_impl.cc b/cc/delegated_renderer_layer_impl.cc
index 8b56a72..8528edf 100644
--- a/cc/delegated_renderer_layer_impl.cc
+++ b/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());
diff --git a/cc/delegated_renderer_layer_impl.h b/cc/delegated_renderer_layer_impl.h
index acbb856..7e7caa5 100644
--- a/cc/delegated_renderer_layer_impl.h
+++ b/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;
diff --git a/cc/delegated_renderer_layer_impl_unittest.cc b/cc/delegated_renderer_layer_impl_unittest.cc
index d07bbb5..f39285c 100644
--- a/cc/delegated_renderer_layer_impl_unittest.cc
+++ b/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.
diff --git a/cc/direct_renderer.cc b/cc/direct_renderer.cc
index c0efca4..7e2e31e 100644
--- a/cc/direct_renderer.cc
+++ b/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
diff --git a/cc/gl_renderer.cc b/cc/gl_renderer.cc
index e4e8034..850b8c2 100644
--- a/cc/gl_renderer.cc
+++ b/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;
diff --git a/cc/gl_renderer_unittest.cc b/cc/gl_renderer_unittest.cc
index 3d3f68a..f948743 100644
--- a/cc/gl_renderer_unittest.cc
+++ b/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);
diff --git a/cc/layer_tree_host_impl.cc b/cc/layer_tree_host_impl.cc
index a3f8656..a8a3faa 100644
--- a/cc/layer_tree_host_impl.cc
+++ b/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++)
diff --git a/cc/layer_tree_host_impl_unittest.cc b/cc/layer_tree_host_impl_unittest.cc
index 846449e..56b2519 100644
--- a/cc/layer_tree_host_impl_unittest.cc
+++ b/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++;
diff --git a/cc/quad_culler.cc b/cc/quad_culler.cc
index 2f3e18f..41c1550 100644
--- a/cc/quad_culler.cc
+++ b/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
diff --git a/cc/quad_culler.h b/cc/quad_culler.h
index 7381f4b..29db35e 100644
--- a/cc/quad_culler.h
+++ b/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;
};
diff --git a/cc/quad_culler_unittest.cc b/cc/quad_culler_unittest.cc
index c94aadb..82de2bb 100644
--- a/cc/quad_culler_unittest.cc
+++ b/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);
diff --git a/cc/render_pass.cc b/cc/render_pass.cc
index bbb36e5..0a8dc48 100644
--- a/cc/render_pass.cc
+++ b/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> 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> RenderPass::Copy(Id new_id) const {
+ DCHECK(new_id != id);
+
+ 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);
-}
-
-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);
-
- 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());
- }
-}
+ this->id = id;
+ this->output_rect = output_rect;
+ this->damage_rect = damage_rect;
+ this->transform_to_root_target = transform_to_root_target;
-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>());
- }
+ DCHECK(quad_list.isEmpty());
+ DCHECK(shared_quad_state_list.isEmpty());
}
-void RenderPass::setFilter(SkImageFilter* filter) {
- SkRefCnt_SafeAssign(m_filter, filter);
+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);
+
+ 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;
+
+ DCHECK(quad_list.isEmpty());
+ DCHECK(shared_quad_state_list.isEmpty());
}
} // namespace cc
diff --git a/cc/render_pass.h b/cc/render_pass.h
index 97ab8ee..e14b5e6 100644
--- a/cc/render_pass.h
+++ b/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;
-
- inline backToFrontIterator backToFrontBegin() { return rbegin(); }
- inline backToFrontIterator backToFrontEnd() { return rend(); }
- inline constBackToFrontIterator backToFrontBegin() const { return rbegin(); }
- inline constBackToFrontIterator backToFrontEnd() const { return rend(); }
+ 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(); }
};
typedef ScopedPtrVector<SharedQuadState> SharedQuadStateList;
class CC_EXPORT RenderPass {
-public:
- ~RenderPass();
-
- struct Id {
- int layerId;
- int index;
+ public:
+ struct Id {
+ int layer_id;
+ int index;
- Id(int layerId, int index)
- : layerId(layerId)
- , index(index)
- {
- }
+ Id(int layer_id, int index) : layer_id(layer_id), index(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); }
- };
+ 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);
+ }
+ };
- static scoped_ptr<RenderPass> create(Id, gfx::Rect outputRect, const WebKit::WebTransformationMatrix& transformToRootTarget);
+ ~RenderPass();
- // A shallow copy of the render pass, which does not include its quads.
- scoped_ptr<RenderPass> copy(Id newId) const;
+ static scoped_ptr<RenderPass> Create();
- void appendQuadsForLayer(LayerImpl*, OcclusionTrackerImpl*, AppendQuadsData&);
- void appendQuadsForRenderSurfaceLayer(LayerImpl*, const RenderPass* contributingRenderPass, OcclusionTrackerImpl*, AppendQuadsData&);
- void appendQuadsToFillScreen(LayerImpl* rootLayer, SkColor screenBackgroundColor, const OcclusionTrackerImpl&);
+ // A shallow copy of the render pass, which does not include its quads.
+ scoped_ptr<RenderPass> Copy(Id newId) const;
- const QuadList& quadList() const { return m_quadList; }
+ void SetNew(Id id,
+ gfx::Rect output_rect,
+ gfx::RectF damage_rect,
+ const WebKit::WebTransformationMatrix& transform_to_root_target);
- Id id() const { return m_id; }
+ 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);
- // 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; }
+ // Uniquely identifies the render pass in the compositor's current frame.
+ Id id;
- // This denotes the bounds in physical pixels of the output generated by this RenderPass.
- const gfx::Rect& outputRect() const { return m_outputRect; }
+ // These are in the space of the render pass' physical pixels.
+ gfx::Rect output_rect;
+ gfx::RectF damage_rect;
- gfx::RectF damageRect() const { return m_damageRect; }
- void setDamageRect(gfx::RectF rect) { m_damageRect = rect; }
+ // Transforms from the origin of the |output_rect| to the origin of the root
+ // render pass' |output_rect|.
+ WebKit::WebTransformationMatrix transform_to_root_target;
- const WebKit::WebFilterOperations& filters() const { return m_filters; }
- void setFilters(const WebKit::WebFilterOperations& filters) { m_filters = filters; }
+ // If false, the pixels in the render pass' texture are all opaque.
+ bool has_transparent_background;
- const WebKit::WebFilterOperations& backgroundFilters() const { return m_backgroundFilters; }
- void setBackgroundFilters(const WebKit::WebFilterOperations& filters) { m_backgroundFilters = 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;
- SkImageFilter* filter() const { return m_filter; }
- void setFilter(SkImageFilter* filter);
+ // 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;
- bool hasTransparentBackground() const { return m_hasTransparentBackground; }
- void setHasTransparentBackground(bool transparent) { m_hasTransparentBackground = transparent; }
+ // Post-processing filters, applied to the pixels showing through the
+ // background of the render pass, from behind it.
+ WebKit::WebFilterOperations background_filters;
- bool hasOcclusionFromOutsideTargetSurface() const { return m_hasOcclusionFromOutsideTargetSurface; }
- void setHasOcclusionFromOutsideTargetSurface(bool hasOcclusionFromOutsideTargetSurface) { m_hasOcclusionFromOutsideTargetSurface = hasOcclusionFromOutsideTargetSurface; }
-protected:
- RenderPass(Id, gfx::Rect outputRect, const WebKit::WebTransformationMatrix& transformToRootTarget);
+ QuadList quad_list;
+ SharedQuadStateList shared_quad_state_list;
- 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;
+ protected:
+ RenderPass();
- 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
diff --git a/cc/render_pass_draw_quad.cc b/cc/render_pass_draw_quad.cc
index 937a621..5f3df08 100644
--- a/cc/render_pass_draw_quad.cc
+++ b/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,
diff --git a/cc/render_pass_unittest.cc b/cc/render_pass_unittest.cc
index 357b3d3..7a0ec5f 100644
--- a/cc/render_pass_unittest.cc
+++ b/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));
}
diff --git a/cc/render_surface_impl.cc b/cc/render_surface_impl.cc
index 55f8d22..d61d448 100644
--- a/cc/render_surface_impl.cc
+++ b/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());
}
diff --git a/cc/render_surface_unittest.cc b/cc/render_surface_unittest.cc
index bc5b78f..837a3db 100644
--- a/cc/render_surface_unittest.cc
+++ b/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
diff --git a/cc/software_renderer.cc b/cc/software_renderer.cc
index d6a3905..6ec60b4 100644
--- a/cc/software_renderer.cc
+++ b/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);
diff --git a/cc/software_renderer_unittest.cc b/cc/software_renderer_unittest.cc
index 349d8b9..743649e 100644
--- a/cc/software_renderer_unittest.cc
+++ b/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;
diff --git a/cc/test/render_pass_test_common.cc b/cc/test/render_pass_test_common.cc
index 5af6c1e..bbb8a34 100644
--- a/cc/test/render_pass_test_common.cc
+++ b/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);
-
- scoped_ptr<cc::CheckerboardDrawQuad> checkerboardQuad = cc::CheckerboardDrawQuad::Create();
- checkerboardQuad->SetNew(sharedState.get(), rect, SK_ColorRED);
- appendQuad(checkerboardQuad.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::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::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::SolidColorDrawQuad> solidColorQuad = cc::SolidColorDrawQuad::Create();
- solidColorQuad->SetNew(sharedState.get(), rect, SK_ColorRED);
- appendQuad(solidColorQuad.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::TextureDrawQuad> textureQuad = cc::TextureDrawQuad::Create();
- textureQuad->SetNew(sharedState.get(), rect, opaqueRect, textureResource, false, rect, false);
- appendQuad(textureQuad.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>());
-
- 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>());
-
- appendSharedQuadState(sharedState.Pass());
+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> checkerboard_quad =
+ cc::CheckerboardDrawQuad::Create();
+ checkerboard_quad->SetNew(shared_state.get(),
+ rect,
+ SK_ColorRED);
+ AppendQuad(checkerboard_quad.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> 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> 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> 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> 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> 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> 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> 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(shared_state.Pass());
}
} // namespace WebKitTests
diff --git a/cc/test/render_pass_test_common.h b/cc/test/render_pass_test_common.h
index dede7e6..34d8522 100644
--- a/cc/test/render_pass_test_common.h
+++ b/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));
- }
-
- cc::QuadList& quadList() { return m_quadList; }
- cc::SharedQuadStateList& sharedQuadStateList() { return m_sharedQuadStateList; }
-
- 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*);
-
-protected:
- TestRenderPass(Id id, gfx::Rect outputRect, const WebKit::WebTransformationMatrix& transformToRootTarget)
- : RenderPass(id, outputRect, transformToRootTarget) { }
+ public:
+ static scoped_ptr<TestRenderPass> Create() {
+ return make_scoped_ptr(new TestRenderPass);
+ }
+
+ 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 AppendOneOfEveryQuadType(cc::ResourceProvider*);
+
+ protected:
+ TestRenderPass() : RenderPass() {}
};
} // namespace WebKitTests
generated by cgit v1.1 at 2025-05-19 15:05:34 +0000