cc: Chromify Layer and LayerImpl classes.

cc/occlusion_tracker_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/occlusion_tracker.h"
 
 #include "cc/layer.h"
 #include "cc/layer_animation_controller.h"
 #include "cc/layer_impl.h"
 #include "cc/layer_tree_host_common.h"
@@ skipping 15 matching lines @@
 namespace {
 
 class TestContentLayer : public Layer {
 public:
     TestContentLayer()
         : Layer()
         , m_overrideOpaqueContentsRect(false)
     {
     }
 
-    virtual bool drawsContent() const OVERRIDE { return true; }
-    virtual Region visibleContentOpaqueRegion() const OVERRIDE
+    virtual bool DrawsContent() const OVERRIDE { return true; }
+    virtual Region VisibleContentOpaqueRegion() const OVERRIDE
     {
         if (m_overrideOpaqueContentsRect)
-            return gfx::IntersectRects(m_opaqueContentsRect, visibleContentRect());
-        return Layer::visibleContentOpaqueRegion();
+            return gfx::IntersectRects(m_opaqueContentsRect, visible_content_rect());
+        return Layer::VisibleContentOpaqueRegion();
     }
     void setOpaqueContentsRect(const gfx::Rect& opaqueContentsRect)
     {
         m_overrideOpaqueContentsRect = true;
         m_opaqueContentsRect = opaqueContentsRect;
     }
 
 private:
     virtual ~TestContentLayer()
     {
     }
 
     bool m_overrideOpaqueContentsRect;
     gfx::Rect m_opaqueContentsRect;
 };
 
 class TestContentLayerImpl : public LayerImpl {
 public:
     TestContentLayerImpl(LayerTreeImpl* treeImpl, int id)
         : LayerImpl(treeImpl, id)
         , m_overrideOpaqueContentsRect(false)
     {
-        setDrawsContent(true);
+        SetDrawsContent(true);
     }
 
-    virtual Region visibleContentOpaqueRegion() const OVERRIDE
+    virtual Region VisibleContentOpaqueRegion() const OVERRIDE
     {
         if (m_overrideOpaqueContentsRect)
-            return gfx::IntersectRects(m_opaqueContentsRect, visibleContentRect());
-        return LayerImpl::visibleContentOpaqueRegion();
+            return gfx::IntersectRects(m_opaqueContentsRect, visible_content_rect());
+        return LayerImpl::VisibleContentOpaqueRegion();
     }
     void setOpaqueContentsRect(const gfx::Rect& opaqueContentsRect)
     {
         m_overrideOpaqueContentsRect = true;
         m_opaqueContentsRect = opaqueContentsRect;
     }
 
 private:
     bool m_overrideOpaqueContentsRect;
     gfx::Rect m_opaqueContentsRect;
 };
 
-static inline bool layerImplDrawTransformIsUnknown(const Layer* layer) { return layer->drawTransformIsAnimating(); }
+static inline bool layerImplDrawTransformIsUnknown(const Layer* layer) { return layer->draw_transform_is_animating(); }
 static inline bool layerImplDrawTransformIsUnknown(const LayerImpl*) { return false; }
 
 template<typename LayerType, typename RenderSurfaceType>
 class TestOcclusionTrackerWithClip : public TestOcclusionTrackerBase<LayerType, RenderSurfaceType> {
 public:
     TestOcclusionTrackerWithClip(gfx::Rect viewportRect, bool recordMetricsForFrame = false)
         : TestOcclusionTrackerBase<LayerType, RenderSurfaceType>(viewportRect, recordMetricsForFrame)
     {
     }
 
     bool occludedLayer(const LayerType* layer, const gfx::Rect& contentRect, bool* hasOcclusionFromOutsideTargetSurface = 0) const
     {
-        return this->Occluded(layer->renderTarget(), contentRect, layer->drawTransform(), layerImplDrawTransformIsUnknown(layer), layer->isClipped(), layer->clipRect(), hasOcclusionFromOutsideTargetSurface);
+        return this->Occluded(layer->render_target(), contentRect, layer->draw_transform(), layerImplDrawTransformIsUnknown(layer), layer->is_clipped(), layer->clip_rect(), hasOcclusionFromOutsideTargetSurface);
     }
     // Gives an unoccluded sub-rect of |contentRect| in the content space of the layer. Simple wrapper around unoccludedContentRect.
     gfx::Rect unoccludedLayerContentRect(const LayerType* layer, const gfx::Rect& contentRect, bool* hasOcclusionFromOutsideTargetSurface = 0) const
     {
-        return this->UnoccludedContentRect(layer->renderTarget(), contentRect, layer->drawTransform(), layerImplDrawTransformIsUnknown(layer), layer->isClipped(), layer->clipRect(), hasOcclusionFromOutsideTargetSurface);
+        return this->UnoccludedContentRect(layer->render_target(), contentRect, layer->draw_transform(), layerImplDrawTransformIsUnknown(layer), layer->is_clipped(), layer->clip_rect(), hasOcclusionFromOutsideTargetSurface);
     }
 };
 
 struct OcclusionTrackerTestMainThreadTypes {
     typedef Layer LayerType;
     typedef LayerTreeHost HostType;
     typedef RenderSurface RenderSurfaceType;
     typedef TestContentLayer ContentLayerType;
     typedef scoped_refptr<Layer> LayerPtrType;
     typedef scoped_refptr<ContentLayerType> ContentLayerPtrType;
     typedef LayerIterator<Layer, std::vector<scoped_refptr<Layer> >, RenderSurface, LayerIteratorActions::FrontToBack> TestLayerIterator;
     typedef OcclusionTracker OcclusionTrackerType;
 
     static LayerPtrType createLayer(HostType*)
     {
-        return Layer::create();
+        return Layer::Create();
     }
     static ContentLayerPtrType createContentLayer(HostType*) { return make_scoped_refptr(new ContentLayerType()); }
 
     static LayerPtrType passLayerPtr(ContentLayerPtrType& layer)
     {
         LayerPtrType ref(layer);
         layer = NULL;
         return ref;
     }
 
@@ skipping 13 matching lines @@
 struct OcclusionTrackerTestImplThreadTypes {
     typedef LayerImpl LayerType;
     typedef LayerTreeImpl HostType;
     typedef RenderSurfaceImpl RenderSurfaceType;
     typedef TestContentLayerImpl ContentLayerType;
     typedef scoped_ptr<LayerImpl> LayerPtrType;
     typedef scoped_ptr<ContentLayerType> ContentLayerPtrType;
     typedef LayerIterator<LayerImpl, std::vector<LayerImpl*>, RenderSurfaceImpl, LayerIteratorActions::FrontToBack> TestLayerIterator;
     typedef OcclusionTrackerImpl OcclusionTrackerType;
 
-    static LayerPtrType createLayer(HostType* host) { return LayerImpl::create(host, nextLayerImplId++); }
+    static LayerPtrType createLayer(HostType* host) { return LayerImpl::Create(host, nextLayerImplId++); }
     static ContentLayerPtrType createContentLayer(HostType* host) { return make_scoped_ptr(new ContentLayerType(host, nextLayerImplId++)); }
     static int nextLayerImplId;
 
     static LayerPtrType passLayerPtr(LayerPtrType& layer)
     {
         return layer.Pass();
     }
 
     static LayerPtrType passLayerPtr(ContentLayerPtrType& layer)
     {
@@ skipping 39 matching lines @@
         DCHECK(!m_root);
         m_root = Types::passLayerPtr(layer);
         return layerPtr;
     }
 
     typename Types::LayerType* createLayer(typename Types::LayerType* parent, const gfx::Transform& transform, const gfx::PointF& position, const gfx::Size& bounds)
     {
         typename Types::LayerPtrType layer(Types::createLayer(getHost()));
         typename Types::LayerType* layerPtr = layer.get();
         setProperties(layerPtr, transform, position, bounds);
-        parent->addChild(Types::passLayerPtr(layer));
+        parent->AddChild(Types::passLayerPtr(layer));
         return layerPtr;
     }
 
     typename Types::LayerType* createSurface(typename Types::LayerType* parent, const gfx::Transform& transform, const gfx::PointF& position, const gfx::Size& bounds)
     {
         typename Types::LayerType* layer = createLayer(parent, transform, position, bounds);
         WebKit::WebFilterOperations filters;
         filters.append(WebKit::WebFilterOperation::createGrayscaleFilter(0.5));
-        layer->setFilters(filters);
+        layer->SetFilters(filters);
         return layer;
     }
 
     typename Types::ContentLayerType* createDrawingLayer(typename Types::LayerType* parent, const gfx::Transform& transform, const gfx::PointF& position, const gfx::Size& bounds, bool opaque)
     {
         typename Types::ContentLayerPtrType layer(Types::createContentLayer(getHost()));
         typename Types::ContentLayerType* layerPtr = layer.get();
         setProperties(layerPtr, transform, position, bounds);
 
         if (m_opaqueLayers)
-            layerPtr->setContentsOpaque(opaque);
+            layerPtr->SetContentsOpaque(opaque);
         else {
-            layerPtr->setContentsOpaque(false);
+            layerPtr->SetContentsOpaque(false);
             if (opaque)
                 layerPtr->setOpaqueContentsRect(gfx::Rect(gfx::Point(), bounds));
             else
                 layerPtr->setOpaqueContentsRect(gfx::Rect());
         }
 
-        parent->addChild(Types::passLayerPtr(layer));
+        parent->AddChild(Types::passLayerPtr(layer));
         return layerPtr;
     }
 
     typename Types::LayerType* createReplicaLayer(typename Types::LayerType* owningLayer, const gfx::Transform& transform, const gfx::PointF& position, const gfx::Size& bounds)
     {
         typename Types::ContentLayerPtrType layer(Types::createContentLayer(getHost()));
         typename Types::ContentLayerType* layerPtr = layer.get();
         setProperties(layerPtr, transform, position, bounds);
         setReplica(owningLayer, Types::passLayerPtr(layer));
         return layerPtr;
     }
 
     typename Types::LayerType* createMaskLayer(typename Types::LayerType* owningLayer, const gfx::Size& bounds)
     {
         typename Types::ContentLayerPtrType layer(Types::createContentLayer(getHost()));
         typename Types::ContentLayerType* layerPtr = layer.get();
         setProperties(layerPtr, identityMatrix, gfx::PointF(), bounds);
         setMask(owningLayer, Types::passLayerPtr(layer));
         return layerPtr;
     }
 
     typename Types::ContentLayerType* createDrawingSurface(typename Types::LayerType* parent, const gfx::Transform& transform, const gfx::PointF& position, const gfx::Size& bounds, bool opaque)
     {
         typename Types::ContentLayerType* layer = createDrawingLayer(parent, transform, position, bounds, opaque);
         WebKit::WebFilterOperations filters;
         filters.append(WebKit::WebFilterOperation::createGrayscaleFilter(0.5));
-        layer->setFilters(filters);
+        layer->SetFilters(filters);
         return layer;
     }
 
     void calcDrawEtc(TestContentLayerImpl* root)
     {
         DCHECK(root == m_root.get());
         int dummyMaxTextureSize = 512;
 
-        DCHECK(!root->renderSurface());
+        DCHECK(!root->render_surface());
 
         LayerTreeHostCommon::calculateDrawProperties(root, root->bounds(), 1, 1, dummyMaxTextureSize, false, m_renderSurfaceLayerListImpl, false);
 
         m_layerIterator = m_layerIteratorBegin = Types::TestLayerIterator::begin(&m_renderSurfaceLayerListImpl);
     }
 
     void calcDrawEtc(TestContentLayer* root)
     {
         DCHECK(root == m_root.get());
         int dummyMaxTextureSize = 512;
 
-        DCHECK(!root->renderSurface());
+        DCHECK(!root->render_surface());
 
         LayerTreeHostCommon::calculateDrawProperties(root, root->bounds(), 1, 1, dummyMaxTextureSize, false, m_renderSurfaceLayerList);
 
         m_layerIterator = m_layerIteratorBegin = Types::TestLayerIterator::begin(&m_renderSurfaceLayerList);
     }
 
     void EnterLayer(typename Types::LayerType* layer, typename Types::OcclusionTrackerType& occlusion)
     {
         ASSERT_EQ(layer, *m_layerIterator);
         ASSERT_TRUE(m_layerIterator.representsItself());
@@ skipping 42 matching lines @@
     void resetLayerIterator()
     {
         m_layerIterator = m_layerIteratorBegin;
     }
 
     const gfx::Transform identityMatrix;
 
 private:
     void setBaseProperties(typename Types::LayerType* layer, const gfx::Transform& transform, const gfx::PointF& position, const gfx::Size& bounds)
     {
-        layer->setTransform(transform);
-        layer->setSublayerTransform(gfx::Transform());
-        layer->setAnchorPoint(gfx::PointF(0, 0));
-        layer->setPosition(position);
-        layer->setBounds(bounds);
+        layer->SetTransform(transform);
+        layer->SetSublayerTransform(gfx::Transform());
+        layer->SetAnchorPoint(gfx::PointF(0, 0));
+        layer->SetPosition(position);
+        layer->SetBounds(bounds);
     }
 
     void setProperties(Layer* layer, const gfx::Transform& transform, const gfx::PointF& position, const gfx::Size& bounds)
     {
         setBaseProperties(layer, transform, position, bounds);
     }
 
     void setProperties(LayerImpl* layer, const gfx::Transform& transform, const gfx::PointF& position, const gfx::Size& bounds)
     {
         setBaseProperties(layer, transform, position, bounds);
 
-        layer->setContentBounds(layer->bounds());
+        layer->SetContentBounds(layer->bounds());
     }
 
     void setReplica(Layer* owningLayer, scoped_refptr<Layer> layer)
     {
-        owningLayer->setReplicaLayer(layer.get());
+        owningLayer->SetReplicaLayer(layer.get());
         m_replicaLayers.push_back(layer);
     }
 
     void setReplica(LayerImpl* owningLayer, scoped_ptr<LayerImpl> layer)
     {
-        owningLayer->setReplicaLayer(layer.Pass());
+        owningLayer->SetReplicaLayer(layer.Pass());
     }
 
     void setMask(Layer* owningLayer, scoped_refptr<Layer> layer)
     {
-        owningLayer->setMaskLayer(layer.get());
+        owningLayer->SetMaskLayer(layer.get());
         m_maskLayers.push_back(layer);
     }
 
     void setMask(LayerImpl* owningLayer, scoped_ptr<LayerImpl> layer)
     {
-        owningLayer->setMaskLayer(layer.Pass());
+        owningLayer->SetMaskLayer(layer.Pass());
     }
 
     FakeImplProxy m_proxy;
     FakeLayerTreeHostImpl m_hostImpl;
     bool m_opaqueLayers;
     // These hold ownership of the layers for the duration of the test.
     typename Types::LayerPtrType m_root;
     std::vector<scoped_refptr<Layer> > m_renderSurfaceLayerList;
     std::vector<LayerImpl*> m_renderSurfaceLayerListImpl;
     typename Types::TestLayerIterator m_layerIteratorBegin;
@@ skipping 60 matching lines @@
 template<class Types>
 class OcclusionTrackerTestIdentityTransforms : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestIdentityTransforms(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
 
     void runMyTest()
     {
         typename Types::ContentLayerType* root = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(200, 200));
         typename Types::ContentLayerType* parent = this->createDrawingLayer(root, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100), true);
         typename Types::ContentLayerType* layer = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(30, 30), gfx::Size(500, 500), true);
-        parent->setMasksToBounds(true);
+        parent->SetMasksToBounds(true);
         this->calcDrawEtc(root);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         this->visitLayer(layer, occlusion);
         this->EnterLayer(parent, occlusion);
 
         EXPECT_EQ(gfx::Rect().ToString(), occlusion.occlusion_from_outside_target().ToString());
         EXPECT_EQ(gfx::Rect(30, 30, 70, 70).ToString(), occlusion.occlusion_from_inside_target().ToString());
 
@@ skipping 64 matching lines @@
     void runMyTest()
     {
         gfx::Transform layerTransform;
         layerTransform.Translate(250, 250);
         layerTransform.Rotate(90);
         layerTransform.Translate(-250, -250);
 
         typename Types::ContentLayerType* root = this->createRoot(this->identityMatrix, gfx::Point(0, 0), gfx::Size(200, 200));
         typename Types::ContentLayerType* parent = this->createDrawingLayer(root, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100), true);
         typename Types::ContentLayerType* layer = this->createDrawingLayer(parent, layerTransform, gfx::PointF(30, 30), gfx::Size(500, 500), true);
-        parent->setMasksToBounds(true);
+        parent->SetMasksToBounds(true);
         this->calcDrawEtc(root);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         this->visitLayer(layer, occlusion);
         this->EnterLayer(parent, occlusion);
 
         EXPECT_EQ(gfx::Rect().ToString(), occlusion.occlusion_from_outside_target().ToString());
         EXPECT_EQ(gfx::Rect(30, 30, 70, 70).ToString(), occlusion.occlusion_from_inside_target().ToString());
 
@@ skipping 22 matching lines @@
 protected:
     OcclusionTrackerTestTranslatedChild(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
         gfx::Transform layerTransform;
         layerTransform.Translate(20, 20);
 
         typename Types::ContentLayerType* root = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(200, 200));
         typename Types::ContentLayerType* parent = this->createDrawingLayer(root, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100), true);
         typename Types::ContentLayerType* layer = this->createDrawingLayer(parent, layerTransform, gfx::PointF(30, 30), gfx::Size(500, 500), true);
-        parent->setMasksToBounds(true);
+        parent->SetMasksToBounds(true);
         this->calcDrawEtc(root);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         this->visitLayer(layer, occlusion);
         this->EnterLayer(parent, occlusion);
 
         EXPECT_EQ(gfx::Rect().ToString(), occlusion.occlusion_from_outside_target().ToString());
         EXPECT_EQ(gfx::Rect(50, 50, 50, 50).ToString(), occlusion.occlusion_from_inside_target().ToString());
 
@@ skipping 22 matching lines @@
 protected:
     OcclusionTrackerTestChildInRotatedChild(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
         gfx::Transform childTransform;
         childTransform.Translate(250, 250);
         childTransform.Rotate(90);
         childTransform.Translate(-250, -250);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100));
-        parent->setMasksToBounds(true);
+        parent->SetMasksToBounds(true);
         typename Types::LayerType* child = this->createLayer(parent, childTransform, gfx::PointF(30, 30), gfx::Size(500, 500));
-        child->setMasksToBounds(true);
+        child->SetMasksToBounds(true);
         typename Types::ContentLayerType* layer = this->createDrawingLayer(child, this->identityMatrix, gfx::PointF(10, 10), gfx::Size(500, 500), true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         this->visitLayer(layer, occlusion);
         this->enterContributingSurface(child, occlusion);
 
         EXPECT_EQ(gfx::Rect().ToString(), occlusion.occlusion_from_outside_target().ToString());
         EXPECT_EQ(gfx::Rect(10, 430, 60, 70).ToString(), occlusion.occlusion_from_inside_target().ToString());
@@ skipping 44 matching lines @@
 protected:
     OcclusionTrackerTestScaledRenderSurface(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
 
     void runMyTest()
     {
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(200, 200));
 
         gfx::Transform layer1Matrix;
         layer1Matrix.Scale(2, 2);
         typename Types::ContentLayerType* layer1 = this->createDrawingLayer(parent, layer1Matrix, gfx::PointF(0, 0), gfx::Size(100, 100), true);
-        layer1->setForceRenderSurface(true);
+        layer1->SetForceRenderSurface(true);
 
         gfx::Transform layer2Matrix;
         layer2Matrix.Translate(25, 25);
         typename Types::ContentLayerType* layer2 = this->createDrawingLayer(layer1, layer2Matrix, gfx::PointF(0, 0), gfx::Size(50, 50), true);
         typename Types::ContentLayerType* occluder = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(100, 100), gfx::Size(500, 500), true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         this->visitLayer(occluder, occlusion);
@@ skipping 17 matching lines @@
     OcclusionTrackerTestVisitTargetTwoTimes(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
         gfx::Transform childTransform;
         childTransform.Translate(250, 250);
         childTransform.Rotate(90);
         childTransform.Translate(-250, -250);
 
         typename Types::ContentLayerType* root = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(200, 200));
         typename Types::ContentLayerType* parent = this->createDrawingLayer(root, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100), true);
-        parent->setMasksToBounds(true);
+        parent->SetMasksToBounds(true);
         typename Types::LayerType* child = this->createLayer(parent, childTransform, gfx::PointF(30, 30), gfx::Size(500, 500));
-        child->setMasksToBounds(true);
+        child->SetMasksToBounds(true);
         typename Types::ContentLayerType* layer = this->createDrawingLayer(child, this->identityMatrix, gfx::PointF(10, 10), gfx::Size(500, 500), true);
         // |child2| makes |parent|'s surface get considered by OcclusionTracker first, instead of |child|'s. This exercises different code in
         // leaveToTargetRenderSurface, as the target surface has already been seen.
         typename Types::ContentLayerType* child2 = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(30, 30), gfx::Size(60, 20), true);
         this->calcDrawEtc(root);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         this->visitLayer(child2, occlusion);
 
@@ skipping 86 matching lines @@
         childTransform.Translate(250, 250);
         childTransform.Rotate(95);
         childTransform.Translate(-250, -250);
 
         gfx::Transform layerTransform;
         layerTransform.Translate(10, 10);
 
         typename Types::ContentLayerType* root = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(1000, 1000));
         typename Types::ContentLayerType* parent = this->createDrawingLayer(root, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100), true);
         typename Types::LayerType* child = this->createLayer(parent, childTransform, gfx::PointF(30, 30), gfx::Size(500, 500));
