cc: Rename cc classes and members to match filenames

cc/layer.h

 // 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.
 
 #ifndef LayerChromium_h
 #define LayerChromium_h
 
 #include "CCLayerAnimationController.h"
 #include "CCOcclusionTracker.h"
 #include "FloatPoint.h"
 #include "Region.h"
 #include "base/memory/ref_counted.h"
 #include "cc/render_surface.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include <public/WebFilterOperations.h>
 #include <public/WebTransformationMatrix.h>
 #include <string>
 #include <vector>
 
 namespace WebKit {
 class WebAnimationDelegate;
 class WebLayerScrollClient;
 }
 
 namespace cc {
 
-class CCActiveAnimation;
-struct CCAnimationEvent;
-class CCLayerAnimationDelegate;
-class CCLayerImpl;
-class CCLayerTreeHost;
-class CCPriorityCalculator;
-class CCTextureUpdateQueue;
-class ScrollbarLayerChromium;
-struct CCAnimationEvent;
-struct CCRenderingStats;
+class ActiveAnimation;
+struct AnimationEvent;
+class LayerAnimationDelegate;
+class LayerImpl;
+class LayerTreeHost;
+class PriorityCalculator;
+class TextureUpdateQueue;
+class ScrollbarLayer;
+struct AnimationEvent;
+struct RenderingStats;
 
 // Base class for composited layers. Special layer types are derived from
 // this class.
-class LayerChromium : public base::RefCounted<LayerChromium>, public CCLayerAnimationControllerClient {
+class Layer : public base::RefCounted<Layer>, public LayerAnimationControllerClient {
 public:
-    typedef std::vector<scoped_refptr<LayerChromium> > LayerList;
+    typedef std::vector<scoped_refptr<Layer> > LayerList;
 
-    static scoped_refptr<LayerChromium> create();
+    static scoped_refptr<Layer> create();
 
-    // 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;
     // A layer's transform operates layer space. That is, entirely in logical,
     // non-page-scaled pixels (that is, they have page zoom baked in, but not page scale).
     // The root layer is a special case -- it operates in physical pixels.
     virtual const WebKit::WebTransformationMatrix& transform() const OVERRIDE;
 
-    LayerChromium* rootLayer();
-    LayerChromium* parent() const;
-    void addChild(scoped_refptr<LayerChromium>);
-    void insertChild(scoped_refptr<LayerChromium>, size_t index);
-    void replaceChild(LayerChromium* reference, scoped_refptr<LayerChromium> newLayer);
+    Layer* rootLayer();
+    Layer* parent() const;
+    void addChild(scoped_refptr<Layer>);
+    void insertChild(scoped_refptr<Layer>, size_t index);
+    void replaceChild(Layer* reference, scoped_refptr<Layer> newLayer);
     void removeFromParent();
     void removeAllChildren();
     void setChildren(const LayerList&);
 
     const LayerList& children() const { return m_children; }
 
     void setAnchorPoint(const FloatPoint&);
     FloatPoint anchorPoint() const { return m_anchorPoint; }
 
     void setAnchorPointZ(float);
     float anchorPointZ() const { return m_anchorPointZ; }
 
     void setBackgroundColor(SkColor);
     SkColor backgroundColor() const { return m_backgroundColor; }
 
     // A layer's bounds are in logical, non-page-scaled pixels (however, the
     // root layer's bounds are in physical pixels).
     void setBounds(const IntSize&);
     const IntSize& bounds() const { return m_bounds; }
     virtual IntSize contentBounds() const;
 
     void setMasksToBounds(bool);
     bool masksToBounds() const { return m_masksToBounds; }
 
-    void setMaskLayer(LayerChromium*);
-    LayerChromium* maskLayer() const { return m_maskLayer.get(); }
+    void setMaskLayer(Layer*);
+    Layer* maskLayer() const { return m_maskLayer.get(); }
 
     virtual void setNeedsDisplayRect(const FloatRect& dirtyRect);
     void setNeedsDisplay() { setNeedsDisplayRect(FloatRect(FloatPoint(), bounds())); }
     virtual bool needsDisplay() const;
 
     void setOpacity(float);
     bool opacityIsAnimating() const;
 
     void setFilters(const WebKit::WebFilterOperations&);
     const WebKit::WebFilterOperations& filters() const { return m_filters; }
@@ skipping 61 matching lines @@
 
     void setPreserves3D(bool preserve3D) { m_preserves3D = preserve3D; }
     bool preserves3D() const { return m_preserves3D; }
 
     void setUseParentBackfaceVisibility(bool useParentBackfaceVisibility) { m_useParentBackfaceVisibility = useParentBackfaceVisibility; }
     bool useParentBackfaceVisibility() const { return m_useParentBackfaceVisibility; }
 
     virtual void setUseLCDText(bool);
     bool useLCDText() const { return m_useLCDText; }
 
-    virtual void setLayerTreeHost(CCLayerTreeHost*);
+    virtual void setLayerTreeHost(LayerTreeHost*);
 
     bool hasContributingDelegatedRenderPasses() const { return false; }
 
     void setIsDrawable(bool);
 
-    void setReplicaLayer(LayerChromium*);
-    LayerChromium* replicaLayer() const { return m_replicaLayer.get(); }
+    void setReplicaLayer(Layer*);
+    Layer* 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); }
 
     // These methods typically need to be overwritten by derived classes.
     virtual bool drawsContent() const;
-    virtual void update(CCTextureUpdateQueue&, const CCOcclusionTracker*, CCRenderingStats&) { }
+    virtual void update(TextureUpdateQueue&, const OcclusionTracker*, RenderingStats&) { }
     virtual bool needMoreUpdates();
     virtual void setIsMask(bool) { }
     virtual void bindContentsTexture() { }
     virtual bool needsContentsScale() const;
 
     void setDebugBorderColor(SkColor);
     void setDebugBorderWidth(float);
     void setDebugName(const std::string&);
 
-    virtual void pushPropertiesTo(CCLayerImpl*);
+    virtual void pushPropertiesTo(LayerImpl*);
 
     void clearRenderSurface() { m_renderSurface.reset(); }
-    RenderSurfaceChromium* renderSurface() const { return m_renderSurface.get(); }
+    RenderSurface* renderSurface() const { return m_renderSurface.get(); }
     void createRenderSurface();
 
     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; }
 
