cc: Chromify Layer and LayerImpl classes.

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 47 matching lines @@
     scoped_ptr<LayerImpl> root_layer = SolidColorLayerImpl::Create(
         host_impl_->activeTree(), 1).PassAs<LayerImpl>();
     scoped_ptr<LayerImpl> layer_before = SolidColorLayerImpl::Create(
         host_impl_->activeTree(), 2).PassAs<LayerImpl>();
     scoped_ptr<LayerImpl> layer_after = SolidColorLayerImpl::Create(
         host_impl_->activeTree(), 3).PassAs<LayerImpl>();
     scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
         FakeDelegatedRendererLayerImpl::Create(host_impl_->activeTree(), 4);
 
     host_impl_->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
-    root_layer->setBounds(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_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));
-    layer_after->setContentBounds(gfx::Size(15, 15));
-    layer_after->setDrawsContent(true);
-    layer_after->setForceRenderSurface(true);
+    layer_after->SetPosition(gfx::Point(5, 5));
+    layer_after->SetBounds(gfx::Size(15, 15));
+    layer_after->SetContentBounds(gfx::Size(15, 15));
+    layer_after->SetDrawsContent(true);
+    layer_after->SetForceRenderSurface(true);
 
-    delegated_renderer_layer->setPosition(gfx::Point(3, 3));
-    delegated_renderer_layer->setBounds(gfx::Size(10, 10));
-    delegated_renderer_layer->setContentBounds(gfx::Size(10, 10));
-    delegated_renderer_layer->setDrawsContent(true);
+    delegated_renderer_layer->SetPosition(gfx::Point(3, 3));
+    delegated_renderer_layer->SetBounds(gfx::Size(10, 10));
+    delegated_renderer_layer->SetContentBounds(gfx::Size(10, 10));
+    delegated_renderer_layer->SetDrawsContent(true);
     gfx::Transform transform;
     transform.Translate(1.0, 1.0);
-    delegated_renderer_layer->setTransform(transform);
+    delegated_renderer_layer->SetTransform(transform);
 
     ScopedPtrVector<RenderPass> delegated_render_passes;
     TestRenderPass* pass1 = addRenderPass(
         delegated_render_passes,
         RenderPass::Id(9, 6),
         gfx::Rect(6, 6, 6, 6),
         gfx::Transform());
     addQuad(pass1, gfx::Rect(0, 0, 6, 6), 33u);
     TestRenderPass* pass2 = addRenderPass(
         delegated_render_passes,
@@ skipping 14 matching lines @@
     // The RenderPasses should be taken by the layer.
     EXPECT_EQ(0u, delegated_render_passes.size());
 
     root_layer_ = root_layer.get();
     layer_before_ = layer_before.get();
     layer_after_ = layer_after.get();
     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());
+    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());
+    root_layer->AddChild(layer_before.Pass());
     host_impl_->activeTree()->SetRootLayer(root_layer.Pass());
   }
 
  protected:
   LayerImpl* root_layer_;
   LayerImpl* layer_before_;
   LayerImpl* layer_after_;
   DelegatedRendererLayerImpl* delegated_renderer_layer_;
 };
 
@@ skipping 126 matching lines @@
   host_impl_->drawLayers(frame);
   host_impl_->didDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestSimple, DoesNotOwnARenderSurface) {
   LayerTreeHostImpl::FrameData 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_->renderSurface());
+  EXPECT_FALSE(delegated_renderer_layer_->render_surface());
 
   host_impl_->drawLayers(frame);
   host_impl_->didDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestSimple, DoesOwnARenderSurfaceForOpacity) {
-  delegated_renderer_layer_->setOpacity(0.5f);
+  delegated_renderer_layer_->SetOpacity(0.5f);
 
   LayerTreeHostImpl::FrameData 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_->renderSurface());
+  EXPECT_TRUE(delegated_renderer_layer_->render_surface());
 
   host_impl_->drawLayers(frame);
   host_impl_->didDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestSimple,
        DoesOwnARenderSurfaceForTransform) {
   gfx::Transform rotation;
   rotation.RotateAboutZAxis(30.0);
-  delegated_renderer_layer_->setTransform(rotation);
+  delegated_renderer_layer_->SetTransform(rotation);
 
   LayerTreeHostImpl::FrameData 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_->renderSurface());
