cc: Chromify the LayerTreeHostImpl class.

cc/delegated_renderer_layer_impl_unittest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/delegated_renderer_layer_impl.h"
 
 #include "cc/append_quads_data.h"
 #include "cc/layer_tree_host_impl.h"
 #include "cc/layer_tree_impl.h"
 #include "cc/quad_sink.h"
@@ skipping 19 matching lines @@
 namespace {
 
 class DelegatedRendererLayerImplTest : public testing::Test {
  public:
   DelegatedRendererLayerImplTest()
       : proxy_(scoped_ptr<Thread>(NULL))
       , always_impl_thread_and_main_thread_blocked_(&proxy_) {
     LayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = gfx::Size();
 
-    host_impl_ = LayerTreeHostImpl::create(settings, &client_, &proxy_);
-    host_impl_->initializeRenderer(createFakeOutputSurface());
-    host_impl_->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
+    host_impl_ = LayerTreeHostImpl::Create(settings, &client_, &proxy_);
+    host_impl_->InitializeRenderer(createFakeOutputSurface());
+    host_impl_->SetViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
   }
 
  protected:
   FakeProxy proxy_;
   FakeLayerTreeHostImplClient client_;
   DebugScopedSetImplThreadAndMainThreadBlocked
       always_impl_thread_and_main_thread_blocked_;
   scoped_ptr<LayerTreeHostImpl> host_impl_;
 };
 
 class DelegatedRendererLayerImplTestSimple
     : public DelegatedRendererLayerImplTest {
  public:
   DelegatedRendererLayerImplTestSimple()
       : DelegatedRendererLayerImplTest() {
     scoped_ptr<LayerImpl> root_layer = SolidColorLayerImpl::Create(
-        host_impl_->activeTree(), 1).PassAs<LayerImpl>();
+        host_impl_->active_tree(), 1).PassAs<LayerImpl>();
     scoped_ptr<LayerImpl> layer_before = SolidColorLayerImpl::Create(
-        host_impl_->activeTree(), 2).PassAs<LayerImpl>();
+        host_impl_->active_tree(), 2).PassAs<LayerImpl>();
     scoped_ptr<LayerImpl> layer_after = SolidColorLayerImpl::Create(
-        host_impl_->activeTree(), 3).PassAs<LayerImpl>();
+        host_impl_->active_tree(), 3).PassAs<LayerImpl>();
     scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
-        FakeDelegatedRendererLayerImpl::Create(host_impl_->activeTree(), 4);
+        FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 4);
 
-    host_impl_->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
+    host_impl_->SetViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
     root_layer->SetBounds(gfx::Size(100, 100));
 
     layer_before->SetPosition(gfx::Point(20, 20));
     layer_before->SetBounds(gfx::Size(14, 14));
     layer_before->SetContentBounds(gfx::Size(14, 14));
     layer_before->SetDrawsContent(true);
     layer_before->SetForceRenderSurface(true);
 
     layer_after->SetPosition(gfx::Point(5, 5));
     layer_after->SetBounds(gfx::Size(15, 15));
@@ skipping 41 matching lines @@
     delegated_renderer_layer_ = delegated_renderer_layer.get();
 
     // Force the delegated RenderPasses to come before the RenderPass from
     // layer_after.
     layer_after->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
     root_layer->AddChild(layer_after.Pass());
 
     // Get the RenderPass generated by layer_before to come before the delegated
     // RenderPasses.
     root_layer->AddChild(layer_before.Pass());
-    host_impl_->activeTree()->SetRootLayer(root_layer.Pass());
+    host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
   }
 
  protected:
   LayerImpl* root_layer_;
   LayerImpl* layer_before_;
   LayerImpl* layer_after_;
   DelegatedRendererLayerImpl* delegated_renderer_layer_;
 };
 
 TEST_F(DelegatedRendererLayerImplTestSimple, AddsContributingRenderPasses) {
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes.
-  ASSERT_EQ(5u, frame.renderPasses.size());
+  ASSERT_EQ(5u, frame.render_passes.size());
 
   // The DelegatedRendererLayer should have added its contributing RenderPasses
   // to the frame.
-  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);
+  EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
+  EXPECT_EQ(1, frame.render_passes[1]->id.index);
+  EXPECT_EQ(4, frame.render_passes[2]->id.layer_id);
+  EXPECT_EQ(2, frame.render_passes[2]->id.index);
   // And all other RenderPasses should be non-delegated.
-  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);
+  EXPECT_NE(4, frame.render_passes[0]->id.layer_id);
+  EXPECT_EQ(0, frame.render_passes[0]->id.index);
+  EXPECT_NE(4, frame.render_passes[3]->id.layer_id);
+  EXPECT_EQ(0, frame.render_passes[3]->id.index);
+  EXPECT_NE(4, frame.render_passes[4]->id.layer_id);
+  EXPECT_EQ(0, frame.render_passes[4]->id.index);
 
   // The DelegatedRendererLayer should have added its RenderPasses to the frame
   // in order.
   EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
-            frame.renderPasses[1]->output_rect.ToString());
+            frame.render_passes[1]->output_rect.ToString());
   EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
