cc: Rename cc classes and members to match filenames

cc/layer_tree_host_common.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #include "CCLayerTreeHostCommon.h"
 
 #include "CCLayerImpl.h"
 #include "CCLayerIterator.h"
 #include "CCLayerSorter.h"
 #include "CCMathUtil.h"
 #include "CCRenderSurface.h"
 #include "FloatQuad.h"
 #include "IntRect.h"
 #include "cc/layer.h"
 #include "cc/render_surface.h"
 #include <public/WebTransformationMatrix.h>
 
 using WebKit::WebTransformationMatrix;
 
 namespace cc {
 
-CCScrollAndScaleSet::CCScrollAndScaleSet()
+ScrollAndScaleSet::ScrollAndScaleSet()
 {
 }
 
-CCScrollAndScaleSet::~CCScrollAndScaleSet()
+ScrollAndScaleSet::~ScrollAndScaleSet()
 {
 }
 
-IntRect CCLayerTreeHostCommon::calculateVisibleRect(const IntRect& targetSurfaceRect, const IntRect& layerBoundRect, const WebTransformationMatrix& transform)
+IntRect LayerTreeHostCommon::calculateVisibleRect(const IntRect& targetSurfaceRect, const IntRect& layerBoundRect, const WebTransformationMatrix& transform)
 {
     // Is this layer fully contained within the target surface?
-    IntRect layerInSurfaceSpace = CCMathUtil::mapClippedRect(transform, layerBoundRect);
+    IntRect layerInSurfaceSpace = MathUtil::mapClippedRect(transform, layerBoundRect);
     if (targetSurfaceRect.contains(layerInSurfaceSpace))
         return layerBoundRect;
 
     // If the layer doesn't fill up the entire surface, then find the part of
     // the surface rect where the layer could be visible. This avoids trying to
     // project surface rect points that are behind the projection point.
     IntRect minimalSurfaceRect = targetSurfaceRect;
     minimalSurfaceRect.intersect(layerInSurfaceSpace);
 
     // Project the corners of the target surface rect into the layer space.
     // This bounding rectangle may be larger than it needs to be (being
     // axis-aligned), but is a reasonable filter on the space to consider.
     // Non-invertible transforms will create an empty rect here.
     const WebTransformationMatrix surfaceToLayer = transform.inverse();
-    IntRect layerRect = enclosingIntRect(CCMathUtil::projectClippedRect(surfaceToLayer, FloatRect(minimalSurfaceRect)));
+    IntRect layerRect = enclosingIntRect(MathUtil::projectClippedRect(surfaceToLayer, FloatRect(minimalSurfaceRect)));
     layerRect.intersect(layerBoundRect);
     return layerRect;
 }
 
 template<typename LayerType>
 static inline bool layerIsInExisting3DRenderingContext(LayerType* layer)
 {
     // According to current W3C spec on CSS transforms, a layer is part of an established
     // 3d rendering context if its parent has transform-style of preserves-3d.
     return layer->parent() && layer->parent()->preserves3D();
@@ skipping 58 matching lines @@
 
     IntRect targetSurfaceClipRect;
 
     // First, compute visible bounds in target surface space.
     if (layer->renderTarget()->renderSurface()->clipRect().isEmpty())
         targetSurfaceClipRect = layer->drawableContentRect();
     else {
         // In this case the target surface does clip layers that contribute to it. So, we
         // have convert the current surface's clipRect from its ancestor surface space to
         // the current surface space.
-        targetSurfaceClipRect = enclosingIntRect(CCMathUtil::projectClippedRect(layer->renderTarget()->renderSurface()->drawTransform().inverse(), layer->renderTarget()->renderSurface()->clipRect()));
+        targetSurfaceClipRect = enclosingIntRect(MathUtil::projectClippedRect(layer->renderTarget()->renderSurface()->drawTransform().inverse(), layer->renderTarget()->renderSurface()->clipRect()));
         targetSurfaceClipRect.intersect(layer->drawableContentRect());
     }
 
     if (targetSurfaceClipRect.isEmpty())
         return IntRect();
 
-    return CCLayerTreeHostCommon::calculateVisibleRect(targetSurfaceClipRect, IntRect(IntPoint(), layer->contentBounds()), layer->drawTransform());
+    return LayerTreeHostCommon::calculateVisibleRect(targetSurfaceClipRect, IntRect(IntPoint(), layer->contentBounds()), layer->drawTransform());
 }
 
 static bool isScaleOrTranslation(const WebTransformationMatrix& m)
 {
     return !m.m12() && !m.m13() && !m.m14()
            && !m.m21() && !m.m23() && !m.m24()
            && !m.m31() && !m.m32() && !m.m43()
            && m.m44();
 }
 
-static inline bool transformToParentIsKnown(CCLayerImpl*)
+static inline bool transformToParentIsKnown(LayerImpl*)
 {
     return true;
 }
 
-static inline bool transformToParentIsKnown(LayerChromium* layer)
+static inline bool transformToParentIsKnown(Layer* layer)
 {
     return !layer->transformIsAnimating();
 }
 
-static inline bool transformToScreenIsKnown(CCLayerImpl*)
+static inline bool transformToScreenIsKnown(LayerImpl*)
 {
     return true;
 }
 
-static inline bool transformToScreenIsKnown(LayerChromium* layer)
+static inline bool transformToScreenIsKnown(Layer* layer)
 {
     return !layer->screenSpaceTransformIsAnimating();
 }
 
 template<typename LayerType>
 static bool layerShouldBeSkipped(LayerType* layer)
 {
     // Layers can be skipped if any of these conditions are met.
     //   - does not draw content.
     //   - is transparent
@@ skipping 18 matching lines @@
         backfaceTestLayer = layer->parent();
     }
 
     // The layer should not be drawn if (1) it is not double-sided and (2) the back of the layer is known to be facing the screen.
     if (!backfaceTestLayer->doubleSided() && transformToScreenIsKnown(backfaceTestLayer) && isLayerBackFaceVisible(backfaceTestLayer))
         return true;
 
     return false;
 }
 