-        child->setMasksToBounds(true);
+        child->SetMasksToBounds(true);
         typename Types::ContentLayerType* layer = this->createDrawingLayer(child, layerTransform, gfx::PointF(0, 0), gfx::Size(500, 500), true);
         this->calcDrawEtc(root);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
-        gfx::Rect clippedLayerInChild = MathUtil::mapClippedRect(layerTransform, layer->visibleContentRect());
+        gfx::Rect clippedLayerInChild = MathUtil::mapClippedRect(layerTransform, layer->visible_content_rect());
 
         this->visitLayer(layer, occlusion);
         this->enterContributingSurface(child, occlusion);
 
         EXPECT_EQ(gfx::Rect().ToString(), occlusion.occlusion_from_outside_target().ToString());
         EXPECT_EQ(clippedLayerInChild.ToString(), occlusion.occlusion_from_inside_target().ToString());
 
         this->leaveContributingSurface(child, occlusion);
         this->EnterLayer(parent, occlusion);
 
@@ skipping 13 matching lines @@
     OcclusionTrackerTestSurfaceWithTwoOpaqueChildren(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
         gfx::Transform childTransform;
         childTransform.Translate(250, 250);
         childTransform.Rotate(90);
         childTransform.Translate(-250, -250);
 
         typename Types::ContentLayerType* root = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(1000, 1000));
         typename Types::ContentLayerType* parent = this->createDrawingLayer(root, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100), true);
