cc/CCLayerImpl.h - Issue 11122003: [cc] Rename all cc/ filenames to Chromium style

Unified Diff: cc/CCLayerImpl.h

Issue 11122003: [cc] Rename all cc/ filenames to Chromium style (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src

Patch Set: Created 8 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: cc/CCLayerImpl.h

diff --git a/cc/CCLayerImpl.h b/cc/CCLayerImpl.h

index e34ccc86a03735ced93f7b813cb97882335725d9..2f36527df274fdac628371c9a5b2d4e93ff469a1 100644

--- a/cc/CCLayerImpl.h

+++ b/cc/CCLayerImpl.h

@@ -1,399 +1,6 @@

// 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 "SkColor.h"

-#include <public/WebFilterOperations.h>

-#include <public/WebTransformationMatrix.h>

-#include <string>

-#include <wtf/OwnPtr.h>

-namespace cc {

-class CCLayerSorter;

-class CCLayerTreeHostImpl;

-class CCQuadSink;

-class CCRenderer;

-class CCScrollbarAnimationController;

-class CCScrollbarLayerImpl;

-class LayerChromium;

-struct CCAppendQuadsData;

-class CCLayerImpl : public CCLayerAnimationControllerClient {

-public:

- static scoped_ptr<CCLayerImpl> create(int id)

- {

- return make_scoped_ptr(new CCLayerImpl(id));

- }

- virtual ~CCLayerImpl();

- // CCLayerAnimationControllerClient 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>);

- void removeFromParent();

- void removeAllChildren();

- void setMaskLayer(scoped_ptr<CCLayerImpl>);

- CCLayerImpl* maskLayer() const { return m_maskLayer.get(); }

- void setReplicaLayer(scoped_ptr<CCLayerImpl>);

- CCLayerImpl* 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; }

- scoped_ptr<CCSharedQuadState> 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 CCResourceProvider::ResourceId contentsResourceId() const;

- virtual bool hasContributingDelegatedRenderPasses() const;

- virtual CCRenderPass::Id firstContributingRenderPassId() const;

- virtual CCRenderPass::Id nextContributingRenderPassId(CCRenderPass::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();

- void setAnchorPoint(const FloatPoint&);

- const FloatPoint& anchorPoint() const { return m_anchorPoint; }

- void setAnchorPointZ(float);

- float anchorPointZ() const { return m_anchorPointZ; }

- void setBackgroundColor(SkColor);

- SkColor backgroundColor() const { return m_backgroundColor; }

- void setFilters(const WebKit::WebFilterOperations&);

- const WebKit::WebFilterOperations& filters() const { return m_filters; }

- void setBackgroundFilters(const WebKit::WebFilterOperations&);

- const WebKit::WebFilterOperations& backgroundFilters() const { return m_backgroundFilters; }

- void setMasksToBounds(bool);

- bool masksToBounds() const { return m_masksToBounds; }

- void setContentsOpaque(bool);

- bool contentsOpaque() const { return m_contentsOpaque; }

- void setOpacity(float);

- bool opacityIsAnimating() const;

- void setPosition(const FloatPoint&);

- const FloatPoint& position() const { return m_position; }

- void setIsContainerForFixedPositionLayers(bool isContainerForFixedPositionLayers) { m_isContainerForFixedPositionLayers = isContainerForFixedPositionLayers; }

- bool isContainerForFixedPositionLayers() const { return m_isContainerForFixedPositionLayers; }

- void setFixedToContainerLayer(bool fixedToContainerLayer = true) { m_fixedToContainerLayer = fixedToContainerLayer;}

- bool fixedToContainerLayer() const { return m_fixedToContainerLayer; }

- void setPreserves3D(bool);

- bool preserves3D() const { return m_preserves3D; }

- void setUseParentBackfaceVisibility(bool useParentBackfaceVisibility) { m_useParentBackfaceVisibility = useParentBackfaceVisibility; }

- bool useParentBackfaceVisibility() const { return m_useParentBackfaceVisibility; }

- void setUseLCDText(bool useLCDText) { m_useLCDText = useLCDText; }

- bool useLCDText() const { return m_useLCDText; }

- void setSublayerTransform(const WebKit::WebTransformationMatrix&);

- const WebKit::WebTransformationMatrix& sublayerTransform() const { return m_sublayerTransform; }

- // Debug layer border - visual effect only, do not change geometry/clipping/etc.

- 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(); }

- void createRenderSurface();

- void clearRenderSurface() { m_renderSurface.clear(); }

- 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; }

- 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&);

- const IntSize& maxScrollPosition() const {return m_maxScrollPosition; }