-static inline bool subtreeShouldBeSkipped(CCLayerImpl* layer)
+static inline bool subtreeShouldBeSkipped(LayerImpl* layer)
 {
     // The opacity of a layer always applies to its children (either implicitly
     // via a render surface or explicitly if the parent preserves 3D), so the
     // entire subtree can be skipped if this layer is fully transparent.
     return !layer->opacity();
 }
 
-static inline bool subtreeShouldBeSkipped(LayerChromium* layer)
+static inline bool subtreeShouldBeSkipped(Layer* layer)
 {
     // If the opacity is being animated then the opacity on the main thread is unreliable
     // (since the impl thread may be using a different opacity), so it should not be trusted.
     // In particular, it should not cause the subtree to be skipped.
     return !layer->opacity() && !layer->opacityIsAnimating();
 }
 
 template<typename LayerType>
 static bool subtreeShouldRenderToSeparateSurface(LayerType* layer, bool axisAlignedWithRespectToParent)
 {
     // The root layer has a special render surface that is set up externally, so
     // it shouldn't be treated as a surface in this code.
     if (!layer->parent())
         return false;
 
     // Cache this value, because otherwise it walks the entire subtree several times.
     bool descendantDrawsContent = layer->descendantDrawsContent();
 
     //
-    // A layer and its descendants should render onto a new RenderSurface if any of these rules hold:
+    // A layer and its descendants should render onto a new RenderSurfaceImpl if any of these rules hold:
     //
 
     // If we force it.
     if (layer->forceRenderSurface())
         return true;
 
     // If the layer uses a mask.
     if (layer->maskLayer())
         return true;
 
@@ skipping 14 matching lines @@
     if (layerClipsSubtree(layer) && !axisAlignedWithRespectToParent && descendantDrawsContent)
         return true;
 
     // If the layer has opacity != 1 and does not have a preserves-3d transform style.
     if (layer->opacity() != 1 && !layer->preserves3D() && descendantDrawsContent)
         return true;
 
     return false;
 }
 