-        parent->setMasksToBounds(true);
+        parent->SetMasksToBounds(true);
         typename Types::ContentLayerType* child = this->createDrawingLayer(parent, childTransform, gfx::PointF(30, 30), gfx::Size(500, 500), false);
-        child->setMasksToBounds(true);
+        child->SetMasksToBounds(true);
         typename Types::ContentLayerType* layer1 = this->createDrawingLayer(child, this->identityMatrix, gfx::PointF(10, 10), gfx::Size(500, 500), true);
         typename Types::ContentLayerType* layer2 = this->createDrawingLayer(child, this->identityMatrix, gfx::PointF(10, 450), gfx::Size(500, 60), true);
         this->calcDrawEtc(root);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         this->visitLayer(layer2, occlusion);
         this->visitLayer(layer1, occlusion);
         this->visitLayer(child, occlusion);
         this->enterContributingSurface(child, occlusion);
@@ skipping 65 matching lines @@
 protected:
     OcclusionTrackerTestOverlappingSurfaceSiblings(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
         gfx::Transform childTransform;
         childTransform.Translate(250, 250);
         childTransform.Rotate(90);
         childTransform.Translate(-250, -250);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100));
-        parent->setMasksToBounds(true);
+        parent->SetMasksToBounds(true);
         typename Types::LayerType* child1 = this->createSurface(parent, childTransform, gfx::PointF(30, 30), gfx::Size(10, 10));
         typename Types::LayerType* child2 = this->createSurface(parent, childTransform, gfx::PointF(20, 40), gfx::Size(10, 10));
         typename Types::ContentLayerType* layer1 = this->createDrawingLayer(child1, this->identityMatrix, gfx::PointF(-10, -10), gfx::Size(510, 510), true);
         typename Types::ContentLayerType* layer2 = this->createDrawingLayer(child2, this->identityMatrix, gfx::PointF(-10, -10), gfx::Size(510, 510), true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         this->visitLayer(layer2, occlusion);
         this->enterContributingSurface(child2, occlusion);
@@ skipping 74 matching lines @@
         child1Transform.Translate(250, 250);
         child1Transform.Rotate(-90);
         child1Transform.Translate(-250, -250);
 
         gfx::Transform child2Transform;
         child2Transform.Translate(250, 250);
         child2Transform.Rotate(90);
         child2Transform.Translate(-250, -250);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100));