-            frame.renderPasses[2]->output_rect.ToString());
+            frame.render_passes[2]->output_rect.ToString());
 
-  host_impl_->drawLayers(frame);
-  host_impl_->didDrawAllLayers(frame);
+  host_impl_->DrawLayers(&frame);
+  host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestSimple,
        AddsQuadsToContributingRenderPasses) {
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes.
-  ASSERT_EQ(5u, frame.renderPasses.size());
+  ASSERT_EQ(5u, frame.render_passes.size());
 
   // The DelegatedRendererLayer should have added its contributing RenderPasses
   // to the frame.
-  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);
+  EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
+  EXPECT_EQ(1, frame.render_passes[1]->id.index);
+  EXPECT_EQ(4, frame.render_passes[2]->id.layer_id);
+  EXPECT_EQ(2, frame.render_passes[2]->id.index);
 
   // The DelegatedRendererLayer should have added copies of its quads to
   // contributing RenderPasses.
-  ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
+  ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
   EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
-            frame.renderPasses[1]->quad_list[0]->rect.ToString());
+            frame.render_passes[1]->quad_list[0]->rect.ToString());
 
   // Verify it added the right quads.
-  ASSERT_EQ(2u, frame.renderPasses[2]->quad_list.size());
+  ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
   EXPECT_EQ(gfx::Rect(0, 0, 7, 7).ToString(),
-            frame.renderPasses[2]->quad_list[0]->rect.ToString());
+            frame.render_passes[2]->quad_list[0]->rect.ToString());
   EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
-            frame.renderPasses[2]->quad_list[1]->rect.ToString());
-  ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
+            frame.render_passes[2]->quad_list[1]->rect.ToString());
+  ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
   EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
-            frame.renderPasses[1]->quad_list[0]->rect.ToString());
+            frame.render_passes[1]->quad_list[0]->rect.ToString());
 
-  host_impl_->drawLayers(frame);
-  host_impl_->didDrawAllLayers(frame);
+  host_impl_->DrawLayers(&frame);
+  host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestSimple, AddsQuadsToTargetRenderPass) {
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes.
-  ASSERT_EQ(5u, frame.renderPasses.size());
+  ASSERT_EQ(5u, frame.render_passes.size());
 
   // The layer's target is the RenderPass from m_layer_after.
-  EXPECT_EQ(RenderPass::Id(3, 0), frame.renderPasses[3]->id);
+  EXPECT_EQ(RenderPass::Id(3, 0), frame.render_passes[3]->id);
 
   // The DelegatedRendererLayer should have added copies of quads in its root
   // RenderPass to its target RenderPass. The m_layer_after also adds one quad.
-  ASSERT_EQ(2u, frame.renderPasses[3]->quad_list.size());
+  ASSERT_EQ(2u, frame.render_passes[3]->quad_list.size());
 
   // Verify it added the right quads.
   EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
-            frame.renderPasses[3]->quad_list[0]->rect.ToString());
+            frame.render_passes[3]->quad_list[0]->rect.ToString());
 
   // Its target layer should have a quad as well.
   EXPECT_EQ(gfx::Rect(0, 0, 15, 15).ToString(),
-            frame.renderPasses[3]->quad_list[1]->rect.ToString());
+            frame.render_passes[3]->quad_list[1]->rect.ToString());
 
-  host_impl_->drawLayers(frame);
-  host_impl_->didDrawAllLayers(frame);
+  host_impl_->DrawLayers(&frame);
+  host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestSimple,
        QuadsFromRootRenderPassAreModifiedForTheTarget) {
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes.
-  ASSERT_EQ(5u, frame.renderPasses.size());
+  ASSERT_EQ(5u, frame.render_passes.size());
 
   // The DelegatedRendererLayer is at position 3,3 compared to its target, and
   // has a translation transform of 1,1. So its root RenderPass' quads should
   // all be transformed by that combined amount.
   // The DelegatedRendererLayer has a size of 10x10, but the root delegated
   // RenderPass has a size of 8x8, so any quads should be scaled by 10/8.
   gfx::Transform transform;
   transform.Translate(4.0, 4.0);
   transform.Scale(10.0 / 8.0, 10.0 / 8.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      transform, frame.renderPasses[3]->quad_list[0]->quadTransform());
+      transform, frame.render_passes[3]->quad_list[0]->quadTransform());
 
   // Quads from non-root RenderPasses should not be shifted though.
-  ASSERT_EQ(2u, frame.renderPasses[2]->quad_list.size());
+  ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      gfx::Transform(), frame.renderPasses[2]->quad_list[0]->quadTransform());
+      gfx::Transform(), frame.render_passes[2]->quad_list[0]->quadTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      gfx::Transform(), frame.renderPasses[2]->quad_list[1]->quadTransform());
-  ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
+      gfx::Transform(), frame.render_passes[2]->quad_list[1]->quadTransform());
+  ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      gfx::Transform(), frame.renderPasses[1]->quad_list[0]->quadTransform());
+      gfx::Transform(), frame.render_passes[1]->quad_list[0]->quadTransform());
 
