cc: Rename cc classes and members to match filenames

cc/layer_impl.h

 // 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.
 
 #ifndef CCLayerImpl_h
 #define CCLayerImpl_h
 
 #include "base/memory/scoped_ptr.h"
 #include "cc/scoped_ptr_vector.h"
 #include "CCInputHandler.h"
 #include "CCLayerAnimationController.h"
 #include "CCRenderPass.h"
 #include "CCRenderSurface.h"
 #include "CCResourceProvider.h"
 #include "CCSharedQuadState.h"
 #include "FloatRect.h"
 #include "IntRect.h"
 #include "Region.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include <public/WebFilterOperations.h>
 #include <public/WebTransformationMatrix.h>
 #include <string>
 
 namespace cc {
 
-class CCLayerSorter;
-class CCLayerTreeHostImpl;
-class CCQuadSink;
-class CCRenderer;
-class CCScrollbarAnimationController;
-class CCScrollbarLayerImpl;
-class LayerChromium;
+class LayerSorter;
+class LayerTreeHostImpl;
+class QuadSink;
+class Renderer;
+class ScrollbarAnimationController;
+class ScrollbarLayerImpl;
+class Layer;
 
-struct CCAppendQuadsData;
+struct AppendQuadsData;
 
-class CCLayerImpl : public CCLayerAnimationControllerClient {
+class LayerImpl : public LayerAnimationControllerClient {
 public:
-    static scoped_ptr<CCLayerImpl> create(int id)
+    static scoped_ptr<LayerImpl> create(int id)
     {
-        return make_scoped_ptr(new CCLayerImpl(id));
+        return make_scoped_ptr(new LayerImpl(id));
     }
 
-    virtual ~CCLayerImpl();
+    virtual ~LayerImpl();
 
-    // CCLayerAnimationControllerClient implementation.
+    // LayerAnimationControllerClient implementation.
     virtual int id() const OVERRIDE;
     virtual void setOpacityFromAnimation(float) OVERRIDE;
     virtual float opacity() const OVERRIDE;
     virtual void setTransformFromAnimation(const WebKit::WebTransformationMatrix&) OVERRIDE;
     virtual const WebKit::WebTransformationMatrix& transform() const OVERRIDE;
 
     // Tree structure.
-    CCLayerImpl* parent() const { return m_parent; }
-    const ScopedPtrVector<CCLayerImpl>& children() const { return m_children; }
-    void addChild(scoped_ptr<CCLayerImpl>);
+    LayerImpl* parent() const { return m_parent; }
+    const ScopedPtrVector<LayerImpl>& children() const { return m_children; }
+    void addChild(scoped_ptr<LayerImpl>);
     void removeFromParent();
     void removeAllChildren();
 
-    void setMaskLayer(scoped_ptr<CCLayerImpl>);
-    CCLayerImpl* maskLayer() const { return m_maskLayer.get(); }
+    void setMaskLayer(scoped_ptr<LayerImpl>);
+    LayerImpl* maskLayer() const { return m_maskLayer.get(); }
 
-    void setReplicaLayer(scoped_ptr<CCLayerImpl>);
-    CCLayerImpl* replicaLayer() const { return m_replicaLayer.get(); }
+    void setReplicaLayer(scoped_ptr<LayerImpl>);
+    LayerImpl* replicaLayer() const { return m_replicaLayer.get(); }
 
     bool hasMask() const { return m_maskLayer; }
     bool hasReplica() const { return m_replicaLayer; }
     bool replicaHasMask() const { return m_replicaLayer && (m_maskLayer || m_replicaLayer->m_maskLayer); }
 
-    CCLayerTreeHostImpl* layerTreeHostImpl() const { return m_layerTreeHostImpl; }
-    void setLayerTreeHostImpl(CCLayerTreeHostImpl* hostImpl) { m_layerTreeHostImpl = hostImpl; }
+    LayerTreeHostImpl* layerTreeHostImpl() const { return m_layerTreeHostImpl; }
+    void setLayerTreeHostImpl(LayerTreeHostImpl* hostImpl) { m_layerTreeHostImpl = hostImpl; }
 
-    scoped_ptr<CCSharedQuadState> createSharedQuadState() const;
+    scoped_ptr<SharedQuadState> createSharedQuadState() const;
     // willDraw must be called before appendQuads. If willDraw is called,
     // didDraw is guaranteed to be called before another willDraw or before
     // the layer is destroyed. To enforce this, any class that overrides
     // willDraw/didDraw must call the base class version.
-    virtual void willDraw(CCResourceProvider*);
-    virtual void appendQuads(CCQuadSink&, CCAppendQuadsData&) { }
-    virtual void didDraw(CCResourceProvider*);
+    virtual void willDraw(ResourceProvider*);
+    virtual void appendQuads(QuadSink&, AppendQuadsData&) { }
+    virtual void didDraw(ResourceProvider*);
 
-    virtual CCResourceProvider::ResourceId contentsResourceId() const;
+    virtual ResourceProvider::ResourceId contentsResourceId() const;
 
     virtual bool hasContributingDelegatedRenderPasses() const;
-    virtual CCRenderPass::Id firstContributingRenderPassId() const;
-    virtual CCRenderPass::Id nextContributingRenderPassId(CCRenderPass::Id) const;
+    virtual RenderPass::Id firstContributingRenderPassId() const;
+    virtual RenderPass::Id nextContributingRenderPassId(RenderPass::Id) const;
 
     // Returns true if this layer has content to draw.
     void setDrawsContent(bool);
     bool drawsContent() const { return m_drawsContent; }
 
     bool forceRenderSurface() const { return m_forceRenderSurface; }
     void setForceRenderSurface(bool force) { m_forceRenderSurface = force; }
 
     // Returns true if any of the layer's descendants has content to draw.
     virtual bool descendantDrawsContent();
@@ skipping 47 matching lines @@
     void setDebugBorderColor(SkColor);
     SkColor debugBorderColor() const { return m_debugBorderColor; }
     void setDebugBorderWidth(float);
     float debugBorderWidth() const { return m_debugBorderWidth; }
     bool hasDebugBorders() const;
 
     // Debug layer name.
     void setDebugName(const std::string& debugName) { m_debugName = debugName; }
     std::string debugName() const { return m_debugName; }
 
-    CCRenderSurface* renderSurface() const { return m_renderSurface.get(); }
+    RenderSurfaceImpl* renderSurface() const { return m_renderSurface.get(); }
     void createRenderSurface();
     void clearRenderSurface() { m_renderSurface.reset(); }
 
     float drawOpacity() const { return m_drawOpacity; }
     void setDrawOpacity(float opacity) { m_drawOpacity = opacity; }
 
     bool drawOpacityIsAnimating() const { return m_drawOpacityIsAnimating; }
     void setDrawOpacityIsAnimating(bool drawOpacityIsAnimating) { m_drawOpacityIsAnimating = drawOpacityIsAnimating; }
 
-    CCLayerImpl* renderTarget() const { ASSERT(!m_renderTarget || m_renderTarget->renderSurface()); return m_renderTarget; }
-    void setRenderTarget(CCLayerImpl* target) { m_renderTarget = target; }
+    LayerImpl* renderTarget() const { ASSERT(!m_renderTarget || m_renderTarget->renderSurface()); return m_renderTarget; }
+    void setRenderTarget(LayerImpl* target) { m_renderTarget = target; }
 
     void setBounds(const IntSize&);
     const IntSize& bounds() const { return m_bounds; }
 
     const IntSize& contentBounds() const { return m_contentBounds; }
     void setContentBounds(const IntSize&);
 
     const IntPoint& scrollPosition() const { return m_scrollPosition; }
     void setScrollPosition(const IntPoint&);
 
@@ skipping 20 matching lines @@
 
     bool haveWheelEventHandlers() const { return m_haveWheelEventHandlers; }
     void setHaveWheelEventHandlers(bool haveWheelEventHandlers) { m_haveWheelEventHandlers = haveWheelEventHandlers; }
 
     const Region& nonFastScrollableRegion() const { return m_nonFastScrollableRegion; }
     void setNonFastScrollableRegion(const Region& region) { m_nonFastScrollableRegion = region; }
 
     void setDrawCheckerboardForMissingTiles(bool checkerboard) { m_drawCheckerboardForMissingTiles = checkerboard; }
     bool drawCheckerboardForMissingTiles() const;
 
-    CCInputHandlerClient::ScrollStatus tryScroll(const IntPoint& viewportPoint, CCInputHandlerClient::ScrollInputType) const;
+    InputHandlerClient::ScrollStatus tryScroll(const IntPoint& viewportPoint, InputHandlerClient::ScrollInputType) const;
 
     const IntRect& visibleContentRect() const { return m_visibleContentRect; }
     void setVisibleContentRect(const IntRect& visibleContentRect) { m_visibleContentRect = visibleContentRect; }
 
     bool doubleSided() const { return m_doubleSided; }
     void setDoubleSided(bool);
 
     void setTransform(const WebKit::WebTransformationMatrix&);
     bool transformIsAnimating() const;
 
@@ skipping 16 matching lines @@
 
     void setStackingOrderChanged(bool);
 
     bool layerPropertyChanged() const { return m_layerPropertyChanged || layerIsAlwaysDamaged(); }
     bool layerSurfacePropertyChanged() const;
 
     void resetAllChangeTrackingForSubtree();
 
     virtual bool layerIsAlwaysDamaged() const;
 
-    CCLayerAnimationController* layerAnimationController() { return m_layerAnimationController.get(); }
+    LayerAnimationController* layerAnimationController() { return m_layerAnimationController.get(); }
 
     virtual Region visibleContentOpaqueRegion() const;
 
     // Indicates that the context previously used to render this layer
     // was lost and that a new one has been created. Won't be called
     // until the new context has been created successfully.
     virtual void didLoseContext();
 
-    CCScrollbarAnimationController* scrollbarAnimationController() const { return m_scrollbarAnimationController.get(); }
+    ScrollbarAnimationController* scrollbarAnimationController() const { return m_scrollbarAnimationController.get(); }
 
-    CCScrollbarLayerImpl* horizontalScrollbarLayer() const;
-    void setHorizontalScrollbarLayer(CCScrollbarLayerImpl*);
+    ScrollbarLayerImpl* horizontalScrollbarLayer() const;
+    void setHorizontalScrollbarLayer(ScrollbarLayerImpl*);
 
-    CCScrollbarLayerImpl* verticalScrollbarLayer() const;
-    void setVerticalScrollbarLayer(CCScrollbarLayerImpl*);
+    ScrollbarLayerImpl* verticalScrollbarLayer() const;
+    void setVerticalScrollbarLayer(ScrollbarLayerImpl*);
 
 protected:
-    explicit CCLayerImpl(int);
+    explicit LayerImpl(int);
 
-    void appendDebugBorderQuad(CCQuadSink&, const CCSharedQuadState*, CCAppendQuadsData&) const;
+    void appendDebugBorderQuad(QuadSink&, const SharedQuadState*, AppendQuadsData&) const;
 
     IntRect layerRectToContentRect(const WebKit::WebRect& layerRect);
 
     virtual void dumpLayerProperties(std::string*, int indent) const;
     static std::string indentString(int indent);
 
 private:
-    void setParent(CCLayerImpl* parent) { m_parent = parent; }
+    void setParent(LayerImpl* parent) { m_parent = parent; }
     friend class TreeSynchronizer;
     void clearChildList(); // Warning: This does not preserve tree structure invariants and so is only exposed to the tree synchronizer.
 
     void noteLayerPropertyChangedForSubtree();
 
     // Note carefully this does not affect the current layer.
     void noteLayerPropertyChangedForDescendants();
 
     virtual const char* layerTypeAsString() const;
 
     void dumpLayer(std::string*, int indent) const;
 
-    // Properties internal to CCLayerImpl
-    CCLayerImpl* m_parent;
-    ScopedPtrVector<CCLayerImpl> m_children;
+    // Properties internal to LayerImpl
+    LayerImpl* m_parent;
+    ScopedPtrVector<LayerImpl> m_children;
     // m_maskLayer can be temporarily stolen during tree sync, we need this ID to confirm newly assigned layer is still the previous one
     int m_maskLayerId;
-    scoped_ptr<CCLayerImpl> m_maskLayer;
+    scoped_ptr<LayerImpl> m_maskLayer;
     int m_replicaLayerId; // ditto
-    scoped_ptr<CCLayerImpl> m_replicaLayer;
+    scoped_ptr<LayerImpl> m_replicaLayer;
     int m_layerId;
-    CCLayerTreeHostImpl* m_layerTreeHostImpl;
+    LayerTreeHostImpl* m_layerTreeHostImpl;
 
-    // Properties synchronized from the associated LayerChromium.
+    // Properties synchronized from the associated Layer.
     FloatPoint m_anchorPoint;
     float m_anchorPointZ;
     IntSize m_bounds;
     IntSize m_contentBounds;
     IntPoint m_scrollPosition;
     bool m_scrollable;
     bool m_shouldScrollOnMainThread;
     bool m_haveWheelEventHandlers;
     Region m_nonFastScrollableRegion;
     SkColor m_backgroundColor;
@@ skipping 32 matching lines @@
     bool m_fixedToContainerLayer;
 
     FloatSize m_scrollDelta;
     IntSize m_sentScrollDelta;
     IntSize m_maxScrollPosition;
     WebKit::WebTransformationMatrix m_implTransform;
 
     // The layer whose coordinate space this layer draws into. This can be
     // either the same layer (m_renderTarget == this) or an ancestor of this
     // layer.
-    CCLayerImpl* m_renderTarget;
+    LayerImpl* m_renderTarget;
 
     // The global depth value of the center of the layer. This value is used
     // to sort layers from back to front.
     float m_drawDepth;
     float m_drawOpacity;
     bool m_drawOpacityIsAnimating;
 
     // Debug borders.
     SkColor m_debugBorderColor;
     float m_debugBorderWidth;
 
     // Debug layer name.
     std::string m_debugName;
 
     WebKit::WebFilterOperations m_filters;
     WebKit::WebFilterOperations m_backgroundFilters;
 
     WebKit::WebTransformationMatrix m_drawTransform;
     WebKit::WebTransformationMatrix m_screenSpaceTransform;
     bool m_drawTransformIsAnimating;
     bool m_screenSpaceTransformIsAnimating;
 
 #ifndef NDEBUG
     bool m_betweenWillDrawAndDidDraw;
 #endif
 
     // Render surface associated with this layer. The layer and its descendants
     // will render to this surface.
-    scoped_ptr<CCRenderSurface> m_renderSurface;
+    scoped_ptr<RenderSurfaceImpl> m_renderSurface;
 
     // Hierarchical bounding rect containing the layer and its descendants.
     // Uses target surface's space.
     IntRect m_drawableContentRect;
 
     // Rect indicating what was repainted/updated during update.
     // Note that plugin layers bypass this and leave it empty.
     // Uses layer's content space.
     FloatRect m_updateRect;
 
     // Manages animations for this layer.
-    scoped_ptr<CCLayerAnimationController> m_layerAnimationController;
+    scoped_ptr<LayerAnimationController> m_layerAnimationController;
 
     // Manages scrollbars for this layer
-    scoped_ptr<CCScrollbarAnimationController> m_scrollbarAnimationController;
+    scoped_ptr<ScrollbarAnimationController> m_scrollbarAnimationController;
 };
 
-void sortLayers(std::vector<CCLayerImpl*>::iterator first, std::vector<CCLayerImpl*>::iterator end, CCLayerSorter*);
+void sortLayers(std::vector<LayerImpl*>::iterator first, std::vector<LayerImpl*>::iterator end, LayerSorter*);
 
 }
 
 #endif // CCLayerImpl_h