-        parent->setMasksToBounds(true);
+        parent->SetMasksToBounds(true);
         typename Types::LayerType* child1 = this->createSurface(parent, child1Transform, gfx::PointF(30, 20), gfx::Size(10, 10));
         typename Types::LayerType* child2 = this->createDrawingSurface(parent, child2Transform, gfx::PointF(20, 40), gfx::Size(10, 10), false);
         typename Types::ContentLayerType* layer1 = this->createDrawingLayer(child1, this->identityMatrix, gfx::PointF(-10, -20), gfx::Size(510, 510), true);
         typename Types::ContentLayerType* layer2 = this->createDrawingLayer(child2, this->identityMatrix, gfx::PointF(-10, -10), gfx::Size(510, 510), true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         this->visitLayer(layer2, occlusion);
         this->EnterLayer(child2, occlusion);
@@ skipping 58 matching lines @@
 protected:
     OcclusionTrackerTestFilters(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
         gfx::Transform layerTransform;
         layerTransform.Translate(250, 250);
         layerTransform.Rotate(90);
         layerTransform.Translate(-250, -250);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100));
-        parent->setMasksToBounds(true);
+        parent->SetMasksToBounds(true);
         typename Types::ContentLayerType* blurLayer = this->createDrawingLayer(parent, layerTransform, gfx::PointF(30, 30), gfx::Size(500, 500), true);
         typename Types::ContentLayerType* opaqueLayer = this->createDrawingLayer(parent, layerTransform, gfx::PointF(30, 30), gfx::Size(500, 500), true);
         typename Types::ContentLayerType* opacityLayer = this->createDrawingLayer(parent, layerTransform, gfx::PointF(30, 30), gfx::Size(500, 500), true);
 
         WebKit::WebFilterOperations filters;
         filters.append(WebKit::WebFilterOperation::createBlurFilter(10));
-        blurLayer->setFilters(filters);
+        blurLayer->SetFilters(filters);
 
         filters.clear();
         filters.append(WebKit::WebFilterOperation::createGrayscaleFilter(0.5));
-        opaqueLayer->setFilters(filters);
+        opaqueLayer->SetFilters(filters);
 
         filters.clear();
         filters.append(WebKit::WebFilterOperation::createOpacityFilter(0.5));
-        opacityLayer->setFilters(filters);
+        opacityLayer->SetFilters(filters);
 
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         // Opacity layer won't contribute to occlusion.
         this->visitLayer(opacityLayer, occlusion);
         this->enterContributingSurface(opacityLayer, occlusion);
 
         EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
@@ skipping 64 matching lines @@
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestReplicaDoesOcclude);
 
 template<class Types>
 class OcclusionTrackerTestReplicaWithClipping : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestReplicaWithClipping(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 170));
-        parent->setMasksToBounds(true);
+        parent->SetMasksToBounds(true);
         typename Types::LayerType* surface = this->createDrawingSurface(parent, this->identityMatrix, gfx::PointF(0, 100), gfx::Size(50, 50), true);
         this->createReplicaLayer(surface, this->identityMatrix, gfx::PointF(50, 50), gfx::Size());
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         this->visitLayer(surface, occlusion);
 
         EXPECT_EQ(gfx::Rect(0, 0, 50, 50).ToString(), occlusion.occlusion_from_inside_target().ToString());
 