-  host_impl_->drawLayers(frame);
-  host_impl_->didDrawAllLayers(frame);
+  host_impl_->DrawLayers(&frame);
+  host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestSimple, DoesNotOwnARenderSurface) {
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
   // If the DelegatedRendererLayer is axis aligned and has opacity 1, then it
   // has no need to be a renderSurface for the quads it carries.
   EXPECT_FALSE(delegated_renderer_layer_->render_surface());
 
-  host_impl_->drawLayers(frame);
-  host_impl_->didDrawAllLayers(frame);
+  host_impl_->DrawLayers(&frame);
+  host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestSimple, DoesOwnARenderSurfaceForOpacity) {
   delegated_renderer_layer_->SetOpacity(0.5f);
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
   // This test case has quads from multiple layers in the delegated renderer, so
   // if the DelegatedRendererLayer has opacity < 1, it should end up with a
   // render surface.
   EXPECT_TRUE(delegated_renderer_layer_->render_surface());
 
-  host_impl_->drawLayers(frame);
-  host_impl_->didDrawAllLayers(frame);
+  host_impl_->DrawLayers(&frame);
+  host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestSimple,
        DoesOwnARenderSurfaceForTransform) {
   gfx::Transform rotation;
   rotation.RotateAboutZAxis(30.0);
   delegated_renderer_layer_->SetTransform(rotation);
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
   // This test case has quads from multiple layers in the delegated renderer, so
   // if the DelegatedRendererLayer has opacity < 1, it should end up with a
   // render surface.
   EXPECT_TRUE(delegated_renderer_layer_->render_surface());
 
-  host_impl_->drawLayers(frame);
-  host_impl_->didDrawAllLayers(frame);
+  host_impl_->DrawLayers(&frame);
+  host_impl_->DidDrawAllLayers(frame);
 }
 
 class DelegatedRendererLayerImplTestOwnSurface
     : public DelegatedRendererLayerImplTestSimple {
  public:
   DelegatedRendererLayerImplTestOwnSurface()
       : DelegatedRendererLayerImplTestSimple() {
     delegated_renderer_layer_->SetForceRenderSurface(true);
   }
 };
 
 TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsRenderPasses) {
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes and its owned surface
   // added one pass.
-  ASSERT_EQ(6u, frame.renderPasses.size());
+  ASSERT_EQ(6u, frame.render_passes.size());
 
   // The DelegatedRendererLayer should have added its contributing RenderPasses
   // to the frame.
-  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);
+  EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
+  EXPECT_EQ(1, frame.render_passes[1]->id.index);
+  EXPECT_EQ(4, frame.render_passes[2]->id.layer_id);
+  EXPECT_EQ(2, frame.render_passes[2]->id.index);
   // The DelegatedRendererLayer should have added a RenderPass for its surface
   // to the frame.
-  EXPECT_EQ(4, frame.renderPasses[1]->id.layer_id);
-  EXPECT_EQ(0, frame.renderPasses[3]->id.index);
+  EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
+  EXPECT_EQ(0, frame.render_passes[3]->id.index);
   // And all other RenderPasses should be non-delegated.
-  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);
+  EXPECT_NE(4, frame.render_passes[0]->id.layer_id);
+  EXPECT_EQ(0, frame.render_passes[0]->id.index);
+  EXPECT_NE(4, frame.render_passes[4]->id.layer_id);
+  EXPECT_EQ(0, frame.render_passes[4]->id.index);
+  EXPECT_NE(4, frame.render_passes[5]->id.layer_id);
+  EXPECT_EQ(0, frame.render_passes[5]->id.index);
 
   // The DelegatedRendererLayer should have added its RenderPasses to the frame
   // in order.
   EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
-            frame.renderPasses[1]->output_rect.ToString());
+            frame.render_passes[1]->output_rect.ToString());
   EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
-            frame.renderPasses[2]->output_rect.ToString());
+            frame.render_passes[2]->output_rect.ToString());
 
-  host_impl_->drawLayers(frame);
-  host_impl_->didDrawAllLayers(frame);
+  host_impl_->DrawLayers(&frame);
+  host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestOwnSurface,
        AddsQuadsToContributingRenderPasses) {
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes and its owned surface
   // added one pass.
-  ASSERT_EQ(6u, frame.renderPasses.size());
+  ASSERT_EQ(6u, frame.render_passes.size());
 
   // The DelegatedRendererLayer should have added its contributing RenderPasses
   // to the frame.
-  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);
+  EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
+  EXPECT_EQ(1, frame.render_passes[1]->id.index);
+  EXPECT_EQ(4, frame.render_passes[2]->id.layer_id);
+  EXPECT_EQ(2, frame.render_passes[2]->id.index);
 
   // The DelegatedRendererLayer should have added copies of its quads to
   // contributing RenderPasses.
-  ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
+  ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
   EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
-            frame.renderPasses[1]->quad_list[0]->rect.ToString());
+            frame.render_passes[1]->quad_list[0]->rect.ToString());
 
   // Verify it added the right quads.