-WebTransformationMatrix computeScrollCompensationForThisLayer(CCLayerImpl* scrollingLayer, const WebTransformationMatrix& parentMatrix)
+WebTransformationMatrix computeScrollCompensationForThisLayer(LayerImpl* scrollingLayer, const WebTransformationMatrix& parentMatrix)
 {
     // For every layer that has non-zero scrollDelta, we have to compute a transform that can undo the
     // scrollDelta translation. In particular, we want this matrix to premultiply a fixed-position layer's
     // parentMatrix, so we design this transform in three steps as follows. The steps described here apply
     // from right-to-left, so Step 1 would be the right-most matrix:
     //
     //     Step 1. transform from target surface space to the exact space where scrollDelta is actually applied.
     //           -- this is inverse of the matrix in step 3
     //     Step 2. undo the scrollDelta
     //           -- this is just a translation by scrollDelta.
     //     Step 3. transform back to target surface space.
     //           -- this transform is the "partialLayerOriginTransform" = (parentMatrix * scale(layer->pageScaleDelta()));
     //
     // These steps create a matrix that both start and end in targetSurfaceSpace. So this matrix can
     // pre-multiply any fixed-position layer's drawTransform to undo the scrollDeltas -- as long as
     // that fixed position layer is fixed onto the same renderTarget as this scrollingLayer.
     //
 
     WebTransformationMatrix partialLayerOriginTransform = parentMatrix;
     partialLayerOriginTransform.multiply(scrollingLayer->implTransform());
 
     WebTransformationMatrix scrollCompensationForThisLayer = partialLayerOriginTransform; // Step 3
     scrollCompensationForThisLayer.translate(scrollingLayer->scrollDelta().width(), scrollingLayer->scrollDelta().height()); // Step 2
     scrollCompensationForThisLayer.multiply(partialLayerOriginTransform.inverse()); // Step 1
     return scrollCompensationForThisLayer;
 }
 
-WebTransformationMatrix computeScrollCompensationMatrixForChildren(LayerChromium* currentLayer, const WebTransformationMatrix& currentParentMatrix, const WebTransformationMatrix& currentScrollCompensation)
+WebTransformationMatrix computeScrollCompensationMatrixForChildren(Layer* currentLayer, const WebTransformationMatrix& currentParentMatrix, const WebTransformationMatrix& currentScrollCompensation)
 {
-    // The main thread (i.e. LayerChromium) does not need to worry about scroll compensation.
+    // The main thread (i.e. Layer) does not need to worry about scroll compensation.
     // So we can just return an identity matrix here.
     return WebTransformationMatrix();
 }
 
