cc: Rename cc classes and members to match filenames

cc/layer.cc

 // Copyright 2010 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 "config.h"
 
 #include "cc/layer.h"
 
 #include "CCActiveAnimation.h"
 #include "CCAnimationEvents.h"
 #include "CCLayerAnimationController.h"
 #include "CCLayerImpl.h"
 #include "CCLayerTreeHost.h"
 #include "CCSettings.h"
 #include <public/WebAnimationDelegate.h>
 #include <public/WebLayerScrollClient.h>
 #include <public/WebSize.h>
 
 using namespace std;
 using WebKit::WebTransformationMatrix;
 
 namespace cc {
 
 static int s_nextLayerId = 1;
 
-scoped_refptr<LayerChromium> LayerChromium::create()
+scoped_refptr<Layer> Layer::create()
 {
-    return make_scoped_refptr(new LayerChromium());
+    return make_scoped_refptr(new Layer());
 }
 
-LayerChromium::LayerChromium()
+Layer::Layer()
     : m_needsDisplay(false)
     , m_stackingOrderChanged(false)
     , m_layerId(s_nextLayerId++)
     , m_parent(0)
     , m_layerTreeHost(0)
-    , m_layerAnimationController(CCLayerAnimationController::create(this))
+    , m_layerAnimationController(LayerAnimationController::create(this))
     , m_scrollable(false)
     , m_shouldScrollOnMainThread(false)
     , m_haveWheelEventHandlers(false)
     , m_nonFastScrollableRegionChanged(false)
     , m_anchorPoint(0.5, 0.5)
     , m_backgroundColor(0)
     , m_debugBorderColor(0)
     , m_debugBorderWidth(0)
     , m_opacity(1.0)
     , m_anchorPointZ(0)
@@ skipping 18 matching lines @@
     , m_boundsContainPageScale(false)
     , m_layerAnimationDelegate(0)
     , m_layerScrollClient(0)
 {
     if (m_layerId < 0) {
         s_nextLayerId = 1;
         m_layerId = s_nextLayerId++;
     }
 }
 
-LayerChromium::~LayerChromium()
+Layer::~Layer()
 {
     // Our parent should be holding a reference to us so there should be no
     // way for us to be destroyed while we still have a parent.
     ASSERT(!parent());
 
     // Remove the parent reference from all children.
     removeAllChildren();
 }
 
-void LayerChromium::setUseLCDText(bool useLCDText)
+void Layer::setUseLCDText(bool useLCDText)
 {
     m_useLCDText = useLCDText;
 }
 
-void LayerChromium::setLayerTreeHost(CCLayerTreeHost* host)
+void Layer::setLayerTreeHost(LayerTreeHost* host)
 {
     if (m_layerTreeHost == host)
         return;
 
     m_layerTreeHost = host;
 
     for (size_t i = 0; i < m_children.size(); ++i)
         m_children[i]->setLayerTreeHost(host);
 
     if (m_maskLayer)
         m_maskLayer->setLayerTreeHost(host);
     if (m_replicaLayer)
         m_replicaLayer->setLayerTreeHost(host);
 
     // If this layer already has active animations, the host needs to be notified.
     if (host && m_layerAnimationController->hasActiveAnimation())
         host->didAddAnimation();
 }
 
-void LayerChromium::setNeedsCommit()
+void Layer::setNeedsCommit()
 {
     if (m_layerTreeHost)
         m_layerTreeHost->setNeedsCommit();
 }
 
-IntRect LayerChromium::layerRectToContentRect(const WebKit::WebRect& layerRect)
+IntRect Layer::layerRectToContentRect(const WebKit::WebRect& layerRect)
 {
     float widthScale = static_cast<float>(contentBounds().width()) / bounds().width();
     float heightScale = static_cast<float>(contentBounds().height()) / bounds().height();
     FloatRect contentRect(layerRect.x, layerRect.y, layerRect.width, layerRect.height);
     contentRect.scale(widthScale, heightScale);
     return enclosingIntRect(contentRect);
 }
 
-void LayerChromium::setParent(LayerChromium* layer)
+void Layer::setParent(Layer* layer)
 {
     ASSERT(!layer || !layer->hasAncestor(this));
     m_parent = layer;
     setLayerTreeHost(m_parent ? m_parent->layerTreeHost() : 0);
 }
 
-bool LayerChromium::hasAncestor(LayerChromium* ancestor) const
+bool Layer::hasAncestor(Layer* ancestor) const
 {
-    for (LayerChromium* layer = parent(); layer; layer = layer->parent()) {
+    for (Layer* layer = parent(); layer; layer = layer->parent()) {
         if (layer == ancestor)
             return true;
     }
     return false;
 }
 
-void LayerChromium::addChild(scoped_refptr<LayerChromium> child)
+void Layer::addChild(scoped_refptr<Layer> child)
 {
     insertChild(child, numChildren());
 }
 
-void LayerChromium::insertChild(scoped_refptr<LayerChromium> child, size_t index)
+void Layer::insertChild(scoped_refptr<Layer> child, size_t index)
 {
     index = min(index, m_children.size());
     child->removeFromParent();
     child->setParent(this);
     child->m_stackingOrderChanged = true;
 
     LayerList::iterator iter = m_children.begin();
     m_children.insert(iter + index, child);
     setNeedsCommit();
 }
 
-void LayerChromium::removeFromParent()
+void Layer::removeFromParent()
 {
     if (m_parent)
         m_parent->removeChild(this);
 }
 
-void LayerChromium::removeChild(LayerChromium* child)
+void Layer::removeChild(Layer* child)
 {
     for (LayerList::iterator iter = m_children.begin(); iter != m_children.end(); ++iter)
     {
         if (*iter != child)
             continue;
 
         child->setParent(0);
         m_children.erase(iter);
         setNeedsCommit();
         return;
     }
 }
 
-void LayerChromium::replaceChild(LayerChromium* reference, scoped_refptr<LayerChromium> newLayer)
+void Layer::replaceChild(Layer* reference, scoped_refptr<Layer> newLayer)
 {
     ASSERT_ARG(reference, reference);
     ASSERT_ARG(reference, reference->parent() == this);
 
     if (reference == newLayer)
         return;
 
     int referenceIndex = indexOfChild(reference);
     if (referenceIndex == -1) {
         ASSERT_NOT_REACHED();
         return;
     }
 
     reference->removeFromParent();
 
     if (newLayer) {
         newLayer->removeFromParent();
         insertChild(newLayer, referenceIndex);
     }
 }
 
-int LayerChromium::indexOfChild(const LayerChromium* reference)
+int Layer::indexOfChild(const Layer* reference)
 {
     for (size_t i = 0; i < m_children.size(); i++) {
         if (m_children[i] == reference)
             return i;
     }
     return -1;
 }
 
-void LayerChromium::setBounds(const IntSize& size)
+void Layer::setBounds(const IntSize& size)
 {
     if (bounds() == size)
         return;
 
     bool firstResize = bounds().isEmpty() && !size.isEmpty();
 
     m_bounds = size;
 
     if (firstResize)
         setNeedsDisplay();
     else
         setNeedsCommit();
 }
 
-LayerChromium* LayerChromium::rootLayer()
+Layer* Layer::rootLayer()
 {
-    LayerChromium* layer = this;
+    Layer* layer = this;
     while (layer->parent())
         layer = layer->parent();
     return layer;
 }
 
-void LayerChromium::removeAllChildren()
+void Layer::removeAllChildren()
 {
     while (m_children.size()) {
-        LayerChromium* layer = m_children[0].get();
+        Layer* layer = m_children[0].get();
         ASSERT(layer->parent());
         layer->removeFromParent();
     }
 }
 
-void LayerChromium::setChildren(const LayerList& children)
+void Layer::setChildren(const LayerList& children)
 {
     if (children == m_children)
         return;
 
     removeAllChildren();
     size_t listSize = children.size();
     for (size_t i = 0; i < listSize; i++)
         addChild(children[i]);
 }
 
-void LayerChromium::setAnchorPoint(const FloatPoint& anchorPoint)
+void Layer::setAnchorPoint(const FloatPoint& anchorPoint)
 {
     if (m_anchorPoint == anchorPoint)
         return;
     m_anchorPoint = anchorPoint;
     setNeedsCommit();
 }
 
-void LayerChromium::setAnchorPointZ(float anchorPointZ)
+void Layer::setAnchorPointZ(float anchorPointZ)
 {
     if (m_anchorPointZ == anchorPointZ)
         return;
     m_anchorPointZ = anchorPointZ;
     setNeedsCommit();
 }
 
-void LayerChromium::setBackgroundColor(SkColor backgroundColor)
+void Layer::setBackgroundColor(SkColor backgroundColor)
 {
     if (m_backgroundColor == backgroundColor)
         return;
     m_backgroundColor = backgroundColor;
     setNeedsCommit();
 }
 
-IntSize LayerChromium::contentBounds() const
+IntSize Layer::contentBounds() const
 {
     return bounds();
 }
 
-void LayerChromium::setMasksToBounds(bool masksToBounds)
+void Layer::setMasksToBounds(bool masksToBounds)
 {
     if (m_masksToBounds == masksToBounds)
         return;
     m_masksToBounds = masksToBounds;
     setNeedsCommit();
 }
 
-void LayerChromium::setMaskLayer(LayerChromium* maskLayer)
+void Layer::setMaskLayer(Layer* maskLayer)
 {
     if (m_maskLayer == maskLayer)
         return;
     if (m_maskLayer)
         m_maskLayer->setLayerTreeHost(0);
     m_maskLayer = maskLayer;
     if (m_maskLayer) {
         m_maskLayer->setLayerTreeHost(m_layerTreeHost);
         m_maskLayer->setIsMask(true);
     }
     setNeedsCommit();
 }
 
-void LayerChromium::setReplicaLayer(LayerChromium* layer)
+void Layer::setReplicaLayer(Layer* layer)
 {
     if (m_replicaLayer == layer)
         return;
     if (m_replicaLayer)
         m_replicaLayer->setLayerTreeHost(0);
     m_replicaLayer = layer;
     if (m_replicaLayer)
         m_replicaLayer->setLayerTreeHost(m_layerTreeHost);
     setNeedsCommit();
 }
 
-void LayerChromium::setFilters(const WebKit::WebFilterOperations& filters)
+void Layer::setFilters(const WebKit::WebFilterOperations& filters)
 {
     if (m_filters == filters)
         return;
     m_filters = filters;
     setNeedsCommit();
     if (!filters.isEmpty())
-        CCLayerTreeHost::setNeedsFilterContext(true);
+        LayerTreeHost::setNeedsFilterContext(true);
 }
 
-void LayerChromium::setBackgroundFilters(const WebKit::WebFilterOperations& backgroundFilters)
+void Layer::setBackgroundFilters(const WebKit::WebFilterOperations& backgroundFilters)
 {
     if (m_backgroundFilters == backgroundFilters)
         return;
     m_backgroundFilters = backgroundFilters;
     setNeedsCommit();
     if (!backgroundFilters.isEmpty())
-        CCLayerTreeHost::setNeedsFilterContext(true);
+        LayerTreeHost::setNeedsFilterContext(true);
 }
 
-bool LayerChromium::needsDisplay() const
+bool Layer::needsDisplay() const
 {
     return m_needsDisplay;
 }
 
-void LayerChromium::setOpacity(float opacity)
+void Layer::setOpacity(float opacity)
 {
     if (m_opacity == opacity)
         return;
     m_opacity = opacity;
     setNeedsCommit();
 }
 
-bool LayerChromium::opacityIsAnimating() const
+bool Layer::opacityIsAnimating() const
 {
-    return m_layerAnimationController->isAnimatingProperty(CCActiveAnimation::Opacity);
+    return m_layerAnimationController->isAnimatingProperty(ActiveAnimation::Opacity);
 }
 
-void LayerChromium::setContentsOpaque(bool opaque)
+void Layer::setContentsOpaque(bool opaque)
 {
     if (m_contentsOpaque == opaque)
         return;
     m_contentsOpaque = opaque;
     setNeedsDisplay();
 }
 
-void LayerChromium::setPosition(const FloatPoint& position)
+void Layer::setPosition(const FloatPoint& position)
 {
     if (m_position == position)
         return;
     m_position = position;
     setNeedsCommit();
 }
 
-void LayerChromium::setSublayerTransform(const WebTransformationMatrix& sublayerTransform)
+void Layer::setSublayerTransform(const WebTransformationMatrix& sublayerTransform)
 {
     if (m_sublayerTransform == sublayerTransform)
         return;
     m_sublayerTransform = sublayerTransform;
     setNeedsCommit();
 }
 
-void LayerChromium::setTransform(const WebTransformationMatrix& transform)
+void Layer::setTransform(const WebTransformationMatrix& transform)
 {
     if (m_transform == transform)
         return;
     m_transform = transform;
     setNeedsCommit();
 }
 
-bool LayerChromium::transformIsAnimating() const
+bool Layer::transformIsAnimating() const
 {
-    return m_layerAnimationController->isAnimatingProperty(CCActiveAnimation::Transform);
+    return m_layerAnimationController->isAnimatingProperty(ActiveAnimation::Transform);
 }
 
-void LayerChromium::setScrollPosition(const IntPoint& scrollPosition)
+void Layer::setScrollPosition(const IntPoint& scrollPosition)
 {
     if (m_scrollPosition == scrollPosition)
         return;
     m_scrollPosition = scrollPosition;
     if (m_layerScrollClient)
         m_layerScrollClient->didScroll();
     setNeedsCommit();
 }
 
-void LayerChromium::setMaxScrollPosition(const IntSize& maxScrollPosition)
+void Layer::setMaxScrollPosition(const IntSize& maxScrollPosition)
 {
     if (m_maxScrollPosition == maxScrollPosition)
         return;
     m_maxScrollPosition = maxScrollPosition;
     setNeedsCommit();
 }
 
-void LayerChromium::setScrollable(bool scrollable)
+void Layer::setScrollable(bool scrollable)
 {
     if (m_scrollable == scrollable)
         return;
     m_scrollable = scrollable;
     setNeedsCommit();
 }
 
-void LayerChromium::setShouldScrollOnMainThread(bool shouldScrollOnMainThread)
+void Layer::setShouldScrollOnMainThread(bool shouldScrollOnMainThread)
 {
     if (m_shouldScrollOnMainThread == shouldScrollOnMainThread)
         return;
     m_shouldScrollOnMainThread = shouldScrollOnMainThread;
     setNeedsCommit();
 }
 
-void LayerChromium::setHaveWheelEventHandlers(bool haveWheelEventHandlers)
+void Layer::setHaveWheelEventHandlers(bool haveWheelEventHandlers)
 {
     if (m_haveWheelEventHandlers == haveWheelEventHandlers)
         return;
     m_haveWheelEventHandlers = haveWheelEventHandlers;
     setNeedsCommit();
 }
 
-void LayerChromium::setNonFastScrollableRegion(const Region& region)
+void Layer::setNonFastScrollableRegion(const Region& region)
 {
     if (m_nonFastScrollableRegion == region)
         return;
     m_nonFastScrollableRegion = region;
     m_nonFastScrollableRegionChanged = true;
     setNeedsCommit();
 }
 
-void LayerChromium::setDrawCheckerboardForMissingTiles(bool checkerboard)
+void Layer::setDrawCheckerboardForMissingTiles(bool checkerboard)
 {
     if (m_drawCheckerboardForMissingTiles == checkerboard)
         return;
     m_drawCheckerboardForMissingTiles = checkerboard;
     setNeedsCommit();
 }
 
-void LayerChromium::setForceRenderSurface(bool force)
+void Layer::setForceRenderSurface(bool force)
 {
     if (m_forceRenderSurface == force)
         return;
     m_forceRenderSurface = force;
     setNeedsCommit();
 }
 
-void LayerChromium::setImplTransform(const WebTransformationMatrix& transform)
+void Layer::setImplTransform(const WebTransformationMatrix& transform)
 {
     if (m_implTransform == transform)
         return;
     m_implTransform = transform;
     setNeedsCommit();
 }
 
-void LayerChromium::setDoubleSided(bool doubleSided)
+void Layer::setDoubleSided(bool doubleSided)
 {
     if (m_doubleSided == doubleSided)
         return;
     m_doubleSided = doubleSided;
     setNeedsCommit();
 }
 
-void LayerChromium::setIsDrawable(bool isDrawable)
+void Layer::setIsDrawable(bool isDrawable)
 {
     if (m_isDrawable == isDrawable)
         return;
 
     m_isDrawable = isDrawable;
     setNeedsCommit();
 }
 
-LayerChromium* LayerChromium::parent() const
+Layer* Layer::parent() const
 {
     return m_parent;
 }
 
-void LayerChromium::setNeedsDisplayRect(const FloatRect& dirtyRect)
+void Layer::setNeedsDisplayRect(const FloatRect& dirtyRect)
 {
     m_updateRect.unite(dirtyRect);
 
     // Simply mark the contents as dirty. For non-root layers, the call to
     // setNeedsCommit will schedule a fresh compositing pass.
     // For the root layer, setNeedsCommit has no effect.
     if (!dirtyRect.isEmpty())
         m_needsDisplay = true;
 
     setNeedsCommit();
 }
 
-bool LayerChromium::descendantIsFixedToContainerLayer() const
+bool Layer::descendantIsFixedToContainerLayer() const
 {
     for (size_t i = 0; i < m_children.size(); ++i) {
         if (m_children[i]->fixedToContainerLayer() || m_children[i]->descendantIsFixedToContainerLayer())
             return true;
     }
     return false;
 }
 
-void LayerChromium::setIsContainerForFixedPositionLayers(bool isContainerForFixedPositionLayers)
+void Layer::setIsContainerForFixedPositionLayers(bool isContainerForFixedPositionLayers)
 {
     if (m_isContainerForFixedPositionLayers == isContainerForFixedPositionLayers)
         return;
     m_isContainerForFixedPositionLayers = isContainerForFixedPositionLayers;
 
     if (m_layerTreeHost && m_layerTreeHost->commitRequested())
         return;
 
     // Only request a commit if we have a fixed positioned descendant.
     if (descendantIsFixedToContainerLayer())
         setNeedsCommit();
 }
 
-void LayerChromium::setFixedToContainerLayer(bool fixedToContainerLayer)
+void Layer::setFixedToContainerLayer(bool fixedToContainerLayer)
 {
     if (m_fixedToContainerLayer == fixedToContainerLayer)
         return;
     m_fixedToContainerLayer = fixedToContainerLayer;
     setNeedsCommit();
 }
 
-void LayerChromium::pushPropertiesTo(CCLayerImpl* layer)
+void Layer::pushPropertiesTo(LayerImpl* layer)
 {
     layer->setAnchorPoint(m_anchorPoint);
     layer->setAnchorPointZ(m_anchorPointZ);
     layer->setBackgroundColor(m_backgroundColor);
     layer->setBounds(m_bounds);
     layer->setContentBounds(contentBounds());
     layer->setDebugBorderColor(m_debugBorderColor);
     layer->setDebugBorderWidth(m_debugBorderWidth);
     layer->setDebugName(m_debugName);
     layer->setDoubleSided(m_doubleSided);
@@ skipping 21 matching lines @@
     layer->setFixedToContainerLayer(m_fixedToContainerLayer);
     layer->setPreserves3D(preserves3D());
     layer->setUseParentBackfaceVisibility(m_useParentBackfaceVisibility);
     layer->setScrollPosition(m_scrollPosition);
     layer->setMaxScrollPosition(m_maxScrollPosition);
     layer->setSublayerTransform(m_sublayerTransform);
     if (!transformIsAnimating())
         layer->setTransform(m_transform);
 
     // If the main thread commits multiple times before the impl thread actually draws, then damage tracking
-    // will become incorrect if we simply clobber the updateRect here. The CCLayerImpl's updateRect needs to
+    // will become incorrect if we simply clobber the updateRect here. The LayerImpl's updateRect needs to
     // accumulate (i.e. union) any update changes that have occurred on the main thread.
     m_updateRect.uniteIfNonZero(layer->updateRect());
     layer->setUpdateRect(m_updateRect);
 
     layer->setScrollDelta(layer->scrollDelta() - layer->sentScrollDelta());
     layer->setSentScrollDelta(IntSize());
 
     layer->setStackingOrderChanged(m_stackingOrderChanged);
 
     if (maskLayer())
         maskLayer()->pushPropertiesTo(layer->maskLayer());
     if (replicaLayer())
         replicaLayer()->pushPropertiesTo(layer->replicaLayer());
 
     m_layerAnimationController->pushAnimationUpdatesTo(layer->layerAnimationController());
 
     // Reset any state that should be cleared for the next update.
     m_stackingOrderChanged = false;
     m_updateRect = FloatRect();
 }
 
-scoped_ptr<CCLayerImpl> LayerChromium::createCCLayerImpl()
+scoped_ptr<LayerImpl> Layer::createLayerImpl()
 {
-    return CCLayerImpl::create(m_layerId);
+    return LayerImpl::create(m_layerId);
 }
 
-bool LayerChromium::drawsContent() const
+bool Layer::drawsContent() const
 {
     return m_isDrawable;
 }
 
-bool LayerChromium::needMoreUpdates()
+bool Layer::needMoreUpdates()
 {
     return false;
 }
 
-bool LayerChromium::needsContentsScale() const
+bool Layer::needsContentsScale() const
 {
     return false;
 }
 
-void LayerChromium::setDebugBorderColor(SkColor color)
+void Layer::setDebugBorderColor(SkColor color)
 {
     m_debugBorderColor = color;
     setNeedsCommit();
 }
 
-void LayerChromium::setDebugBorderWidth(float width)
+void Layer::setDebugBorderWidth(float width)
 {
     m_debugBorderWidth = width;
     setNeedsCommit();
 }
 
-void LayerChromium::setDebugName(const std::string& debugName)
+void Layer::setDebugName(const std::string& debugName)
 {
     m_debugName = debugName;
     setNeedsCommit();
 }
 
-void LayerChromium::setContentsScale(float contentsScale)
+void Layer::setContentsScale(float contentsScale)
 {
     if (!needsContentsScale() || m_contentsScale == contentsScale)
         return;
     m_contentsScale = contentsScale;
 
     setNeedsDisplay();
 }
 
-void LayerChromium::setBoundsContainPageScale(bool boundsContainPageScale)
+void Layer::setBoundsContainPageScale(bool boundsContainPageScale)
 {
     for (size_t i = 0; i < m_children.size(); ++i)
         m_children[i]->setBoundsContainPageScale(boundsContainPageScale);
 
     if (boundsContainPageScale == m_boundsContainPageScale)
         return;
 
     m_boundsContainPageScale = boundsContainPageScale;
     setNeedsDisplay();
 }
 
-void LayerChromium::createRenderSurface()
+void Layer::createRenderSurface()
 {
     ASSERT(!m_renderSurface);
-    m_renderSurface = make_scoped_ptr(new RenderSurfaceChromium(this));
+    m_renderSurface = make_scoped_ptr(new RenderSurface(this));
     setRenderTarget(this);
 }
 
-bool LayerChromium::descendantDrawsContent()
+bool Layer::descendantDrawsContent()
 {
     for (size_t i = 0; i < m_children.size(); ++i) {
         if (m_children[i]->drawsContent() || m_children[i]->descendantDrawsContent())
             return true;
     }
     return false;
 }
 
-int LayerChromium::id() const
+int Layer::id() const
 {
     return m_layerId;
 }
 
-float LayerChromium::opacity() const
+float Layer::opacity() const
 {
     return m_opacity;
 }
 
-void LayerChromium::setOpacityFromAnimation(float opacity)
+void Layer::setOpacityFromAnimation(float opacity)
 {
     // This is called due to an ongoing accelerated animation. Since this animation is
     // also being run on the impl thread, there is no need to request a commit to push
     // this value over, so set the value directly rather than calling setOpacity.
     m_opacity = opacity;
 }
 
-const WebKit::WebTransformationMatrix& LayerChromium::transform() const
+const WebKit::WebTransformationMatrix& Layer::transform() const
 {
     return m_transform;
 }
 
-void LayerChromium::setTransformFromAnimation(const WebTransformationMatrix& transform)
+void Layer::setTransformFromAnimation(const WebTransformationMatrix& transform)
 {
     // This is called due to an ongoing accelerated animation. Since this animation is
     // also being run on the impl thread, there is no need to request a commit to push
     // this value over, so set this value directly rather than calling setTransform.
     m_transform = transform;
 }
 
-bool LayerChromium::addAnimation(scoped_ptr <CCActiveAnimation> animation)
+bool Layer::addAnimation(scoped_ptr <ActiveAnimation> animation)
 {
     // WebCore currently assumes that accelerated animations will start soon
     // after the animation is added. However we cannot guarantee that if we do
     // not have a layerTreeHost that will setNeedsCommit().
     if (!m_layerTreeHost)
         return false;
 
-    if (!CCSettings::acceleratedAnimationEnabled())
+    if (!Settings::acceleratedAnimationEnabled())
         return false;
 
     m_layerAnimationController->addAnimation(animation.Pass());
     if (m_layerTreeHost) {
         m_layerTreeHost->didAddAnimation();
         setNeedsCommit();
     }
     return true;
 }
 
-void LayerChromium::pauseAnimation(int animationId, double timeOffset)
+void Layer::pauseAnimation(int animationId, double timeOffset)
 {
     m_layerAnimationController->pauseAnimation(animationId, timeOffset);
     setNeedsCommit();
 }
 
-void LayerChromium::removeAnimation(int animationId)
+void Layer::removeAnimation(int animationId)
 {
     m_layerAnimationController->removeAnimation(animationId);
     setNeedsCommit();
 }
 
-void LayerChromium::suspendAnimations(double monotonicTime)
+void Layer::suspendAnimations(double monotonicTime)
 {
     m_layerAnimationController->suspendAnimations(monotonicTime);
     setNeedsCommit();
 }
 
-void LayerChromium::resumeAnimations(double monotonicTime)
+void Layer::resumeAnimations(double monotonicTime)
 {
     m_layerAnimationController->resumeAnimations(monotonicTime);
     setNeedsCommit();
 }
 
-void LayerChromium::setLayerAnimationController(scoped_ptr<CCLayerAnimationController> layerAnimationController)
+void Layer::setLayerAnimationController(scoped_ptr<LayerAnimationController> layerAnimationController)
 {
     m_layerAnimationController = layerAnimationController.Pass();
     if (m_layerAnimationController) {
         m_layerAnimationController->setClient(this);
         m_layerAnimationController->setForceSync();
     }
     setNeedsCommit();
 }
 
-scoped_ptr<CCLayerAnimationController> LayerChromium::releaseLayerAnimationController()
+scoped_ptr<LayerAnimationController> Layer::releaseLayerAnimationController()
 {
-    scoped_ptr<CCLayerAnimationController> toReturn = m_layerAnimationController.Pass();
-    m_layerAnimationController = CCLayerAnimationController::create(this);
+    scoped_ptr<LayerAnimationController> toReturn = m_layerAnimationController.Pass();
+    m_layerAnimationController = LayerAnimationController::create(this);
     return toReturn.Pass();
 }
 
-bool LayerChromium::hasActiveAnimation() const
+bool Layer::hasActiveAnimation() const
 {
     return m_layerAnimationController->hasActiveAnimation();
 }
 
-void LayerChromium::notifyAnimationStarted(const CCAnimationEvent& event, double wallClockTime)
+void Layer::notifyAnimationStarted(const AnimationEvent& event, double wallClockTime)
 {
     m_layerAnimationController->notifyAnimationStarted(event);
     if (m_layerAnimationDelegate)
         m_layerAnimationDelegate->notifyAnimationStarted(wallClockTime);
 }
 
-void LayerChromium::notifyAnimationFinished(double wallClockTime)
+void Layer::notifyAnimationFinished(double wallClockTime)
 {
     if (m_layerAnimationDelegate)
         m_layerAnimationDelegate->notifyAnimationFinished(wallClockTime);
 }
 
-Region LayerChromium::visibleContentOpaqueRegion() const
+Region Layer::visibleContentOpaqueRegion() const
 {
     if (contentsOpaque())
         return visibleContentRect();
     return Region();
 }
 
-ScrollbarLayerChromium* LayerChromium::toScrollbarLayerChromium()
+ScrollbarLayer* Layer::toScrollbarLayer()
 {
     return 0;
 }
 
-void sortLayers(std::vector<scoped_refptr<LayerChromium> >::iterator, std::vector<scoped_refptr<LayerChromium> >::iterator, void*)
+void sortLayers(std::vector<scoped_refptr<Layer> >::iterator, std::vector<scoped_refptr<Layer> >::iterator, void*)
 {
-    // Currently we don't use z-order to decide what to paint, so there's no need to actually sort LayerChromiums.
+    // Currently we don't use z-order to decide what to paint, so there's no need to actually sort Layers.
 }
 
 }