+  EXPECT_TRUE(delegated_renderer_layer_->render_surface());
 
   host_impl_->drawLayers(frame);
   host_impl_->didDrawAllLayers(frame);
 }
 
 class DelegatedRendererLayerImplTestOwnSurface
     : public DelegatedRendererLayerImplTestSimple {
  public:
   DelegatedRendererLayerImplTestOwnSurface()
       : DelegatedRendererLayerImplTestSimple() {
-    delegated_renderer_layer_->setForceRenderSurface(true);
+    delegated_renderer_layer_->SetForceRenderSurface(true);
   }
 };
 
 TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsRenderPasses) {
   LayerTreeHostImpl::FrameData 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.
@@ skipping 119 matching lines @@
       gfx::Transform(), frame.renderPasses[1]->quad_list[0]->quadTransform());
 
   host_impl_->drawLayers(frame);
   host_impl_->didDrawAllLayers(frame);
 }
 
 class DelegatedRendererLayerImplTestTransform
     : public DelegatedRendererLayerImplTest {
  public:
   void SetUpTest() {
-    scoped_ptr<LayerImpl> root_layer = LayerImpl::create(
+    scoped_ptr<LayerImpl> root_layer = LayerImpl::Create(
         host_impl_->activeTree(), 1);
     scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
         FakeDelegatedRendererLayerImpl::Create(host_impl_->activeTree(), 2);
 
     host_impl_->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
-    root_layer->setBounds(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);
+    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);
+    delegated_renderer_layer->SetTransform(transform);
 
     ScopedPtrVector<RenderPass> delegated_render_passes;
 
     gfx::Size child_pass_content_bounds(7, 7);
     gfx::Rect child_pass_rect(20, 20, 7, 7);
     gfx::Transform child_pass_transform;
     child_pass_transform.Scale(0.8, 0.8);
     child_pass_transform.Translate(9.0, 9.0);
     gfx::Rect child_pass_clip_rect(21, 21, 3, 3);
     bool child_pass_clipped = false;
@@ skipping 12 matching lines @@
           child_pass_transform,
           child_pass_content_bounds,
           child_pass_rect,
           child_pass_clip_rect,
           child_pass_clipped,
           1.f);
 
       scoped_ptr<SolidColorDrawQuad> color_quad;
       color_quad = SolidColorDrawQuad::Create();
       color_quad->SetNew(shared_quad_state, gfx::Rect(20, 20, 3, 7), 1u);
-      quad_sink.append(color_quad.PassAs<DrawQuad>(), data);
+      quad_sink.append(color_quad.PassAs<DrawQuad>(), &data);
 
       color_quad = SolidColorDrawQuad::Create();
       color_quad->SetNew(shared_quad_state, gfx::Rect(23, 20, 4, 7), 1u);
-      quad_sink.append(color_quad.PassAs<DrawQuad>(), data);
+      quad_sink.append(color_quad.PassAs<DrawQuad>(), &data);
     }
 
     gfx::Size root_pass_content_bounds(50, 50);
     gfx::Rect root_pass_rect(0, 0, 50, 50);
     gfx::Transform root_pass_transform;
     root_pass_transform.Scale(1.5, 1.5);
     root_pass_transform.Translate(7.0, 7.0);
     gfx::Rect root_pass_clip_rect(10, 10, 35, 35);
     bool root_pass_clipped = root_delegated_render_pass_is_clipped_;
 
@@ skipping 19 matching lines @@
         shared_quad_state,
         gfx::Rect(5, 5, 7, 7),  // rect
         RenderPass::Id(10, 7),  // render_pass_id
         false,  // is_replica
         0,  // mask_resource_id
         child_pass_rect,  // contents_changed_since_last_frame
         gfx::RectF(),  // mask_uv_rect
         WebKit::WebFilterOperations(),  // filters
         skia::RefPtr<SkImageFilter>(),  // filter
         WebKit::WebFilterOperations());  // background_filters
-    quad_sink.append(render_pass_quad.PassAs<DrawQuad>(), data);
+    quad_sink.append(render_pass_quad.PassAs<DrawQuad>(), &data);
 
     scoped_ptr<SolidColorDrawQuad> color_quad;
     color_quad = SolidColorDrawQuad::Create();
     color_quad->SetNew(shared_quad_state, gfx::Rect(0, 0, 10, 10), 1u);
-    quad_sink.append(color_quad.PassAs<DrawQuad>(), data);
+    quad_sink.append(color_quad.PassAs<DrawQuad>(), &data);
 
     color_quad = SolidColorDrawQuad::Create();
     color_quad->SetNew(shared_quad_state, gfx::Rect(0, 10, 10, 10), 2u);