@@ skipping 36 matching lines @@
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestReplicaWithMask);
 
 template<class Types>
 class OcclusionTrackerTestLayerClipRectOutsideChild : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestLayerClipRectOutsideChild(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 300));
         typename Types::ContentLayerType* clip = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(200, 100), gfx::Size(100, 100), false);
-        clip->setMasksToBounds(true);
+        clip->SetMasksToBounds(true);
         typename Types::ContentLayerType* layer = this->createDrawingLayer(clip, this->identityMatrix, gfx::PointF(-200, -100), gfx::Size(200, 200), false);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         this->EnterLayer(layer, occlusion);
 
         EXPECT_TRUE(occlusion.occludedLayer(layer, gfx::Rect(0, 0, 100, 100)));
         EXPECT_TRUE(occlusion.occludedLayer(layer, gfx::Rect(100, 0, 100, 100)));
         EXPECT_TRUE(occlusion.occludedLayer(layer, gfx::Rect(0, 100, 100, 100)));
@@ skipping 56 matching lines @@
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestViewportRectOutsideChild);
 
 template<class Types>
 class OcclusionTrackerTestLayerClipRectOverChild : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestLayerClipRectOverChild(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 300));
         typename Types::ContentLayerType* clip = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(100, 100), gfx::Size(100, 100), false);
-        clip->setMasksToBounds(true);
+        clip->SetMasksToBounds(true);
         typename Types::ContentLayerType* layer = this->createDrawingSurface(clip, this->identityMatrix, gfx::PointF(-100, -100), gfx::Size(200, 200), true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         this->EnterLayer(layer, occlusion);
 
         EXPECT_TRUE(occlusion.occludedLayer(layer, gfx::Rect(0, 0, 100, 100)));
         EXPECT_TRUE(occlusion.occludedLayer(layer, gfx::Rect(0, 100, 100, 100)));
         EXPECT_TRUE(occlusion.occludedLayer(layer, gfx::Rect(100, 0, 100, 100)));
@@ skipping 62 matching lines @@
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestViewportRectOverChild);
 
 template<class Types>
 class OcclusionTrackerTestLayerClipRectPartlyOverChild : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestLayerClipRectPartlyOverChild(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 300));
         typename Types::ContentLayerType* clip = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(50, 50), gfx::Size(200, 200), false);
-        clip->setMasksToBounds(true);
+        clip->SetMasksToBounds(true);
         typename Types::ContentLayerType* layer = this->createDrawingSurface(clip, this->identityMatrix, gfx::PointF(-50, -50), gfx::Size(200, 200), true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         this->EnterLayer(layer, occlusion);
 
         EXPECT_FALSE(occlusion.occludedLayer(layer, gfx::Rect(0, 0, 100, 100)));
         EXPECT_FALSE(occlusion.occludedLayer(layer, gfx::Rect(0, 100, 100, 100)));
         EXPECT_FALSE(occlusion.occludedLayer(layer, gfx::Rect(100, 0, 100, 100)));
@@ skipping 253 matching lines @@
         // tracker.
 
         gfx::Transform translationToFront;
         translationToFront.Translate3d(0, 0, -10);
         gfx::Transform translationToBack;
         translationToFront.Translate3d(0, 0, -100);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 300));
         typename Types::ContentLayerType* child1 = this->createDrawingLayer(parent, translationToBack, gfx::PointF(0, 0), gfx::Size(100, 100), true);
         typename Types::ContentLayerType* child2 = this->createDrawingLayer(parent, translationToFront, gfx::PointF(50, 50), gfx::Size(100, 100), true);
-        parent->setPreserves3D(true);
+        parent->SetPreserves3d(true);
 
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
         this->visitLayer(child2, occlusion);
         EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
         EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty());
 
         this->visitLayer(child1, occlusion);
         EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
@@ skipping 12 matching lines @@
     {
         gfx::Transform transform;
         transform.Translate(150, 150);
         transform.ApplyPerspectiveDepth(400);
         transform.RotateAboutXAxis(-30);
         transform.Translate(-150, -150);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 300));
         typename Types::LayerType* container = this->createLayer(parent, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 300));
         typename Types::ContentLayerType* layer = this->createDrawingLayer(container, transform, gfx::PointF(100, 100), gfx::Size(200, 200), true);
-        container->setPreserves3D(true);
-        layer->setPreserves3D(true);
+        container->SetPreserves3d(true);
+        layer->SetPreserves3d(true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
         this->EnterLayer(layer, occlusion);
 
         EXPECT_RECT_EQ(gfx::Rect(0, 0, 200, 200), occlusion.unoccludedLayerContentRect(layer, gfx::Rect(0, 0, 200, 200)));
     }
 };
 
 // This test requires accumulating occlusion of 3d layers, which are skipped by the occlusion tracker on the main thread. So this test should run on the impl thread.
@@ skipping 10 matching lines @@
         transform.Translate(250, 50);
         transform.ApplyPerspectiveDepth(10);
         transform.Translate(-250, -50);
         transform.Translate(250, 50);
         transform.RotateAboutXAxis(-167);
         transform.Translate(-250, -50);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(500, 100));
         typename Types::LayerType* container = this->createLayer(parent, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(500, 500));
         typename Types::ContentLayerType* layer = this->createDrawingLayer(container, transform, gfx::PointF(0, 0), gfx::Size(500, 500), true);
-        container->setPreserves3D(true);
-        layer->setPreserves3D(true);
+        container->SetPreserves3d(true);
+        layer->SetPreserves3d(true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
         this->EnterLayer(layer, occlusion);
 
         // The bottom 11 pixel rows of this layer remain visible inside the container, after translation to the target surface. When translated back,
         // this will include many more pixels but must include at least the bottom 11 rows.
         EXPECT_TRUE(occlusion.unoccludedLayerContentRect(layer, gfx::Rect(0, 0, 500, 500)).Contains(gfx::Rect(0, 489, 500, 11)));
     }
 };
 
 // This test requires accumulating occlusion of 3d layers, which are skipped by the occlusion tracker on the main thread. So this test should run on the impl thread.
 IMPL_THREAD_TEST(OcclusionTrackerTestPerspectiveTransformBehindCamera);
 
 template<class Types>
 class OcclusionTrackerTestLayerBehindCameraDoesNotOcclude : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestLayerBehindCameraDoesNotOcclude(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
         gfx::Transform transform;
         transform.Translate(50, 50);
         transform.ApplyPerspectiveDepth(100);
         transform.Translate3d(0, 0, 110);
         transform.Translate(-50, -50);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100));
         typename Types::ContentLayerType* layer = this->createDrawingLayer(parent, transform, gfx::PointF(0, 0), gfx::Size(100, 100), true);
-        parent->setPreserves3D(true);
-        layer->setPreserves3D(true);
+        parent->SetPreserves3d(true);
+        layer->SetPreserves3d(true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         // The |layer| is entirely behind the camera and should not occlude.
         this->visitLayer(layer, occlusion);
         this->EnterLayer(parent, occlusion);
         EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty());
         EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
     }
 };
 
 // This test requires accumulating occlusion of 3d layers, which are skipped by the occlusion tracker on the main thread. So this test should run on the impl thread.
 IMPL_THREAD_TEST(OcclusionTrackerTestLayerBehindCameraDoesNotOcclude);
 
 template<class Types>
 class OcclusionTrackerTestLargePixelsOccludeInsideClipRect : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestLargePixelsOccludeInsideClipRect(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
         gfx::Transform transform;
         transform.Translate(50, 50);
         transform.ApplyPerspectiveDepth(100);
         transform.Translate3d(0, 0, 99);
         transform.Translate(-50, -50);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100));
