Revert of Rename WebAnimation to WebCompositorAnimation

Source/platform/graphics/GraphicsLayer.h

 /*
  * 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
@@ skipping 20 matching lines @@
 #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/graphics/GraphicsLayerClient.h"
 #include "platform/graphics/GraphicsLayerDebugInfo.h"
 #include "platform/graphics/OpaqueRectTrackingContentLayerDelegate.h"
 #include "platform/graphics/filters/FilterOperations.h"
 #include "platform/transforms/TransformationMatrix.h"
-#include "public/platform/WebCompositorAnimationDelegate.h"
+#include "public/platform/WebAnimationDelegate.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 "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 class GraphicsLayerFactoryChromium;
-class WebCompositorAnimation;
+class WebAnimation;
 class WebLayer;
 }
 
 namespace blink {
 
 class FloatRect;
 class GraphicsContext;
 class GraphicsLayer;
 class GraphicsLayerFactory;
 class Image;
 class JSONObject;
 class ScrollableArea;
 class TextStream;
 
 // FIXME: find a better home for this declaration.
 class PLATFORM_EXPORT LinkHighlightClient {
 public:
     virtual void invalidate() = 0;
     virtual void clearCurrentGraphicsLayer() = 0;
-    virtual WebLayer* layer() = 0;
+    virtual blink::WebLayer* layer() = 0;
 
 protected:
     virtual ~LinkHighlightClient() { }
 };
 
 typedef Vector<GraphicsLayer*, 64> GraphicsLayerVector;
 
 // GraphicsLayer is an abstraction for a rendering surface with backing store,
 // which may have associated transformation and animations.
 
-class PLATFORM_EXPORT GraphicsLayer : public GraphicsContextPainter, public WebCompositorAnimationDelegate, public WebLayerScrollClient, public WebLayerClient {
+class PLATFORM_EXPORT 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; }
 
-    // WebLayerClient implementation.
-    virtual WebGraphicsLayerDebugInfo* takeDebugInfoFor(WebLayer*) OVERRIDE;
+    // blink::WebLayerClient implementation.
+    virtual blink::WebGraphicsLayerDebugInfo* takeDebugInfoFor(blink::WebLayer*) OVERRIDE;
 
     GraphicsLayerDebugInfo& debugInfo();
 
     void setCompositingReasons(CompositingReasons);
     CompositingReasons compositingReasons() const { return m_debugInfo.compositingReasons(); }
     void setOwnerNodeId(int);
 
     GraphicsLayer* parent() const { return m_parent; };
     void setParent(GraphicsLayer*); // Internal use only.
 
@@ skipping 46 matching lines @@
     void setShouldFlattenTransform(bool);
     void setRenderingContext(int id);
     void setMasksToBounds(bool);
 
     bool drawsContent() const { return m_drawsContent; }
     void setDrawsContent(bool);
 
     bool contentsAreVisible() const { return m_contentsVisible; }
     void setContentsVisible(bool);
 
-    void setScrollParent(WebLayer*);
-    void setClipParent(WebLayer*);
+    void setScrollParent(blink::WebLayer*);
+    void setClipParent(blink::WebLayer*);
 
     // 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.
     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);
 
-    void setBlendMode(WebBlendMode);
+    void setBlendMode(blink::WebBlendMode);
     void setIsRootForIsolatedGroup(bool);
 
     void setFilters(const FilterOperations&);
 
     // Some GraphicsLayers paint only the foreground or the background content
     void setPaintingPhase(GraphicsLayerPaintingPhase);
 
     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).
     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<WebCompositorAnimation>);
+    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);
-    void setContentsToPlatformLayer(WebLayer* layer) { setContentsTo(layer); }
+    void setContentsToPlatformLayer(blink::WebLayer* layer) { setContentsTo(layer); }
     bool hasContentsLayer() const { return m_contentsLayer; }
 
     // For hosting this GraphicsLayer in a native layer hierarchy.
-    WebLayer* platformLayer() const;
+    blink::WebLayer* platformLayer() const;
 
     typedef HashMap<int, int> RenderingContextMap;
     PassRefPtr<JSONObject> layerTreeAsJSON(LayerTreeFlags, RenderingContextMap&) const;
 
     int paintCount() const { return m_paintCount; }
 
     // 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;
 
     void resetTrackedRepaints();
     void addRepaintRect(const FloatRect&);
 
     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; }
 
-    WebContentLayer* contentLayer() const { return m_layer.get(); }
+    blink::WebContentLayer* contentLayer() const { return m_layer.get(); }
 
-    static void registerContentsLayer(WebLayer*);
-    static void unregisterContentsLayer(WebLayer*);
+    static void registerContentsLayer(blink::WebLayer*);
+    static void unregisterContentsLayer(blink::WebLayer*);
 
     // GraphicsContextPainter implementation.
     virtual void paint(GraphicsContext&, const IntRect& clip) OVERRIDE;
 
-    // WebCompositorAnimationDelegate implementation.
-    virtual void notifyAnimationStarted(double monotonicTime, WebCompositorAnimation::TargetProperty) OVERRIDE;
-    virtual void notifyAnimationFinished(double monotonicTime, WebCompositorAnimation::TargetProperty) OVERRIDE;
+    // WebAnimationDelegate implementation.
+    virtual void notifyAnimationStarted(double monotonicTime, blink::WebAnimation::TargetProperty) OVERRIDE;
+    virtual void notifyAnimationFinished(double monotonicTime, blink::WebAnimation::TargetProperty) OVERRIDE;
 
     // WebLayerScrollClient implementation.
     virtual void didScroll() OVERRIDE;
 
 protected:
-    String debugName(WebLayer*) const;
+    String debugName(blink::WebLayer*) const;
 
     explicit GraphicsLayer(GraphicsLayerClient*);
     // GraphicsLayerFactoryChromium that wants to create a GraphicsLayer need to be friends.
-    friend class GraphicsLayerFactoryChromium;
+    friend class blink::GraphicsLayerFactoryChromium;
 
     // Exposed for tests.
-    virtual WebLayer* contentsLayer() const { return m_contentsLayer; }
+    virtual blink::WebLayer* contentsLayer() const { return m_contentsLayer; }
 
 private:
     // Callback from the underlying graphics system to draw layer contents.
     void paintGraphicsLayerContents(GraphicsContext&, const IntRect& clip);
 
     // Adds a child without calling updateChildList(), so that adding children
     // can be batched before updating.
     void addChildInternal(GraphicsLayer*);
 
 #if ENABLE(ASSERT)
     bool hasAncestor(GraphicsLayer*) const;
 #endif
 
     void setReplicatedLayer(GraphicsLayer* layer) { m_replicatedLayer = layer; }
 
     void incrementPaintCount() { ++m_paintCount; }
 
     // Helper functions used by settors to keep layer's the state consistent.
     void updateChildList();
     void updateLayerIsDrawable();
     void updateContentsRect();
 
-    void setContentsTo(WebLayer*);
-    void setupContentsLayer(WebLayer*);
+    void setContentsTo(blink::WebLayer*);
+    void setupContentsLayer(blink::WebLayer*);
     void clearContentsLayerIfUnregistered();
-    WebLayer* contentsLayerIfRegistered();
+    blink::WebLayer* contentsLayerIfRegistered();
 
     GraphicsLayerClient* m_client;
 
     // Offset from the owning renderer
     IntSize m_offsetFromRenderer;
 
     // Position is relative to the parent GraphicsLayer
     FloatPoint m_position;
     FloatSize m_size;
 
     TransformationMatrix m_transform;
     FloatPoint3D m_transformOrigin;
 
     Color m_backgroundColor;
     float m_opacity;
 
-    WebBlendMode m_blendMode;
+    blink::WebBlendMode m_blendMode;
 
     bool m_hasTransformOrigin : 1;
     bool m_contentsOpaque : 1;
     bool m_shouldFlattenTransform: 1;
     bool m_backfaceVisibility : 1;
     bool m_masksToBounds : 1;
     bool m_drawsContent : 1;
     bool m_contentsVisible : 1;
     bool m_isRootForIsolatedGroup : 1;
 
@@ skipping 10 matching lines @@
 
     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<WebContentLayer> m_layer;
-    OwnPtr<WebImageLayer> m_imageLayer;
-    OwnPtr<WebNinePatchLayer> m_ninePatchLayer;
-    WebLayer* m_contentsLayer;
+    OwnPtr<blink::WebContentLayer> m_layer;
+    OwnPtr<blink::WebImageLayer> m_imageLayer;
+    OwnPtr<blink::WebNinePatchLayer> m_ninePatchLayer;
+    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;
     GraphicsLayerDebugInfo m_debugInfo;
     int m_3dRenderingContext;
 };
 
 } // namespace blink
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 void PLATFORM_EXPORT showGraphicsLayerTree(const blink::GraphicsLayer*);
 #endif
 
 #endif // GraphicsLayer_h