1 /*
2 * Copyright (C) 2009 Apple Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26 #include "config.h"
27
28 #include "platform/graphics/GraphicsLayer.h"
29
30 #include "SkImageFilter.h"
31 #include "SkMatrix44.h"
32 #include "platform/geometry/FloatRect.h"
33 #include "platform/geometry/LayoutRect.h"
34 #include "platform/graphics/GraphicsLayerFactory.h"
35 #include "platform/graphics/Image.h"
36 #include "platform/graphics/filters/SkiaImageFilterBuilder.h"
37 #include "platform/graphics/skia/NativeImageSkia.h"
38 #include "platform/scroll/ScrollableArea.h"
39 #include "platform/text/TextStream.h"
40 #include "public/platform/Platform.h"
41 #include "public/platform/WebAnimation.h"
42 #include "public/platform/WebCompositorSupport.h"
43 #include "public/platform/WebFilterOperations.h"
44 #include "public/platform/WebFloatPoint.h"
45 #include "public/platform/WebFloatRect.h"
46 #include "public/platform/WebGraphicsLayerDebugInfo.h"
47 #include "public/platform/WebLayer.h"
48 #include "public/platform/WebPoint.h"
49 #include "public/platform/WebSize.h"
50 #include "wtf/CurrentTime.h"
51 #include "wtf/HashMap.h"
52 #include "wtf/HashSet.h"
53 #include "wtf/text/WTFString.h"
54
55 #include <algorithm>
56
57 #ifndef NDEBUG
58 #include <stdio.h>
59 #endif
60
61 using blink::Platform;
62 using blink::WebAnimation;
63 using blink::WebFilterOperations;
64 using blink::WebLayer;
65 using blink::WebPoint;
66
67 namespace WebCore {
68
69 typedef HashMap<const GraphicsLayer*, Vector<FloatRect> > RepaintMap;
repaintRectMap()70 static RepaintMap& repaintRectMap()
71 {
72 DEFINE_STATIC_LOCAL(RepaintMap, map, ());
73 return map;
74 }
75
create(GraphicsLayerFactory * factory,GraphicsLayerClient * client)76 PassOwnPtr<GraphicsLayer> GraphicsLayer::create(GraphicsLayerFactory* factory, GraphicsLayerClient* client)
77 {
78 return factory->createGraphicsLayer(client);
79 }
80
GraphicsLayer(GraphicsLayerClient * client)81 GraphicsLayer::GraphicsLayer(GraphicsLayerClient* client)
82 : m_client(client)
83 , m_backgroundColor(Color::transparent)
84 , m_opacity(1)
85 , m_blendMode(blink::WebBlendModeNormal)
86 , m_hasTransformOrigin(false)
87 , m_contentsOpaque(false)
88 , m_shouldFlattenTransform(true)
89 , m_backfaceVisibility(true)
90 , m_masksToBounds(false)
91 , m_drawsContent(false)
92 , m_contentsVisible(true)
93 , m_isRootForIsolatedGroup(false)
94 , m_hasScrollParent(false)
95 , m_hasClipParent(false)
96 , m_paintingPhase(GraphicsLayerPaintAllWithOverflowClip)
97 , m_parent(0)
98 , m_maskLayer(0)
99 , m_contentsClippingMaskLayer(0)
100 , m_replicaLayer(0)
101 , m_replicatedLayer(0)
102 , m_paintCount(0)
103 , m_contentsLayer(0)
104 , m_contentsLayerId(0)
105 , m_scrollableArea(0)
106 , m_3dRenderingContext(0)
107 {
108 #ifndef NDEBUG
109 if (m_client)
110 m_client->verifyNotPainting();
111 #endif
112
113 m_opaqueRectTrackingContentLayerDelegate = adoptPtr(new OpaqueRectTrackingContentLayerDelegate(this));
114 m_layer = adoptPtr(Platform::current()->compositorSupport()->createContentLayer(m_opaqueRectTrackingContentLayerDelegate.get()));
115 m_layer->layer()->setDrawsContent(m_drawsContent && m_contentsVisible);
116 m_layer->layer()->setWebLayerClient(this);
117 m_layer->setAutomaticallyComputeRasterScale(true);
118 }
119
~GraphicsLayer()120 GraphicsLayer::~GraphicsLayer()
121 {
122 for (size_t i = 0; i < m_linkHighlights.size(); ++i)
123 m_linkHighlights[i]->clearCurrentGraphicsLayer();
124 m_linkHighlights.clear();
125
126 #ifndef NDEBUG
127 if (m_client)
128 m_client->verifyNotPainting();
129 #endif
130
131 if (m_replicaLayer)
132 m_replicaLayer->setReplicatedLayer(0);
133
134 if (m_replicatedLayer)
135 m_replicatedLayer->setReplicatedByLayer(0);
136
137 removeAllChildren();
138 removeFromParent();
139
140 resetTrackedRepaints();
141 ASSERT(!m_parent);
142 }
143
setParent(GraphicsLayer * layer)144 void GraphicsLayer::setParent(GraphicsLayer* layer)
145 {
146 ASSERT(!layer || !layer->hasAncestor(this));
147 m_parent = layer;
148 }
149
150 #if ASSERT_ENABLED
151
hasAncestor(GraphicsLayer * ancestor) const152 bool GraphicsLayer::hasAncestor(GraphicsLayer* ancestor) const
153 {
154 for (GraphicsLayer* curr = parent(); curr; curr = curr->parent()) {
155 if (curr == ancestor)
156 return true;
157 }
158
159 return false;
160 }
161
162 #endif
163
setChildren(const GraphicsLayerVector & newChildren)164 bool GraphicsLayer::setChildren(const GraphicsLayerVector& newChildren)
165 {
166 // If the contents of the arrays are the same, nothing to do.
167 if (newChildren == m_children)
168 return false;
169
170 removeAllChildren();
171
172 size_t listSize = newChildren.size();
173 for (size_t i = 0; i < listSize; ++i)
174 addChildInternal(newChildren[i]);
175
176 updateChildList();
177
178 return true;
179 }
180
addChildInternal(GraphicsLayer * childLayer)181 void GraphicsLayer::addChildInternal(GraphicsLayer* childLayer)
182 {
183 ASSERT(childLayer != this);
184
185 if (childLayer->parent())
186 childLayer->removeFromParent();
187
188 childLayer->setParent(this);
189 m_children.append(childLayer);
190
191 // Don't call updateChildList here, this function is used in cases where it
192 // should not be called until all children are processed.
193 }
194
addChild(GraphicsLayer * childLayer)195 void GraphicsLayer::addChild(GraphicsLayer* childLayer)
196 {
197 addChildInternal(childLayer);
198 updateChildList();
199 }
200
addChildAtIndex(GraphicsLayer * childLayer,int index)201 void GraphicsLayer::addChildAtIndex(GraphicsLayer* childLayer, int index)
202 {
203 ASSERT(childLayer != this);
204
205 if (childLayer->parent())
206 childLayer->removeFromParent();
207
208 childLayer->setParent(this);
209 m_children.insert(index, childLayer);
210
211 updateChildList();
212 }
213
addChildBelow(GraphicsLayer * childLayer,GraphicsLayer * sibling)214 void GraphicsLayer::addChildBelow(GraphicsLayer* childLayer, GraphicsLayer* sibling)
215 {
216 ASSERT(childLayer != this);
217 childLayer->removeFromParent();
218
219 bool found = false;
220 for (unsigned i = 0; i < m_children.size(); i++) {
221 if (sibling == m_children[i]) {
222 m_children.insert(i, childLayer);
223 found = true;
224 break;
225 }
226 }
227
228 childLayer->setParent(this);
229
230 if (!found)
231 m_children.append(childLayer);
232
233 updateChildList();
234 }
235
addChildAbove(GraphicsLayer * childLayer,GraphicsLayer * sibling)236 void GraphicsLayer::addChildAbove(GraphicsLayer* childLayer, GraphicsLayer* sibling)
237 {
238 childLayer->removeFromParent();
239 ASSERT(childLayer != this);
240
241 bool found = false;
242 for (unsigned i = 0; i < m_children.size(); i++) {
243 if (sibling == m_children[i]) {
244 m_children.insert(i+1, childLayer);
245 found = true;
246 break;
247 }
248 }
249
250 childLayer->setParent(this);
251
252 if (!found)
253 m_children.append(childLayer);
254
255 updateChildList();
256 }
257
replaceChild(GraphicsLayer * oldChild,GraphicsLayer * newChild)258 bool GraphicsLayer::replaceChild(GraphicsLayer* oldChild, GraphicsLayer* newChild)
259 {
260 ASSERT(!newChild->parent());
261 bool found = false;
262 for (unsigned i = 0; i < m_children.size(); i++) {
263 if (oldChild == m_children[i]) {
264 m_children[i] = newChild;
265 found = true;
266 break;
267 }
268 }
269
270 if (found) {
271 oldChild->setParent(0);
272
273 newChild->removeFromParent();
274 newChild->setParent(this);
275
276 updateChildList();
277 return true;
278 }
279
280 return false;
281 }
282
removeAllChildren()283 void GraphicsLayer::removeAllChildren()
284 {
285 while (!m_children.isEmpty()) {
286 GraphicsLayer* curLayer = m_children.last();
287 ASSERT(curLayer->parent());
288 curLayer->removeFromParent();
289 }
290 }
291
removeFromParent()292 void GraphicsLayer::removeFromParent()
293 {
294 if (m_parent) {
295 // We use reverseFind so that removeAllChildren() isn't n^2.
296 m_parent->m_children.remove(m_parent->m_children.reverseFind(this));
297 setParent(0);
298 }
299
300 platformLayer()->removeFromParent();
301 }
302
setReplicatedByLayer(GraphicsLayer * layer)303 void GraphicsLayer::setReplicatedByLayer(GraphicsLayer* layer)
304 {
305 // FIXME: this could probably be a full early exit.
306 if (m_replicaLayer != layer) {
307 if (m_replicaLayer)
308 m_replicaLayer->setReplicatedLayer(0);
309
310 if (layer)
311 layer->setReplicatedLayer(this);
312
313 m_replicaLayer = layer;
314 }
315
316 WebLayer* webReplicaLayer = layer ? layer->platformLayer() : 0;
317 platformLayer()->setReplicaLayer(webReplicaLayer);
318 }
319
setOffsetFromRenderer(const IntSize & offset,ShouldSetNeedsDisplay shouldSetNeedsDisplay)320 void GraphicsLayer::setOffsetFromRenderer(const IntSize& offset, ShouldSetNeedsDisplay shouldSetNeedsDisplay)
321 {
322 if (offset == m_offsetFromRenderer)
323 return;
324
325 m_offsetFromRenderer = offset;
326
327 // If the compositing layer offset changes, we need to repaint.
328 if (shouldSetNeedsDisplay == SetNeedsDisplay)
329 setNeedsDisplay();
330 }
331
paintGraphicsLayerContents(GraphicsContext & context,const IntRect & clip)332 void GraphicsLayer::paintGraphicsLayerContents(GraphicsContext& context, const IntRect& clip)
333 {
334 if (!m_client)
335 return;
336 incrementPaintCount();
337 m_client->paintContents(this, context, m_paintingPhase, clip);
338 }
339
updateChildList()340 void GraphicsLayer::updateChildList()
341 {
342 WebLayer* childHost = m_layer->layer();
343 childHost->removeAllChildren();
344
345 clearContentsLayerIfUnregistered();
346
347 if (m_contentsLayer) {
348 // FIXME: add the contents layer in the correct order with negative z-order children.
349 // This does not cause visible rendering issues because currently contents layers are only used
350 // for replaced elements that don't have children.
351 childHost->addChild(m_contentsLayer);
352 }
353
354 for (size_t i = 0; i < m_children.size(); ++i)
355 childHost->addChild(m_children[i]->platformLayer());
356
357 for (size_t i = 0; i < m_linkHighlights.size(); ++i)
358 childHost->addChild(m_linkHighlights[i]->layer());
359 }
360
updateLayerIsDrawable()361 void GraphicsLayer::updateLayerIsDrawable()
362 {
363 // For the rest of the accelerated compositor code, there is no reason to make a
364 // distinction between drawsContent and contentsVisible. So, for m_layer->layer(), these two
365 // flags are combined here. m_contentsLayer shouldn't receive the drawsContent flag
366 // so it is only given contentsVisible.
367
368 m_layer->layer()->setDrawsContent(m_drawsContent && m_contentsVisible);
369 if (WebLayer* contentsLayer = contentsLayerIfRegistered())
370 contentsLayer->setDrawsContent(m_contentsVisible);
371
372 if (m_drawsContent) {
373 m_layer->layer()->invalidate();
374 for (size_t i = 0; i < m_linkHighlights.size(); ++i)
375 m_linkHighlights[i]->invalidate();
376 }
377 }
378
updateContentsRect()379 void GraphicsLayer::updateContentsRect()
380 {
381 WebLayer* contentsLayer = contentsLayerIfRegistered();
382 if (!contentsLayer)
383 return;
384
385 contentsLayer->setPosition(FloatPoint(m_contentsRect.x(), m_contentsRect.y()));
386 contentsLayer->setBounds(IntSize(m_contentsRect.width(), m_contentsRect.height()));
387
388 if (m_contentsClippingMaskLayer) {
389 if (m_contentsClippingMaskLayer->size() != m_contentsRect.size()) {
390 m_contentsClippingMaskLayer->setSize(m_contentsRect.size());
391 m_contentsClippingMaskLayer->setNeedsDisplay();
392 }
393 m_contentsClippingMaskLayer->setPosition(FloatPoint());
394 m_contentsClippingMaskLayer->setOffsetFromRenderer(offsetFromRenderer() + IntSize(m_contentsRect.location().x(), m_contentsRect.location().y()));
395 }
396 }
397
398 static HashSet<int>* s_registeredLayerSet;
399
registerContentsLayer(WebLayer * layer)400 void GraphicsLayer::registerContentsLayer(WebLayer* layer)
401 {
402 if (!s_registeredLayerSet)
403 s_registeredLayerSet = new HashSet<int>;
404 if (s_registeredLayerSet->contains(layer->id()))
405 CRASH();
406 s_registeredLayerSet->add(layer->id());
407 }
408
unregisterContentsLayer(WebLayer * layer)409 void GraphicsLayer::unregisterContentsLayer(WebLayer* layer)
410 {
411 ASSERT(s_registeredLayerSet);
412 if (!s_registeredLayerSet->contains(layer->id()))
413 CRASH();
414 s_registeredLayerSet->remove(layer->id());
415 }
416
setContentsTo(WebLayer * layer)417 void GraphicsLayer::setContentsTo(WebLayer* layer)
418 {
419 bool childrenChanged = false;
420 if (layer) {
421 ASSERT(s_registeredLayerSet);
422 if (!s_registeredLayerSet->contains(layer->id()))
423 CRASH();
424 if (m_contentsLayerId != layer->id()) {
425 setupContentsLayer(layer);
426 childrenChanged = true;
427 }
428 updateContentsRect();
429 } else {
430 if (m_contentsLayer) {
431 childrenChanged = true;
432
433 // The old contents layer will be removed via updateChildList.
434 m_contentsLayer = 0;
435 m_contentsLayerId = 0;
436 }
437 }
438
439 if (childrenChanged)
440 updateChildList();
441 }
442
setupContentsLayer(WebLayer * contentsLayer)443 void GraphicsLayer::setupContentsLayer(WebLayer* contentsLayer)
444 {
445 ASSERT(contentsLayer);
446 m_contentsLayer = contentsLayer;
447 m_contentsLayerId = m_contentsLayer->id();
448
449 m_contentsLayer->setWebLayerClient(this);
450 m_contentsLayer->setTransformOrigin(FloatPoint3D());
451 m_contentsLayer->setUseParentBackfaceVisibility(true);
452
453 // It is necessary to call setDrawsContent as soon as we receive the new contentsLayer, for
454 // the correctness of early exit conditions in setDrawsContent() and setContentsVisible().
455 m_contentsLayer->setDrawsContent(m_contentsVisible);
456
457 // Insert the content layer first. Video elements require this, because they have
458 // shadow content that must display in front of the video.
459 m_layer->layer()->insertChild(m_contentsLayer, 0);
460 WebLayer* borderWebLayer = m_contentsClippingMaskLayer ? m_contentsClippingMaskLayer->platformLayer() : 0;
461 m_contentsLayer->setMaskLayer(borderWebLayer);
462
463 m_contentsLayer->setRenderingContext(m_3dRenderingContext);
464 }
465
clearContentsLayerIfUnregistered()466 void GraphicsLayer::clearContentsLayerIfUnregistered()
467 {
468 if (!m_contentsLayerId || s_registeredLayerSet->contains(m_contentsLayerId))
469 return;
470
471 m_contentsLayer = 0;
472 m_contentsLayerId = 0;
473 }
474
debugInfo()475 GraphicsLayerDebugInfo& GraphicsLayer::debugInfo()
476 {
477 return m_debugInfo;
478 }
479
takeDebugInfoFor(WebLayer * layer)480 blink::WebGraphicsLayerDebugInfo* GraphicsLayer::takeDebugInfoFor(WebLayer* layer)
481 {
482 GraphicsLayerDebugInfo* clone = m_debugInfo.clone();
483 clone->setDebugName(debugName(layer));
484 return clone;
485 }
486
contentsLayerIfRegistered()487 WebLayer* GraphicsLayer::contentsLayerIfRegistered()
488 {
489 clearContentsLayerIfUnregistered();
490 return m_contentsLayer;
491 }
492
resetTrackedRepaints()493 void GraphicsLayer::resetTrackedRepaints()
494 {
495 repaintRectMap().remove(this);
496 }
497
addRepaintRect(const FloatRect & repaintRect)498 void GraphicsLayer::addRepaintRect(const FloatRect& repaintRect)
499 {
500 if (m_client->isTrackingRepaints()) {
501 FloatRect largestRepaintRect(FloatPoint(), m_size);
502 largestRepaintRect.intersect(repaintRect);
503 RepaintMap::iterator repaintIt = repaintRectMap().find(this);
504 if (repaintIt == repaintRectMap().end()) {
505 Vector<FloatRect> repaintRects;
506 repaintRects.append(largestRepaintRect);
507 repaintRectMap().set(this, repaintRects);
508 } else {
509 Vector<FloatRect>& repaintRects = repaintIt->value;
510 repaintRects.append(largestRepaintRect);
511 }
512 }
513 }
514
collectTrackedRepaintRects(Vector<FloatRect> & rects) const515 void GraphicsLayer::collectTrackedRepaintRects(Vector<FloatRect>& rects) const
516 {
517 if (!m_client->isTrackingRepaints())
518 return;
519
520 RepaintMap::iterator repaintIt = repaintRectMap().find(this);
521 if (repaintIt != repaintRectMap().end())
522 rects.appendVector(repaintIt->value);
523 }
524
dumpLayer(TextStream & ts,int indent,LayerTreeFlags flags,RenderingContextMap & renderingContextMap) const525 void GraphicsLayer::dumpLayer(TextStream& ts, int indent, LayerTreeFlags flags, RenderingContextMap& renderingContextMap) const
526 {
527 writeIndent(ts, indent);
528 ts << "(" << "GraphicsLayer";
529
530 if (flags & LayerTreeIncludesDebugInfo) {
531 ts << " " << static_cast<void*>(const_cast<GraphicsLayer*>(this));
532 ts << " \"" << m_client->debugName(this) << "\"";
533 }
534
535 ts << "\n";
536 dumpProperties(ts, indent, flags, renderingContextMap);
537 writeIndent(ts, indent);
538 ts << ")\n";
539 }
540
compareFloatRects(const FloatRect & a,const FloatRect & b)541 static bool compareFloatRects(const FloatRect& a, const FloatRect& b)
542 {
543 if (a.x() != b.x())
544 return a.x() > b.x();
545 if (a.y() != b.y())
546 return a.y() > b.y();
547 if (a.width() != b.width())
548 return a.width() > b.width();
549 return a.height() > b.height();
550 }
551
dumpProperties(TextStream & ts,int indent,LayerTreeFlags flags,RenderingContextMap & renderingContextMap) const552 void GraphicsLayer::dumpProperties(TextStream& ts, int indent, LayerTreeFlags flags, RenderingContextMap& renderingContextMap) const
553 {
554 if (m_position != FloatPoint()) {
555 writeIndent(ts, indent + 1);
556 ts << "(position " << m_position.x() << " " << m_position.y() << ")\n";
557 }
558
559 if (m_boundsOrigin != FloatPoint()) {
560 writeIndent(ts, indent + 1);
561 ts << "(bounds origin " << m_boundsOrigin.x() << " " << m_boundsOrigin.y() << ")\n";
562 }
563
564 if (m_hasTransformOrigin && m_transformOrigin != FloatPoint3D(m_size.width() * 0.5f, m_size.height() * 0.5f, 0)) {
565 writeIndent(ts, indent + 1);
566 ts << "(transformOrigin " << m_transformOrigin.x() << " " << m_transformOrigin.y() << ")\n";
567 }
568
569 if (m_size != IntSize()) {
570 writeIndent(ts, indent + 1);
571 ts << "(bounds " << m_size.width() << " " << m_size.height() << ")\n";
572 }
573
574 if (m_opacity != 1) {
575 writeIndent(ts, indent + 1);
576 ts << "(opacity " << m_opacity << ")\n";
577 }
578
579 if (m_blendMode != blink::WebBlendModeNormal) {
580 writeIndent(ts, indent + 1);
581 ts << "(blendMode " << compositeOperatorName(CompositeSourceOver, m_blendMode) << ")\n";
582 }
583
584 if (m_isRootForIsolatedGroup) {
585 writeIndent(ts, indent + 1);
586 ts << "(isolate " << m_isRootForIsolatedGroup << ")\n";
587 }
588
589 if (m_contentsOpaque) {
590 writeIndent(ts, indent + 1);
591 ts << "(contentsOpaque " << m_contentsOpaque << ")\n";
592 }
593
594 if (!m_shouldFlattenTransform) {
595 writeIndent(ts, indent + 1);
596 ts << "(shouldFlattenTransform " << m_shouldFlattenTransform << ")\n";
597 }
598
599 if (m_3dRenderingContext) {
600 RenderingContextMap::const_iterator it = renderingContextMap.find(m_3dRenderingContext);
601 int contextId = renderingContextMap.size() + 1;
602 if (it == renderingContextMap.end())
603 renderingContextMap.set(m_3dRenderingContext, contextId);
604 else
605 contextId = it->value;
606
607 writeIndent(ts, indent + 1);
608 ts << "(3dRenderingContext " << contextId << ")\n";
609 }
610
611 if (m_drawsContent) {
612 writeIndent(ts, indent + 1);
613 ts << "(drawsContent " << m_drawsContent << ")\n";
614 }
615
616 if (!m_contentsVisible) {
617 writeIndent(ts, indent + 1);
618 ts << "(contentsVisible " << m_contentsVisible << ")\n";
619 }
620
621 if (!m_backfaceVisibility) {
622 writeIndent(ts, indent + 1);
623 ts << "(backfaceVisibility " << (m_backfaceVisibility ? "visible" : "hidden") << ")\n";
624 }
625
626 if (flags & LayerTreeIncludesDebugInfo) {
627 writeIndent(ts, indent + 1);
628 ts << "(";
629 if (m_client)
630 ts << "client " << static_cast<void*>(m_client);
631 else
632 ts << "no client";
633 ts << ")\n";
634 }
635
636 if (m_backgroundColor.alpha()) {
637 writeIndent(ts, indent + 1);
638 ts << "(backgroundColor " << m_backgroundColor.nameForRenderTreeAsText() << ")\n";
639 }
640
641 if (!m_transform.isIdentity()) {
642 writeIndent(ts, indent + 1);
643 ts << "(transform ";
644 ts << "[" << m_transform.m11() << " " << m_transform.m12() << " " << m_transform.m13() << " " << m_transform.m14() << "] ";
645 ts << "[" << m_transform.m21() << " " << m_transform.m22() << " " << m_transform.m23() << " " << m_transform.m24() << "] ";
646 ts << "[" << m_transform.m31() << " " << m_transform.m32() << " " << m_transform.m33() << " " << m_transform.m34() << "] ";
647 ts << "[" << m_transform.m41() << " " << m_transform.m42() << " " << m_transform.m43() << " " << m_transform.m44() << "])\n";
648 }
649
650 if (m_replicaLayer) {
651 writeIndent(ts, indent + 1);
652 ts << "(replica layer";
653 if (flags & LayerTreeIncludesDebugInfo)
654 ts << " " << m_replicaLayer;
655 ts << ")\n";
656 m_replicaLayer->dumpLayer(ts, indent + 2, flags, renderingContextMap);
657 }
658
659 if (m_replicatedLayer) {
660 writeIndent(ts, indent + 1);
661 ts << "(replicated layer";
662 if (flags & LayerTreeIncludesDebugInfo)
663 ts << " " << m_replicatedLayer;
664 ts << ")\n";
665 }
666
667 if ((flags & LayerTreeIncludesRepaintRects) && repaintRectMap().contains(this) && !repaintRectMap().get(this).isEmpty()) {
668 Vector<FloatRect> repaintRectsCopy = repaintRectMap().get(this);
669 std::sort(repaintRectsCopy.begin(), repaintRectsCopy.end(), &compareFloatRects);
670 writeIndent(ts, indent + 1);
671 ts << "(repaint rects\n";
672 for (size_t i = 0; i < repaintRectsCopy.size(); ++i) {
673 if (repaintRectsCopy[i].isEmpty())
674 continue;
675 writeIndent(ts, indent + 2);
676 ts << "(rect ";
677 ts << repaintRectsCopy[i].x() << " ";
678 ts << repaintRectsCopy[i].y() << " ";
679 ts << repaintRectsCopy[i].width() << " ";
680 ts << repaintRectsCopy[i].height();
681 ts << ")\n";
682 }
683 writeIndent(ts, indent + 1);
684 ts << ")\n";
685 }
686
687 if ((flags & LayerTreeIncludesPaintingPhases) && m_paintingPhase) {
688 writeIndent(ts, indent + 1);
689 ts << "(paintingPhases\n";
690 if (m_paintingPhase & GraphicsLayerPaintBackground) {
691 writeIndent(ts, indent + 2);
692 ts << "GraphicsLayerPaintBackground\n";
693 }
694 if (m_paintingPhase & GraphicsLayerPaintForeground) {
695 writeIndent(ts, indent + 2);
696 ts << "GraphicsLayerPaintForeground\n";
697 }
698 if (m_paintingPhase & GraphicsLayerPaintMask) {
699 writeIndent(ts, indent + 2);
700 ts << "GraphicsLayerPaintMask\n";
701 }
702 if (m_paintingPhase & GraphicsLayerPaintChildClippingMask) {
703 writeIndent(ts, indent + 2);
704 ts << "GraphicsLayerPaintChildClippingMask\n";
705 }
706 if (m_paintingPhase & GraphicsLayerPaintOverflowContents) {
707 writeIndent(ts, indent + 2);
708 ts << "GraphicsLayerPaintOverflowContents\n";
709 }
710 if (m_paintingPhase & GraphicsLayerPaintCompositedScroll) {
711 writeIndent(ts, indent + 2);
712 ts << "GraphicsLayerPaintCompositedScroll\n";
713 }
714 writeIndent(ts, indent + 1);
715 ts << ")\n";
716 }
717
718 if (flags & LayerTreeIncludesClipAndScrollParents) {
719 if (m_hasScrollParent) {
720 writeIndent(ts, indent + 1);
721 ts << "(hasScrollParent 1)\n";
722 }
723 if (m_hasClipParent) {
724 writeIndent(ts, indent + 1);
725 ts << "(hasClipParent 1)\n";
726 }
727 }
728
729 if (flags & LayerTreeIncludesDebugInfo) {
730 writeIndent(ts, indent + 1);
731 ts << "(compositingReasons\n";
732 for (size_t i = 0; i < WTF_ARRAY_LENGTH(compositingReasonStringMap); ++i) {
733 if (m_debugInfo.compositingReasons() & compositingReasonStringMap[i].reason) {
734 writeIndent(ts, indent + 2);
735 ts << compositingReasonStringMap[i].description << "\n";
736 }
737 }
738 writeIndent(ts, indent + 1);
739 ts << ")\n";
740 }
741
742 if (m_children.size()) {
743 writeIndent(ts, indent + 1);
744 ts << "(children " << m_children.size() << "\n";
745
746 unsigned i;
747 for (i = 0; i < m_children.size(); i++)
748 m_children[i]->dumpLayer(ts, indent + 2, flags, renderingContextMap);
749 writeIndent(ts, indent + 1);
750 ts << ")\n";
751 }
752 }
753
layerTreeAsText(LayerTreeFlags flags) const754 String GraphicsLayer::layerTreeAsText(LayerTreeFlags flags) const
755 {
756 TextStream ts;
757
758 RenderingContextMap renderingContextMap;
759 dumpLayer(ts, 0, flags, renderingContextMap);
760 return ts.release();
761 }
762
debugName(blink::WebLayer * webLayer) const763 String GraphicsLayer::debugName(blink::WebLayer* webLayer) const
764 {
765 String name;
766 if (!m_client)
767 return name;
768
769 String highlightDebugName;
770 for (size_t i = 0; i < m_linkHighlights.size(); ++i) {
771 if (webLayer == m_linkHighlights[i]->layer()) {
772 highlightDebugName = "LinkHighlight[" + String::number(i) + "] for " + m_client->debugName(this);
773 break;
774 }
775 }
776
777 if (webLayer == m_contentsLayer) {
778 name = "ContentsLayer for " + m_client->debugName(this);
779 } else if (!highlightDebugName.isEmpty()) {
780 name = highlightDebugName;
781 } else if (webLayer == m_layer->layer()) {
782 name = m_client->debugName(this);
783 } else {
784 ASSERT_NOT_REACHED();
785 }
786 return name;
787 }
788
setCompositingReasons(CompositingReasons reasons)789 void GraphicsLayer::setCompositingReasons(CompositingReasons reasons)
790 {
791 m_debugInfo.setCompositingReasons(reasons);
792 }
793
setOwnerNodeId(int nodeId)794 void GraphicsLayer::setOwnerNodeId(int nodeId)
795 {
796 m_debugInfo.setOwnerNodeId(nodeId);
797 }
798
setPosition(const FloatPoint & point)799 void GraphicsLayer::setPosition(const FloatPoint& point)
800 {
801 m_position = point;
802 platformLayer()->setPosition(m_position);
803 }
804
setSize(const FloatSize & size)805 void GraphicsLayer::setSize(const FloatSize& size)
806 {
807 // We are receiving negative sizes here that cause assertions to fail in the compositor. Clamp them to 0 to
808 // avoid those assertions.
809 // FIXME: This should be an ASSERT instead, as negative sizes should not exist in WebCore.
810 FloatSize clampedSize = size;
811 if (clampedSize.width() < 0 || clampedSize.height() < 0)
812 clampedSize = FloatSize();
813
814 if (clampedSize == m_size)
815 return;
816
817 m_size = clampedSize;
818
819 m_layer->layer()->setBounds(flooredIntSize(m_size));
820 // Note that we don't resize m_contentsLayer. It's up the caller to do that.
821 }
822
setTransform(const TransformationMatrix & transform)823 void GraphicsLayer::setTransform(const TransformationMatrix& transform)
824 {
825 m_transform = transform;
826 platformLayer()->setTransform(TransformationMatrix::toSkMatrix44(m_transform));
827 }
828
setTransformOrigin(const FloatPoint3D & transformOrigin)829 void GraphicsLayer::setTransformOrigin(const FloatPoint3D& transformOrigin)
830 {
831 m_hasTransformOrigin = true;
832 m_transformOrigin = transformOrigin;
833 platformLayer()->setTransformOrigin(transformOrigin);
834 }
835
setShouldFlattenTransform(bool shouldFlatten)836 void GraphicsLayer::setShouldFlattenTransform(bool shouldFlatten)
837 {
838 if (shouldFlatten == m_shouldFlattenTransform)
839 return;
840
841 m_shouldFlattenTransform = shouldFlatten;
842
843 m_layer->layer()->setShouldFlattenTransform(shouldFlatten);
844 }
845
setRenderingContext(int context)846 void GraphicsLayer::setRenderingContext(int context)
847 {
848 if (m_3dRenderingContext == context)
849 return;
850
851 m_3dRenderingContext = context;
852 m_layer->layer()->setRenderingContext(context);
853
854 if (m_contentsLayer)
855 m_contentsLayer->setRenderingContext(m_3dRenderingContext);
856 }
857
setMasksToBounds(bool masksToBounds)858 void GraphicsLayer::setMasksToBounds(bool masksToBounds)
859 {
860 m_masksToBounds = masksToBounds;
861 m_layer->layer()->setMasksToBounds(m_masksToBounds);
862 }
863
setDrawsContent(bool drawsContent)864 void GraphicsLayer::setDrawsContent(bool drawsContent)
865 {
866 // Note carefully this early-exit is only correct because we also properly call
867 // WebLayer::setDrawsContent whenever m_contentsLayer is set to a new layer in setupContentsLayer().
868 if (drawsContent == m_drawsContent)
869 return;
870
871 m_drawsContent = drawsContent;
872 updateLayerIsDrawable();
873 }
874
setContentsVisible(bool contentsVisible)875 void GraphicsLayer::setContentsVisible(bool contentsVisible)
876 {
877 // Note carefully this early-exit is only correct because we also properly call
878 // WebLayer::setDrawsContent whenever m_contentsLayer is set to a new layer in setupContentsLayer().
879 if (contentsVisible == m_contentsVisible)
880 return;
881
882 m_contentsVisible = contentsVisible;
883 updateLayerIsDrawable();
884 }
885
setClipParent(blink::WebLayer * parent)886 void GraphicsLayer::setClipParent(blink::WebLayer* parent)
887 {
888 m_hasClipParent = !!parent;
889 m_layer->layer()->setClipParent(parent);
890 }
891
setScrollParent(blink::WebLayer * parent)892 void GraphicsLayer::setScrollParent(blink::WebLayer* parent)
893 {
894 m_hasScrollParent = !!parent;
895 m_layer->layer()->setScrollParent(parent);
896 }
897
setBackgroundColor(const Color & color)898 void GraphicsLayer::setBackgroundColor(const Color& color)
899 {
900 if (color == m_backgroundColor)
901 return;
902
903 m_backgroundColor = color;
904 m_layer->layer()->setBackgroundColor(m_backgroundColor.rgb());
905 }
906
setContentsOpaque(bool opaque)907 void GraphicsLayer::setContentsOpaque(bool opaque)
908 {
909 m_contentsOpaque = opaque;
910 m_layer->layer()->setOpaque(m_contentsOpaque);
911 m_opaqueRectTrackingContentLayerDelegate->setOpaque(m_contentsOpaque);
912 }
913
setMaskLayer(GraphicsLayer * maskLayer)914 void GraphicsLayer::setMaskLayer(GraphicsLayer* maskLayer)
915 {
916 if (maskLayer == m_maskLayer)
917 return;
918
919 m_maskLayer = maskLayer;
920 WebLayer* maskWebLayer = m_maskLayer ? m_maskLayer->platformLayer() : 0;
921 m_layer->layer()->setMaskLayer(maskWebLayer);
922 }
923
setContentsClippingMaskLayer(GraphicsLayer * contentsClippingMaskLayer)924 void GraphicsLayer::setContentsClippingMaskLayer(GraphicsLayer* contentsClippingMaskLayer)
925 {
926 if (contentsClippingMaskLayer == m_contentsClippingMaskLayer)
927 return;
928
929 m_contentsClippingMaskLayer = contentsClippingMaskLayer;
930 WebLayer* contentsLayer = contentsLayerIfRegistered();
931 if (!contentsLayer)
932 return;
933 WebLayer* contentsClippingMaskWebLayer = m_contentsClippingMaskLayer ? m_contentsClippingMaskLayer->platformLayer() : 0;
934 contentsLayer->setMaskLayer(contentsClippingMaskWebLayer);
935 updateContentsRect();
936 }
937
setBackfaceVisibility(bool visible)938 void GraphicsLayer::setBackfaceVisibility(bool visible)
939 {
940 m_backfaceVisibility = visible;
941 m_layer->setDoubleSided(m_backfaceVisibility);
942 }
943
setOpacity(float opacity)944 void GraphicsLayer::setOpacity(float opacity)
945 {
946 float clampedOpacity = std::max(std::min(opacity, 1.0f), 0.0f);
947 m_opacity = clampedOpacity;
948 platformLayer()->setOpacity(opacity);
949 }
950
setBlendMode(blink::WebBlendMode blendMode)951 void GraphicsLayer::setBlendMode(blink::WebBlendMode blendMode)
952 {
953 if (m_blendMode == blendMode)
954 return;
955 m_blendMode = blendMode;
956 platformLayer()->setBlendMode(blink::WebBlendMode(blendMode));
957 }
958
setIsRootForIsolatedGroup(bool isolated)959 void GraphicsLayer::setIsRootForIsolatedGroup(bool isolated)
960 {
961 if (m_isRootForIsolatedGroup == isolated)
962 return;
963 m_isRootForIsolatedGroup = isolated;
964 platformLayer()->setIsRootForIsolatedGroup(isolated);
965 }
966
setContentsNeedsDisplay()967 void GraphicsLayer::setContentsNeedsDisplay()
968 {
969 if (WebLayer* contentsLayer = contentsLayerIfRegistered()) {
970 contentsLayer->invalidate();
971 addRepaintRect(m_contentsRect);
972 }
973 }
974
setNeedsDisplay()975 void GraphicsLayer::setNeedsDisplay()
976 {
977 if (drawsContent()) {
978 m_layer->layer()->invalidate();
979 addRepaintRect(FloatRect(FloatPoint(), m_size));
980 for (size_t i = 0; i < m_linkHighlights.size(); ++i)
981 m_linkHighlights[i]->invalidate();
982 }
983 }
984
setNeedsDisplayInRect(const FloatRect & rect)985 void GraphicsLayer::setNeedsDisplayInRect(const FloatRect& rect)
986 {
987 if (drawsContent()) {
988 m_layer->layer()->invalidateRect(rect);
989 addRepaintRect(rect);
990 for (size_t i = 0; i < m_linkHighlights.size(); ++i)
991 m_linkHighlights[i]->invalidate();
992 }
993 }
994
setContentsRect(const IntRect & rect)995 void GraphicsLayer::setContentsRect(const IntRect& rect)
996 {
997 if (rect == m_contentsRect)
998 return;
999
1000 m_contentsRect = rect;
1001 updateContentsRect();
1002 }
1003
setContentsToImage(Image * image)1004 void GraphicsLayer::setContentsToImage(Image* image)
1005 {
1006 RefPtr<NativeImageSkia> nativeImage = image ? image->nativeImageForCurrentFrame() : nullptr;
1007 if (nativeImage) {
1008 if (!m_imageLayer) {
1009 m_imageLayer = adoptPtr(Platform::current()->compositorSupport()->createImageLayer());
1010 registerContentsLayer(m_imageLayer->layer());
1011 }
1012 m_imageLayer->setBitmap(nativeImage->bitmap());
1013 m_imageLayer->layer()->setOpaque(image->currentFrameKnownToBeOpaque());
1014 updateContentsRect();
1015 } else {
1016 if (m_imageLayer) {
1017 unregisterContentsLayer(m_imageLayer->layer());
1018 m_imageLayer.clear();
1019 }
1020 }
1021
1022 setContentsTo(m_imageLayer ? m_imageLayer->layer() : 0);
1023 }
1024
setContentsToNinePatch(Image * image,const IntRect & aperture)1025 void GraphicsLayer::setContentsToNinePatch(Image* image, const IntRect& aperture)
1026 {
1027 if (m_ninePatchLayer) {
1028 unregisterContentsLayer(m_ninePatchLayer->layer());
1029 m_ninePatchLayer.clear();
1030 }
1031 RefPtr<NativeImageSkia> nativeImage = image ? image->nativeImageForCurrentFrame() : nullptr;
1032 if (nativeImage) {
1033 m_ninePatchLayer = adoptPtr(Platform::current()->compositorSupport()->createNinePatchLayer());
1034 m_ninePatchLayer->setBitmap(nativeImage->bitmap(), aperture);
1035 m_ninePatchLayer->layer()->setOpaque(image->currentFrameKnownToBeOpaque());
1036 registerContentsLayer(m_ninePatchLayer->layer());
1037 }
1038 setContentsTo(m_ninePatchLayer ? m_ninePatchLayer->layer() : 0);
1039 }
1040
addAnimation(PassOwnPtr<WebAnimation> popAnimation)1041 bool GraphicsLayer::addAnimation(PassOwnPtr<WebAnimation> popAnimation)
1042 {
1043 OwnPtr<WebAnimation> animation(popAnimation);
1044 ASSERT(animation);
1045 platformLayer()->setAnimationDelegate(this);
1046
1047 // Remove any existing animations with the same animation id and target property.
1048 platformLayer()->removeAnimation(animation->id(), animation->targetProperty());
1049 return platformLayer()->addAnimation(animation.leakPtr());
1050 }
1051
pauseAnimation(int animationId,double timeOffset)1052 void GraphicsLayer::pauseAnimation(int animationId, double timeOffset)
1053 {
1054 platformLayer()->pauseAnimation(animationId, timeOffset);
1055 }
1056
removeAnimation(int animationId)1057 void GraphicsLayer::removeAnimation(int animationId)
1058 {
1059 platformLayer()->removeAnimation(animationId);
1060 }
1061
platformLayer() const1062 WebLayer* GraphicsLayer::platformLayer() const
1063 {
1064 return m_layer->layer();
1065 }
1066
copyWebCoreFilterOperationsToWebFilterOperations(const FilterOperations & filters,WebFilterOperations & webFilters)1067 static bool copyWebCoreFilterOperationsToWebFilterOperations(const FilterOperations& filters, WebFilterOperations& webFilters)
1068 {
1069 for (size_t i = 0; i < filters.size(); ++i) {
1070 const FilterOperation& op = *filters.at(i);
1071 switch (op.type()) {
1072 case FilterOperation::REFERENCE:
1073 return false; // Not supported.
1074 case FilterOperation::GRAYSCALE:
1075 case FilterOperation::SEPIA:
1076 case FilterOperation::SATURATE:
1077 case FilterOperation::HUE_ROTATE: {
1078 float amount = toBasicColorMatrixFilterOperation(op).amount();
1079 switch (op.type()) {
1080 case FilterOperation::GRAYSCALE:
1081 webFilters.appendGrayscaleFilter(amount);
1082 break;
1083 case FilterOperation::SEPIA:
1084 webFilters.appendSepiaFilter(amount);
1085 break;
1086 case FilterOperation::SATURATE:
1087 webFilters.appendSaturateFilter(amount);
1088 break;
1089 case FilterOperation::HUE_ROTATE:
1090 webFilters.appendHueRotateFilter(amount);
1091 break;
1092 default:
1093 ASSERT_NOT_REACHED();
1094 }
1095 break;
1096 }
1097 case FilterOperation::INVERT:
1098 case FilterOperation::OPACITY:
1099 case FilterOperation::BRIGHTNESS:
1100 case FilterOperation::CONTRAST: {
1101 float amount = toBasicComponentTransferFilterOperation(op).amount();
1102 switch (op.type()) {
1103 case FilterOperation::INVERT:
1104 webFilters.appendInvertFilter(amount);
1105 break;
1106 case FilterOperation::OPACITY:
1107 webFilters.appendOpacityFilter(amount);
1108 break;
1109 case FilterOperation::BRIGHTNESS:
1110 webFilters.appendBrightnessFilter(amount);
1111 break;
1112 case FilterOperation::CONTRAST:
1113 webFilters.appendContrastFilter(amount);
1114 break;
1115 default:
1116 ASSERT_NOT_REACHED();
1117 }
1118 break;
1119 }
1120 case FilterOperation::BLUR: {
1121 float pixelRadius = toBlurFilterOperation(op).stdDeviation().getFloatValue();
1122 webFilters.appendBlurFilter(pixelRadius);
1123 break;
1124 }
1125 case FilterOperation::DROP_SHADOW: {
1126 const DropShadowFilterOperation& dropShadowOp = toDropShadowFilterOperation(op);
1127 webFilters.appendDropShadowFilter(WebPoint(dropShadowOp.x(), dropShadowOp.y()), dropShadowOp.stdDeviation(), dropShadowOp.color().rgb());
1128 break;
1129 }
1130 case FilterOperation::NONE:
1131 break;
1132 }
1133 }
1134 return true;
1135 }
1136
setFilters(const FilterOperations & filters)1137 bool GraphicsLayer::setFilters(const FilterOperations& filters)
1138 {
1139 SkiaImageFilterBuilder builder;
1140 OwnPtr<WebFilterOperations> webFilters = adoptPtr(Platform::current()->compositorSupport()->createFilterOperations());
1141 FilterOutsets outsets = filters.outsets();
1142 builder.setCropOffset(FloatSize(outsets.left(), outsets.top()));
1143 if (!builder.buildFilterOperations(filters, webFilters.get())) {
1144 // Make sure the filters are removed from the platform layer, as they are
1145 // going to fallback to software mode.
1146 webFilters->clear();
1147 m_layer->layer()->setFilters(*webFilters);
1148 m_filters = FilterOperations();
1149 return false;
1150 }
1151
1152 m_layer->layer()->setFilters(*webFilters);
1153 m_filters = filters;
1154 return true;
1155 }
1156
setBackgroundFilters(const FilterOperations & filters)1157 void GraphicsLayer::setBackgroundFilters(const FilterOperations& filters)
1158 {
1159 OwnPtr<WebFilterOperations> webFilters = adoptPtr(Platform::current()->compositorSupport()->createFilterOperations());
1160 if (!copyWebCoreFilterOperationsToWebFilterOperations(filters, *webFilters))
1161 return;
1162 m_layer->layer()->setBackgroundFilters(*webFilters);
1163 }
1164
setPaintingPhase(GraphicsLayerPaintingPhase phase)1165 void GraphicsLayer::setPaintingPhase(GraphicsLayerPaintingPhase phase)
1166 {
1167 if (m_paintingPhase == phase)
1168 return;
1169 m_paintingPhase = phase;
1170 setNeedsDisplay();
1171 }
1172
addLinkHighlight(LinkHighlightClient * linkHighlight)1173 void GraphicsLayer::addLinkHighlight(LinkHighlightClient* linkHighlight)
1174 {
1175 ASSERT(linkHighlight && !m_linkHighlights.contains(linkHighlight));
1176 m_linkHighlights.append(linkHighlight);
1177 linkHighlight->layer()->setWebLayerClient(this);
1178 updateChildList();
1179 }
1180
removeLinkHighlight(LinkHighlightClient * linkHighlight)1181 void GraphicsLayer::removeLinkHighlight(LinkHighlightClient* linkHighlight)
1182 {
1183 m_linkHighlights.remove(m_linkHighlights.find(linkHighlight));
1184 updateChildList();
1185 }
1186
setScrollableArea(ScrollableArea * scrollableArea,bool isMainFrame)1187 void GraphicsLayer::setScrollableArea(ScrollableArea* scrollableArea, bool isMainFrame)
1188 {
1189 if (m_scrollableArea == scrollableArea)
1190 return;
1191
1192 m_scrollableArea = scrollableArea;
1193
1194 // Main frame scrolling may involve pinch zoom and gets routed through
1195 // WebViewImpl explicitly rather than via GraphicsLayer::didScroll.
1196 // TODO(bokan): With pinch virtual viewport the special case will no
1197 // longer be needed, remove once old-style pinch is gone.
1198 if (isMainFrame)
1199 m_layer->layer()->setScrollClient(0);
1200 else
1201 m_layer->layer()->setScrollClient(this);
1202 }
1203
paint(GraphicsContext & context,const IntRect & clip)1204 void GraphicsLayer::paint(GraphicsContext& context, const IntRect& clip)
1205 {
1206 paintGraphicsLayerContents(context, clip);
1207 }
1208
1209
notifyAnimationStarted(double monotonicTime,WebAnimation::TargetProperty)1210 void GraphicsLayer::notifyAnimationStarted(double monotonicTime, WebAnimation::TargetProperty)
1211 {
1212 if (m_client)
1213 m_client->notifyAnimationStarted(this, monotonicTime);
1214 }
1215
notifyAnimationFinished(double,WebAnimation::TargetProperty)1216 void GraphicsLayer::notifyAnimationFinished(double, WebAnimation::TargetProperty)
1217 {
1218 // Do nothing.
1219 }
1220
didScroll()1221 void GraphicsLayer::didScroll()
1222 {
1223 if (m_scrollableArea)
1224 m_scrollableArea->scrollToOffsetWithoutAnimation(m_scrollableArea->minimumScrollPosition() + toIntSize(m_layer->layer()->scrollPosition()));
1225 }
1226
1227 } // namespace WebCore
1228
1229 #ifndef NDEBUG
showGraphicsLayerTree(const WebCore::GraphicsLayer * layer)1230 void showGraphicsLayerTree(const WebCore::GraphicsLayer* layer)
1231 {
1232 if (!layer)
1233 return;
1234
1235 String output = layer->layerTreeAsText(WebCore::LayerTreeIncludesDebugInfo);
1236 fprintf(stderr, "%s\n", output.utf8().data());
1237 }
1238 #endif
1239