-        parent->setMasksToBounds(true);
+        parent->SetMasksToBounds(true);
         typename Types::ContentLayerType* layer = this->createDrawingLayer(parent, transform, gfx::PointF(0, 0), gfx::Size(100, 100), true);
-        parent->setPreserves3D(true);
-        layer->setPreserves3D(true);
+        parent->SetPreserves3d(true);
+        layer->SetPreserves3d(true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         // This is very close to the camera, so pixels in its visibleContentRect will actually go outside of the layer's clipRect.
         // Ensure that those pixels don't occlude things outside the clipRect.
         this->visitLayer(layer, occlusion);
         this->EnterLayer(parent, occlusion);
         EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(), occlusion.occlusion_from_inside_target().ToString());
         EXPECT_EQ(gfx::Rect().ToString(), occlusion.occlusion_from_outside_target().ToString());
@@ skipping 18 matching lines @@
         // +--topmost
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 300));
         typename Types::ContentLayerType* layer = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 300), true);
         typename Types::ContentLayerType* surface = this->createDrawingSurface(parent, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 300), true);
         typename Types::ContentLayerType* surfaceChild = this->createDrawingLayer(surface, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(200, 300), true);
         typename Types::ContentLayerType* surfaceChild2 = this->createDrawingLayer(surface, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 300), true);
         typename Types::ContentLayerType* parent2 = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 300), false);
         typename Types::ContentLayerType* topmost = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(250, 0), gfx::Size(50, 300), true);
 
-        addOpacityTransitionToController(*layer->layerAnimationController(), 10, 0, 1, false);
-        addOpacityTransitionToController(*surface->layerAnimationController(), 10, 0, 1, false);
+        addOpacityTransitionToController(*layer->layer_animation_controller(), 10, 0, 1, false);
+        addOpacityTransitionToController(*surface->layer_animation_controller(), 10, 0, 1, false);
         this->calcDrawEtc(parent);
 
-        EXPECT_TRUE(layer->drawOpacityIsAnimating());
-        EXPECT_FALSE(surface->drawOpacityIsAnimating());
-        EXPECT_TRUE(surface->renderSurface()->draw_opacity_is_animating());
+        EXPECT_TRUE(layer->draw_opacity_is_animating());
+        EXPECT_FALSE(surface->draw_opacity_is_animating());
+        EXPECT_TRUE(surface->render_surface()->draw_opacity_is_animating());
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         this->visitLayer(topmost, occlusion);
         this->EnterLayer(parent2, occlusion);
         // This occlusion will affect all surfaces.
         EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(), occlusion.occlusion_from_inside_target().ToString());
         EXPECT_EQ(gfx::Rect().ToString(), occlusion.occlusion_from_outside_target().ToString());
         EXPECT_EQ(gfx::Rect(0, 0, 250, 300).ToString(), occlusion.unoccludedLayerContentRect(parent2, gfx::Rect(0, 0, 300, 300)).ToString());
         this->LeaveLayer(parent2, occlusion);
@@ skipping 38 matching lines @@
     void runMyTest()
     {
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 300));
         typename Types::ContentLayerType* layer = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 300), true);
         typename Types::ContentLayerType* surface = this->createDrawingSurface(parent, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 300), true);
         typename Types::ContentLayerType* surfaceChild = this->createDrawingLayer(surface, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(200, 300), true);
         typename Types::ContentLayerType* surfaceChild2 = this->createDrawingLayer(surface, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 300), true);
         typename Types::ContentLayerType* parent2 = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 300), false);
         typename Types::ContentLayerType* topmost = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(250, 0), gfx::Size(50, 300), true);
 
-        addOpacityTransitionToController(*layer->layerAnimationController(), 10, 1, 0, false);
-        addOpacityTransitionToController(*surface->layerAnimationController(), 10, 1, 0, false);
+        addOpacityTransitionToController(*layer->layer_animation_controller(), 10, 1, 0, false);
+        addOpacityTransitionToController(*surface->layer_animation_controller(), 10, 1, 0, false);
         this->calcDrawEtc(parent);
 
-        EXPECT_TRUE(layer->drawOpacityIsAnimating());
-        EXPECT_FALSE(surface->drawOpacityIsAnimating());
-        EXPECT_TRUE(surface->renderSurface()->draw_opacity_is_animating());
+        EXPECT_TRUE(layer->draw_opacity_is_animating());
+        EXPECT_FALSE(surface->draw_opacity_is_animating());
+        EXPECT_TRUE(surface->render_surface()->draw_opacity_is_animating());
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         this->visitLayer(topmost, occlusion);
         this->EnterLayer(parent2, occlusion);
         // This occlusion will affect all surfaces.
         EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(), occlusion.occlusion_from_inside_target().ToString());
         EXPECT_EQ(gfx::Rect().ToString(), occlusion.occlusion_from_outside_target().ToString());
         EXPECT_RECT_EQ(gfx::Rect(0, 0, 250, 300), occlusion.unoccludedLayerContentRect(parent, gfx::Rect(0, 0, 300, 300)));
         this->LeaveLayer(parent2, occlusion);
@@ skipping 37 matching lines @@
     OcclusionTrackerTestAnimationTranslateOnMainThread(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 300));
         typename Types::ContentLayerType* layer = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 300), true);
         typename Types::ContentLayerType* surface = this->createDrawingSurface(parent, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 300), true);
         typename Types::ContentLayerType* surfaceChild = this->createDrawingLayer(surface, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(200, 300), true);
         typename Types::ContentLayerType* surfaceChild2 = this->createDrawingLayer(surface, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 300), true);
         typename Types::ContentLayerType* surface2 = this->createDrawingSurface(parent, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(50, 300), true);
 
-        addAnimatedTransformToController(*layer->layerAnimationController(), 10, 30, 0);
-        addAnimatedTransformToController(*surface->layerAnimationController(), 10, 30, 0);
-        addAnimatedTransformToController(*surfaceChild->layerAnimationController(), 10, 30, 0);
+        addAnimatedTransformToController(*layer->layer_animation_controller(), 10, 30, 0);
+        addAnimatedTransformToController(*surface->layer_animation_controller(), 10, 30, 0);
+        addAnimatedTransformToController(*surfaceChild->layer_animation_controller(), 10, 30, 0);
         this->calcDrawEtc(parent);
 
-        EXPECT_TRUE(layer->drawTransformIsAnimating());
-        EXPECT_TRUE(layer->screenSpaceTransformIsAnimating());
-        EXPECT_TRUE(surface->renderSurface()->target_surface_transforms_are_animating());
-        EXPECT_TRUE(surface->renderSurface()->screen_space_transforms_are_animating());
+        EXPECT_TRUE(layer->draw_transform_is_animating());
+        EXPECT_TRUE(layer->screen_space_transform_is_animating());
+        EXPECT_TRUE(surface->render_surface()->target_surface_transforms_are_animating());
+        EXPECT_TRUE(surface->render_surface()->screen_space_transforms_are_animating());
         // The surface owning layer doesn't animate against its own surface.
