Moving GraphicsContext and dependencies from core to platform.

Source/core/platform/graphics/GraphicsLayer.h

Index: Source/core/platform/graphics/GraphicsLayer.h
diff --git a/Source/core/platform/graphics/GraphicsLayer.h b/Source/core/platform/graphics/GraphicsLayer.h
deleted file mode 100644
index 38569e41c9df67c8ad3334897b30e5100f9f54fa..0000000000000000000000000000000000000000
--- a/Source/core/platform/graphics/GraphicsLayer.h
+++ /dev/null
@@ -1,419 +0,0 @@
-/*
- * Copyright (C) 2009 Apple Inc. All rights reserved.
- * Copyright (C) 2013 Intel Corporation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef GraphicsLayer_h
-#define GraphicsLayer_h
-
-#include "core/platform/graphics/GraphicsLayerClient.h"
-#include "core/platform/graphics/OpaqueRectTrackingContentLayerDelegate.h"
-#include "core/platform/graphics/filters/FilterOperations.h"
-#include "platform/geometry/FloatPoint.h"
-#include "platform/geometry/FloatPoint3D.h"
-#include "platform/geometry/FloatSize.h"
-#include "platform/geometry/IntRect.h"
-#include "platform/graphics/Color.h"
-#include "platform/transforms/TransformationMatrix.h"
-#include "wtf/OwnPtr.h"
-#include "wtf/PassOwnPtr.h"
-#include "wtf/Vector.h"
-
-#include "public/platform/WebAnimationDelegate.h"
-#include "public/platform/WebCompositingReasons.h"
-#include "public/platform/WebContentLayer.h"
-#include "public/platform/WebImageLayer.h"
-#include "public/platform/WebLayerClient.h"
-#include "public/platform/WebLayerScrollClient.h"
-#include "public/platform/WebNinePatchLayer.h"
-#include "public/platform/WebSolidColorLayer.h"
-
-namespace blink {
-class GraphicsLayerFactoryChromium;
-class WebAnimation;
-class WebGraphicsLayerDebugInfo;
-class WebLayer;
-}
-
-namespace WebCore {
-
-class FloatRect;
-class GraphicsContext;
-class GraphicsLayerFactory;
-class Image;
-class ScrollableArea;
-class TextStream;
-
-// FIXME: find a better home for this declaration.
-class LinkHighlightClient {
-public:
-    virtual void invalidate() = 0;
-    virtual void clearCurrentGraphicsLayer() = 0;
-    virtual blink::WebLayer* layer() = 0;
-
-protected:
-    virtual ~LinkHighlightClient() { }
-};
-
-// GraphicsLayer is an abstraction for a rendering surface with backing store,
-// which may have associated transformation and animations.
-
-class GraphicsLayer : public GraphicsContextPainter, public blink::WebAnimationDelegate, public blink::WebLayerScrollClient, public blink::WebLayerClient {
-    WTF_MAKE_NONCOPYABLE(GraphicsLayer); WTF_MAKE_FAST_ALLOCATED;
-public:
-    static PassOwnPtr<GraphicsLayer> create(GraphicsLayerFactory*, GraphicsLayerClient*);
-
-    virtual ~GraphicsLayer();
-
-    GraphicsLayerClient* client() const { return m_client; }
-
-    // blink::WebLayerClient implementation.
-    virtual blink::WebString debugName(blink::WebLayer*) OVERRIDE;
-    virtual blink::WebGraphicsLayerDebugInfo* takeDebugInfo() OVERRIDE;
-
-    void setCompositingReasons(blink::WebCompositingReasons);
-    blink::WebCompositingReasons compositingReasons() const { return m_compositingReasons; }
-
-    GraphicsLayer* parent() const { return m_parent; };
-    void setParent(GraphicsLayer*); // Internal use only.
-
-    // Returns true if the layer has the given layer as an ancestor (excluding self).
-    bool hasAncestor(GraphicsLayer*) const;
-
-    const Vector<GraphicsLayer*>& children() const { return m_children; }
-    // Returns true if the child list changed.
-    bool setChildren(const Vector<GraphicsLayer*>&);
-
-    // Add child layers. If the child is already parented, it will be removed from its old parent.
-    void addChild(GraphicsLayer*);
-    void addChildAtIndex(GraphicsLayer*, int index);
-    void addChildAbove(GraphicsLayer*, GraphicsLayer* sibling);
-    void addChildBelow(GraphicsLayer*, GraphicsLayer* sibling);
-    bool replaceChild(GraphicsLayer* oldChild, GraphicsLayer* newChild);
-
-    void removeAllChildren();
-    void removeFromParent();
-
-    GraphicsLayer* maskLayer() const { return m_maskLayer; }
-    void setMaskLayer(GraphicsLayer*);
-
-    GraphicsLayer* contentsClippingMaskLayer() const { return m_contentsClippingMaskLayer; }
-    void setContentsClippingMaskLayer(GraphicsLayer*);
-
-    // The given layer will replicate this layer and its children; the replica renders behind this layer.
-    void setReplicatedByLayer(GraphicsLayer*);
-    // Whether this layer is being replicated by another layer.
-    bool isReplicated() const { return m_replicaLayer; }
-    // The layer that replicates this layer (if any).
-    GraphicsLayer* replicaLayer() const { return m_replicaLayer; }
-    // The layer being replicated.
-    GraphicsLayer* replicatedLayer() const { return m_replicatedLayer; }
-
-    const FloatPoint& replicatedLayerPosition() const { return m_replicatedLayerPosition; }
-    void setReplicatedLayerPosition(const FloatPoint& p) { m_replicatedLayerPosition = p; }
-
-    enum ShouldSetNeedsDisplay {
-        DontSetNeedsDisplay,
-        SetNeedsDisplay
-    };
-
-    // Offset is origin of the renderer minus origin of the graphics layer (so either zero or negative).
-    IntSize offsetFromRenderer() const { return m_offsetFromRenderer; }
-    void setOffsetFromRenderer(const IntSize&, ShouldSetNeedsDisplay = SetNeedsDisplay);
-
-    // The position of the layer (the location of its top-left corner in its parent)
-    const FloatPoint& position() const { return m_position; }
-    void setPosition(const FloatPoint&);
-
-    // Anchor point: (0, 0) is top left, (1, 1) is bottom right. The anchor point
-    // affects the origin of the transforms.
-    const FloatPoint3D& anchorPoint() const { return m_anchorPoint; }
-    void setAnchorPoint(const FloatPoint3D&);
-
-    // The size of the layer.
-    const FloatSize& size() const { return m_size; }
-    void setSize(const FloatSize&);
-
-    // The boundOrigin affects the offset at which content is rendered, and sublayers are positioned.
-    const FloatPoint& boundsOrigin() const { return m_boundsOrigin; }
-    void setBoundsOrigin(const FloatPoint& origin) { m_boundsOrigin = origin; }
-
-    const TransformationMatrix& transform() const { return m_transform; }
-    void setTransform(const TransformationMatrix&);
-
-    const TransformationMatrix& childrenTransform() const { return m_childrenTransform; }
-    void setChildrenTransform(const TransformationMatrix&);
-
-    bool preserves3D() const { return m_preserves3D; }
-    void setPreserves3D(bool);
-
-    bool masksToBounds() const { return m_masksToBounds; }
-    void setMasksToBounds(bool);
-
-    bool drawsContent() const { return m_drawsContent; }
-    void setDrawsContent(bool);
-
-    bool contentsAreVisible() const { return m_contentsVisible; }
-    void setContentsVisible(bool);
-
-    void setScrollParent(blink::WebLayer*);
-    void setClipParent(blink::WebLayer*);
-
-    void setDebugInfo(blink::WebGraphicsLayerDebugInfo*);
-
-    // For special cases, e.g. drawing missing tiles on Android.
-    // The compositor should never paint this color in normal cases because the RenderLayer
-    // will paint background by itself.
-    const Color& backgroundColor() const { return m_backgroundColor; }
-    void setBackgroundColor(const Color&);
-
-    // opaque means that we know the layer contents have no alpha
-    bool contentsOpaque() const { return m_contentsOpaque; }
-    void setContentsOpaque(bool);
-
-    bool backfaceVisibility() const { return m_backfaceVisibility; }
-    void setBackfaceVisibility(bool visible);
-
-    float opacity() const { return m_opacity; }
-    void setOpacity(float);
-
-    blink::WebBlendMode blendMode() const { return m_blendMode; }
-    void setBlendMode(blink::WebBlendMode);
-
-    bool isRootForIsolatedGroup() const { return m_isRootForIsolatedGroup; }
-    void setIsRootForIsolatedGroup(bool);
-
-    const FilterOperations& filters() const { return m_filters; }
-
-    // Returns true if filter can be rendered by the compositor
-    bool setFilters(const FilterOperations&);
-    void setBackgroundFilters(const FilterOperations&);
-
-    // Some GraphicsLayers paint only the foreground or the background content
-    GraphicsLayerPaintingPhase paintingPhase() const { return m_paintingPhase; }
-    void setPaintingPhase(GraphicsLayerPaintingPhase phase) { m_paintingPhase = phase; }
-
-    void setNeedsDisplay();
-    // mark the given rect (in layer coords) as needing dispay. Never goes deep.
-    void setNeedsDisplayInRect(const FloatRect&);
-
-    void setContentsNeedsDisplay();
-
-    // Set that the position/size of the contents (image or video).
-    IntRect contentsRect() const { return m_contentsRect; }
-    void setContentsRect(const IntRect&);
-
-    // Return true if the animation is handled by the compositing system. If this returns
-    // false, the animation will be run by AnimationController.
-    // These methods handle both transitions and keyframe animations.
-    bool addAnimation(PassOwnPtr<blink::WebAnimation>);
-    void pauseAnimation(int animationId, double /*timeOffset*/);
-    void removeAnimation(int animationId);
-
-    // Layer contents
-    void setContentsToImage(Image*);
-    void setContentsToNinePatch(Image*, const IntRect& aperture);
-    // Pass an invalid color to remove the contents layer.
-    void setContentsToSolidColor(const Color&);
-    void setContentsToPlatformLayer(blink::WebLayer* layer) { setContentsTo(layer); }
-    bool hasContentsLayer() const { return m_contentsLayer; }
-
-    // Callback from the underlying graphics system to draw layer contents.
-    void paintGraphicsLayerContents(GraphicsContext&, const IntRect& clip);
-
-    // For hosting this GraphicsLayer in a native layer hierarchy.
-    blink::WebLayer* platformLayer() const;
-
-    enum CompositingCoordinatesOrientation { CompositingCoordinatesTopDown, CompositingCoordinatesBottomUp };
-
-    // Flippedness of the contents of this layer. Does not affect sublayer geometry.
-    void setContentsOrientation(CompositingCoordinatesOrientation orientation) { m_contentsOrientation = orientation; }
-    CompositingCoordinatesOrientation contentsOrientation() const { return m_contentsOrientation; }
-
-    void dumpLayer(TextStream&, int indent, LayerTreeFlags) const;
-
-    int paintCount() const { return m_paintCount; }
-
-    // z-position is the z-equivalent of position(). It's only used for debugging purposes.
-    float zPosition() const { return m_zPosition; }
-    void setZPosition(float);
-
-    void distributeOpacity(float);
-    float accumulatedOpacity() const;
-
-    // If the exposed rect of this layer changes, returns true if this or descendant layers need a flush,
-    // for example to allocate new tiles.
-    bool visibleRectChangeRequiresFlush(const FloatRect& /* clipRect */) const { return false; }
-
-    // Return a string with a human readable form of the layer tree, If debug is true
-    // pointers for the layers and timing data will be included in the returned string.
-    String layerTreeAsText(LayerTreeFlags = LayerTreeNormal) const;
-
-    // Return an estimate of the backing store memory cost (in bytes). May be incorrect for tiled layers.
-    double backingStoreMemoryEstimate() const;
-
-    void resetTrackedRepaints();
-    void addRepaintRect(const FloatRect&);
-
-    void collectTrackedRepaintRects(Vector<FloatRect>&) const;
-
-    void addLinkHighlight(LinkHighlightClient*);
-    void removeLinkHighlight(LinkHighlightClient*);
-    // Exposed for tests
-    unsigned numLinkHighlights() { return m_linkHighlights.size(); }
-    LinkHighlightClient* linkHighlight(int i) { return m_linkHighlights[i]; }
-
-    void setScrollableArea(ScrollableArea*, bool isMainFrame);
-    ScrollableArea* scrollableArea() const { return m_scrollableArea; }
-
-    blink::WebContentLayer* contentLayer() const { return m_layer.get(); }
-
-    static void registerContentsLayer(blink::WebLayer*);
-    static void unregisterContentsLayer(blink::WebLayer*);
-
-    // GraphicsContextPainter implementation.
-    virtual void paint(GraphicsContext&, const IntRect& clip) OVERRIDE;
-
-    // WebAnimationDelegate implementation.
-    virtual void notifyAnimationStarted(double startTime) OVERRIDE;
-    virtual void notifyAnimationFinished(double finishTime) OVERRIDE;
-
-    // WebLayerScrollClient implementation.
-    virtual void didScroll() OVERRIDE;
-
-protected:
-    explicit GraphicsLayer(GraphicsLayerClient*);
-    // GraphicsLayerFactoryChromium that wants to create a GraphicsLayer need to be friends.
-    friend class blink::GraphicsLayerFactoryChromium;
-
-    // Exposed for tests.
-    virtual blink::WebLayer* contentsLayer() const { return m_contentsLayer; }
-
-private:
-    // Adds a child without calling updateChildList(), so that adding children
-    // can be batched before updating.
-    void addChildInternal(GraphicsLayer*);
-
-    // This method is used by platform GraphicsLayer classes to clear the filters
-    // when compositing is not done in hardware. It is not virtual, so the caller
-    // needs to notifiy the change to the platform layer as needed.
-    void clearFilters() { m_filters.clear(); }
-
-    void setReplicatedLayer(GraphicsLayer* layer) { m_replicatedLayer = layer; }
-
-    int incrementPaintCount() { return ++m_paintCount; }
-
-    void dumpProperties(TextStream&, int indent, LayerTreeFlags) const;
-
-    // Helper functions used by settors to keep layer's the state consistent.
-    void updateChildList();
-    void updateLayerIsDrawable();
-    void updateContentsRect();
-
-    void setContentsTo(blink::WebLayer*);
-    void setupContentsLayer(blink::WebLayer*);
-    void clearContentsLayerIfUnregistered();
-    blink::WebLayer* contentsLayerIfRegistered();
-
-    GraphicsLayerClient* m_client;
-
-    // Offset from the owning renderer
-    IntSize m_offsetFromRenderer;
-
-    // Position is relative to the parent GraphicsLayer
-    FloatPoint m_position;
-    FloatPoint3D m_anchorPoint;
-    FloatSize m_size;
-    FloatPoint m_boundsOrigin;
-
-    TransformationMatrix m_transform;
-    TransformationMatrix m_childrenTransform;
-
-    Color m_backgroundColor;
-    float m_opacity;
-    float m_zPosition;
-
-    blink::WebBlendMode m_blendMode;
-
-    FilterOperations m_filters;
-
-    bool m_contentsOpaque : 1;
-    bool m_preserves3D: 1;
-    bool m_backfaceVisibility : 1;
-    bool m_masksToBounds : 1;
-    bool m_drawsContent : 1;
-    bool m_contentsVisible : 1;
-    bool m_isRootForIsolatedGroup : 1;
-
-    bool m_hasScrollParent : 1;
-    bool m_hasClipParent : 1;
-
-    GraphicsLayerPaintingPhase m_paintingPhase;
-    CompositingCoordinatesOrientation m_contentsOrientation; // affects orientation of layer contents
-
-    Vector<GraphicsLayer*> m_children;
-    GraphicsLayer* m_parent;
-
-    GraphicsLayer* m_maskLayer; // Reference to mask layer. We don't own this.
-    GraphicsLayer* m_contentsClippingMaskLayer; // Reference to clipping mask layer. We don't own this.
-
-    GraphicsLayer* m_replicaLayer; // A layer that replicates this layer. We only allow one, for now.
-                                   // The replica is not parented; this is the primary reference to it.
-    GraphicsLayer* m_replicatedLayer; // For a replica layer, a reference to the original layer.
-    FloatPoint m_replicatedLayerPosition; // For a replica layer, the position of the replica.
-
-    IntRect m_contentsRect;
-
-    int m_paintCount;
-
-    OwnPtr<blink::WebContentLayer> m_layer;
-    OwnPtr<blink::WebImageLayer> m_imageLayer;
-    OwnPtr<blink::WebNinePatchLayer> m_ninePatchLayer;
-    Color m_contentsSolidColor;
-    OwnPtr<blink::WebSolidColorLayer> m_solidColorLayer;
-    blink::WebLayer* m_contentsLayer;
-    // We don't have ownership of m_contentsLayer, but we do want to know if a given layer is the
-    // same as our current layer in setContentsTo(). Since m_contentsLayer may be deleted at this point,
-    // we stash an ID away when we know m_contentsLayer is alive and use that for comparisons from that point
-    // on.
-    int m_contentsLayerId;
-
-    Vector<LinkHighlightClient*> m_linkHighlights;
-
-    OwnPtr<OpaqueRectTrackingContentLayerDelegate> m_opaqueRectTrackingContentLayerDelegate;
-
-    ScrollableArea* m_scrollableArea;
-    blink::WebCompositingReasons m_compositingReasons;
-    blink::WebGraphicsLayerDebugInfo* m_debugInfo;
-};
-
-
-} // namespace WebCore
-
-#ifndef NDEBUG
-// Outside the WebCore namespace for ease of invocation from gdb.
-void showGraphicsLayerTree(const WebCore::GraphicsLayer* layer);
-#endif
-
-#endif // GraphicsLayer_h