- void setMaxScrollPosition(const IntSize&);

- const FloatSize& scrollDelta() const { return m_scrollDelta; }

- void setScrollDelta(const FloatSize&);

- const WebKit::WebTransformationMatrix& implTransform() const { return m_implTransform; }

- void setImplTransform(const WebKit::WebTransformationMatrix& transform);

- const IntSize& sentScrollDelta() const { return m_sentScrollDelta; }

- void setSentScrollDelta(const IntSize& sentScrollDelta) { m_sentScrollDelta = sentScrollDelta; }

- // Returns the delta of the scroll that was outside of the bounds of the initial scroll

- FloatSize scrollBy(const FloatSize& scroll);

- bool scrollable() const { return m_scrollable; }

- void setScrollable(bool scrollable) { m_scrollable = scrollable; }

- bool shouldScrollOnMainThread() const { return m_shouldScrollOnMainThread; }

- void setShouldScrollOnMainThread(bool shouldScrollOnMainThread) { m_shouldScrollOnMainThread = shouldScrollOnMainThread; }

- 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;

- 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;

- const WebKit::WebTransformationMatrix& drawTransform() const { return m_drawTransform; }

- void setDrawTransform(const WebKit::WebTransformationMatrix& matrix) { m_drawTransform = matrix; }

- const WebKit::WebTransformationMatrix& screenSpaceTransform() const { return m_screenSpaceTransform; }

- void setScreenSpaceTransform(const WebKit::WebTransformationMatrix& matrix) { m_screenSpaceTransform = matrix; }

- 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; }

- const IntRect& drawableContentRect() const { return m_drawableContentRect; }

- void setDrawableContentRect(const IntRect& rect) { m_drawableContentRect = rect; }

- const FloatRect& updateRect() const { return m_updateRect; }

- void setUpdateRect(const FloatRect& updateRect) { m_updateRect = updateRect; }

- std::string layerTreeAsText() const;

- 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(); }

- 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(); }

- CCScrollbarLayerImpl* horizontalScrollbarLayer() const;

- void setHorizontalScrollbarLayer(CCScrollbarLayerImpl*);

- CCScrollbarLayerImpl* verticalScrollbarLayer() const;

- void setVerticalScrollbarLayer(CCScrollbarLayerImpl*);

-protected:

- explicit CCLayerImpl(int);

- void appendDebugBorderQuad(CCQuadSink&, const CCSharedQuadState*, CCAppendQuadsData&) 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; }

- 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;

- // 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;

- int m_replicaLayerId; // ditto

- scoped_ptr<CCLayerImpl> m_replicaLayer;

- int m_layerId;

- CCLayerTreeHostImpl* m_layerTreeHostImpl;

- // Properties synchronized from the associated LayerChromium.

- 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;

- // Whether the "back" of this layer should draw.

- bool m_doubleSided;

- // Tracks if drawing-related properties have changed since last redraw.

- bool m_layerPropertyChanged;

- // Indicates that a property has changed on this layer that would not

- // affect the pixels on its target surface, but would require redrawing

- // but would require redrawing the targetSurface onto its ancestor targetSurface.

- // For layers that do not own a surface this flag acts as m_layerPropertyChanged.

- bool m_layerSurfacePropertyChanged;

- // Uses layer's content space.

- IntRect m_visibleContentRect;

- bool m_masksToBounds;

- bool m_contentsOpaque;

- float m_opacity;

- FloatPoint m_position;

- bool m_preserves3D;

- bool m_useParentBackfaceVisibility;

- bool m_drawCheckerboardForMissingTiles;

- WebKit::WebTransformationMatrix m_sublayerTransform;

- WebKit::WebTransformationMatrix m_transform;

- bool m_useLCDText;

- bool m_drawsContent;

- bool m_forceRenderSurface;

- // Set for the layer that other layers are fixed to.

- bool m_isContainerForFixedPositionLayers;

- // This is true if the layer should be fixed to the closest ancestor container.

- 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;

- // 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.

- OwnPtr<CCRenderSurface> 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;

- // Manages scrollbars for this layer

- OwnPtr<CCScrollbarAnimationController> m_scrollbarAnimationController;

-};

-void sortLayers(std::vector<CCLayerImpl*>::iterator first, std::vector<CCLayerImpl*>::iterator end, CCLayerSorter*);

-#endif // CCLayerImpl_h

+// Temporary forwarding header

+#include "cc/layer_impl.h"

« no previous file with comments | « cc/CCLayerAnimationController.cpp ('k') | cc/CCLayerImpl.cpp » ('j') | no next file with comments »