-  ASSERT_EQ(2u, frame.renderPasses[2]->quad_list.size());
+  ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
   EXPECT_EQ(gfx::Rect(0, 0, 7, 7).ToString(),
-            frame.renderPasses[2]->quad_list[0]->rect.ToString());
+            frame.render_passes[2]->quad_list[0]->rect.ToString());
   EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
-            frame.renderPasses[2]->quad_list[1]->rect.ToString());
-  ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
+            frame.render_passes[2]->quad_list[1]->rect.ToString());
+  ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
   EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
-            frame.renderPasses[1]->quad_list[0]->rect.ToString());
+            frame.render_passes[1]->quad_list[0]->rect.ToString());
 
-  host_impl_->drawLayers(frame);
-  host_impl_->didDrawAllLayers(frame);
+  host_impl_->DrawLayers(&frame);
+  host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsQuadsToTargetRenderPass) {
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes and its owned surface
   // added one pass.
-  ASSERT_EQ(6u, frame.renderPasses.size());
+  ASSERT_EQ(6u, frame.render_passes.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.render_passes[3]->id);
 
   // The DelegatedRendererLayer should have added copies of quads in its root
   // RenderPass to its target RenderPass.
   // The m_layer_after also adds one quad.
-  ASSERT_EQ(1u, frame.renderPasses[3]->quad_list.size());
+  ASSERT_EQ(1u, frame.render_passes[3]->quad_list.size());
 
   // Verify it added the right quads.
   EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
-            frame.renderPasses[3]->quad_list[0]->rect.ToString());
+            frame.render_passes[3]->quad_list[0]->rect.ToString());
 
-  host_impl_->drawLayers(frame);
-  host_impl_->didDrawAllLayers(frame);
+  host_impl_->DrawLayers(&frame);
+  host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestOwnSurface,
        QuadsFromRootRenderPassAreNotModifiedForTheTarget) {
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes and its owned surface
   // added one pass.
-  ASSERT_EQ(6u, frame.renderPasses.size());
+  ASSERT_EQ(6u, frame.render_passes.size());
 
   // Because the DelegatedRendererLayer owns a RenderSurfaceImpl, its root
   // RenderPass' quads do not need to be translated at all. However, they are
   // scaled from the frame's size (8x8) to the layer's bounds (10x10).
   gfx::Transform transform;
   transform.Scale(10.0 / 8.0, 10.0 / 8.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      transform, frame.renderPasses[3]->quad_list[0]->quadTransform());
+      transform, frame.render_passes[3]->quad_list[0]->quadTransform());
 
   // Quads from non-root RenderPasses should not be shifted either.
-  ASSERT_EQ(2u, frame.renderPasses[2]->quad_list.size());
+  ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      gfx::Transform(), frame.renderPasses[2]->quad_list[0]->quadTransform());
+      gfx::Transform(), frame.render_passes[2]->quad_list[0]->quadTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      gfx::Transform(), frame.renderPasses[2]->quad_list[1]->quadTransform());
-  ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
+      gfx::Transform(), frame.render_passes[2]->quad_list[1]->quadTransform());
+  ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      gfx::Transform(), frame.renderPasses[1]->quad_list[0]->quadTransform());
+      gfx::Transform(), frame.render_passes[1]->quad_list[0]->quadTransform());
 
-  host_impl_->drawLayers(frame);
-  host_impl_->didDrawAllLayers(frame);
+  host_impl_->DrawLayers(&frame);
+  host_impl_->DidDrawAllLayers(frame);
 }
 
 class DelegatedRendererLayerImplTestTransform
     : public DelegatedRendererLayerImplTest {
  public:
   void SetUpTest() {
     scoped_ptr<LayerImpl> root_layer = LayerImpl::Create(
-        host_impl_->activeTree(), 1);
+        host_impl_->active_tree(), 1);
     scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
-        FakeDelegatedRendererLayerImpl::Create(host_impl_->activeTree(), 2);
+        FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 2);
 
-    host_impl_->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
+    host_impl_->SetViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
     root_layer->SetBounds(gfx::Size(100, 100));
 
     delegated_renderer_layer->SetPosition(gfx::Point(20, 20));
     delegated_renderer_layer->SetBounds(gfx::Size(30, 30)); 
     delegated_renderer_layer->SetContentBounds(gfx::Size(30, 30));
     delegated_renderer_layer->SetDrawsContent(true);
     gfx::Transform transform;
     transform.Scale(2.0, 2.0);
     transform.Translate(8.0, 8.0);
     delegated_renderer_layer->SetTransform(transform);
@@ skipping 44 matching lines @@
     gfx::Rect root_pass_clip_rect(10, 10, 35, 35);
     bool root_pass_clipped = root_delegated_render_pass_is_clipped_;
 
     TestRenderPass* pass = addRenderPass(
         delegated_render_passes,
         RenderPass::Id(9, 6),
         root_pass_rect,
         gfx::Transform());
     MockQuadCuller quad_sink(pass->quad_list, pass->shared_quad_state_list);
     AppendQuadsData data(pass->id);