-    LayerChromium* renderTarget() const { ASSERT(!m_renderTarget || m_renderTarget->renderSurface()); return m_renderTarget; }
-    void setRenderTarget(LayerChromium* target) { m_renderTarget = target; }
+    Layer* renderTarget() const { ASSERT(!m_renderTarget || m_renderTarget->renderSurface()); return m_renderTarget; }
+    void setRenderTarget(Layer* target) { m_renderTarget = target; }
 
     bool drawTransformIsAnimating() const { return m_drawTransformIsAnimating; }
     void setDrawTransformIsAnimating(bool animating) { m_drawTransformIsAnimating = animating; }
     bool screenSpaceTransformIsAnimating() const { return m_screenSpaceTransformIsAnimating; }
     void setScreenSpaceTransformIsAnimating(bool animating) { m_screenSpaceTransformIsAnimating = animating; }
 
     // This moves from layer space, with origin in the center to target space with origin in the top left.
     // That is, it converts from logical, non-page-scaled, to target pixels (and if the target is the
     // root render surface, then this converts to physical pixels).
     const WebKit::WebTransformationMatrix& drawTransform() const { return m_drawTransform; }
@@ skipping 10 matching lines @@
     void setContentsScale(float);
 
     // When true, the layer's contents are not scaled by the current page scale factor.
     // setBoundsContainPageScale recursively sets the value on all child layers.
     void setBoundsContainPageScale(bool);
     bool boundsContainPageScale() const { return m_boundsContainPageScale; }
 
     // Returns true if any of the layer's descendants has content to draw.
     bool descendantDrawsContent();
 
-    CCLayerTreeHost* layerTreeHost() const { return m_layerTreeHost; }
+    LayerTreeHost* layerTreeHost() const { return m_layerTreeHost; }
 
     // Set the priority of all desired textures in this layer.
-    virtual void setTexturePriorities(const CCPriorityCalculator&) { }
+    virtual void setTexturePriorities(const PriorityCalculator&) { }
 
-    bool addAnimation(scoped_ptr<CCActiveAnimation>);
+    bool addAnimation(scoped_ptr<ActiveAnimation>);
     void pauseAnimation(int animationId, double timeOffset);
     void removeAnimation(int animationId);
 
     void suspendAnimations(double monotonicTime);
     void resumeAnimations(double monotonicTime);
 
-    CCLayerAnimationController* layerAnimationController() { return m_layerAnimationController.get(); }
-    void setLayerAnimationController(scoped_ptr<CCLayerAnimationController>);
-    scoped_ptr<CCLayerAnimationController> releaseLayerAnimationController();
+    LayerAnimationController* layerAnimationController() { return m_layerAnimationController.get(); }
+    void setLayerAnimationController(scoped_ptr<LayerAnimationController>);
+    scoped_ptr<LayerAnimationController> releaseLayerAnimationController();
 
     void setLayerAnimationDelegate(WebKit::WebAnimationDelegate* layerAnimationDelegate) { m_layerAnimationDelegate = layerAnimationDelegate; }
 
     bool hasActiveAnimation() const;
 
-    virtual void notifyAnimationStarted(const CCAnimationEvent&, double wallClockTime);
+    virtual void notifyAnimationStarted(const AnimationEvent&, double wallClockTime);
     virtual void notifyAnimationFinished(double wallClockTime);
 
     virtual Region visibleContentOpaqueRegion() const;
 
