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

Unified Diff: cc/LayerChromium.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/LayerChromium.h

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

index a87caa0ca370dec51668a55af8c4690855328e9d..ea56428ac7f52415c5460abeeaf9322745bc16cd 100644

--- a/cc/LayerChromium.h

+++ b/cc/LayerChromium.h

@@ -1,390 +1,6 @@

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

-#if USE(ACCELERATED_COMPOSITING)

-#include "base/memory/ref_counted.h"

-#include "CCLayerAnimationController.h"

-#include "CCOcclusionTracker.h"

-#include "FloatPoint.h"

-#include "Region.h"

-#include "RenderSurfaceChromium.h"

-#include "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;

-// Base class for composited layers. Special layer types are derived from

-// this class.

-class LayerChromium : public base::RefCounted<LayerChromium>, public CCLayerAnimationControllerClient {

-public:

- typedef std::vector<scoped_refptr<LayerChromium> > LayerList;

- static scoped_refptr<LayerChromium> create();

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

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

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

- // Background filters are filters applied to what is behind this layer, when they are viewed through non-opaque

- // regions in this layer. They are used through the WebLayer interface, and are not exposed to HTML.

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

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

- virtual void setContentsOpaque(bool);

- bool contentsOpaque() const { return m_contentsOpaque; }

- void setPosition(const FloatPoint&);

- FloatPoint position() const { return m_position; }

- void setIsContainerForFixedPositionLayers(bool);

- bool isContainerForFixedPositionLayers() const { return m_isContainerForFixedPositionLayers; }

- void setFixedToContainerLayer(bool);

- bool fixedToContainerLayer() const { return m_fixedToContainerLayer; }

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

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

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

- bool transformIsAnimating() const;

- const IntRect& visibleContentRect() const { return m_visibleContentRect; }

- void setVisibleContentRect(const IntRect& visibleContentRect) { m_visibleContentRect = visibleContentRect; }

- void setScrollPosition(const IntPoint&);

- const IntPoint& scrollPosition() const { return m_scrollPosition; }

- void setMaxScrollPosition(const IntSize&);

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

- void setScrollable(bool);

- bool scrollable() const { return m_scrollable; }

- void setShouldScrollOnMainThread(bool);

- bool shouldScrollOnMainThread() const { return m_shouldScrollOnMainThread; }

- void setHaveWheelEventHandlers(bool);

- bool haveWheelEventHandlers() const { return m_haveWheelEventHandlers; }

- void setNonFastScrollableRegion(const Region&);

- void setNonFastScrollableRegionChanged() { m_nonFastScrollableRegionChanged = true; }

- const Region& nonFastScrollableRegion() const { return m_nonFastScrollableRegion; }

- void setLayerScrollClient(WebKit::WebLayerScrollClient* layerScrollClient) { m_layerScrollClient = layerScrollClient; }

- void setDrawCheckerboardForMissingTiles(bool);

- bool drawCheckerboardForMissingTiles() const { return m_drawCheckerboardForMissingTiles; }

- bool forceRenderSurface() const { return m_forceRenderSurface; }

- void setForceRenderSurface(bool);

- IntSize scrollDelta() const { return IntSize(); }

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

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

- void setDoubleSided(bool);

- bool doubleSided() const { return m_doubleSided; }

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

- bool hasContributingDelegatedRenderPasses() const { return false; }

- void setIsDrawable(bool);

- void setReplicaLayer(LayerChromium*);

- LayerChromium* 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 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*);

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

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

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

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

- // This moves from content space, with origin the top left to screen space with origin in the top left.

- // It converts logical, non-page-scaled pixels to physical pixels.

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

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

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

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

- // The contentsScale converts from logical, non-page-scaled pixels to target pixels.

- // The contentsScale is 1 for the root layer as it is already in physical pixels.

- float contentsScale() const { return m_contentsScale; }

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

- // Set the priority of all desired textures in this layer.

- virtual void setTexturePriorities(const CCPriorityCalculator&) { }

- bool addAnimation(scoped_ptr<CCActiveAnimation>);

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

- void setLayerAnimationDelegate(WebKit::WebAnimationDelegate* layerAnimationDelegate) { m_layerAnimationDelegate = layerAnimationDelegate; }

- bool hasActiveAnimation() const;

- virtual void notifyAnimationStarted(const CCAnimationEvent&, double wallClockTime);

- virtual void notifyAnimationFinished(double wallClockTime);

- virtual Region visibleContentOpaqueRegion() const;

- virtual ScrollbarLayerChromium* toScrollbarLayerChromium();

-protected:

- friend class CCLayerImpl;

- friend class TreeSynchronizer;

- virtual ~LayerChromium();

- LayerChromium();

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

- // Constructs a CCLayerImpl of the correct runtime type for this LayerChromium type.

- virtual scoped_ptr<CCLayerImpl> createCCLayerImpl();

- int m_layerId;

-private:

- friend class base::RefCounted<LayerChromium>;

- void setParent(LayerChromium*);

- bool hasAncestor(LayerChromium*) 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*);

- // This should only be called from removeFromParent.

- void removeChild(LayerChromium*);

- LayerList m_children;

- LayerChromium* 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

- // updated via setLayerTreeHost() if a layer moves between trees.

- CCLayerTreeHost* m_layerTreeHost;

- scoped_ptr<CCLayerAnimationController> m_layerAnimationController;

- // Layer properties.

- IntSize m_bounds;

- // Uses layer's content space.

- IntRect m_visibleContentRect;

- IntPoint m_scrollPosition;

- IntSize m_maxScrollPosition;

- bool m_scrollable;

- bool m_shouldScrollOnMainThread;

- bool m_haveWheelEventHandlers;

- Region m_nonFastScrollableRegion;

- bool m_nonFastScrollableRegionChanged;

- FloatPoint m_position;

- FloatPoint m_anchorPoint;

- SkColor m_backgroundColor;

- SkColor m_debugBorderColor;

- float m_debugBorderWidth;

- std::string m_debugName;

- float m_opacity;

- WebKit::WebFilterOperations m_filters;

- WebKit::WebFilterOperations m_backgroundFilters;

- float m_anchorPointZ;

- bool m_isContainerForFixedPositionLayers;

- bool m_fixedToContainerLayer;

- bool m_isDrawable;

- bool m_masksToBounds;

- bool m_contentsOpaque;

- bool m_doubleSided;

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

- // Transient properties.

- scoped_ptr<RenderSurfaceChromium> m_renderSurface;

- float m_drawOpacity;

- bool m_drawOpacityIsAnimating;

- LayerChromium* 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*);

-#endif // USE(ACCELERATED_COMPOSITING)

-#endif

+// Temporary forwarding header

+#include "cc/layer.h"

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