Merge WebKit at r75315: Initial merge by git.

Change-Id: I570314b346ce101c935ed22a626b48c2af266b84

1 files changed, 434 insertions, 0 deletions

diff --git a/Source/WebCore/platform/graphics/GraphicsLayer.h b/Source/WebCore/platform/graphics/GraphicsLayer.h
new file mode 100644
index 0000000..ef3c1bc
--- /dev/null
+++ b/Source/WebCore/platform/graphics/GraphicsLayer.h
@@ -0,0 +1,434 @@
+/*
+ * Copyright (C) 2009 Apple Inc. 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
+
+#if USE(ACCELERATED_COMPOSITING)
+
+#include "Animation.h"
+#include "Color.h"
+#include "FloatPoint.h"
+#include "FloatPoint3D.h"
+#include "FloatSize.h"
+#include "GraphicsLayerClient.h"
+#include "IntRect.h"
+#include "TransformationMatrix.h"
+#include "TransformOperations.h"
+#include <wtf/OwnPtr.h>
+#include <wtf/PassOwnPtr.h>
+
+#if USE(TEXTURE_MAPPER)
+#include "texmap/TextureMapperPlatformLayer.h"
+#endif
+
+#if PLATFORM(MAC)
+#ifdef __OBJC__
+@class WebLayer;
+@class CALayer;
+typedef CALayer PlatformLayer;
+#else
+typedef void* PlatformLayer;
+#endif
+#elif PLATFORM(WIN)
+typedef struct _CACFLayer PlatformLayer;
+#elif PLATFORM(QT)
+#if USE(TEXTURE_MAPPER)
+namespace WebCore {
+class TextureMapperPlatformLayer;
+typedef TextureMapperPlatformLayer PlatformLayer;
+};
+#else
+QT_BEGIN_NAMESPACE
+class QGraphicsObject;
+QT_END_NAMESPACE
+namespace WebCore {
+typedef QGraphicsObject PlatformLayer;
+}
+#endif
+#elif PLATFORM(CHROMIUM)
+namespace WebCore {
+class LayerChromium;
+typedef LayerChromium PlatformLayer;
+}
+#elif PLATFORM(ANDROID)
+namespace WebCore {
+class LayerAndroid;
+typedef LayerAndroid PlatformLayer;
+typedef void* NativeLayer;
+}
+#else
+typedef void* PlatformLayer;
+#endif
+
+enum LayerTreeAsTextBehaviorFlags {
+    LayerTreeAsTextBehaviorNormal = 0,
+    LayerTreeAsTextDebug = 1 << 0, // Dump extra debugging info like layer addresses.
+};
+typedef unsigned LayerTreeAsTextBehavior;
+
+namespace WebCore {
+
+class FloatPoint3D;
+class GraphicsContext;
+class Image;
+class TextStream;
+class TimingFunction;
+
+// Base class for animation values (also used for transitions). Here to
+// represent values for properties being animated via the GraphicsLayer,
+// without pulling in style-related data from outside of the platform directory.
+class AnimationValue : public Noncopyable {
+public:
+    AnimationValue(float keyTime, PassRefPtr<TimingFunction> timingFunction = 0)
+        : m_keyTime(keyTime)
+    {
+        if (timingFunction)
+            m_timingFunction = timingFunction;
+    }
+    
+    virtual ~AnimationValue() { }
+
+    float keyTime() const { return m_keyTime; }
+    const TimingFunction* timingFunction() const { return m_timingFunction.get(); }
+
+private:
+    float m_keyTime;
+    RefPtr<TimingFunction> m_timingFunction;
+};
+
+// Used to store one float value of an animation.
+class FloatAnimationValue : public AnimationValue {
+public:
+    FloatAnimationValue(float keyTime, float value, PassRefPtr<TimingFunction> timingFunction = 0)
+        : AnimationValue(keyTime, timingFunction)
+        , m_value(value)
+    {
+    }
+
+    float value() const { return m_value; }
+
+private:
+    float m_value;
+};
+
+// Used to store one transform value in a keyframe list.
+class TransformAnimationValue : public AnimationValue {
+public:
+    TransformAnimationValue(float keyTime, const TransformOperations* value = 0, PassRefPtr<TimingFunction> timingFunction = 0)
+        : AnimationValue(keyTime, timingFunction)
+    {
+        if (value)
+            m_value = adoptPtr(new TransformOperations(*value));
+    }
+
+    const TransformOperations* value() const { return m_value.get(); }
+
+private:
+    OwnPtr<TransformOperations> m_value;
+};
+
+// Used to store a series of values in a keyframe list. Values will all be of the same type,
+// which can be inferred from the property.
+class KeyframeValueList : public Noncopyable {
+public:
+
+    KeyframeValueList(AnimatedPropertyID property)
+        : m_property(property)
+    {
+    }
+    
+    ~KeyframeValueList()
+    {
+        deleteAllValues(m_values);
+    }
+    
+    AnimatedPropertyID property() const { return m_property; }
+
+    size_t size() const { return m_values.size(); }
+    const AnimationValue* at(size_t i) const { return m_values.at(i); }
+    
+    // Insert, sorted by keyTime. Takes ownership of the pointer.
+    void insert(const AnimationValue*);
+    
+protected:
+    Vector<const AnimationValue*> m_values;
+    AnimatedPropertyID m_property;
+};
+
+
+
+// GraphicsLayer is an abstraction for a rendering surface with backing store,
+// which may have associated transformation and animations.
+
+class GraphicsLayer {
+public:
+
+    static PassOwnPtr<GraphicsLayer> create(GraphicsLayerClient*);
+    
+    virtual ~GraphicsLayer();
+
+    GraphicsLayerClient* client() const { return m_client; }
+
+    // Layer name. Only used to identify layers in debug output
+    const String& name() const { return m_name; }
+    virtual void setName(const String& name) { m_name = name; }
+
+    GraphicsLayer* parent() const { return m_parent; };
+    void setParent(GraphicsLayer* layer) { m_parent = layer; } // 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.
+    virtual bool setChildren(const Vector<GraphicsLayer*>&);
+
+    // Add child layers. If the child is already parented, it will be removed from its old parent.
+    virtual void addChild(GraphicsLayer*);
+    virtual void addChildAtIndex(GraphicsLayer*, int index);
+    virtual void addChildAbove(GraphicsLayer* layer, GraphicsLayer* sibling);
+    virtual void addChildBelow(GraphicsLayer* layer, GraphicsLayer* sibling);
+    virtual bool replaceChild(GraphicsLayer* oldChild, GraphicsLayer* newChild);
+
+    void removeAllChildren();
+    virtual void removeFromParent();
+
+    GraphicsLayer* maskLayer() const { return m_maskLayer; }
+    virtual void setMaskLayer(GraphicsLayer* layer) { m_maskLayer = layer; }
+    
+    // The given layer will replicate this layer and its children; the replica renders behind this layer.
+    virtual 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; }
+
+    const FloatPoint& replicatedLayerPosition() const { return m_replicatedLayerPosition; }
+    void setReplicatedLayerPosition(const FloatPoint& p) { m_replicatedLayerPosition = p; }
+
+    // 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& offset) { m_offsetFromRenderer = offset; }
+
+    // The position of the layer (the location of its top-left corner in its parent)
+    const FloatPoint& position() const { return m_position; }
+    virtual void setPosition(const FloatPoint& p) { m_position = p; }
+    
+    // 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; }
+    virtual void setAnchorPoint(const FloatPoint3D& p) { m_anchorPoint = p; }
+
+    // The bounds of the layer
+    const FloatSize& size() const { return m_size; }
+    virtual void setSize(const FloatSize& size) { m_size = size; }
+
+    const TransformationMatrix& transform() const { return m_transform; }
+    virtual void setTransform(const TransformationMatrix& t) { m_transform = t; }
+
+    const TransformationMatrix& childrenTransform() const { return m_childrenTransform; }
+    virtual void setChildrenTransform(const TransformationMatrix& t) { m_childrenTransform = t; }
+
+    bool preserves3D() const { return m_preserves3D; }
+    virtual void setPreserves3D(bool b) { m_preserves3D = b; }
+    
+    bool masksToBounds() const { return m_masksToBounds; }
+    virtual void setMasksToBounds(bool b) { m_masksToBounds = b; }
+    
+    bool drawsContent() const { return m_drawsContent; }
+    virtual void setDrawsContent(bool b) { m_drawsContent = b; }
+
+    bool acceleratesDrawing() const { return m_acceleratesDrawing; }
+    virtual void setAcceleratesDrawing(bool b) { m_acceleratesDrawing = b; }
+
+    // The color used to paint the layer backgrounds
+    const Color& backgroundColor() const { return m_backgroundColor; }
+    virtual void setBackgroundColor(const Color&);
+    virtual void clearBackgroundColor();
+    bool backgroundColorSet() const { return m_backgroundColorSet; }
+
+    // opaque means that we know the layer contents have no alpha
+    bool contentsOpaque() const { return m_contentsOpaque; }
+    virtual void setContentsOpaque(bool b) { m_contentsOpaque = b; }
+
+    bool backfaceVisibility() const { return m_backfaceVisibility; }
+    virtual void setBackfaceVisibility(bool b) { m_backfaceVisibility = b; }
+
+    float opacity() const { return m_opacity; }
+    virtual void setOpacity(float opacity) { m_opacity = opacity; }
+
+    // Some GraphicsLayers paint only the foreground or the background content
+    GraphicsLayerPaintingPhase paintingPhase() const { return m_paintingPhase; }
+    void setPaintingPhase(GraphicsLayerPaintingPhase phase) { m_paintingPhase = phase; }
+
+    virtual void setNeedsDisplay() = 0;
+    // mark the given rect (in layer coords) as needing dispay. Never goes deep.
+    virtual void setNeedsDisplayInRect(const FloatRect&) = 0;
+    
+    virtual void setContentsNeedsDisplay() { };
+
+    // Set that the position/size of the contents (image or video).
+    IntRect contentsRect() const { return m_contentsRect; }
+    virtual void setContentsRect(const IntRect& r) { m_contentsRect = r; }
+    
+    // Transitions are identified by a special animation name that cannot clash with a keyframe identifier.
+    static String animationNameForTransition(AnimatedPropertyID);
+    
+    // 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.
+    virtual bool addAnimation(const KeyframeValueList&, const IntSize& /*boxSize*/, const Animation*, const String& /*animationName*/, double /*timeOffset*/)  { return false; }
+    virtual void pauseAnimation(const String& /*animationName*/, double /*timeOffset*/) { }
+    virtual void removeAnimation(const String& /*animationName*/) { }
+
+    virtual void suspendAnimations(double time);
+    virtual void resumeAnimations();
+    
+    // Layer contents
+    virtual void setContentsToImage(Image*) { }
+    virtual void setContentsToMedia(PlatformLayer*) { } // video or plug-in
+    virtual void setContentsBackgroundColor(const Color&) { }
+    virtual void setContentsToCanvas(PlatformLayer*) { }
+    virtual bool hasContentsLayer() const { return false; }
+
+    // Callback from the underlying graphics system to draw layer contents.
+    void paintGraphicsLayerContents(GraphicsContext&, const IntRect& clip);
+    // Callback from the underlying graphics system when the layer has been displayed
+    virtual void layerDidDisplay(PlatformLayer*) { }
+    
+    // For hosting this GraphicsLayer in a native layer hierarchy.
+    virtual PlatformLayer* platformLayer() const { return 0; }
+    
+    void dumpLayer(TextStream&, int indent = 0, LayerTreeAsTextBehavior = LayerTreeAsTextBehaviorNormal) const;
+
+    int repaintCount() const { return m_repaintCount; }
+    int incrementRepaintCount() { return ++m_repaintCount; }
+
+    enum CompositingCoordinatesOrientation { CompositingCoordinatesTopDown, CompositingCoordinatesBottomUp };
+
+    // Flippedness of the contents of this layer. Does not affect sublayer geometry.
+    virtual void setContentsOrientation(CompositingCoordinatesOrientation orientation) { m_contentsOrientation = orientation; }
+    CompositingCoordinatesOrientation contentsOrientation() const { return m_contentsOrientation; }
+
+    bool showDebugBorders() const { return m_client ? m_client->showDebugBorders() : false; }
+    bool showRepaintCounter() const { return m_client ? m_client->showRepaintCounter() : false; }
+    
+    void updateDebugIndicators();
+    
+    virtual void setDebugBackgroundColor(const Color&) { }
+    virtual void setDebugBorder(const Color&, float /*borderWidth*/) { }
+    // z-position is the z-equivalent of position(). It's only used for debugging purposes.
+    virtual float zPosition() const { return m_zPosition; }
+    virtual void setZPosition(float);
+
+    virtual void distributeOpacity(float);
+    virtual float accumulatedOpacity() const;
+
+    // Some compositing systems may do internal batching to synchronize compositing updates
+    // with updates drawn into the window. These methods flush internal batched state on this layer
+    // and descendant layers, and this layer only.
+    virtual void syncCompositingState() { }
+    virtual void syncCompositingStateForThisLayerOnly() { }
+    
+    // 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(LayerTreeAsTextBehavior = LayerTreeAsTextBehaviorNormal) const;
+
+    bool usingTiledLayer() const { return m_usingTiledLayer; }
+
+protected:
+
+    typedef Vector<TransformOperation::OperationType> TransformOperationList;
+    // Given a list of TransformAnimationValues, return an array of transform operations.
+    // On return, if hasBigRotation is true, functions contain rotations of >= 180 degrees
+    static void fetchTransformOperationList(const KeyframeValueList&, TransformOperationList&, bool& isValid, bool& hasBigRotation);
+
+    virtual void setOpacityInternal(float) { }
+    
+    // The layer being replicated.
+    GraphicsLayer* replicatedLayer() const { return m_replicatedLayer; }
+    virtual void setReplicatedLayer(GraphicsLayer* layer) { m_replicatedLayer = layer; }
+
+    GraphicsLayer(GraphicsLayerClient*);
+
+    void dumpProperties(TextStream&, int indent, LayerTreeAsTextBehavior) const;
+
+    GraphicsLayerClient* m_client;
+    String m_name;
+    
+    // Offset from the owning renderer
+    IntSize m_offsetFromRenderer;
+    
+    // Position is relative to the parent GraphicsLayer
+    FloatPoint m_position;
+    FloatPoint3D m_anchorPoint;
+    FloatSize m_size;
+    TransformationMatrix m_transform;
+    TransformationMatrix m_childrenTransform;
+
+    Color m_backgroundColor;
+    float m_opacity;
+    float m_zPosition;
+
+    bool m_backgroundColorSet : 1;
+    bool m_contentsOpaque : 1;
+    bool m_preserves3D: 1;
+    bool m_backfaceVisibility : 1;
+    bool m_usingTiledLayer : 1;
+    bool m_masksToBounds : 1;
+    bool m_drawsContent : 1;
+    bool m_acceleratesDrawing : 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_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_repaintCount;
+};
+
+
+} // namespace WebCore
+
+#ifndef NDEBUG
+// Outside the WebCore namespace for ease of invocation from gdb.
+void showGraphicsLayerTree(const WebCore::GraphicsLayer* layer);
+#endif
+
+#endif // USE(ACCELERATED_COMPOSITING)
+
+#endif // GraphicsLayer_h
+