-    SharedQuadState* shared_quad_state = quad_sink.useSharedQuadState(SharedQuadState::Create());
+    SharedQuadState* shared_quad_state =
+        quad_sink.useSharedQuadState(SharedQuadState::Create());
     shared_quad_state->SetAll(
         root_pass_transform,
         root_pass_content_bounds,
         root_pass_rect,
         root_pass_clip_rect,
         root_pass_clipped,
         1.f);
 
     scoped_ptr<RenderPassDrawQuad> render_pass_quad =
         RenderPassDrawQuad::Create();
@@ skipping 30 matching lines @@
     delegated_renderer_layer->SetFrameDataForRenderPasses(
         &delegated_render_passes);
 
     // The RenderPasses should be taken by the layer.
     EXPECT_EQ(0u, delegated_render_passes.size());
 
     root_layer_ = root_layer.get();
     delegated_renderer_layer_ = delegated_renderer_layer.get();
 
     root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
-    host_impl_->activeTree()->SetRootLayer(root_layer.Pass());
+    host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
   }
 
   void VerifyRenderPasses(
       const LayerTreeHostImpl::FrameData& frame,
       size_t num_render_passes,
       const SharedQuadState** root_delegated_shared_quad_state,
       const SharedQuadState** contrib_delegated_shared_quad_state) {
-    ASSERT_EQ(num_render_passes, frame.renderPasses.size());
+    ASSERT_EQ(num_render_passes, frame.render_passes.size());
     // The contributing render pass in the DelegatedRendererLayer.
-    EXPECT_EQ(2, frame.renderPasses[0]->id.layer_id);
-    EXPECT_EQ(1, frame.renderPasses[0]->id.index);
+    EXPECT_EQ(2, frame.render_passes[0]->id.layer_id);
+    EXPECT_EQ(1, frame.render_passes[0]->id.index);
     // The root render pass.
-    EXPECT_EQ(1, frame.renderPasses.back()->id.layer_id);
-    EXPECT_EQ(0, frame.renderPasses.back()->id.index);
+    EXPECT_EQ(1, frame.render_passes.back()->id.layer_id);
+    EXPECT_EQ(0, frame.render_passes.back()->id.index);
 
     const QuadList& contrib_delegated_quad_list =
-        frame.renderPasses[0]->quad_list;
+        frame.render_passes[0]->quad_list;
     ASSERT_EQ(2u, contrib_delegated_quad_list.size());
 
-    const QuadList& root_delegated_quad_list = frame.renderPasses[1]->quad_list;
+    const QuadList& root_delegated_quad_list =
+        frame.render_passes[1]->quad_list;
     ASSERT_EQ(5u, root_delegated_quad_list.size());
 
     // All quads in a render pass should share the same state.
     *contrib_delegated_shared_quad_state =
         contrib_delegated_quad_list[0]->shared_quad_state;
     EXPECT_EQ(*contrib_delegated_shared_quad_state,
               contrib_delegated_quad_list[1]->shared_quad_state);
 
     *root_delegated_shared_quad_state =
         root_delegated_quad_list[0]->shared_quad_state;
@@ skipping 14 matching lines @@
   LayerImpl* root_layer_;
   DelegatedRendererLayerImpl* delegated_renderer_layer_;
   bool root_delegated_render_pass_is_clipped_;
 };
 
 TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_NoSurface) {
   root_delegated_render_pass_is_clipped_ = false;
   SetUpTest();
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
   const SharedQuadState* root_delegated_shared_quad_state = NULL;
   const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
   VerifyRenderPasses(
       frame,
       2,
       &root_delegated_shared_quad_state,
       &contrib_delegated_shared_quad_state);
 
   // When the quads don't have a clip of their own, the clip rect is set to
@@ skipping 24 matching lines @@
   EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
             contrib_delegated_shared_quad_state->clip_rect.ToString());
   EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
   expected.MakeIdentity();
   expected.Scale(0.8, 0.8);
   expected.Translate(9.0, 9.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected,
       contrib_delegated_shared_quad_state->content_to_target_transform);
 
-  host_impl_->drawLayers(frame);
-  host_impl_->didDrawAllLayers(frame);
+  host_impl_->DrawLayers(&frame);
+  host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_NoSurface) {
   root_delegated_render_pass_is_clipped_ = true;
   SetUpTest();
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
   const SharedQuadState* root_delegated_shared_quad_state = NULL;
   const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
   VerifyRenderPasses(
       frame,
       2,
       &root_delegated_shared_quad_state,
       &contrib_delegated_shared_quad_state);
 
   // Since the quads have a clip_rect it should be modified by delegated
@@ skipping 29 matching lines @@
   EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
             contrib_delegated_shared_quad_state->clip_rect.ToString());
   EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
   expected.MakeIdentity();
   expected.Scale(0.8, 0.8);
   expected.Translate(9.0, 9.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected,
       contrib_delegated_shared_quad_state->content_to_target_transform);
 