-    quad_sink.append(color_quad.PassAs<DrawQuad>(), data);
+    quad_sink.append(color_quad.PassAs<DrawQuad>(), &data);
 
     color_quad = SolidColorDrawQuad::Create();
     color_quad->SetNew(shared_quad_state, gfx::Rect(10, 0, 10, 10), 3u);
-    quad_sink.append(color_quad.PassAs<DrawQuad>(), data);
+    quad_sink.append(color_quad.PassAs<DrawQuad>(), &data);
 
     color_quad = SolidColorDrawQuad::Create();
     color_quad->SetNew(shared_quad_state, gfx::Rect(10, 10, 10, 10), 4u);
-    quad_sink.append(color_quad.PassAs<DrawQuad>(), data);
+    quad_sink.append(color_quad.PassAs<DrawQuad>(), &data);
 
     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>());
+    root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
     host_impl_->activeTree()->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());
     // The contributing render pass in the DelegatedRendererLayer.
@@ skipping 147 matching lines @@
       contrib_delegated_shared_quad_state->content_to_target_transform);
 
   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);
+  delegated_renderer_layer_->SetForceRenderSurface(true);
 
   LayerTreeHostImpl::FrameData 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,
@@ skipping 34 matching lines @@
       contrib_delegated_shared_quad_state->content_to_target_transform);
 
   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);
+  delegated_renderer_layer_->SetForceRenderSurface(true);
 
   LayerTreeHostImpl::FrameData 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,
@@ skipping 34 matching lines @@
 
   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_->activeTree(), 1);
     scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
         FakeDelegatedRendererLayerImpl::Create(host_impl_->activeTree(), 2);
     scoped_ptr<LayerImpl> clip_layer =
-        LayerImpl::create(host_impl_->activeTree(), 3);
+        LayerImpl::Create(host_impl_->activeTree(), 3);
     scoped_ptr<LayerImpl> origin_layer =
-        LayerImpl::create(host_impl_->activeTree(), 4);
+        LayerImpl::Create(host_impl_->activeTree(), 4);
 
     host_impl_->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
-    root_layer->setBounds(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);
+    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);
     gfx::Rect child_pass_rect(20, 20, 7, 7);
     gfx::Transform child_pass_transform;
     gfx::Rect child_pass_clip_rect(21, 21, 3, 3);
     bool child_pass_clipped = false;
 
     {
@@ skipping 10 matching lines @@
           child_pass_transform,
           child_pass_content_bounds,
           child_pass_rect,
           child_pass_clip_rect,
           child_pass_clipped,
           1.f);
 
       scoped_ptr<SolidColorDrawQuad> color_quad;
       color_quad = SolidColorDrawQuad::Create();
       color_quad->SetNew(shared_quad_state, gfx::Rect(20, 20, 3, 7), 1u);
-      quad_sink.append(color_quad.PassAs<DrawQuad>(), data);
+      quad_sink.append(color_quad.PassAs<DrawQuad>(), &data);
 
       color_quad = SolidColorDrawQuad::Create();
       color_quad->SetNew(shared_quad_state, gfx::Rect(23, 20, 4, 7), 1u);
-      quad_sink.append(color_quad.PassAs<DrawQuad>(), data);
+      quad_sink.append(color_quad.PassAs<DrawQuad>(), &data);
     }
 
     gfx::Size root_pass_content_bounds(50, 50);
     gfx::Rect root_pass_rect(0, 0, 50, 50);
     gfx::Transform root_pass_transform;
     gfx::Rect root_pass_clip_rect(5, 5, 40, 40);
     bool root_pass_clipped = root_delegated_render_pass_is_clipped_;
 
     TestRenderPass* pass = addRenderPass(
         delegated_render_passes,
@@ skipping 17 matching lines @@
         shared_quad_state,
         gfx::Rect(5, 5, 7, 7),  // rect
         RenderPass::Id(10, 7),  // render_pass_id
         false,  // is_replica
         0,  // mask_resource_id
         child_pass_rect,  // contents_changed_since_last_frame
         gfx::RectF(),  // mask_uv_rect
         WebKit::WebFilterOperations(),  // filters
         skia::RefPtr<SkImageFilter>(),  // filter
         WebKit::WebFilterOperations());  // background_filters