-        EXPECT_FALSE(surface->drawTransformIsAnimating());
-        EXPECT_TRUE(surface->screenSpaceTransformIsAnimating());
-        EXPECT_TRUE(surfaceChild->drawTransformIsAnimating());
-        EXPECT_TRUE(surfaceChild->screenSpaceTransformIsAnimating());
+        EXPECT_FALSE(surface->draw_transform_is_animating());
+        EXPECT_TRUE(surface->screen_space_transform_is_animating());
+        EXPECT_TRUE(surfaceChild->draw_transform_is_animating());
+        EXPECT_TRUE(surfaceChild->screen_space_transform_is_animating());
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         this->visitLayer(surface2, occlusion);
         this->enterContributingSurface(surface2, occlusion);
 
         EXPECT_EQ(gfx::Rect(0, 0, 50, 300).ToString(), occlusion.occlusion_from_inside_target().ToString());
 
         this->leaveContributingSurface(surface2, occlusion);
         this->EnterLayer(surfaceChild2, occlusion);
@@ skipping 87 matching lines @@
 
 MAIN_AND_IMPL_THREAD_TEST(OcclusionTrackerTestSurfaceOcclusionTranslatesToParent);
 
 template<class Types>
 class OcclusionTrackerTestSurfaceOcclusionTranslatesWithClipping : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestSurfaceOcclusionTranslatesWithClipping(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 300));
-        parent->setMasksToBounds(true);
+        parent->SetMasksToBounds(true);
         typename Types::ContentLayerType* surface = this->createDrawingSurface(parent, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(500, 300), false);
         surface->setOpaqueContentsRect(gfx::Rect(0, 0, 400, 200));
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         this->visitLayer(surface, occlusion);
         this->visitContributingSurface(surface, occlusion);
 
         EXPECT_EQ(gfx::Rect().ToString(), occlusion.occlusion_from_outside_target().ToString());
@@ skipping 204 matching lines @@
 
 template<class Types>
 class OcclusionTrackerTestSurfaceChildOfClippingSurface : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestSurfaceChildOfClippingSurface(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
         // This test verifies that the surface cliprect does not end up empty and clip away the entire unoccluded rect.
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(80, 200));
-        parent->setMasksToBounds(true);
+        parent->SetMasksToBounds(true);
         typename Types::LayerType* surface = this->createDrawingSurface(parent, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100), true);
         typename Types::LayerType* surfaceChild = this->createDrawingSurface(surface, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100), false);
         typename Types::LayerType* topmost = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 50), true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         // |topmost| occludes everything partially so we know occlusion is happening at all.
         this->visitLayer(topmost, occlusion);
 
@@ skipping 41 matching lines @@
         this->createReplicaLayer(filteredSurface, this->identityMatrix, gfx::PointF(300, 0), gfx::Size());
         typename Types::LayerType* occludingLayer1 = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 50), true);
         typename Types::LayerType* occludingLayer2 = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(0, 100), gfx::Size(300, 50), true);
         typename Types::LayerType* occludingLayer3 = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(0, 50), gfx::Size(50, 50), true);
         typename Types::LayerType* occludingLayer4 = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(100, 50), gfx::Size(100, 50), true);
         typename Types::LayerType* occludingLayer5 = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(250, 50), gfx::Size(50, 50), true);
 
         // Filters make the layer own a surface.
         WebKit::WebFilterOperations filters;
         filters.append(WebKit::WebFilterOperation::createBlurFilter(10));
-        filteredSurface->setBackgroundFilters(filters);
+        filteredSurface->SetBackgroundFilters(filters);
 
         // Save the distance of influence for the blur effect.
         int outsetTop, outsetRight, outsetBottom, outsetLeft;
         filters.getOutsets(outsetTop, outsetRight, outsetBottom, outsetLeft);
 
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         // These layers occlude pixels directly beside the filteredSurface. Because filtered surface blends pixels in a radius, it will
@@ skipping 93 matching lines @@
 protected:
     OcclusionTrackerTestTwoBackgroundFiltersReduceOcclusionTwice(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
         gfx::Transform scaleByHalf;
         scaleByHalf.Scale(0.5, 0.5);
 
         // Makes two surfaces that completely cover |parent|. The occlusion both above and below the filters will be reduced by each of them.
         typename Types::ContentLayerType* root = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(75, 75));
         typename Types::LayerType* parent = this->createSurface(root, scaleByHalf, gfx::PointF(0, 0), gfx::Size(150, 150));
-        parent->setMasksToBounds(true);
+        parent->SetMasksToBounds(true);
         typename Types::LayerType* filteredSurface1 = this->createDrawingLayer(parent, scaleByHalf, gfx::PointF(0, 0), gfx::Size(300, 300), false);
         typename Types::LayerType* filteredSurface2 = this->createDrawingLayer(parent, scaleByHalf, gfx::PointF(0, 0), gfx::Size(300, 300), false);
         typename Types::LayerType* occludingLayerAbove = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(100, 100), gfx::Size(50, 50), true);
 
         // Filters make the layers own surfaces.
         WebKit::WebFilterOperations filters;
         filters.append(WebKit::WebFilterOperation::createBlurFilter(1));
-        filteredSurface1->setBackgroundFilters(filters);
-        filteredSurface2->setBackgroundFilters(filters);
+        filteredSurface1->SetBackgroundFilters(filters);
+        filteredSurface2->SetBackgroundFilters(filters);
 
         // Save the distance of influence for the blur effect.
         int outsetTop, outsetRight, outsetBottom, outsetLeft;
         filters.getOutsets(outsetTop, outsetRight, outsetBottom, outsetLeft);
 
         this->calcDrawEtc(root);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         this->visitLayer(occludingLayerAbove, occlusion);
@@ skipping 20 matching lines @@
 class OcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilterWithClip : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilterWithClip(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
         // Make a surface and its replica, each 50x50, that are completely surrounded by opaque layers which are above them in the z-order.
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 150));
         // We stick the filtered surface inside a clipping surface so that we can make sure the clip is honored when exposing pixels for
         // the background filter.
         typename Types::LayerType* clippingSurface = this->createDrawingSurface(parent, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 70), false);
-        clippingSurface->setMasksToBounds(true);
+        clippingSurface->SetMasksToBounds(true);
         typename Types::LayerType* filteredSurface = this->createDrawingLayer(clippingSurface, this->identityMatrix, gfx::PointF(50, 50), gfx::Size(50, 50), false);
         this->createReplicaLayer(filteredSurface, this->identityMatrix, gfx::PointF(150, 0), gfx::Size());
         typename Types::LayerType* occludingLayer1 = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 50), true);
         typename Types::LayerType* occludingLayer2 = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(0, 100), gfx::Size(300, 50), true);
         typename Types::LayerType* occludingLayer3 = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(0, 50), gfx::Size(50, 50), true);
         typename Types::LayerType* occludingLayer4 = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(100, 50), gfx::Size(100, 50), true);
         typename Types::LayerType* occludingLayer5 = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(250, 50), gfx::Size(50, 50), true);
 
         // Filters make the layer own a surface. This filter is large enough that it goes outside the bottom of the clippingSurface.
         WebKit::WebFilterOperations filters;
         filters.append(WebKit::WebFilterOperation::createBlurFilter(12));
