Remove unused cruft from GraphicsLayer

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 84 matching lines @@
 
     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.
 
-    // 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 GraphicsLayerVector&);
 
     // 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; }
 
     enum ShouldSetNeedsDisplay {
         DontSetNeedsDisplay,
         SetNeedsDisplay
     };
 
@@ skipping 11 matching lines @@
     // 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&);
-
-    bool shouldFlattenTransform() const { return m_shouldFlattenTransform; }
     void setShouldFlattenTransform(bool);
-
-    int renderingContext() const { return m_3dRenderingContext; }
     void setRenderingContext(int id);
-
-    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*);
 
     // 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);
 
     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);
     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; }
-
     typedef HashMap<int, int> RenderingContextMap;
     void dumpLayer(TextStream&, int indent, LayerTreeFlags, RenderingContextMap&) 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);
-
-    // 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;
     String debugName(blink::WebLayer*) const;
 
     void resetTrackedRepaints();
     void addRepaintRect(const FloatRect&);
 
     void collectTrackedRepaintRects(Vector<FloatRect>&) const;
 
@@ skipping 27 matching lines @@
     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*);
 
+#if ASSERT_ENABLED
+    bool hasAncestor(GraphicsLayer*) const;
+#endif
+
     // 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, RenderingContextMap&) const;
@@ skipping 16 matching lines @@
     // Position is relative to the parent GraphicsLayer
     FloatPoint m_position;
     FloatSize m_size;
     FloatPoint m_boundsOrigin;
 
     TransformationMatrix m_transform;
     FloatPoint3D m_transformOrigin;
 
     Color m_backgroundColor;
     float m_opacity;
-    float m_zPosition;
 
     blink::WebBlendMode m_blendMode;
 
     FilterOperations m_filters;
 
     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;
 
     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.
@@ skipping 23 matching lines @@
 };
 
 } // namespace WebCore
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 void PLATFORM_EXPORT showGraphicsLayerTree(const WebCore::GraphicsLayer*);
 #endif
 
 #endif // GraphicsLayer_h