-    quad_sink.append(render_pass_quad.PassAs<DrawQuad>(), data);
+    quad_sink.append(render_pass_quad.PassAs<DrawQuad>(), &data);
 
     scoped_ptr<SolidColorDrawQuad> color_quad;
     color_quad = SolidColorDrawQuad::Create();
     color_quad->SetNew(shared_quad_state, gfx::Rect(0, 0, 10, 10), 1u);
-    quad_sink.append(color_quad.PassAs<DrawQuad>(), data);
+    quad_sink.append(color_quad.PassAs<DrawQuad>(), &data);
 
     color_quad = SolidColorDrawQuad::Create();
     color_quad->SetNew(shared_quad_state, gfx::Rect(0, 10, 10, 10), 2u);
-    quad_sink.append(color_quad.PassAs<DrawQuad>(), data);
+    quad_sink.append(color_quad.PassAs<DrawQuad>(), &data);
 
     color_quad = SolidColorDrawQuad::Create();
     color_quad->SetNew(shared_quad_state, gfx::Rect(10, 0, 10, 10), 3u);
-    quad_sink.append(color_quad.PassAs<DrawQuad>(), data);
+    quad_sink.append(color_quad.PassAs<DrawQuad>(), &data);
 
     color_quad = SolidColorDrawQuad::Create();
     color_quad->SetNew(shared_quad_state, gfx::Rect(10, 10, 10, 10), 4u);
-    quad_sink.append(color_quad.PassAs<DrawQuad>(), data);
+    quad_sink.append(color_quad.PassAs<DrawQuad>(), &data);
 
     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();
 
     if (clip_delegated_renderer_layer_) {
       gfx::Rect clip_rect(21, 27, 23, 21);
 
-      clip_layer->setPosition(clip_rect.origin());
-      clip_layer->setBounds(clip_rect.size());
-      clip_layer->setContentBounds(clip_rect.size());
-      clip_layer->setMasksToBounds(true);
+      clip_layer->SetPosition(clip_rect.origin());
+      clip_layer->SetBounds(clip_rect.size());
+      clip_layer->SetContentBounds(clip_rect.size());
+      clip_layer->SetMasksToBounds(true);
 
-      origin_layer->setPosition(
+      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());
+      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>());
+      root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
     }
 
     host_impl_->activeTree()->SetRootLayer(root_layer.Pass());
   }
 
  protected:
   LayerImpl* root_layer_;
   DelegatedRendererLayerImpl* delegated_renderer_layer_;
   bool root_delegated_render_pass_is_clipped_;
   bool clip_delegated_renderer_layer_;
@@ skipping 123 matching lines @@
   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);
+  delegated_renderer_layer_->SetForceRenderSurface(true);
 
   LayerTreeHostImpl::FrameData 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(2u, contrib_delegated_quad_list.size());
   const QuadList& root_delegated_quad_list = frame.renderPasses[1]->quad_list;
   ASSERT_EQ(5u, root_delegated_quad_list.size());
@@ skipping 10 matching lines @@
   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);
+  delegated_renderer_layer_->SetForceRenderSurface(true);
 
   LayerTreeHostImpl::FrameData 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(2u, contrib_delegated_quad_list.size());
   const QuadList& root_delegated_quad_list = frame.renderPasses[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(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);
 }
 
 TEST_F(DelegatedRendererLayerImplTestClip,
        QuadsUnclipped_LayerClipped_Surface) {
   root_delegated_render_pass_is_clipped_ = false;
   clip_delegated_renderer_layer_ = true;
   SetUpTest();
 
-  delegated_renderer_layer_->setForceRenderSurface(true);
+  delegated_renderer_layer_->SetForceRenderSurface(true);
 
   LayerTreeHostImpl::FrameData 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(2u, contrib_delegated_quad_list.size());
   const QuadList& root_delegated_quad_list = frame.renderPasses[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);
 }
 
 TEST_F(DelegatedRendererLayerImplTestClip, QuadsClipped_LayerClipped_Surface) {
   root_delegated_render_pass_is_clipped_ = true;
   clip_delegated_renderer_layer_ = true;
   SetUpTest();
 
-  delegated_renderer_layer_->setForceRenderSurface(true);
+  delegated_renderer_layer_->SetForceRenderSurface(true);
 
   LayerTreeHostImpl::FrameData 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(2u, contrib_delegated_quad_list.size());
   const QuadList& root_delegated_quad_list = frame.renderPasses[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);
 }
 
 }  // namespace
 }  // namespace cc