| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright (C) 2009 Apple Inc. All rights reserved. | |
| 3 * Copyright (C) 2013 Intel Corporation. All rights reserved. | |
| 4 * | |
| 5 * Redistribution and use in source and binary forms, with or without | |
| 6 * modification, are permitted provided that the following conditions | |
| 7 * are met: | |
| 8 * 1. Redistributions of source code must retain the above copyright | |
| 9 * notice, this list of conditions and the following disclaimer. | |
| 10 * 2. Redistributions in binary form must reproduce the above copyright | |
| 11 * notice, this list of conditions and the following disclaimer in the | |
| 12 * documentation and/or other materials provided with the distribution. | |
| 13 * | |
| 14 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY | |
| 15 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | |
| 17 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR | |
| 18 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | |
| 19 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | |
| 20 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | |
| 21 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY | |
| 22 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| 24 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| 25 */ | |
| 26 | |
| 27 #ifndef GraphicsLayer_h | |
| 28 #define GraphicsLayer_h | |
| 29 | |
| 30 #include "core/platform/graphics/GraphicsLayerClient.h" | |
| 31 #include "core/platform/graphics/OpaqueRectTrackingContentLayerDelegate.h" | |
| 32 #include "core/platform/graphics/filters/FilterOperations.h" | |
| 33 #include "platform/geometry/FloatPoint.h" | |
| 34 #include "platform/geometry/FloatPoint3D.h" | |
| 35 #include "platform/geometry/FloatSize.h" | |
| 36 #include "platform/geometry/IntRect.h" | |
| 37 #include "platform/graphics/Color.h" | |
| 38 #include "platform/transforms/TransformationMatrix.h" | |
| 39 #include "wtf/OwnPtr.h" | |
| 40 #include "wtf/PassOwnPtr.h" | |
| 41 #include "wtf/Vector.h" | |
| 42 | |
| 43 #include "public/platform/WebAnimationDelegate.h" | |
| 44 #include "public/platform/WebCompositingReasons.h" | |
| 45 #include "public/platform/WebContentLayer.h" | |
| 46 #include "public/platform/WebImageLayer.h" | |
| 47 #include "public/platform/WebLayerClient.h" | |
| 48 #include "public/platform/WebLayerScrollClient.h" | |
| 49 #include "public/platform/WebNinePatchLayer.h" | |
| 50 #include "public/platform/WebSolidColorLayer.h" | |
| 51 | |
| 52 namespace blink { | |
| 53 class GraphicsLayerFactoryChromium; | |
| 54 class WebAnimation; | |
| 55 class WebGraphicsLayerDebugInfo; | |
| 56 class WebLayer; | |
| 57 } | |
| 58 | |
| 59 namespace WebCore { | |
| 60 | |
| 61 class FloatRect; | |
| 62 class GraphicsContext; | |
| 63 class GraphicsLayerFactory; | |
| 64 class Image; | |
| 65 class ScrollableArea; | |
| 66 class TextStream; | |
| 67 | |
| 68 // FIXME: find a better home for this declaration. | |
| 69 class LinkHighlightClient { | |
| 70 public: | |
| 71 virtual void invalidate() = 0; | |
| 72 virtual void clearCurrentGraphicsLayer() = 0; | |
| 73 virtual blink::WebLayer* layer() = 0; | |
| 74 | |
| 75 protected: | |
| 76 virtual ~LinkHighlightClient() { } | |
| 77 }; | |
| 78 | |
| 79 // GraphicsLayer is an abstraction for a rendering surface with backing store, | |
| 80 // which may have associated transformation and animations. | |
| 81 | |
| 82 class GraphicsLayer : public GraphicsContextPainter, public blink::WebAnimationD
elegate, public blink::WebLayerScrollClient, public blink::WebLayerClient { | |
| 83 WTF_MAKE_NONCOPYABLE(GraphicsLayer); WTF_MAKE_FAST_ALLOCATED; | |
| 84 public: | |
| 85 static PassOwnPtr<GraphicsLayer> create(GraphicsLayerFactory*, GraphicsLayer
Client*); | |
| 86 | |
| 87 virtual ~GraphicsLayer(); | |
| 88 | |
| 89 GraphicsLayerClient* client() const { return m_client; } | |
| 90 | |
| 91 // blink::WebLayerClient implementation. | |
| 92 virtual blink::WebString debugName(blink::WebLayer*) OVERRIDE; | |
| 93 virtual blink::WebGraphicsLayerDebugInfo* takeDebugInfo() OVERRIDE; | |
| 94 | |
| 95 void setCompositingReasons(blink::WebCompositingReasons); | |
| 96 blink::WebCompositingReasons compositingReasons() const { return m_compositi
ngReasons; } | |
| 97 | |
| 98 GraphicsLayer* parent() const { return m_parent; }; | |
| 99 void setParent(GraphicsLayer*); // Internal use only. | |
| 100 | |
| 101 // Returns true if the layer has the given layer as an ancestor (excluding s
elf). | |
| 102 bool hasAncestor(GraphicsLayer*) const; | |
| 103 | |
| 104 const Vector<GraphicsLayer*>& children() const { return m_children; } | |
| 105 // Returns true if the child list changed. | |
| 106 bool setChildren(const Vector<GraphicsLayer*>&); | |
| 107 | |
| 108 // Add child layers. If the child is already parented, it will be removed fr
om its old parent. | |
| 109 void addChild(GraphicsLayer*); | |
| 110 void addChildAtIndex(GraphicsLayer*, int index); | |
| 111 void addChildAbove(GraphicsLayer*, GraphicsLayer* sibling); | |
| 112 void addChildBelow(GraphicsLayer*, GraphicsLayer* sibling); | |
| 113 bool replaceChild(GraphicsLayer* oldChild, GraphicsLayer* newChild); | |
| 114 | |
| 115 void removeAllChildren(); | |
| 116 void removeFromParent(); | |
| 117 | |
| 118 GraphicsLayer* maskLayer() const { return m_maskLayer; } | |
| 119 void setMaskLayer(GraphicsLayer*); | |
| 120 | |
| 121 GraphicsLayer* contentsClippingMaskLayer() const { return m_contentsClipping
MaskLayer; } | |
| 122 void setContentsClippingMaskLayer(GraphicsLayer*); | |
| 123 | |
| 124 // The given layer will replicate this layer and its children; the replica r
enders behind this layer. | |
| 125 void setReplicatedByLayer(GraphicsLayer*); | |
| 126 // Whether this layer is being replicated by another layer. | |
| 127 bool isReplicated() const { return m_replicaLayer; } | |
| 128 // The layer that replicates this layer (if any). | |
| 129 GraphicsLayer* replicaLayer() const { return m_replicaLayer; } | |
| 130 // The layer being replicated. | |
| 131 GraphicsLayer* replicatedLayer() const { return m_replicatedLayer; } | |
| 132 | |
| 133 const FloatPoint& replicatedLayerPosition() const { return m_replicatedLayer
Position; } | |
| 134 void setReplicatedLayerPosition(const FloatPoint& p) { m_replicatedLayerPosi
tion = p; } | |
| 135 | |
| 136 enum ShouldSetNeedsDisplay { | |
| 137 DontSetNeedsDisplay, | |
| 138 SetNeedsDisplay | |
| 139 }; | |
| 140 | |
| 141 // Offset is origin of the renderer minus origin of the graphics layer (so e
ither zero or negative). | |
| 142 IntSize offsetFromRenderer() const { return m_offsetFromRenderer; } | |
| 143 void setOffsetFromRenderer(const IntSize&, ShouldSetNeedsDisplay = SetNeedsD
isplay); | |
| 144 | |
| 145 // The position of the layer (the location of its top-left corner in its par
ent) | |
| 146 const FloatPoint& position() const { return m_position; } | |
| 147 void setPosition(const FloatPoint&); | |
| 148 | |
| 149 // Anchor point: (0, 0) is top left, (1, 1) is bottom right. The anchor poin
t | |
| 150 // affects the origin of the transforms. | |
| 151 const FloatPoint3D& anchorPoint() const { return m_anchorPoint; } | |
| 152 void setAnchorPoint(const FloatPoint3D&); | |
| 153 | |
| 154 // The size of the layer. | |
| 155 const FloatSize& size() const { return m_size; } | |
| 156 void setSize(const FloatSize&); | |
| 157 | |
| 158 // The boundOrigin affects the offset at which content is rendered, and subl
ayers are positioned. | |
| 159 const FloatPoint& boundsOrigin() const { return m_boundsOrigin; } | |
| 160 void setBoundsOrigin(const FloatPoint& origin) { m_boundsOrigin = origin; } | |
| 161 | |
| 162 const TransformationMatrix& transform() const { return m_transform; } | |
| 163 void setTransform(const TransformationMatrix&); | |
| 164 | |
| 165 const TransformationMatrix& childrenTransform() const { return m_childrenTra
nsform; } | |
| 166 void setChildrenTransform(const TransformationMatrix&); | |
| 167 | |
| 168 bool preserves3D() const { return m_preserves3D; } | |
| 169 void setPreserves3D(bool); | |
| 170 | |
| 171 bool masksToBounds() const { return m_masksToBounds; } | |
| 172 void setMasksToBounds(bool); | |
| 173 | |
| 174 bool drawsContent() const { return m_drawsContent; } | |
| 175 void setDrawsContent(bool); | |
| 176 | |
| 177 bool contentsAreVisible() const { return m_contentsVisible; } | |
| 178 void setContentsVisible(bool); | |
| 179 | |
| 180 void setScrollParent(blink::WebLayer*); | |
| 181 void setClipParent(blink::WebLayer*); | |
| 182 | |
| 183 void setDebugInfo(blink::WebGraphicsLayerDebugInfo*); | |
| 184 | |
| 185 // For special cases, e.g. drawing missing tiles on Android. | |
| 186 // The compositor should never paint this color in normal cases because the
RenderLayer | |
| 187 // will paint background by itself. | |
| 188 const Color& backgroundColor() const { return m_backgroundColor; } | |
| 189 void setBackgroundColor(const Color&); | |
| 190 | |
| 191 // opaque means that we know the layer contents have no alpha | |
| 192 bool contentsOpaque() const { return m_contentsOpaque; } | |
| 193 void setContentsOpaque(bool); | |
| 194 | |
| 195 bool backfaceVisibility() const { return m_backfaceVisibility; } | |
| 196 void setBackfaceVisibility(bool visible); | |
| 197 | |
| 198 float opacity() const { return m_opacity; } | |
| 199 void setOpacity(float); | |
| 200 | |
| 201 blink::WebBlendMode blendMode() const { return m_blendMode; } | |
| 202 void setBlendMode(blink::WebBlendMode); | |
| 203 | |
| 204 bool isRootForIsolatedGroup() const { return m_isRootForIsolatedGroup; } | |
| 205 void setIsRootForIsolatedGroup(bool); | |
| 206 | |
| 207 const FilterOperations& filters() const { return m_filters; } | |
| 208 | |
| 209 // Returns true if filter can be rendered by the compositor | |
| 210 bool setFilters(const FilterOperations&); | |
| 211 void setBackgroundFilters(const FilterOperations&); | |
| 212 | |
| 213 // Some GraphicsLayers paint only the foreground or the background content | |
| 214 GraphicsLayerPaintingPhase paintingPhase() const { return m_paintingPhase; } | |
| 215 void setPaintingPhase(GraphicsLayerPaintingPhase phase) { m_paintingPhase =
phase; } | |
| 216 | |
| 217 void setNeedsDisplay(); | |
| 218 // mark the given rect (in layer coords) as needing dispay. Never goes deep. | |
| 219 void setNeedsDisplayInRect(const FloatRect&); | |
| 220 | |
| 221 void setContentsNeedsDisplay(); | |
| 222 | |
| 223 // Set that the position/size of the contents (image or video). | |
| 224 IntRect contentsRect() const { return m_contentsRect; } | |
| 225 void setContentsRect(const IntRect&); | |
| 226 | |
| 227 // Return true if the animation is handled by the compositing system. If thi
s returns | |
| 228 // false, the animation will be run by AnimationController. | |
| 229 // These methods handle both transitions and keyframe animations. | |
| 230 bool addAnimation(PassOwnPtr<blink::WebAnimation>); | |
| 231 void pauseAnimation(int animationId, double /*timeOffset*/); | |
| 232 void removeAnimation(int animationId); | |
| 233 | |
| 234 // Layer contents | |
| 235 void setContentsToImage(Image*); | |
| 236 void setContentsToNinePatch(Image*, const IntRect& aperture); | |
| 237 // Pass an invalid color to remove the contents layer. | |
| 238 void setContentsToSolidColor(const Color&); | |
| 239 void setContentsToPlatformLayer(blink::WebLayer* layer) { setContentsTo(laye
r); } | |
| 240 bool hasContentsLayer() const { return m_contentsLayer; } | |
| 241 | |
| 242 // Callback from the underlying graphics system to draw layer contents. | |
| 243 void paintGraphicsLayerContents(GraphicsContext&, const IntRect& clip); | |
| 244 | |
| 245 // For hosting this GraphicsLayer in a native layer hierarchy. | |
| 246 blink::WebLayer* platformLayer() const; | |
| 247 | |
| 248 enum CompositingCoordinatesOrientation { CompositingCoordinatesTopDown, Comp
ositingCoordinatesBottomUp }; | |
| 249 | |
| 250 // Flippedness of the contents of this layer. Does not affect sublayer geome
try. | |
| 251 void setContentsOrientation(CompositingCoordinatesOrientation orientation) {
m_contentsOrientation = orientation; } | |
| 252 CompositingCoordinatesOrientation contentsOrientation() const { return m_con
tentsOrientation; } | |
| 253 | |
| 254 void dumpLayer(TextStream&, int indent, LayerTreeFlags) const; | |
| 255 | |
| 256 int paintCount() const { return m_paintCount; } | |
| 257 | |
| 258 // z-position is the z-equivalent of position(). It's only used for debuggin
g purposes. | |
| 259 float zPosition() const { return m_zPosition; } | |
| 260 void setZPosition(float); | |
| 261 | |
| 262 void distributeOpacity(float); | |
| 263 float accumulatedOpacity() const; | |
| 264 | |
| 265 // If the exposed rect of this layer changes, returns true if this or descen
dant layers need a flush, | |
| 266 // for example to allocate new tiles. | |
| 267 bool visibleRectChangeRequiresFlush(const FloatRect& /* clipRect */) const {
return false; } | |
| 268 | |
| 269 // Return a string with a human readable form of the layer tree, If debug is
true | |
| 270 // pointers for the layers and timing data will be included in the returned
string. | |
| 271 String layerTreeAsText(LayerTreeFlags = LayerTreeNormal) const; | |
| 272 | |
| 273 // Return an estimate of the backing store memory cost (in bytes). May be in
correct for tiled layers. | |
| 274 double backingStoreMemoryEstimate() const; | |
| 275 | |
| 276 void resetTrackedRepaints(); | |
| 277 void addRepaintRect(const FloatRect&); | |
| 278 | |
| 279 void collectTrackedRepaintRects(Vector<FloatRect>&) const; | |
| 280 | |
| 281 void addLinkHighlight(LinkHighlightClient*); | |
| 282 void removeLinkHighlight(LinkHighlightClient*); | |
| 283 // Exposed for tests | |
| 284 unsigned numLinkHighlights() { return m_linkHighlights.size(); } | |
| 285 LinkHighlightClient* linkHighlight(int i) { return m_linkHighlights[i]; } | |
| 286 | |
| 287 void setScrollableArea(ScrollableArea*, bool isMainFrame); | |
| 288 ScrollableArea* scrollableArea() const { return m_scrollableArea; } | |
| 289 | |
| 290 blink::WebContentLayer* contentLayer() const { return m_layer.get(); } | |
| 291 | |
| 292 static void registerContentsLayer(blink::WebLayer*); | |
| 293 static void unregisterContentsLayer(blink::WebLayer*); | |
| 294 | |
| 295 // GraphicsContextPainter implementation. | |
| 296 virtual void paint(GraphicsContext&, const IntRect& clip) OVERRIDE; | |
| 297 | |
| 298 // WebAnimationDelegate implementation. | |
| 299 virtual void notifyAnimationStarted(double startTime) OVERRIDE; | |
| 300 virtual void notifyAnimationFinished(double finishTime) OVERRIDE; | |
| 301 | |
| 302 // WebLayerScrollClient implementation. | |
| 303 virtual void didScroll() OVERRIDE; | |
| 304 | |
| 305 protected: | |
| 306 explicit GraphicsLayer(GraphicsLayerClient*); | |
| 307 // GraphicsLayerFactoryChromium that wants to create a GraphicsLayer need to
be friends. | |
| 308 friend class blink::GraphicsLayerFactoryChromium; | |
| 309 | |
| 310 // Exposed for tests. | |
| 311 virtual blink::WebLayer* contentsLayer() const { return m_contentsLayer; } | |
| 312 | |
| 313 private: | |
| 314 // Adds a child without calling updateChildList(), so that adding children | |
| 315 // can be batched before updating. | |
| 316 void addChildInternal(GraphicsLayer*); | |
| 317 | |
| 318 // This method is used by platform GraphicsLayer classes to clear the filter
s | |
| 319 // when compositing is not done in hardware. It is not virtual, so the calle
r | |
| 320 // needs to notifiy the change to the platform layer as needed. | |
| 321 void clearFilters() { m_filters.clear(); } | |
| 322 | |
| 323 void setReplicatedLayer(GraphicsLayer* layer) { m_replicatedLayer = layer; } | |
| 324 | |
| 325 int incrementPaintCount() { return ++m_paintCount; } | |
| 326 | |
| 327 void dumpProperties(TextStream&, int indent, LayerTreeFlags) const; | |
| 328 | |
| 329 // Helper functions used by settors to keep layer's the state consistent. | |
| 330 void updateChildList(); | |
| 331 void updateLayerIsDrawable(); | |
| 332 void updateContentsRect(); | |
| 333 | |
| 334 void setContentsTo(blink::WebLayer*); | |
| 335 void setupContentsLayer(blink::WebLayer*); | |
| 336 void clearContentsLayerIfUnregistered(); | |
| 337 blink::WebLayer* contentsLayerIfRegistered(); | |
| 338 | |
| 339 GraphicsLayerClient* m_client; | |
| 340 | |
| 341 // Offset from the owning renderer | |
| 342 IntSize m_offsetFromRenderer; | |
| 343 | |
| 344 // Position is relative to the parent GraphicsLayer | |
| 345 FloatPoint m_position; | |
| 346 FloatPoint3D m_anchorPoint; | |
| 347 FloatSize m_size; | |
| 348 FloatPoint m_boundsOrigin; | |
| 349 | |
| 350 TransformationMatrix m_transform; | |
| 351 TransformationMatrix m_childrenTransform; | |
| 352 | |
| 353 Color m_backgroundColor; | |
| 354 float m_opacity; | |
| 355 float m_zPosition; | |
| 356 | |
| 357 blink::WebBlendMode m_blendMode; | |
| 358 | |
| 359 FilterOperations m_filters; | |
| 360 | |
| 361 bool m_contentsOpaque : 1; | |
| 362 bool m_preserves3D: 1; | |
| 363 bool m_backfaceVisibility : 1; | |
| 364 bool m_masksToBounds : 1; | |
| 365 bool m_drawsContent : 1; | |
| 366 bool m_contentsVisible : 1; | |
| 367 bool m_isRootForIsolatedGroup : 1; | |
| 368 | |
| 369 bool m_hasScrollParent : 1; | |
| 370 bool m_hasClipParent : 1; | |
| 371 | |
| 372 GraphicsLayerPaintingPhase m_paintingPhase; | |
| 373 CompositingCoordinatesOrientation m_contentsOrientation; // affects orientat
ion of layer contents | |
| 374 | |
| 375 Vector<GraphicsLayer*> m_children; | |
| 376 GraphicsLayer* m_parent; | |
| 377 | |
| 378 GraphicsLayer* m_maskLayer; // Reference to mask layer. We don't own this. | |
| 379 GraphicsLayer* m_contentsClippingMaskLayer; // Reference to clipping mask la
yer. We don't own this. | |
| 380 | |
| 381 GraphicsLayer* m_replicaLayer; // A layer that replicates this layer. We onl
y allow one, for now. | |
| 382 // The replica is not parented; this is the p
rimary reference to it. | |
| 383 GraphicsLayer* m_replicatedLayer; // For a replica layer, a reference to the
original layer. | |
| 384 FloatPoint m_replicatedLayerPosition; // For a replica layer, the position o
f the replica. | |
| 385 | |
| 386 IntRect m_contentsRect; | |
| 387 | |
| 388 int m_paintCount; | |
| 389 | |
| 390 OwnPtr<blink::WebContentLayer> m_layer; | |
| 391 OwnPtr<blink::WebImageLayer> m_imageLayer; | |
| 392 OwnPtr<blink::WebNinePatchLayer> m_ninePatchLayer; | |
| 393 Color m_contentsSolidColor; | |
| 394 OwnPtr<blink::WebSolidColorLayer> m_solidColorLayer; | |
| 395 blink::WebLayer* m_contentsLayer; | |
| 396 // We don't have ownership of m_contentsLayer, but we do want to know if a g
iven layer is the | |
| 397 // same as our current layer in setContentsTo(). Since m_contentsLayer may b
e deleted at this point, | |
| 398 // we stash an ID away when we know m_contentsLayer is alive and use that fo
r comparisons from that point | |
| 399 // on. | |
| 400 int m_contentsLayerId; | |
| 401 | |
| 402 Vector<LinkHighlightClient*> m_linkHighlights; | |
| 403 | |
| 404 OwnPtr<OpaqueRectTrackingContentLayerDelegate> m_opaqueRectTrackingContentLa
yerDelegate; | |
| 405 | |
| 406 ScrollableArea* m_scrollableArea; | |
| 407 blink::WebCompositingReasons m_compositingReasons; | |
| 408 blink::WebGraphicsLayerDebugInfo* m_debugInfo; | |
| 409 }; | |
| 410 | |
| 411 | |
| 412 } // namespace WebCore | |
| 413 | |
| 414 #ifndef NDEBUG | |
| 415 // Outside the WebCore namespace for ease of invocation from gdb. | |
| 416 void showGraphicsLayerTree(const WebCore::GraphicsLayer* layer); | |
| 417 #endif | |
| 418 | |
| 419 #endif // GraphicsLayer_h | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 99103006:
Moving GraphicsContext and dependencies from core to platform. (Closed)
Base URL: svn://svn.chromium.org/blink/trunk