-  host_impl_->drawLayers(frame);
-  host_impl_->didDrawAllLayers(frame);
+  host_impl_->DrawLayers(&frame);
+  host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_Surface) {
   root_delegated_render_pass_is_clipped_ = false;
   SetUpTest();
 
   delegated_renderer_layer_->SetForceRenderSurface(true);
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
   const SharedQuadState* root_delegated_shared_quad_state = NULL;
   const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
   VerifyRenderPasses(
       frame,
       3,
       &root_delegated_shared_quad_state,
       &contrib_delegated_shared_quad_state);
 
   // When the layer owns a surface, then its position and translation are not
@@ skipping 23 matching lines @@
   EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
             contrib_delegated_shared_quad_state->clip_rect.ToString());
   EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
   expected.MakeIdentity();
   expected.Scale(0.8, 0.8);
   expected.Translate(9.0, 9.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected,
       contrib_delegated_shared_quad_state->content_to_target_transform);
 
-  host_impl_->drawLayers(frame);
-  host_impl_->didDrawAllLayers(frame);
+  host_impl_->DrawLayers(&frame);
+  host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_Surface) {
   root_delegated_render_pass_is_clipped_ = true;
   SetUpTest();
 
   delegated_renderer_layer_->SetForceRenderSurface(true);
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
   const SharedQuadState* root_delegated_shared_quad_state = NULL;
   const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
   VerifyRenderPasses(
       frame,
       3,
       &root_delegated_shared_quad_state,
       &contrib_delegated_shared_quad_state);
 
   // When the layer owns a surface, then its position and translation are not
@@ skipping 22 matching lines @@
   EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
             contrib_delegated_shared_quad_state->clip_rect.ToString());
   EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
   expected.MakeIdentity();
   expected.Scale(0.8, 0.8);
   expected.Translate(9.0, 9.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected,
       contrib_delegated_shared_quad_state->content_to_target_transform);
 
-  host_impl_->drawLayers(frame);
-  host_impl_->didDrawAllLayers(frame);
+  host_impl_->DrawLayers(&frame);
+  host_impl_->DidDrawAllLayers(frame);
 }
 
 class DelegatedRendererLayerImplTestClip
     : public DelegatedRendererLayerImplTest {
  public:
   void SetUpTest() {
     scoped_ptr<LayerImpl> root_layer =
-        LayerImpl::Create(host_impl_->activeTree(), 1);
+        LayerImpl::Create(host_impl_->active_tree(), 1);
     scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
-        FakeDelegatedRendererLayerImpl::Create(host_impl_->activeTree(), 2);
+        FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 2);
     scoped_ptr<LayerImpl> clip_layer =
-        LayerImpl::Create(host_impl_->activeTree(), 3);
+        LayerImpl::Create(host_impl_->active_tree(), 3);
     scoped_ptr<LayerImpl> origin_layer =
-        LayerImpl::Create(host_impl_->activeTree(), 4);
+        LayerImpl::Create(host_impl_->active_tree(), 4);
 
-    host_impl_->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
+    host_impl_->SetViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
     root_layer->SetBounds(gfx::Size(100, 100));
 
     delegated_renderer_layer->SetPosition(gfx::Point(20, 20));
     delegated_renderer_layer->SetBounds(gfx::Size(50, 50));
     delegated_renderer_layer->SetContentBounds(gfx::Size(50, 50));
     delegated_renderer_layer->SetDrawsContent(true);
 
     ScopedPtrVector<RenderPass> delegated_render_passes;
 
     gfx::Size child_pass_content_bounds(7, 7);
@@ skipping 104 matching lines @@
       origin_layer->SetPosition(
           gfx::PointAtOffsetFromOrigin(-clip_rect.OffsetFromOrigin()));
 
       origin_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
       clip_layer->AddChild(origin_layer.Pass());
       root_layer->AddChild(clip_layer.Pass());
     } else {
       root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
     }
 