-WebTransformationMatrix computeScrollCompensationMatrixForChildren(CCLayerImpl* layer, const WebTransformationMatrix& parentMatrix, const WebTransformationMatrix& currentScrollCompensationMatrix)
+WebTransformationMatrix computeScrollCompensationMatrixForChildren(LayerImpl* layer, const WebTransformationMatrix& parentMatrix, const WebTransformationMatrix& currentScrollCompensationMatrix)
 {
     // "Total scroll compensation" is the transform needed to cancel out all scrollDelta translations that
     // occurred since the nearest container layer, even if there are renderSurfaces in-between.
     //
     // There are some edge cases to be aware of, that are not explicit in the code:
     //  - A layer that is both a fixed-position and container should not be its own container, instead, that means
     //    it is fixed to an ancestor, and is a container for any fixed-position descendants.
     //  - A layer that is a fixed-position container and has a renderSurface should behave the same as a container
     //    without a renderSurface, the renderSurface is irrelevant in that case.
     //  - A layer that does not have an explicit container is simply fixed to the viewport
@@ skipping 183 matching lines @@
     WebTransformationMatrix drawTransform = combinedTransform;
     if (!layer->contentBounds().isEmpty() && !layer->bounds().isEmpty()) {
         // M[draw] = M[parent] * LT * S[layer2content]
         drawTransform.scaleNonUniform(layer->bounds().width() / static_cast<double>(layer->contentBounds().width()),
                                       layer->bounds().height() / static_cast<double>(layer->contentBounds().height()));
     }
 
     // layerScreenSpaceTransform represents the transform between root layer's "screen space" and local content space.
     WebTransformationMatrix layerScreenSpaceTransform = fullHierarchyMatrix;
     if (!layer->preserves3D())
-        CCMathUtil::flattenTransformTo2d(layerScreenSpaceTransform);
+        MathUtil::flattenTransformTo2d(layerScreenSpaceTransform);
     layerScreenSpaceTransform.multiply(drawTransform);
     layer->setScreenSpaceTransform(layerScreenSpaceTransform);
 
     bool animatingTransformToTarget = layer->transformIsAnimating();
     bool animatingTransformToScreen = animatingTransformToTarget;
     if (layer->parent()) {
         animatingTransformToTarget |= layer->parent()->drawTransformIsAnimating();
         animatingTransformToScreen |= layer->parent()->screenSpaceTransformIsAnimating();
     }
 
     FloatRect contentRect(FloatPoint(), layer->contentBounds());
 
-    // fullHierarchyMatrix is the matrix that transforms objects between screen space (except projection matrix) and the most recent RenderSurface's space.
-    // nextHierarchyMatrix will only change if this layer uses a new RenderSurface, otherwise remains the same.
+    // fullHierarchyMatrix is the matrix that transforms objects between screen space (except projection matrix) and the most recent RenderSurfaceImpl's space.
+    // nextHierarchyMatrix will only change if this layer uses a new RenderSurfaceImpl, otherwise remains the same.
     WebTransformationMatrix nextHierarchyMatrix = fullHierarchyMatrix;
     WebTransformationMatrix sublayerMatrix;
 
     if (subtreeShouldRenderToSeparateSurface(layer, isScaleOrTranslation(combinedTransform))) {
         // Check back-face visibility before continuing with this surface and its subtree
         if (!layer->doubleSided() && transformToParentIsKnown(layer) && isSurfaceBackFaceVisible(layer, combinedTransform))
             return;
 
         if (!layer->renderSurface())
             layer->createRenderSurface();
@@ skipping 22 matching lines @@
         layer->setDrawOpacity(1);
         layer->setDrawOpacityIsAnimating(false);
 
         renderSurface->setTargetSurfaceTransformsAreAnimating(animatingTransformToTarget);
         renderSurface->setScreenSpaceTransformsAreAnimating(animatingTransformToScreen);
         animatingTransformToTarget = false;
         layer->setDrawTransformIsAnimating(animatingTransformToTarget);
         layer->setScreenSpaceTransformIsAnimating(animatingTransformToScreen);
 
         // Update the aggregate hierarchy matrix to include the transform of the
-        // newly created RenderSurface.
+        // newly created RenderSurfaceImpl.
         nextHierarchyMatrix.multiply(renderSurface->drawTransform());
 
         // The new renderSurface here will correctly clip the entire subtree. So, we do
         // not need to continue propagating the clipping state further down the tree. This
         // way, we can avoid transforming clipRects from ancestor target surface space to
         // current target surface space that could cause more w < 0 headaches.
         subtreeShouldBeClipped = false;
 
         if (layer->maskLayer()) {
             layer->maskLayer()->setRenderTarget(layer);
@@ skipping 40 matching lines @@
         } else {
             // FIXME: This root layer special case code should eventually go away. https://bugs.webkit.org/show_bug.cgi?id=92290
             ASSERT(!layer->parent());
             ASSERT(layer->renderSurface());
             ASSERT(ancestorClipsSubtree);
             layer->renderSurface()->setClipRect(clipRectFromAncestor);
             subtreeShouldBeClipped = false;
         }
     }
 
-    IntRect rectInTargetSpace = enclosingIntRect(CCMathUtil::mapClippedRect(layer->drawTransform(), contentRect));
+    IntRect rectInTargetSpace = enclosingIntRect(MathUtil::mapClippedRect(layer->drawTransform(), contentRect));
 
     if (layerClipsSubtree(layer)) {
         subtreeShouldBeClipped = true;
         if (ancestorClipsSubtree && !layer->renderSurface()) {
             clipRectForSubtree = clipRectFromAncestor;
             clipRectForSubtree.intersect(rectInTargetSpace);
         } else
             clipRectForSubtree = rectInTargetSpace;
     }
 
     // Flatten to 2D if the layer doesn't preserve 3D.
     if (!layer->preserves3D())
-        CCMathUtil::flattenTransformTo2d(sublayerMatrix);
+        MathUtil::flattenTransformTo2d(sublayerMatrix);
 
     // Apply the sublayer transform at the center of the layer.
     sublayerMatrix.translate(0.5 * bounds.width(), 0.5 * bounds.height());
     sublayerMatrix.multiply(layer->sublayerTransform());
     sublayerMatrix.translate(-0.5 * bounds.width(), -0.5 * bounds.height());
 
     LayerList& descendants = (layer->renderSurface() ? layer->renderSurface()->layerList() : layerList);
 
     // Any layers that are appended after this point are in the layer's subtree and should be included in the sorting process.
     unsigned sortingStartIndex = descendants.size();
 
     if (!layerShouldBeSkipped(layer))
         descendants.push_back(layer);
 
     WebTransformationMatrix nextScrollCompensationMatrix = computeScrollCompensationMatrixForChildren(layer, parentMatrix, currentScrollCompensationMatrix);;
 
     IntRect accumulatedDrawableContentRectOfChildren;
     for (size_t i = 0; i < layer->children().size(); ++i) {
-        LayerType* child = CCLayerTreeHostCommon::getChildAsRawPtr(layer->children(), i);
+        LayerType* child = LayerTreeHostCommon::getChildAsRawPtr(layer->children(), i);
         IntRect drawableContentRectOfChildSubtree;
         calculateDrawTransformsInternal<LayerType, LayerList, RenderSurfaceType, LayerSorter>(child, rootLayer, sublayerMatrix, nextHierarchyMatrix, nextScrollCompensationMatrix,
                                                                                               clipRectForSubtree, subtreeShouldBeClipped, nearestAncestorThatMovesPixels,
                                                                                               renderSurfaceLayerList, descendants, layerSorter, maxTextureSize, deviceScaleFactor, drawableContentRectOfChildSubtree);
         if (!drawableContentRectOfChildSubtree.isEmpty()) {
             accumulatedDrawableContentRectOfChildren.unite(drawableContentRectOfChildSubtree);
             if (child->renderSurface())
                 descendants.push_back(child);
         }
     }
@@ skipping 20 matching lines @@
         RenderSurfaceType* renderSurface = layer->renderSurface();
         IntRect clippedContentRect = localDrawableContentRectOfSubtree;
 
         // Don't clip if the layer is reflected as the reflection shouldn't be
         // clipped. If the layer is animating, then the surface's transform to
         // its target is not known on the main thread, and we should not use it
         // to clip.
         if (!layer->replicaLayer() && transformToParentIsKnown(layer)) {
             // Note, it is correct to use ancestorClipsSubtree here, because we are looking at this layer's renderSurface, not the layer itself.
             if (ancestorClipsSubtree && !clippedContentRect.isEmpty()) {
-                IntRect surfaceClipRect = CCLayerTreeHostCommon::calculateVisibleRect(renderSurface->clipRect(), clippedContentRect, renderSurface->drawTransform());
+                IntRect surfaceClipRect = LayerTreeHostCommon::calculateVisibleRect(renderSurface->clipRect(), clippedContentRect, renderSurface->drawTransform());
                 clippedContentRect.intersect(surfaceClipRect);
             }
         }
 
-        // The RenderSurface backing texture cannot exceed the maximum supported
+        // The RenderSurfaceImpl backing texture cannot exceed the maximum supported
         // texture size.
         clippedContentRect.setWidth(std::min(clippedContentRect.width(), maxTextureSize));
         clippedContentRect.setHeight(std::min(clippedContentRect.height(), maxTextureSize));
 
         if (clippedContentRect.isEmpty())
             renderSurface->clearLayerLists();
 
         renderSurface->setContentRect(clippedContentRect);
         renderSurface->setScreenSpaceTransform(layer->screenSpaceTransform());
 
@@ skipping 45 matching lines @@
 
     if (layer->renderSurface())
         drawableContentRectOfSubtree = enclosingIntRect(layer->renderSurface()->drawableContentRect());
     else
         drawableContentRectOfSubtree = localDrawableContentRectOfSubtree;
 
     if (layer->hasContributingDelegatedRenderPasses())
         layer->renderTarget()->renderSurface()->addContributingDelegatedRenderPassLayer(layer);
 }
 