-        filteredSurface->setBackgroundFilters(filters);
+        filteredSurface->SetBackgroundFilters(filters);
 
         // Save the distance of influence for the blur effect.
         int outsetTop, outsetRight, outsetBottom, outsetLeft;
         filters.getOutsets(outsetTop, outsetRight, outsetBottom, outsetLeft);
 
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         // These layers occlude pixels directly beside the filteredSurface. Because filtered surface blends pixels in a radius, it will
@@ skipping 111 matching lines @@
         // appears at 50, 50 and the replica at 200, 50.
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 150));
         typename Types::LayerType* behindSurfaceLayer = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(60, 60), gfx::Size(30, 30), true);
         typename Types::LayerType* behindReplicaLayer = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(210, 60), gfx::Size(30, 30), true);
         typename Types::LayerType* filteredSurface = this->createDrawingLayer(parent, scaleByHalf, gfx::PointF(50, 50), gfx::Size(100, 100), false);
         this->createReplicaLayer(filteredSurface, this->identityMatrix, gfx::PointF(300, 0), gfx::Size());
 
         // Filters make the layer own a surface.
         WebKit::WebFilterOperations filters;
         filters.append(WebKit::WebFilterOperation::createBlurFilter(3));
-        filteredSurface->setBackgroundFilters(filters);
+        filteredSurface->SetBackgroundFilters(filters);
 
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         // The surface has a background blur, so it blurs non-opaque pixels below it.
         this->visitLayer(filteredSurface, occlusion);
         this->visitContributingSurface(filteredSurface, occlusion);
 
         this->visitLayer(behindReplicaLayer, occlusion);
@@ skipping 27 matching lines @@
         // appears at 50, 50 and the replica at 200, 50.
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(300, 150));
         typename Types::LayerType* filteredSurface = this->createDrawingLayer(parent, scaleByHalf, gfx::PointF(50, 50), gfx::Size(100, 100), false);
         this->createReplicaLayer(filteredSurface, this->identityMatrix, gfx::PointF(300, 0), gfx::Size());
         typename Types::LayerType* aboveSurfaceLayer = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(50, 50), gfx::Size(50, 50), true);
         typename Types::LayerType* aboveReplicaLayer = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(200, 50), gfx::Size(50, 50), true);
 
         // Filters make the layer own a surface.
         WebKit::WebFilterOperations filters;
         filters.append(WebKit::WebFilterOperation::createBlurFilter(3));
-        filteredSurface->setBackgroundFilters(filters);
+        filteredSurface->SetBackgroundFilters(filters);
 
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         this->visitLayer(aboveReplicaLayer, occlusion);
         this->visitLayer(aboveSurfaceLayer, occlusion);
 
         this->visitLayer(filteredSurface, occlusion);
 
@@ skipping 40 matching lines @@
         typename Types::LayerType* filteredSurface = this->createDrawingLayer(parent, scaleByHalf, gfx::PointF(50, 50), gfx::Size(100, 100), false);
         this->createReplicaLayer(filteredSurface, this->identityMatrix, gfx::PointF(300, 0), gfx::Size());
         typename Types::LayerType* aboveSurfaceLayer = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(70, 50), gfx::Size(30, 50), true);
         typename Types::LayerType* aboveReplicaLayer = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(200, 50), gfx::Size(30, 50), true);
         typename Types::LayerType* besideSurfaceLayer = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(90, 40), gfx::Size(10, 10), true);
         typename Types::LayerType* besideReplicaLayer = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(200, 40), gfx::Size(10, 10), true);
 
         // Filters make the layer own a surface.
         WebKit::WebFilterOperations filters;
         filters.append(WebKit::WebFilterOperation::createBlurFilter(3));
-        filteredSurface->setBackgroundFilters(filters);
+        filteredSurface->SetBackgroundFilters(filters);
 
         // Save the distance of influence for the blur effect.
         int outsetTop, outsetRight, outsetBottom, outsetLeft;
         filters.getOutsets(outsetTop, outsetRight, outsetBottom, outsetLeft);
 
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         this->visitLayer(besideReplicaLayer, occlusion);
@@ skipping 69 matching lines @@
 
 template<class Types>
 class OcclusionTrackerTestViewportClipIsExternalOcclusion : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestViewportClipIsExternalOcclusion(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(400, 400));
         typename Types::LayerType* small = this->createDrawingSurface(parent, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(200, 200), false);
         typename Types::LayerType* large = this->createDrawingLayer(small, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(400, 400), false);
-        small->setMasksToBounds(true);
+        small->SetMasksToBounds(true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 100, 100));
 
         this->EnterLayer(large, occlusion);
 
         bool hasOcclusionFromOutsideTargetSurface = false;
         EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), occlusion.unoccludedLayerContentRect(large, gfx::Rect(0, 0, 400, 400), &hasOcclusionFromOutsideTargetSurface));
         EXPECT_TRUE(hasOcclusionFromOutsideTargetSurface);
 
@@ skipping 26 matching lines @@
 class OcclusionTrackerTestLayerClipIsExternalOcclusion : public OcclusionTrackerTest<Types> {
 protected:
     OcclusionTrackerTestLayerClipIsExternalOcclusion(bool opaqueLayers) : OcclusionTrackerTest<Types>(opaqueLayers) {}
     void runMyTest()
     {
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, gfx::PointF(0, 0), gfx::Size(400, 400));
         typename Types::LayerType* smallest = this->createDrawingLayer(parent, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(50, 50), false);
         typename Types::LayerType* smaller = this->createDrawingSurface(smallest, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(100, 100), false);
         typename Types::LayerType* small = this->createDrawingSurface(smaller, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(200, 200), false);
         typename Types::LayerType* large = this->createDrawingLayer(small, this->identityMatrix, gfx::PointF(0, 0), gfx::Size(400, 400), false);
-        smallest->setMasksToBounds(true);
-        smaller->setMasksToBounds(true);
-        small->setMasksToBounds(true);
+        smallest->SetMasksToBounds(true);
+        smaller->SetMasksToBounds(true);
+        small->SetMasksToBounds(true);
         this->calcDrawEtc(parent);
 
         TestOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(gfx::Rect(0, 0, 1000, 1000));
 
         this->EnterLayer(large, occlusion);
 
         // Clipping from the smaller layer is from outside the target surface.
         bool hasOcclusionFromOutsideTargetSurface = false;
         EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), occlusion.unoccludedLayerContentRect(large, gfx::Rect(0, 0, 400, 400), &hasOcclusionFromOutsideTargetSurface));
         EXPECT_TRUE(hasOcclusionFromOutsideTargetSurface);
@@ skipping 29 matching lines @@
         hasOcclusionFromOutsideTargetSurface = false;
         EXPECT_RECT_EQ(gfx::Rect(0, 0, 50, 50), occlusion.UnoccludedContributingSurfaceContentRect(smaller, false, gfx::Rect(0, 0, 100, 100), &hasOcclusionFromOutsideTargetSurface));
         EXPECT_FALSE(hasOcclusionFromOutsideTargetSurface);
     }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestLayerClipIsExternalOcclusion)
 
 }  // namespace
 }  // namespace cc