-    host_impl_->activeTree()->SetRootLayer(root_layer.Pass());
+    host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
   }
 
  protected:
   LayerImpl* root_layer_;
   DelegatedRendererLayerImpl* delegated_renderer_layer_;
   bool root_delegated_render_pass_is_clipped_;
   bool clip_delegated_renderer_layer_;
 };
 
 TEST_F(DelegatedRendererLayerImplTestClip,
        QuadsUnclipped_LayerUnclipped_NoSurface) {
   root_delegated_render_pass_is_clipped_ = false;
   clip_delegated_renderer_layer_ = false;
   SetUpTest();
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
-  ASSERT_EQ(2u, frame.renderPasses.size());
+  ASSERT_EQ(2u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
-      frame.renderPasses[0]->quad_list;
+      frame.render_passes[0]->quad_list;
   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
-  const QuadList& root_delegated_quad_list = frame.renderPasses[1]->quad_list;
+  const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
   ASSERT_EQ(5u, root_delegated_quad_list.size());
   const SharedQuadState* root_delegated_shared_quad_state =
       root_delegated_quad_list[0]->shared_quad_state;
   const SharedQuadState* contrib_delegated_shared_quad_state =
       contrib_delegated_quad_list[0]->shared_quad_state;
 
   // When the quads don't have a clip of their own, the clip rect is set to
   // the drawableContentRect of the delegated renderer layer.
   EXPECT_EQ(gfx::Rect(20, 20, 50, 50).ToString(),
             root_delegated_shared_quad_state->clip_rect.ToString());
   // Quads are clipped to the delegated renderer layer.
   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
 
-  host_impl_->drawLayers(frame);
-  host_impl_->didDrawAllLayers(frame);
+  host_impl_->DrawLayers(&frame);
+  host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestClip,
        QuadsClipped_LayerUnclipped_NoSurface) {
   root_delegated_render_pass_is_clipped_ = true;
   clip_delegated_renderer_layer_ = false;
   SetUpTest();
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
-  ASSERT_EQ(2u, frame.renderPasses.size());
+  ASSERT_EQ(2u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
-      frame.renderPasses[0]->quad_list;
+      frame.render_passes[0]->quad_list;
   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
   const QuadList& root_delegated_quad_list =
-      frame.renderPasses[1]->quad_list;
+      frame.render_passes[1]->quad_list;
   ASSERT_EQ(5u, root_delegated_quad_list.size());
   const SharedQuadState* root_delegated_shared_quad_state =
       root_delegated_quad_list[0]->shared_quad_state;
   const SharedQuadState* contrib_delegated_shared_quad_state =
       contrib_delegated_quad_list[0]->shared_quad_state;
 
   // When the quads have a clip of their own, it is used.
   EXPECT_EQ(gfx::Rect(25, 25, 40, 40).ToString(),
             root_delegated_shared_quad_state->clip_rect.ToString());
   // Quads came with a clip rect.
   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
 
-  host_impl_->drawLayers(frame);
-  host_impl_->didDrawAllLayers(frame);
+  host_impl_->DrawLayers(&frame);
+  host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestClip,
        QuadsUnclipped_LayerClipped_NoSurface) {
   root_delegated_render_pass_is_clipped_ = false;
   clip_delegated_renderer_layer_ = true;
   SetUpTest();
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
-  ASSERT_EQ(2u, frame.renderPasses.size());
+  ASSERT_EQ(2u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
-      frame.renderPasses[0]->quad_list;
+      frame.render_passes[0]->quad_list;
   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
-  const QuadList& root_delegated_quad_list = frame.renderPasses[1]->quad_list;
+  const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
   ASSERT_EQ(5u, root_delegated_quad_list.size());
   const SharedQuadState* root_delegated_shared_quad_state =
       root_delegated_quad_list[0]->shared_quad_state;
   const SharedQuadState* contrib_delegated_shared_quad_state =
       contrib_delegated_quad_list[0]->shared_quad_state;
 
   // When the quads don't have a clip of their own, the clip rect is set to
   // the drawableContentRect of the delegated renderer layer. When the layer
   // is clipped, that should be seen in the quads' clip_rect.
   EXPECT_EQ(gfx::Rect(21, 27, 23, 21).ToString(),
             root_delegated_shared_quad_state->clip_rect.ToString());
   // Quads are clipped to the delegated renderer layer.
   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
 
-  host_impl_->drawLayers(frame);
-  host_impl_->didDrawAllLayers(frame);
+  host_impl_->DrawLayers(&frame);
+  host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestClip,
        QuadsClipped_LayerClipped_NoSurface) {
   root_delegated_render_pass_is_clipped_ = true;
   clip_delegated_renderer_layer_ = true;
   SetUpTest();
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
-  ASSERT_EQ(2u, frame.renderPasses.size());
+  ASSERT_EQ(2u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
-      frame.renderPasses[0]->quad_list;
+      frame.render_passes[0]->quad_list;
   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
-  const QuadList& root_delegated_quad_list = frame.renderPasses[1]->quad_list;
+  const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
   ASSERT_EQ(5u, root_delegated_quad_list.size());
   const SharedQuadState* root_delegated_shared_quad_state =
       root_delegated_quad_list[0]->shared_quad_state;
   const SharedQuadState* contrib_delegated_shared_quad_state =
       contrib_delegated_quad_list[0]->shared_quad_state;
 
   // When the quads have a clip of their own, it is used, but it is
   // combined with the clip rect of the delegated renderer layer.
   EXPECT_EQ(gfx::Rect(25, 27, 19, 21).ToString(),
             root_delegated_shared_quad_state->clip_rect.ToString());
   // Quads came with a clip rect.
   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
 
-  host_impl_->drawLayers(frame);
-  host_impl_->didDrawAllLayers(frame);
+  host_impl_->DrawLayers(&frame);
+  host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestClip,
        QuadsUnclipped_LayerUnclipped_Surface) {
   root_delegated_render_pass_is_clipped_ = false;
   clip_delegated_renderer_layer_ = false;
   SetUpTest();
 
   delegated_renderer_layer_->SetForceRenderSurface(true);
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
-  ASSERT_EQ(3u, frame.renderPasses.size());
+  ASSERT_EQ(3u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
-      frame.renderPasses[0]->quad_list;
+      frame.render_passes[0]->quad_list;
   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
-  const QuadList& root_delegated_quad_list = frame.renderPasses[1]->quad_list;
+  const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
   ASSERT_EQ(5u, root_delegated_quad_list.size());
   const SharedQuadState* root_delegated_shared_quad_state =
       root_delegated_quad_list[0]->shared_quad_state;
   const SharedQuadState* contrib_delegated_shared_quad_state =
       contrib_delegated_quad_list[0]->shared_quad_state;
 
   // When the layer owns a surface, the quads don't need to be clipped
   // further than they already specify. If they aren't clipped, then their
   // clip rect is ignored, and they are not set as clipped.
   EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped);
 
-  host_impl_->drawLayers(frame);
-  host_impl_->didDrawAllLayers(frame);
+  host_impl_->DrawLayers(&frame);
+  host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestClip,
        QuadsClipped_LayerUnclipped_Surface) {
   root_delegated_render_pass_is_clipped_ = true;
   clip_delegated_renderer_layer_ = false;
   SetUpTest();
 
   delegated_renderer_layer_->SetForceRenderSurface(true);
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
-  ASSERT_EQ(3u, frame.renderPasses.size());
-  const QuadList& contrib_delegated_quad_list = frame.renderPasses[0]->quad_list;
+  ASSERT_EQ(3u, frame.render_passes.size());
+  const QuadList& contrib_delegated_quad_list =
+      frame.render_passes[0]->quad_list;
   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
-  const QuadList& root_delegated_quad_list = frame.renderPasses[1]->quad_list;
+  const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
   ASSERT_EQ(5u, root_delegated_quad_list.size());
-  const SharedQuadState* root_delegated_shared_quad_state = root_delegated_quad_list[0]->shared_quad_state;
+  const SharedQuadState* root_delegated_shared_quad_state =
+      root_delegated_quad_list[0]->shared_quad_state;
   const SharedQuadState* contrib_delegated_shared_quad_state =
       contrib_delegated_quad_list[0]->shared_quad_state;
 
   // When the quads have a clip of their own, it is used.
   EXPECT_EQ(gfx::Rect(5, 5, 40, 40).ToString(),
             root_delegated_shared_quad_state->clip_rect.ToString());
   // Quads came with a clip rect.
   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
 
-  host_impl_->drawLayers(frame);
-  host_impl_->didDrawAllLayers(frame);
+  host_impl_->DrawLayers(&frame);
+  host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestClip,
        QuadsUnclipped_LayerClipped_Surface) {
   root_delegated_render_pass_is_clipped_ = false;
   clip_delegated_renderer_layer_ = true;
   SetUpTest();
 
   delegated_renderer_layer_->SetForceRenderSurface(true);
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
-  ASSERT_EQ(3u, frame.renderPasses.size());
+  ASSERT_EQ(3u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
-      frame.renderPasses[0]->quad_list;
+      frame.render_passes[0]->quad_list;
   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
-  const QuadList& root_delegated_quad_list = frame.renderPasses[1]->quad_list;
+  const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
   ASSERT_EQ(5u, root_delegated_quad_list.size());
   const SharedQuadState* root_delegated_shared_quad_state =
       root_delegated_quad_list[0]->shared_quad_state;
   const SharedQuadState* contrib_delegated_shared_quad_state =
       contrib_delegated_quad_list[0]->shared_quad_state;
 
   // When the layer owns a surface, the quads don't need to be clipped
   // further than they already specify. If they aren't clipped, then their
   // clip rect is ignored, and they are not set as clipped.
   EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped);
 
-  host_impl_->drawLayers(frame);
-  host_impl_->didDrawAllLayers(frame);
+  host_impl_->DrawLayers(&frame);
+  host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestClip, QuadsClipped_LayerClipped_Surface) {
   root_delegated_render_pass_is_clipped_ = true;
   clip_delegated_renderer_layer_ = true;
   SetUpTest();
 
   delegated_renderer_layer_->SetForceRenderSurface(true);
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
 
-  ASSERT_EQ(3u, frame.renderPasses.size());
+  ASSERT_EQ(3u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
-      frame.renderPasses[0]->quad_list;
+      frame.render_passes[0]->quad_list;
   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
-  const QuadList& root_delegated_quad_list = frame.renderPasses[1]->quad_list;
+  const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
   ASSERT_EQ(5u, root_delegated_quad_list.size());
   const SharedQuadState* root_delegated_shared_quad_state =
       root_delegated_quad_list[0]->shared_quad_state;
   const SharedQuadState* contrib_delegated_shared_quad_state =
       contrib_delegated_quad_list[0]->shared_quad_state;
 
   // When the quads have a clip of their own, it is used, but it is
   // combined with the clip rect of the delegated renderer layer. If the
   // layer owns a surface, then it does not have a clip rect of its own.
   EXPECT_EQ(gfx::Rect(5, 5, 40, 40).ToString(),
             root_delegated_shared_quad_state->clip_rect.ToString());
   // Quads came with a clip rect.
   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
 
-  host_impl_->drawLayers(frame);
-  host_impl_->didDrawAllLayers(frame);
+  host_impl_->DrawLayers(&frame);
+  host_impl_->DidDrawAllLayers(frame);
 }
 
 }  // namespace
 }  // namespace cc