-    virtual ScrollbarLayerChromium* toScrollbarLayerChromium();
+    virtual ScrollbarLayer* toScrollbarLayer();
 
 protected:
-    friend class CCLayerImpl;
+    friend class LayerImpl;
     friend class TreeSynchronizer;
-    virtual ~LayerChromium();
+    virtual ~Layer();
 
-    LayerChromium();
+    Layer();
 
     void setNeedsCommit();
 
     IntRect layerRectToContentRect(const WebKit::WebRect& layerRect);
 
     // This flag is set when layer need repainting/updating.
     bool m_needsDisplay;
 
     // Tracks whether this layer may have changed stacking order with its siblings.
     bool m_stackingOrderChanged;
 
     // The update rect is the region of the compositor resource that was actually updated by the compositor.
     // For layers that may do updating outside the compositor's control (i.e. plugin layers), this information
     // is not available and the update rect will remain empty.
     // Note this rect is in layer space (not content space).
     FloatRect m_updateRect;
 
-    scoped_refptr<LayerChromium> m_maskLayer;
+    scoped_refptr<Layer> m_maskLayer;
 
-    // Constructs a CCLayerImpl of the correct runtime type for this LayerChromium type.
-    virtual scoped_ptr<CCLayerImpl> createCCLayerImpl();
+    // Constructs a LayerImpl of the correct runtime type for this Layer type.
+    virtual scoped_ptr<LayerImpl> createLayerImpl();
     int m_layerId;
 
 private:
-    friend class base::RefCounted<LayerChromium>;
+    friend class base::RefCounted<Layer>;
 
-    void setParent(LayerChromium*);
-    bool hasAncestor(LayerChromium*) const;
+    void setParent(Layer*);
+    bool hasAncestor(Layer*) const;
     bool descendantIsFixedToContainerLayer() const;
 
     size_t numChildren() const { return m_children.size(); }
 
     // Returns the index of the child or -1 if not found.
-    int indexOfChild(const LayerChromium*);
+    int indexOfChild(const Layer*);
 
     // This should only be called from removeFromParent.
-    void removeChild(LayerChromium*);
+    void removeChild(Layer*);
 
     LayerList m_children;
-    LayerChromium* m_parent;
+    Layer* m_parent;
 
-    // LayerChromium instances have a weak pointer to their CCLayerTreeHost.
-    // This pointer value is nil when a LayerChromium is not in a tree and is
+    // Layer instances have a weak pointer to their LayerTreeHost.
+    // This pointer value is nil when a Layer is not in a tree and is
     // updated via setLayerTreeHost() if a layer moves between trees.
-    CCLayerTreeHost* m_layerTreeHost;
+    LayerTreeHost* m_layerTreeHost;
 
-    scoped_ptr<CCLayerAnimationController> m_layerAnimationController;
+    scoped_ptr<LayerAnimationController> m_layerAnimationController;
 
     // Layer properties.
     IntSize m_bounds;
 
     // Uses layer's content space.
     IntRect m_visibleContentRect;
 
     IntPoint m_scrollPosition;
     IntSize m_maxScrollPosition;
     bool m_scrollable;
@@ skipping 20 matching lines @@
     bool m_useLCDText;
     bool m_preserves3D;
     bool m_useParentBackfaceVisibility;
     bool m_drawCheckerboardForMissingTiles;
     bool m_forceRenderSurface;
 
     WebKit::WebTransformationMatrix m_transform;
     WebKit::WebTransformationMatrix m_sublayerTransform;
 
     // Replica layer used for reflections.
-    scoped_refptr<LayerChromium> m_replicaLayer;
+    scoped_refptr<Layer> m_replicaLayer;
 
     // Transient properties.
-    scoped_ptr<RenderSurfaceChromium> m_renderSurface;
+    scoped_ptr<RenderSurface> m_renderSurface;
     float m_drawOpacity;
     bool m_drawOpacityIsAnimating;
 
-    LayerChromium* m_renderTarget;
+    Layer* m_renderTarget;
 
     WebKit::WebTransformationMatrix m_drawTransform;
     WebKit::WebTransformationMatrix m_screenSpaceTransform;
     bool m_drawTransformIsAnimating;
     bool m_screenSpaceTransformIsAnimating;
 
     // Uses target surface space.
     IntRect m_drawableContentRect;
     float m_contentsScale;
     bool m_boundsContainPageScale;
 
     WebKit::WebTransformationMatrix m_implTransform;
 
     WebKit::WebAnimationDelegate* m_layerAnimationDelegate;
     WebKit::WebLayerScrollClient* m_layerScrollClient;
 };
 
-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*);
 
 }  // namespace cc
 
 #endif