cc: Chromify Layer and LayerImpl classes.

cc/layer_tree_host_unittest.cc

 // Copyright 2011 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/layer_tree_host.h"
 
 #include "base/synchronization/lock.h"
 #include "cc/content_layer.h"
 #include "cc/content_layer_client.h"
 #include "cc/frame_rate_controller.h"
@@ skipping 271 matching lines @@
 };
 
 TEST_F(LayerTreeHostTestSetNeedsRedraw, runMultiThread)
 {
     runTest(true);
 }
 
 class LayerTreeHostTestNoExtraCommitFromInvalidate : public LayerTreeHostTest {
 public:
     LayerTreeHostTestNoExtraCommitFromInvalidate()
-        : m_rootLayer(ContentLayer::create(&m_client))
+        : m_rootLayer(ContentLayer::Create(&m_client))
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
-        m_rootLayer->setAutomaticallyComputeRasterScale(false);
-        m_rootLayer->setIsDrawable(true);
-        m_rootLayer->setBounds(gfx::Size(1, 1));
+        m_rootLayer->SetAutomaticallyComputeRasterScale(false);
+        m_rootLayer->SetIsDrawable(true);
+        m_rootLayer->SetBounds(gfx::Size(1, 1));
         m_layerTreeHost->setRootLayer(m_rootLayer);
         postSetNeedsCommitToMainThread();
     }
 
     virtual void didCommit() OVERRIDE
     {
         switch (m_layerTreeHost->commitNumber()) {
         case 1:
             // Changing the content bounds will cause a single commit!
-            m_rootLayer->setRasterScale(4.0f);
+            m_rootLayer->SetRasterScale(4.0f);
             break;
         default:
             // No extra commits.
             EXPECT_EQ(2, m_layerTreeHost->commitNumber());
             endTest();
         }
     }
 
     virtual void afterTest() OVERRIDE
     {
@@ skipping 346 matching lines @@
 class LayerTreeHostTestStartPageScaleAnimation : public LayerTreeHostTest {
 public:
 
     LayerTreeHostTestStartPageScaleAnimation()
         : m_animationRequested(false)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
-        m_layerTreeHost->rootLayer()->setScrollable(true);
-        m_layerTreeHost->rootLayer()->setScrollOffset(gfx::Vector2d());
+        m_layerTreeHost->rootLayer()->SetScrollable(true);
+        m_layerTreeHost->rootLayer()->SetScrollOffset(gfx::Vector2d());
         postSetNeedsCommitToMainThread();
         postSetNeedsRedrawToMainThread();
     }
 
     void requestStartPageScaleAnimation()
     {
-        layerTreeHost()->startPageScaleAnimation(gfx::Vector2d(), false, 1.25, base::TimeDelta());
+        m_layerTreeHost->startPageScaleAnimation(gfx::Vector2d(), false, 1.25, base::TimeDelta());
     }
 
     virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
-        impl->rootLayer()->setScrollable(true);
-        impl->rootLayer()->setScrollOffset(gfx::Vector2d());
+        impl->rootLayer()->SetScrollable(true);
+        impl->rootLayer()->SetScrollOffset(gfx::Vector2d());
         impl->activeTree()->SetPageScaleFactorAndLimits(impl->activeTree()->page_scale_factor(), 0.5, 2);
 
         // We request animation only once.
         if (!m_animationRequested) {
             impl->proxy()->MainThread()->postTask(base::Bind(&LayerTreeHostTestStartPageScaleAnimation::requestStartPageScaleAnimation, base::Unretained(this)));
             m_animationRequested = true;
         }
     }
 
     virtual void applyScrollAndScale(gfx::Vector2d scrollDelta, float scale) OVERRIDE
     {
-        gfx::Vector2d offset = m_layerTreeHost->rootLayer()->scrollOffset();
-        m_layerTreeHost->rootLayer()->setScrollOffset(offset + scrollDelta);
+        gfx::Vector2d offset = m_layerTreeHost->rootLayer()->scroll_offset();
+        m_layerTreeHost->rootLayer()->SetScrollOffset(offset + scrollDelta);
         m_layerTreeHost->setPageScaleFactorAndLimits(scale, 0.5, 2);
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         impl->processScrollDeltas();
         // We get one commit before the first draw, and the animation doesn't happen until the second draw.
         if (impl->activeTree()->source_frame_number() == 1) {
             EXPECT_EQ(1.25, impl->activeTree()->page_scale_factor());
             endTest();
@@ skipping 61 matching lines @@
 
     void setTestLayer(Layer* testLayer)
     {
         m_testLayer = testLayer;
     }
 
     virtual void paintContents(SkCanvas*, const gfx::Rect&, gfx::RectF&) OVERRIDE
     {
         // Set layer opacity to 0.
         if (m_testLayer)
-            m_testLayer->setOpacity(0);
+            m_testLayer->SetOpacity(0);
     }
 
 private:
     Layer* m_testLayer;
 };
 
 class ContentLayerWithUpdateTracking : public ContentLayer {
 public:
-    static scoped_refptr<ContentLayerWithUpdateTracking> create(ContentLayerClient* client) { return make_scoped_refptr(new ContentLayerWithUpdateTracking(client)); }
+    static scoped_refptr<ContentLayerWithUpdateTracking> Create(ContentLayerClient* client) { return make_scoped_refptr(new ContentLayerWithUpdateTracking(client)); }
 
     int paintContentsCount() { return m_paintContentsCount; }
     void resetPaintContentsCount() { m_paintContentsCount = 0; }
 
-    virtual void update(ResourceUpdateQueue& queue, const OcclusionTracker* occlusion, RenderingStats* stats) OVERRIDE
+    virtual void Update(ResourceUpdateQueue* queue, const OcclusionTracker* occlusion, RenderingStats* stats) OVERRIDE
     {
-        ContentLayer::update(queue, occlusion, stats);
+        ContentLayer::Update(queue, occlusion, stats);
         m_paintContentsCount++;
     }
 
 private:
     explicit ContentLayerWithUpdateTracking(ContentLayerClient* client)
         : ContentLayer(client)
         , m_paintContentsCount(0)
     {
-        setAnchorPoint(gfx::PointF(0, 0));
-        setBounds(gfx::Size(10, 10));
-        setIsDrawable(true);
+        SetAnchorPoint(gfx::PointF(0, 0));
+        SetBounds(gfx::Size(10, 10));
+        SetIsDrawable(true);
     }
     virtual ~ContentLayerWithUpdateTracking()
     {
     }
 
     int m_paintContentsCount;
 };
 
 // Layer opacity change during paint should not prevent compositor resources from being updated during commit.
 class LayerTreeHostTestOpacityChange : public LayerTreeHostTest {
 public:
     LayerTreeHostTestOpacityChange()
         : m_testOpacityChangeDelegate()
-        , m_updateCheckLayer(ContentLayerWithUpdateTracking::create(&m_testOpacityChangeDelegate))
+        , m_updateCheckLayer(ContentLayerWithUpdateTracking::Create(&m_testOpacityChangeDelegate))
     {
         m_testOpacityChangeDelegate.setTestLayer(m_updateCheckLayer.get());
     }
 
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
-        m_layerTreeHost->rootLayer()->addChild(m_updateCheckLayer);
+        m_layerTreeHost->rootLayer()->AddChild(m_updateCheckLayer);
 
         postSetNeedsCommitToMainThread();
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl*) OVERRIDE
     {
         endTest();
     }
 
     virtual void afterTest() OVERRIDE
     {
-        // update() should have been called once.
+        // Update() should have been called once.
         EXPECT_EQ(1, m_updateCheckLayer->paintContentsCount());
 
         // clear m_updateCheckLayer so LayerTreeHost dies.
         m_updateCheckLayer = NULL;
     }
 
 private:
     TestOpacityChangeLayerDelegate m_testOpacityChangeDelegate;
     scoped_refptr<ContentLayerWithUpdateTracking> m_updateCheckLayer;
 };
 
 TEST_F(LayerTreeHostTestOpacityChange, runMultiThread)
 {
     runTest(true);
 }
 
 class NoScaleContentLayer : public ContentLayer {
 public:
-    static scoped_refptr<NoScaleContentLayer> create(ContentLayerClient* client) { return make_scoped_refptr(new NoScaleContentLayer(client)); }
+    static scoped_refptr<NoScaleContentLayer> Create(ContentLayerClient* client) { return make_scoped_refptr(new NoScaleContentLayer(client)); }
 
-    virtual void calculateContentsScale(
-        float idealContentsScale,
-        bool animatingTransformToScreen,
-        float* contentsScaleX,
-        float* contentsScaleY,
+    virtual void CalculateContentsScale(
+        float ideal_contents_scale,
+        bool animating_transform_to_screen,
+        float* contents_scale_x,
+        float* contents_scale_y,
         gfx::Size* contentBounds) OVERRIDE
     {
         // Skip over the ContentLayer's method to the base Layer class.
-        Layer::calculateContentsScale(
-             idealContentsScale,
-             animatingTransformToScreen,
-             contentsScaleX,
-             contentsScaleY,
+        Layer::CalculateContentsScale(
+             ideal_contents_scale,
+             animating_transform_to_screen,
+             contents_scale_x,
+             contents_scale_y,
              contentBounds);
     }
 
 private:
     explicit NoScaleContentLayer(ContentLayerClient* client)
         : ContentLayer(client) { }
     virtual ~NoScaleContentLayer() { }
 };
 
 class LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers : public LayerTreeHostTest {
 public:
 
     LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers()
-        : m_rootLayer(NoScaleContentLayer::create(&m_client))
-        , m_childLayer(ContentLayer::create(&m_client))
+        : m_rootLayer(NoScaleContentLayer::Create(&m_client))
+        , m_childLayer(ContentLayer::Create(&m_client))
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->setViewportSize(gfx::Size(40, 40), gfx::Size(60, 60));
         m_layerTreeHost->setDeviceScaleFactor(1.5);
         EXPECT_EQ(gfx::Size(40, 40), m_layerTreeHost->layoutViewportSize());
         EXPECT_EQ(gfx::Size(60, 60), m_layerTreeHost->deviceViewportSize());
 
-        m_rootLayer->addChild(m_childLayer);
+        m_rootLayer->AddChild(m_childLayer);
 
-        m_rootLayer->setIsDrawable(true);
-        m_rootLayer->setBounds(gfx::Size(30, 30));
-        m_rootLayer->setAnchorPoint(gfx::PointF(0, 0));
+        m_rootLayer->SetIsDrawable(true);
+        m_rootLayer->SetBounds(gfx::Size(30, 30));
+        m_rootLayer->SetAnchorPoint(gfx::PointF(0, 0));
 
-        m_childLayer->setIsDrawable(true);
-        m_childLayer->setPosition(gfx::Point(2, 2));
-        m_childLayer->setBounds(gfx::Size(10, 10));
-        m_childLayer->setAnchorPoint(gfx::PointF(0, 0));
+        m_childLayer->SetIsDrawable(true);
+        m_childLayer->SetPosition(gfx::Point(2, 2));
+        m_childLayer->SetBounds(gfx::Size(10, 10));
+        m_childLayer->SetAnchorPoint(gfx::PointF(0, 0));
 
         m_layerTreeHost->setRootLayer(m_rootLayer);
 
         ASSERT_TRUE(m_layerTreeHost->initializeRendererIfNeeded());
         ResourceUpdateQueue queue;
         m_layerTreeHost->updateLayers(queue, std::numeric_limits<size_t>::max());
         postSetNeedsCommitToMainThread();
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
@@ skipping 23 matching lines @@
         // Compute all the layer transforms for the frame.
         LayerTreeHostImpl::FrameData frameData;
         mockImpl->prepareToDraw(frameData);
         mockImpl->didDrawAllLayers(frameData);
 
         const MockLayerTreeHostImpl::LayerList& renderSurfaceLayerList =
           *frameData.renderSurfaceLayerList;
 
         // Both layers should be drawing into the root render surface.
         ASSERT_EQ(1u, renderSurfaceLayerList.size());
-        ASSERT_EQ(root->renderSurface(), renderSurfaceLayerList[0]->renderSurface());
-        ASSERT_EQ(2u, root->renderSurface()->layer_list().size());
+        ASSERT_EQ(root->render_surface(), renderSurfaceLayerList[0]->render_surface());
+        ASSERT_EQ(2u, root->render_surface()->layer_list().size());
 
         // The root render surface is the size of the viewport.
-        EXPECT_RECT_EQ(gfx::Rect(0, 0, 60, 60), root->renderSurface()->content_rect());
+        EXPECT_RECT_EQ(gfx::Rect(0, 0, 60, 60), root->render_surface()->content_rect());
 
         // The content bounds of the child should be scaled.
         gfx::Size childBoundsScaled = gfx::ToCeiledSize(gfx::ScaleSize(child->bounds(), 1.5));
-        EXPECT_EQ(childBoundsScaled, child->contentBounds());
+        EXPECT_EQ(childBoundsScaled, child->content_bounds());
 
         gfx::Transform scaleTransform;
         scaleTransform.Scale(impl->deviceScaleFactor(), impl->deviceScaleFactor());
 
         // The root layer is scaled by 2x.
         gfx::Transform rootScreenSpaceTransform = scaleTransform;
         gfx::Transform rootDrawTransform = scaleTransform;
 
-        EXPECT_EQ(rootDrawTransform, root->drawTransform());
-        EXPECT_EQ(rootScreenSpaceTransform, root->screenSpaceTransform());
+        EXPECT_EQ(rootDrawTransform, root->draw_transform());
+        EXPECT_EQ(rootScreenSpaceTransform, root->screen_space_transform());
 
         // The child is at position 2,2, which is transformed to 3,3 after the scale
         gfx::Transform childScreenSpaceTransform;
         childScreenSpaceTransform.Translate(3, 3);
         gfx::Transform childDrawTransform = childScreenSpaceTransform;
 
-        EXPECT_TRANSFORMATION_MATRIX_EQ(childDrawTransform, child->drawTransform());
-        EXPECT_TRANSFORMATION_MATRIX_EQ(childScreenSpaceTransform, child->screenSpaceTransform());
+        EXPECT_TRANSFORMATION_MATRIX_EQ(childDrawTransform, child->draw_transform());
+        EXPECT_TRANSFORMATION_MATRIX_EQ(childScreenSpaceTransform, child->screen_space_transform());
 
         endTest();
     }
 
     virtual void afterTest() OVERRIDE
     {
         m_rootLayer = NULL;
         m_childLayer = NULL;
     }
 
@@ skipping 15 matching lines @@
     {
         // Make sure partial texture updates are turned off.
         m_settings.maxPartialTextureUpdates = 0;
         // Linear fade animator prevents scrollbars from drawing immediately.
         m_settings.useLinearFadeScrollbarAnimator = false;
     }
 
     virtual void setupTree() OVERRIDE
     {
         m_layer = FakeContentLayer::Create(&m_client);
-        m_layer->setBounds(gfx::Size(10, 20));
+        m_layer->SetBounds(gfx::Size(10, 20));
 
         bool paint_scrollbar = true;
         bool has_thumb = false;
         m_scrollbar = FakeScrollbarLayer::Create(
             paint_scrollbar, has_thumb, m_layer->id());
-        m_scrollbar->setPosition(gfx::Point(0, 10));
-        m_scrollbar->setBounds(gfx::Size(10, 10));
+        m_scrollbar->SetPosition(gfx::Point(0, 10));
+        m_scrollbar->SetBounds(gfx::Size(10, 10));
 
-        m_layer->addChild(m_scrollbar);
+        m_layer->AddChild(m_scrollbar);
 
         m_layerTreeHost->setRootLayer(m_layer);
         LayerTreeHostTest::setupTree();
     }
 
     virtual void beginTest() OVERRIDE
     {
         postSetNeedsCommitToMainThread();
     }
 
@@ skipping 45 matching lines @@
     {
         TestWebGraphicsContext3D* context = static_cast<TestWebGraphicsContext3D*>(impl->outputSurface()->context3d());
 
         // Number of textures used for draw should always be one for each layer.
         EXPECT_EQ(2, context->NumUsedTextures());
         context->ResetUsedTextures();
     }
 
     virtual void layout() OVERRIDE
     {
-        m_layer->setNeedsDisplay();
-        m_scrollbar->setNeedsDisplay();
+        m_layer->SetNeedsDisplay();
+        m_scrollbar->SetNeedsDisplay();
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
 
 private:
     FakeContentLayerClient m_client;
     scoped_refptr<FakeContentLayer> m_layer;
     scoped_refptr<FakeScrollbarLayer> m_scrollbar;
 };
 
 TEST_F(LayerTreeHostTestAtomicCommit, runMultiThread)
 {
     runTest(true);
 }
 
 static void setLayerPropertiesForTesting(Layer* layer, Layer* parent, const gfx::Transform& transform, const gfx::PointF& anchor, const gfx::PointF& position, const gfx::Size& bounds, bool opaque)
 {
-    layer->removeAllChildren();
+    layer->RemoveAllChildren();
     if (parent)
-        parent->addChild(layer);
-    layer->setTransform(transform);
-    layer->setAnchorPoint(anchor);
-    layer->setPosition(position);
-    layer->setBounds(bounds);
-    layer->setContentsOpaque(opaque);
+        parent->AddChild(layer);
+    layer->SetTransform(transform);
+    layer->SetAnchorPoint(anchor);
+    layer->SetPosition(position);
+    layer->SetBounds(bounds);
+    layer->SetContentsOpaque(opaque);
 }
 
 class LayerTreeHostTestAtomicCommitWithPartialUpdate : public LayerTreeHostTest {
 public:
     LayerTreeHostTestAtomicCommitWithPartialUpdate()
         : m_numCommits(0)
     {
         // Allow one partial texture update.
         m_settings.maxPartialTextureUpdates = 1;
         // Linear fade animator prevents scrollbars from drawing immediately.
         m_settings.useLinearFadeScrollbarAnimator = false;
     }
 
     virtual void setupTree() OVERRIDE
     {
-        m_parent = FakeContentLayer::Create(&m_client);
-        m_parent->setBounds(gfx::Size(10, 20));
+        parent_ = FakeContentLayer::Create(&m_client);
+        parent_->SetBounds(gfx::Size(10, 20));
 
         m_child = FakeContentLayer::Create(&m_client);
-        m_child->setPosition(gfx::Point(0, 10));
-        m_child->setBounds(gfx::Size(3, 10));
+        m_child->SetPosition(gfx::Point(0, 10));
+        m_child->SetBounds(gfx::Size(3, 10));
 
         bool paint_scrollbar = true;
         bool has_thumb = false;
         m_scrollbarWithPaints = FakeScrollbarLayer::Create(
-            paint_scrollbar, has_thumb, m_parent->id());
-        m_scrollbarWithPaints->setPosition(gfx::Point(3, 10));
-        m_scrollbarWithPaints->setBounds(gfx::Size(3, 10));
+            paint_scrollbar, has_thumb, parent_->id());
+        m_scrollbarWithPaints->SetPosition(gfx::Point(3, 10));
+        m_scrollbarWithPaints->SetBounds(gfx::Size(3, 10));
 
         paint_scrollbar = false;
         m_scrollbarWithoutPaints = FakeScrollbarLayer::Create(
-            paint_scrollbar, has_thumb, m_parent->id());
-        m_scrollbarWithoutPaints->setPosition(gfx::Point(6, 10));
-        m_scrollbarWithoutPaints->setBounds(gfx::Size(3, 10));
+            paint_scrollbar, has_thumb, parent_->id());
+        m_scrollbarWithoutPaints->SetPosition(gfx::Point(6, 10));
+        m_scrollbarWithoutPaints->SetBounds(gfx::Size(3, 10));
 
-        m_parent->addChild(m_child);
-        m_parent->addChild(m_scrollbarWithPaints);
-        m_parent->addChild(m_scrollbarWithoutPaints);
+        parent_->AddChild(m_child);
+        parent_->AddChild(m_scrollbarWithPaints);
+        parent_->AddChild(m_scrollbarWithoutPaints);
 
-        m_layerTreeHost->setRootLayer(m_parent);
+        m_layerTreeHost->setRootLayer(parent_);
         LayerTreeHostTest::setupTree();
     }
 
     virtual void beginTest() OVERRIDE
     {
         postSetNeedsCommitToMainThread();
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
@@ skipping 94 matching lines @@
             EXPECT_EQ(4, context->NumUsedTextures());
 
         context->ResetUsedTextures();
     }
 
     virtual void layout() OVERRIDE
     {
         switch (m_numCommits++) {
         case 0:
         case 1:
-            m_parent->setNeedsDisplay();
-            m_child->setNeedsDisplay();
-            m_scrollbarWithPaints->setNeedsDisplay();
-            m_scrollbarWithoutPaints->setNeedsDisplay();
+            parent_->SetNeedsDisplay();
+            m_child->SetNeedsDisplay();
+            m_scrollbarWithPaints->SetNeedsDisplay();
+            m_scrollbarWithoutPaints->SetNeedsDisplay();
             break;
         case 2:
             // Damage part of layers.
-            m_parent->setNeedsDisplayRect(gfx::RectF(0, 0, 5, 5));
-            m_child->setNeedsDisplayRect(gfx::RectF(0, 0, 5, 5));
-            m_scrollbarWithPaints->setNeedsDisplayRect(gfx::RectF(0, 0, 5, 5));
-            m_scrollbarWithoutPaints->setNeedsDisplayRect(gfx::RectF(0, 0, 5, 5));
+            parent_->SetNeedsDisplayRect(gfx::RectF(0, 0, 5, 5));
+            m_child->SetNeedsDisplayRect(gfx::RectF(0, 0, 5, 5));
+            m_scrollbarWithPaints->SetNeedsDisplayRect(gfx::RectF(0, 0, 5, 5));
+            m_scrollbarWithoutPaints->SetNeedsDisplayRect(gfx::RectF(0, 0, 5, 5));
             break;
         case 3:
-            m_child->setNeedsDisplay();
-            m_scrollbarWithPaints->setNeedsDisplay();
-            m_scrollbarWithoutPaints->setNeedsDisplay();
+            m_child->SetNeedsDisplay();
+            m_scrollbarWithPaints->SetNeedsDisplay();
+            m_scrollbarWithoutPaints->SetNeedsDisplay();
             m_layerTreeHost->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
             break;
         case 4:
             m_layerTreeHost->setViewportSize(gfx::Size(10, 20), gfx::Size(10, 20));
             break;
         case 5:
             break;
         default:
             NOTREACHED();
             break;
         }
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
 
 private:
     FakeContentLayerClient m_client;
-    scoped_refptr<FakeContentLayer> m_parent;
+    scoped_refptr<FakeContentLayer> parent_;
     scoped_refptr<FakeContentLayer> m_child;
     scoped_refptr<FakeScrollbarLayer> m_scrollbarWithPaints;
     scoped_refptr<FakeScrollbarLayer> m_scrollbarWithoutPaints;
     int m_numCommits;
 };
 
 TEST_F(LayerTreeHostTestAtomicCommitWithPartialUpdate, runMultiThread)
 {
     runTest(true);
 }
@@ skipping 52 matching lines @@
 class LayerTreeHostTestCompositeAndReadbackCleanup : public LayerTreeHostTest {
 public:
     LayerTreeHostTestCompositeAndReadbackCleanup() { }
 
     virtual void beginTest() OVERRIDE
     {
         Layer* rootLayer = m_layerTreeHost->rootLayer();
 
         char pixels[4];
         m_layerTreeHost->compositeAndReadback(static_cast<void*>(&pixels), gfx::Rect(0, 0, 1, 1));
-        EXPECT_FALSE(rootLayer->renderSurface());
+        EXPECT_FALSE(rootLayer->render_surface());
 
         endTest();
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestCompositeAndReadbackCleanup)
 
 class LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit : public LayerTreeHostTest {
 public:
     LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit()
-        : m_rootLayer(ContentLayerWithUpdateTracking::create(&m_fakeDelegate))
-        , m_surfaceLayer1(ContentLayerWithUpdateTracking::create(&m_fakeDelegate))
-        , m_replicaLayer1(ContentLayerWithUpdateTracking::create(&m_fakeDelegate))
-        , m_surfaceLayer2(ContentLayerWithUpdateTracking::create(&m_fakeDelegate))
-        , m_replicaLayer2(ContentLayerWithUpdateTracking::create(&m_fakeDelegate))
+        : m_rootLayer(ContentLayerWithUpdateTracking::Create(&m_fakeDelegate))
+        , m_surfaceLayer1(ContentLayerWithUpdateTracking::Create(&m_fakeDelegate))
+        , m_replicaLayer1(ContentLayerWithUpdateTracking::Create(&m_fakeDelegate))
+        , m_surfaceLayer2(ContentLayerWithUpdateTracking::Create(&m_fakeDelegate))
+        , m_replicaLayer2(ContentLayerWithUpdateTracking::Create(&m_fakeDelegate))
     {
     }
 
     virtual void initializeSettings(LayerTreeSettings& settings) OVERRIDE
     {
         settings.cacheRenderPassContents = true;
     }
 
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
 
-        m_rootLayer->setBounds(gfx::Size(100, 100));
-        m_surfaceLayer1->setBounds(gfx::Size(100, 100));
-        m_surfaceLayer1->setForceRenderSurface(true);
-        m_surfaceLayer1->setOpacity(0.5);
-        m_surfaceLayer2->setBounds(gfx::Size(100, 100));
-        m_surfaceLayer2->setForceRenderSurface(true);
-        m_surfaceLayer2->setOpacity(0.5);
+        m_rootLayer->SetBounds(gfx::Size(100, 100));
+        m_surfaceLayer1->SetBounds(gfx::Size(100, 100));
+        m_surfaceLayer1->SetForceRenderSurface(true);
+        m_surfaceLayer1->SetOpacity(0.5);
+        m_surfaceLayer2->SetBounds(gfx::Size(100, 100));
+        m_surfaceLayer2->SetForceRenderSurface(true);
+        m_surfaceLayer2->SetOpacity(0.5);
 
-        m_surfaceLayer1->setReplicaLayer(m_replicaLayer1.get());
-        m_surfaceLayer2->setReplicaLayer(m_replicaLayer2.get());
+        m_surfaceLayer1->SetReplicaLayer(m_replicaLayer1.get());
+        m_surfaceLayer2->SetReplicaLayer(m_replicaLayer2.get());
 
-        m_rootLayer->addChild(m_surfaceLayer1);
-        m_surfaceLayer1->addChild(m_surfaceLayer2);
+        m_rootLayer->AddChild(m_surfaceLayer1);
+        m_surfaceLayer1->AddChild(m_surfaceLayer2);
         m_layerTreeHost->setRootLayer(m_rootLayer);
 
         postSetNeedsCommitToMainThread();
     }
 
     virtual void drawLayersOnThread(LayerTreeHostImpl* hostImpl) OVERRIDE
     {
         Renderer* renderer = hostImpl->renderer();
-        RenderPass::Id surface1RenderPassId = hostImpl->rootLayer()->children()[0]->renderSurface()->RenderPassId();
-        RenderPass::Id surface2RenderPassId = hostImpl->rootLayer()->children()[0]->children()[0]->renderSurface()->RenderPassId();
+        RenderPass::Id surface1RenderPassId = hostImpl->rootLayer()->children()[0]->render_surface()->RenderPassId();
+        RenderPass::Id surface2RenderPassId = hostImpl->rootLayer()->children()[0]->children()[0]->render_surface()->RenderPassId();
 
         switch (hostImpl->activeTree()->source_frame_number()) {
         case 0:
             EXPECT_TRUE(renderer->HaveCachedResourcesForRenderPassId(surface1RenderPassId));
             EXPECT_TRUE(renderer->HaveCachedResourcesForRenderPassId(surface2RenderPassId));
 
             // Reduce the memory limit to only fit the root layer and one render surface. This
             // prevents any contents drawing into surfaces from being allocated.
             hostImpl->SetManagedMemoryPolicy(ManagedMemoryPolicy(100 * 100 * 4 * 2));
             break;
@@ skipping 26 matching lines @@
     scoped_refptr<ContentLayerWithUpdateTracking> m_surfaceLayer1;
     scoped_refptr<ContentLayerWithUpdateTracking> m_replicaLayer1;
     scoped_refptr<ContentLayerWithUpdateTracking> m_surfaceLayer2;
     scoped_refptr<ContentLayerWithUpdateTracking> m_replicaLayer2;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit)
 
 class EvictionTestLayer : public Layer {
 public:
-    static scoped_refptr<EvictionTestLayer> create() { return make_scoped_refptr(new EvictionTestLayer()); }
+    static scoped_refptr<EvictionTestLayer> Create() { return make_scoped_refptr(new EvictionTestLayer()); }
 
-    virtual void update(ResourceUpdateQueue&, const OcclusionTracker*, RenderingStats*) OVERRIDE;
-    virtual bool drawsContent() const OVERRIDE { return true; }
+    virtual void Update(ResourceUpdateQueue*, const OcclusionTracker*, RenderingStats*) OVERRIDE;
+    virtual bool DrawsContent() const OVERRIDE { return true; }
 
-    virtual scoped_ptr<LayerImpl> createLayerImpl(LayerTreeImpl* treeImpl) OVERRIDE;
-    virtual void pushPropertiesTo(LayerImpl*) OVERRIDE;
-    virtual void setTexturePriorities(const PriorityCalculator&) OVERRIDE;
+    virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* treeImpl) OVERRIDE;
+    virtual void PushPropertiesTo(LayerImpl*) OVERRIDE;
+    virtual void SetTexturePriorities(const PriorityCalculator&) OVERRIDE;
 
     bool haveBackingTexture() const { return m_texture.get() ? m_texture->haveBackingTexture() : false; }
 
 private:
     EvictionTestLayer() : Layer() { }
     virtual ~EvictionTestLayer() { }
 
     void createTextureIfNeeded()
     {
         if (m_texture.get())
             return;
-        m_texture = PrioritizedResource::create(layerTreeHost()->contentsTextureManager());
+        m_texture = PrioritizedResource::create(layer_tree_host()->contentsTextureManager());
         m_texture->setDimensions(gfx::Size(10, 10), GL_RGBA);
         m_bitmap.setConfig(SkBitmap::kARGB_8888_Config, 10, 10);
     }
 
     scoped_ptr<PrioritizedResource> m_texture;
     SkBitmap m_bitmap;
 };
 
 class EvictionTestLayerImpl : public LayerImpl {
 public:
-    static scoped_ptr<EvictionTestLayerImpl> create(LayerTreeImpl* treeImpl, int id)
+    static scoped_ptr<EvictionTestLayerImpl> Create(LayerTreeImpl* treeImpl, int id)
     {
         return make_scoped_ptr(new EvictionTestLayerImpl(treeImpl, id));
     }
     virtual ~EvictionTestLayerImpl() { }
 
-    virtual void appendQuads(QuadSink& quadSink, AppendQuadsData&) OVERRIDE
+    virtual void AppendQuads(QuadSink* quad_sink,
+                             AppendQuadsData* append_quads_data) OVERRIDE
     {
         ASSERT_TRUE(m_hasTexture);
-        ASSERT_NE(0u, layerTreeImpl()->resource_provider()->num_resources());
+        ASSERT_NE(0u, layer_tree_impl()->resource_provider()->num_resources());
     }
 
     void setHasTexture(bool hasTexture) { m_hasTexture = hasTexture; }
 
 private:
     EvictionTestLayerImpl(LayerTreeImpl* treeImpl, int id)
         : LayerImpl(treeImpl, id)
         , m_hasTexture(false) { }
 
     bool m_hasTexture;
 };
 
-void EvictionTestLayer::setTexturePriorities(const PriorityCalculator&)
+void EvictionTestLayer::SetTexturePriorities(const PriorityCalculator&)
 {
     createTextureIfNeeded();
     if (!m_texture.get())
         return;
     m_texture->setRequestPriority(PriorityCalculator::uiPriority(true));
 }
 
-void EvictionTestLayer::update(ResourceUpdateQueue& queue, const OcclusionTracker*, RenderingStats*)
+void EvictionTestLayer::Update(ResourceUpdateQueue* queue, const OcclusionTracker*, RenderingStats*)
 {
     createTextureIfNeeded();
     if (!m_texture.get())
         return;
 
     gfx::Rect fullRect(0, 0, 10, 10);
     ResourceUpdate upload = ResourceUpdate::Create(
         m_texture.get(), &m_bitmap, fullRect, fullRect, gfx::Vector2d());
-    queue.appendFullUpload(upload);
+    queue->appendFullUpload(upload);
 }
 
-scoped_ptr<LayerImpl> EvictionTestLayer::createLayerImpl(LayerTreeImpl* treeImpl)
+scoped_ptr<LayerImpl> EvictionTestLayer::CreateLayerImpl(LayerTreeImpl* treeImpl)
 {
-    return EvictionTestLayerImpl::create(treeImpl, m_layerId).PassAs<LayerImpl>();
+    return EvictionTestLayerImpl::Create(treeImpl, layer_id_).PassAs<LayerImpl>();
 }
 
-void EvictionTestLayer::pushPropertiesTo(LayerImpl* layerImpl)
+void EvictionTestLayer::PushPropertiesTo(LayerImpl* layerImpl)
 {
-    Layer::pushPropertiesTo(layerImpl);
+    Layer::PushPropertiesTo(layerImpl);
 
     EvictionTestLayerImpl* testLayerImpl = static_cast<EvictionTestLayerImpl*>(layerImpl);
     testLayerImpl->setHasTexture(m_texture->haveBackingTexture());
 }
 
 class LayerTreeHostTestEvictTextures : public LayerTreeHostTest {
 public:
     LayerTreeHostTestEvictTextures()
-        : m_layer(EvictionTestLayer::create())
+        : m_layer(EvictionTestLayer::Create())
         , m_implForEvictTextures(0)
         , m_numCommits(0)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->setRootLayer(m_layer);
         m_layerTreeHost->setViewportSize(gfx::Size(10, 20), gfx::Size(10, 20));
 
@@ skipping 120 matching lines @@
 public:
     LayerTreeHostTestContinuousCommit()
         : m_numCommitComplete(0)
         , m_numDrawLayers(0)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
-        m_layerTreeHost->rootLayer()->setBounds(gfx::Size(10, 10));
+        m_layerTreeHost->rootLayer()->SetBounds(gfx::Size(10, 10));
 
         postSetNeedsCommitToMainThread();
     }
 
     virtual void didCommit() OVERRIDE
     {
         if (m_numDrawLayers == 2)
             return;
         postSetNeedsCommitToMainThread();
     }
@@ skipping 31 matching lines @@
 public:
     LayerTreeHostTestContinuousInvalidate()
         : m_numCommitComplete(0)
         , m_numDrawLayers(0)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
-        m_layerTreeHost->rootLayer()->setBounds(gfx::Size(10, 10));
+        m_layerTreeHost->rootLayer()->SetBounds(gfx::Size(10, 10));
 
-        m_contentLayer = ContentLayer::create(&m_fakeDelegate);
-        m_contentLayer->setBounds(gfx::Size(10, 10));
-        m_contentLayer->setPosition(gfx::PointF(0, 0));
-        m_contentLayer->setAnchorPoint(gfx::PointF(0, 0));
-        m_contentLayer->setIsDrawable(true);
-        m_layerTreeHost->rootLayer()->addChild(m_contentLayer);
+        m_contentLayer = ContentLayer::Create(&m_fakeDelegate);
+        m_contentLayer->SetBounds(gfx::Size(10, 10));
+        m_contentLayer->SetPosition(gfx::PointF(0, 0));
+        m_contentLayer->SetAnchorPoint(gfx::PointF(0, 0));
+        m_contentLayer->SetIsDrawable(true);
+        m_layerTreeHost->rootLayer()->AddChild(m_contentLayer);
 
         postSetNeedsCommitToMainThread();
     }
 
     virtual void didCommit() OVERRIDE
     {
         if (m_numDrawLayers == 2)
             return;
-        m_contentLayer->setNeedsDisplay();
+        m_contentLayer->SetNeedsDisplay();
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl*) OVERRIDE
     {
         if (m_numDrawLayers == 1)
             m_numCommitComplete++;
     }
 
     virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
@@ skipping 194 matching lines @@
     settings.maxPartialTextureUpdates = 4;
 
     scoped_ptr<LayerTreeHost> host = LayerTreeHost::create(&client, settings, scoped_ptr<Thread>());
     EXPECT_TRUE(host->initializeRendererIfNeeded());
     EXPECT_EQ(0u, host->settings().maxPartialTextureUpdates);
 }
 
 class LayerTreeHostTestCapturePicture : public LayerTreeHostTest {
 public:
     LayerTreeHostTestCapturePicture()
-        : m_bounds(gfx::Size(100, 100))
-        , m_layer(PictureLayer::create(&m_contentClient))
+        : bounds_(gfx::Size(100, 100))
+        , m_layer(PictureLayer::Create(&m_contentClient))
     {
         m_settings.implSidePainting = true;
     }
 
     class FillRectContentLayerClient : public ContentLayerClient {
     public:
         virtual void paintContents(SkCanvas* canvas, const gfx::Rect& clip, gfx::RectF& opaque) OVERRIDE
         {
             SkPaint paint;
             paint.setColor(SK_ColorGREEN);
 
             SkRect rect = SkRect::MakeWH(canvas->getDeviceSize().width(), canvas->getDeviceSize().height());
             opaque = gfx::RectF(rect.width(), rect.height());
             canvas->drawRect(rect, paint);
         }
     };
 
     virtual void beginTest() OVERRIDE
     {
-        m_layer->setIsDrawable(true);
-        m_layer->setBounds(m_bounds);
-        m_layerTreeHost->setViewportSize(m_bounds, m_bounds);
+        m_layer->SetIsDrawable(true);
+        m_layer->SetBounds(bounds_);
+        m_layerTreeHost->setViewportSize(bounds_, bounds_);
         m_layerTreeHost->setRootLayer(m_layer);
 
         EXPECT_TRUE(m_layerTreeHost->initializeRendererIfNeeded());
         postSetNeedsCommitToMainThread();
     }
 
     virtual void didCommitAndDrawFrame() OVERRIDE
     {
         m_picture = m_layerTreeHost->capturePicture();
         endTest();
     }
 
     virtual void afterTest() OVERRIDE
     {
-        EXPECT_EQ(m_bounds, gfx::Size(m_picture->width(), m_picture->height()));
+        EXPECT_EQ(bounds_, gfx::Size(m_picture->width(), m_picture->height()));
 
         SkBitmap bitmap;
-        bitmap.setConfig(SkBitmap::kARGB_8888_Config, m_bounds.width(), m_bounds.height());
+        bitmap.setConfig(SkBitmap::kARGB_8888_Config, bounds_.width(), bounds_.height());
         bitmap.allocPixels();
         bitmap.eraseARGB(0, 0, 0, 0);
         SkCanvas canvas(bitmap);
 
         m_picture->draw(&canvas);
 
         bitmap.lockPixels();
         SkColor* pixels = reinterpret_cast<SkColor*>(bitmap.getPixels());
         EXPECT_EQ(SK_ColorGREEN, pixels[0]);
         bitmap.unlockPixels();
     }
 
 private:
-    gfx::Size m_bounds;
+    gfx::Size bounds_;
     FillRectContentLayerClient m_contentClient;
     scoped_refptr<PictureLayer> m_layer;
     skia::RefPtr<SkPicture> m_picture;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestCapturePicture);
 
 class LayerTreeHostTestMaxPendingFrames : public LayerTreeHostTest {
 public:
     LayerTreeHostTestMaxPendingFrames()
@@ skipping 51 matching lines @@
         : m_rootLayer(FakeContentLayer::Create(&m_client))
         , m_childLayer1(FakeContentLayer::Create(&m_client))
         , m_childLayer2(FakeContentLayer::Create(&m_client))
         , m_numCommits(0)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
-        m_rootLayer->setBounds(gfx::Size(100, 100));
-        m_childLayer1->setBounds(gfx::Size(100, 100));
-        m_childLayer2->setBounds(gfx::Size(100, 100));
-        m_rootLayer->addChild(m_childLayer1);
-        m_rootLayer->addChild(m_childLayer2);
+        m_rootLayer->SetBounds(gfx::Size(100, 100));
+        m_childLayer1->SetBounds(gfx::Size(100, 100));
+        m_childLayer2->SetBounds(gfx::Size(100, 100));
+        m_rootLayer->AddChild(m_childLayer1);
+        m_rootLayer->AddChild(m_childLayer2);
         m_layerTreeHost->setRootLayer(m_rootLayer);
         postSetNeedsCommitToMainThread();
     }
 
     virtual void didSetVisibleOnImplTree(LayerTreeHostImpl* hostImpl, bool visible) OVERRIDE
     {
         // One backing should remain unevicted.
         EXPECT_EQ(
             100 * 100 * 4 * 1, 
             m_layerTreeHost->contentsTextureManager()->memoryUseBytes());
@@ skipping 47 matching lines @@
     scoped_refptr<FakeContentLayer> m_rootLayer;
     scoped_refptr<FakeContentLayer> m_childLayer1;
     scoped_refptr<FakeContentLayer> m_childLayer2;
     int m_numCommits;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestShutdownWithOnlySomeResourcesEvicted)
 
 }  // namespace
 }  // namespace cc