-void CCLayerTreeHostCommon::calculateDrawTransforms(LayerChromium* rootLayer, const IntSize& deviceViewportSize, float deviceScaleFactor, int maxTextureSize, std::vector<scoped_refptr<LayerChromium> >& renderSurfaceLayerList)
+void LayerTreeHostCommon::calculateDrawTransforms(Layer* rootLayer, const IntSize& deviceViewportSize, float deviceScaleFactor, int maxTextureSize, std::vector<scoped_refptr<Layer> >& renderSurfaceLayerList)
 {
     IntRect totalDrawableContentRect;
     WebTransformationMatrix identityMatrix;
     WebTransformationMatrix deviceScaleTransform;
     deviceScaleTransform.scale(deviceScaleFactor);
 
-    setupRootLayerAndSurfaceForRecursion<LayerChromium, std::vector<scoped_refptr<LayerChromium> > >(rootLayer, renderSurfaceLayerList, deviceViewportSize);
+    setupRootLayerAndSurfaceForRecursion<Layer, std::vector<scoped_refptr<Layer> > >(rootLayer, renderSurfaceLayerList, deviceViewportSize);
 
-    cc::calculateDrawTransformsInternal<LayerChromium, std::vector<scoped_refptr<LayerChromium> >, RenderSurfaceChromium, void>(rootLayer, rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
+    cc::calculateDrawTransformsInternal<Layer, std::vector<scoped_refptr<Layer> >, RenderSurface, void>(rootLayer, rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
                                                                                                                          rootLayer->renderSurface()->contentRect(), true, 0, renderSurfaceLayerList,
                                                                                                                          rootLayer->renderSurface()->layerList(), 0, maxTextureSize, deviceScaleFactor, totalDrawableContentRect);
 }
 
-void CCLayerTreeHostCommon::calculateDrawTransforms(CCLayerImpl* rootLayer, const IntSize& deviceViewportSize, float deviceScaleFactor, CCLayerSorter* layerSorter, int maxTextureSize, std::vector<CCLayerImpl*>& renderSurfaceLayerList)
+void LayerTreeHostCommon::calculateDrawTransforms(LayerImpl* rootLayer, const IntSize& deviceViewportSize, float deviceScaleFactor, LayerSorter* layerSorter, int maxTextureSize, std::vector<LayerImpl*>& renderSurfaceLayerList)
 {
     IntRect totalDrawableContentRect;
     WebTransformationMatrix identityMatrix;
     WebTransformationMatrix deviceScaleTransform;
     deviceScaleTransform.scale(deviceScaleFactor);
 
-    setupRootLayerAndSurfaceForRecursion<CCLayerImpl, std::vector<CCLayerImpl*> >(rootLayer, renderSurfaceLayerList, deviceViewportSize);
+    setupRootLayerAndSurfaceForRecursion<LayerImpl, std::vector<LayerImpl*> >(rootLayer, renderSurfaceLayerList, deviceViewportSize);
 
-    cc::calculateDrawTransformsInternal<CCLayerImpl, std::vector<CCLayerImpl*>, CCRenderSurface, CCLayerSorter>(rootLayer, rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
+    cc::calculateDrawTransformsInternal<LayerImpl, std::vector<LayerImpl*>, RenderSurfaceImpl, LayerSorter>(rootLayer, rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
                                                                                                                 rootLayer->renderSurface()->contentRect(), true, 0, renderSurfaceLayerList,
                                                                                                                 rootLayer->renderSurface()->layerList(), layerSorter, maxTextureSize, deviceScaleFactor, totalDrawableContentRect);
 }
 
 static bool pointHitsRect(const IntPoint& viewportPoint, const WebTransformationMatrix& localSpaceToScreenSpaceTransform, FloatRect localSpaceRect)
 {
     // If the transform is not invertible, then assume that this point doesn't hit this rect.
     if (!localSpaceToScreenSpaceTransform.isInvertible())
         return false;
 
     // Transform the hit test point from screen space to the local space of the given rect.
     bool clipped = false;
-    FloatPoint hitTestPointInLocalSpace = CCMathUtil::projectPoint(localSpaceToScreenSpaceTransform.inverse(), FloatPoint(viewportPoint), clipped);
+    FloatPoint hitTestPointInLocalSpace = MathUtil::projectPoint(localSpaceToScreenSpaceTransform.inverse(), FloatPoint(viewportPoint), clipped);
 
     // If projectPoint could not project to a valid value, then we assume that this point doesn't hit this rect.
     if (clipped)
         return false;
 
     return localSpaceRect.contains(hitTestPointInLocalSpace);
 }
 
-static bool pointIsClippedBySurfaceOrClipRect(const IntPoint& viewportPoint, CCLayerImpl* layer)
+static bool pointIsClippedBySurfaceOrClipRect(const IntPoint& viewportPoint, LayerImpl* layer)
 {
-    CCLayerImpl* currentLayer = layer;
+    LayerImpl* currentLayer = layer;
 
     // Walk up the layer tree and hit-test any renderSurfaces and any layer clipRects that are active.
     while (currentLayer) {
         if (currentLayer->renderSurface() && !pointHitsRect(viewportPoint, currentLayer->renderSurface()->screenSpaceTransform(), currentLayer->renderSurface()->contentRect()))
             return true;
 
         // Note that drawableContentRects are actually in targetSurface space, so the transform we
         // have to provide is the target surface's screenSpaceTransform.
-        CCLayerImpl* renderTarget = currentLayer->renderTarget();
+        LayerImpl* renderTarget = currentLayer->renderTarget();
         if (layerClipsSubtree(currentLayer) && !pointHitsRect(viewportPoint, renderTarget->renderSurface()->screenSpaceTransform(), currentLayer->drawableContentRect()))
             return true;
 
         currentLayer = currentLayer->parent();
     }
 
     // If we have finished walking all ancestors without having already exited, then the point is not clipped by any ancestors.
     return false;
 }
 
-CCLayerImpl* CCLayerTreeHostCommon::findLayerThatIsHitByPoint(const IntPoint& viewportPoint, std::vector<CCLayerImpl*>& renderSurfaceLayerList)
+LayerImpl* LayerTreeHostCommon::findLayerThatIsHitByPoint(const IntPoint& viewportPoint, std::vector<LayerImpl*>& renderSurfaceLayerList)
 {
-    CCLayerImpl* foundLayer = 0;
+    LayerImpl* foundLayer = 0;
 
-    typedef CCLayerIterator<CCLayerImpl, std::vector<CCLayerImpl*>, CCRenderSurface, CCLayerIteratorActions::FrontToBack> CCLayerIteratorType;
-    CCLayerIteratorType end = CCLayerIteratorType::end(&renderSurfaceLayerList);
+    typedef LayerIterator<LayerImpl, std::vector<LayerImpl*>, RenderSurfaceImpl, LayerIteratorActions::FrontToBack> LayerIteratorType;
+    LayerIteratorType end = LayerIteratorType::end(&renderSurfaceLayerList);
 
-    for (CCLayerIteratorType it = CCLayerIteratorType::begin(&renderSurfaceLayerList); it != end; ++it) {
+    for (LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList); it != end; ++it) {
         // We don't want to consider renderSurfaces for hit testing.
         if (!it.representsItself())
             continue;
 
-        CCLayerImpl* currentLayer = (*it);
+        LayerImpl* currentLayer = (*it);
 
         FloatRect contentRect(FloatPoint::zero(), currentLayer->contentBounds());
         if (!pointHitsRect(viewportPoint, currentLayer->screenSpaceTransform(), contentRect))
             continue;
 
         // At this point, we think the point does hit the layer, but we need to walk up
         // the parents to ensure that the layer was not clipped in such a way that the
         // hit point actually should not hit the layer.
         if (pointIsClippedBySurfaceOrClipRect(viewportPoint, currentLayer))
             continue;
 
         foundLayer = currentLayer;
         break;
     }
 
     // This can potentially return 0, which means the viewportPoint did not successfully hit test any layers, not even the root layer.
     return foundLayer;
 }
 
 } // namespace cc