cc: Make RenderPass into a struct-like class.

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

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

Covered by existing tests.

BUG=152337
TBR=aelias


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

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@168998 0039d316-1c4b-4281-b951-d872f2087c98

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