[cc] Rename all cc/ filenames to Chromium style

cc/layer.h

-// Copyright 2012 The Chromium Authors. All rights reserved.
+// 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
+
+#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