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 #if USE(ACCELERATED_COMPOSITING) 29 30 #include "RenderLayerBacking.h" 31 32 #include "AnimationController.h" 33 #include "CanvasRenderingContext.h" 34 #include "CanvasRenderingContext2D.h" 35 #include "CSSPropertyNames.h" 36 #include "CSSStyleSelector.h" 37 #include "FrameView.h" 38 #include "GraphicsContext.h" 39 #include "GraphicsLayer.h" 40 #include "HTMLCanvasElement.h" 41 #include "HTMLElement.h" 42 #include "HTMLIFrameElement.h" 43 #include "HTMLMediaElement.h" 44 #include "HTMLNames.h" 45 #include "InspectorInstrumentation.h" 46 #include "KeyframeList.h" 47 #include "PluginViewBase.h" 48 #include "RenderApplet.h" 49 #include "RenderBox.h" 50 #include "RenderIFrame.h" 51 #include "RenderImage.h" 52 #include "RenderLayerCompositor.h" 53 #include "RenderEmbeddedObject.h" 54 #include "RenderVideo.h" 55 #include "RenderView.h" 56 #include "Settings.h" 57 58 #if ENABLE(WEBGL) || ENABLE(ACCELERATED_2D_CANVAS) 59 #include "GraphicsContext3D.h" 60 #endif 61 62 using namespace std; 63 64 namespace WebCore { 65 66 using namespace HTMLNames; 67 68 static bool hasBorderOutlineOrShadow(const RenderStyle*); 69 static bool hasBoxDecorationsOrBackground(const RenderObject*); 70 static bool hasBoxDecorationsOrBackgroundImage(const RenderStyle*); 71 static IntRect clipBox(RenderBox* renderer); 72 73 static inline bool isAcceleratedCanvas(RenderObject* renderer) 74 { 75 #if ENABLE(WEBGL) || ENABLE(ACCELERATED_2D_CANVAS) 76 if (renderer->isCanvas()) { 77 HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(renderer->node()); 78 if (CanvasRenderingContext* context = canvas->renderingContext()) 79 return context->isAccelerated(); 80 } 81 #else 82 UNUSED_PARAM(renderer); 83 #endif 84 return false; 85 } 86 87 RenderLayerBacking::RenderLayerBacking(RenderLayer* layer) 88 : m_owningLayer(layer) 89 , m_artificiallyInflatedBounds(false) 90 { 91 createGraphicsLayer(); 92 } 93 94 RenderLayerBacking::~RenderLayerBacking() 95 { 96 updateClippingLayers(false, false); 97 updateOverflowControlsLayers(false, false, false); 98 updateForegroundLayer(false); 99 updateMaskLayer(false); 100 destroyGraphicsLayer(); 101 } 102 103 void RenderLayerBacking::createGraphicsLayer() 104 { 105 m_graphicsLayer = GraphicsLayer::create(this); 106 107 #ifndef NDEBUG 108 m_graphicsLayer->setName(nameForLayer()); 109 #endif // NDEBUG 110 111 #if USE(ACCELERATED_COMPOSITING) 112 ASSERT(renderer() && renderer()->document() && renderer()->document()->frame()); 113 if (Frame* frame = renderer()->document()->frame()) 114 m_graphicsLayer->setContentsScale(frame->pageScaleFactor()); 115 #endif 116 117 updateLayerOpacity(renderer()->style()); 118 updateLayerTransform(renderer()->style()); 119 } 120 121 void RenderLayerBacking::destroyGraphicsLayer() 122 { 123 if (m_graphicsLayer) 124 m_graphicsLayer->removeFromParent(); 125 126 m_graphicsLayer = 0; 127 m_foregroundLayer = 0; 128 m_clippingLayer = 0; 129 m_maskLayer = 0; 130 } 131 132 void RenderLayerBacking::updateLayerOpacity(const RenderStyle* style) 133 { 134 m_graphicsLayer->setOpacity(compositingOpacity(style->opacity())); 135 } 136 137 void RenderLayerBacking::updateLayerTransform(const RenderStyle* style) 138 { 139 // FIXME: This could use m_owningLayer->transform(), but that currently has transform-origin 140 // baked into it, and we don't want that. 141 TransformationMatrix t; 142 if (m_owningLayer->hasTransform()) { 143 style->applyTransform(t, toRenderBox(renderer())->borderBoxRect().size(), RenderStyle::ExcludeTransformOrigin); 144 makeMatrixRenderable(t, compositor()->canRender3DTransforms()); 145 } 146 147 m_graphicsLayer->setTransform(t); 148 } 149 150 static bool hasNonZeroTransformOrigin(const RenderObject* renderer) 151 { 152 RenderStyle* style = renderer->style(); 153 return (style->transformOriginX().type() == Fixed && style->transformOriginX().value()) 154 || (style->transformOriginY().type() == Fixed && style->transformOriginY().value()); 155 } 156 157 static bool layerOrAncestorIsTransformed(RenderLayer* layer) 158 { 159 for (RenderLayer* curr = layer; curr; curr = curr->parent()) { 160 if (curr->hasTransform()) 161 return true; 162 } 163 164 return false; 165 } 166 167 #if ENABLE(FULLSCREEN_API) 168 static bool layerOrAncestorIsFullScreen(RenderLayer* layer) 169 { 170 // Don't traverse through the render layer tree if we do not yet have a full screen renderer. 171 if (!layer->renderer()->document()->fullScreenRenderer()) 172 return false; 173 174 for (RenderLayer* curr = layer; curr; curr = curr->parent()) { 175 if (curr->renderer()->isRenderFullScreen()) 176 return true; 177 } 178 179 return false; 180 } 181 #endif 182 183 void RenderLayerBacking::updateCompositedBounds() 184 { 185 IntRect layerBounds = compositor()->calculateCompositedBounds(m_owningLayer, m_owningLayer); 186 187 // Clip to the size of the document or enclosing overflow-scroll layer. 188 // If this or an ancestor is transformed, we can't currently compute the correct rect to intersect with. 189 // We'd need RenderObject::convertContainerToLocalQuad(), which doesn't yet exist. If this 190 // is a fullscreen renderer, don't clip to the viewport, as the renderer will be asked to 191 // display outside of the viewport bounds. 192 if (compositor()->compositingConsultsOverlap() && !layerOrAncestorIsTransformed(m_owningLayer) 193 #if ENABLE(FULLSCREEN_API) 194 && !layerOrAncestorIsFullScreen(m_owningLayer) 195 #endif 196 ) { 197 RenderView* view = m_owningLayer->renderer()->view(); 198 RenderLayer* rootLayer = view->layer(); 199 200 // Start by clipping to the view's bounds. 201 IntRect clippingBounds = view->layoutOverflowRect(); 202 203 if (m_owningLayer != rootLayer) 204 clippingBounds.intersect(m_owningLayer->backgroundClipRect(rootLayer, true)); 205 206 int deltaX = 0; 207 int deltaY = 0; 208 m_owningLayer->convertToLayerCoords(rootLayer, deltaX, deltaY); 209 clippingBounds.move(-deltaX, -deltaY); 210 211 layerBounds.intersect(clippingBounds); 212 } 213 214 // If the element has a transform-origin that has fixed lengths, and the renderer has zero size, 215 // then we need to ensure that the compositing layer has non-zero size so that we can apply 216 // the transform-origin via the GraphicsLayer anchorPoint (which is expressed as a fractional value). 217 if (layerBounds.isEmpty() && hasNonZeroTransformOrigin(renderer())) { 218 layerBounds.setWidth(1); 219 layerBounds.setHeight(1); 220 m_artificiallyInflatedBounds = true; 221 } else 222 m_artificiallyInflatedBounds = false; 223 224 setCompositedBounds(layerBounds); 225 } 226 227 void RenderLayerBacking::updateAfterWidgetResize() 228 { 229 if (renderer()->isRenderPart()) { 230 if (RenderLayerCompositor* innerCompositor = RenderLayerCompositor::frameContentsCompositor(toRenderPart(renderer()))) { 231 innerCompositor->frameViewDidChangeSize(); 232 innerCompositor->frameViewDidChangeLocation(contentsBox().location()); 233 } 234 } 235 } 236 237 void RenderLayerBacking::updateAfterLayout(UpdateDepth updateDepth, bool isUpdateRoot) 238 { 239 RenderLayerCompositor* layerCompositor = compositor(); 240 if (!layerCompositor->compositingLayersNeedRebuild()) { 241 // Calling updateGraphicsLayerGeometry() here gives incorrect results, because the 242 // position of this layer's GraphicsLayer depends on the position of our compositing 243 // ancestor's GraphicsLayer. That cannot be determined until all the descendant 244 // RenderLayers of that ancestor have been processed via updateLayerPositions(). 245 // 246 // The solution is to update compositing children of this layer here, 247 // via updateCompositingChildrenGeometry(). 248 updateCompositedBounds(); 249 layerCompositor->updateCompositingDescendantGeometry(m_owningLayer, m_owningLayer, updateDepth); 250 251 if (isUpdateRoot) { 252 updateGraphicsLayerGeometry(); 253 layerCompositor->updateRootLayerPosition(); 254 } 255 } 256 } 257 258 bool RenderLayerBacking::updateGraphicsLayerConfiguration() 259 { 260 RenderLayerCompositor* compositor = this->compositor(); 261 RenderObject* renderer = this->renderer(); 262 263 bool layerConfigChanged = false; 264 if (updateForegroundLayer(compositor->needsContentsCompositingLayer(m_owningLayer))) 265 layerConfigChanged = true; 266 267 if (updateClippingLayers(compositor->clippedByAncestor(m_owningLayer), compositor->clipsCompositingDescendants(m_owningLayer))) 268 layerConfigChanged = true; 269 270 if (updateOverflowControlsLayers(requiresHorizontalScrollbarLayer(), requiresVerticalScrollbarLayer(), requiresScrollCornerLayer())) 271 layerConfigChanged = true; 272 273 if (layerConfigChanged) 274 updateInternalHierarchy(); 275 276 if (updateMaskLayer(renderer->hasMask())) 277 m_graphicsLayer->setMaskLayer(m_maskLayer.get()); 278 279 if (m_owningLayer->hasReflection()) { 280 if (m_owningLayer->reflectionLayer()->backing()) { 281 GraphicsLayer* reflectionLayer = m_owningLayer->reflectionLayer()->backing()->graphicsLayer(); 282 m_graphicsLayer->setReplicatedByLayer(reflectionLayer); 283 } 284 } else 285 m_graphicsLayer->setReplicatedByLayer(0); 286 287 if (isDirectlyCompositedImage()) 288 updateImageContents(); 289 290 if ((renderer->isEmbeddedObject() && toRenderEmbeddedObject(renderer)->allowsAcceleratedCompositing()) 291 || (renderer->isApplet() && toRenderApplet(renderer)->allowsAcceleratedCompositing())) { 292 PluginViewBase* pluginViewBase = static_cast<PluginViewBase*>(toRenderWidget(renderer)->widget()); 293 m_graphicsLayer->setContentsToMedia(pluginViewBase->platformLayer()); 294 } 295 #if ENABLE(VIDEO) 296 else if (renderer->isVideo()) { 297 HTMLMediaElement* mediaElement = static_cast<HTMLMediaElement*>(renderer->node()); 298 m_graphicsLayer->setContentsToMedia(mediaElement->platformLayer()); 299 } 300 #endif 301 #if ENABLE(WEBGL) || ENABLE(ACCELERATED_2D_CANVAS) 302 else if (isAcceleratedCanvas(renderer)) { 303 HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(renderer->node()); 304 if (CanvasRenderingContext* context = canvas->renderingContext()) 305 m_graphicsLayer->setContentsToCanvas(context->platformLayer()); 306 layerConfigChanged = true; 307 } 308 #endif 309 310 if (renderer->isRenderPart()) 311 layerConfigChanged = RenderLayerCompositor::parentFrameContentLayers(toRenderPart(renderer)); 312 313 return layerConfigChanged; 314 } 315 316 static IntRect clipBox(RenderBox* renderer) 317 { 318 IntRect result = PaintInfo::infiniteRect(); 319 if (renderer->hasOverflowClip()) 320 result = renderer->overflowClipRect(0, 0); 321 322 if (renderer->hasClip()) 323 result.intersect(renderer->clipRect(0, 0)); 324 325 return result; 326 } 327 328 void RenderLayerBacking::updateGraphicsLayerGeometry() 329 { 330 // If we haven't built z-order lists yet, wait until later. 331 if (m_owningLayer->isStackingContext() && m_owningLayer->m_zOrderListsDirty) 332 return; 333 334 // Set transform property, if it is not animating. We have to do this here because the transform 335 // is affected by the layer dimensions. 336 if (!renderer()->animation()->isRunningAcceleratedAnimationOnRenderer(renderer(), CSSPropertyWebkitTransform)) 337 updateLayerTransform(renderer()->style()); 338 339 // Set opacity, if it is not animating. 340 if (!renderer()->animation()->isRunningAcceleratedAnimationOnRenderer(renderer(), CSSPropertyOpacity)) 341 updateLayerOpacity(renderer()->style()); 342 343 RenderStyle* style = renderer()->style(); 344 m_graphicsLayer->setPreserves3D(style->transformStyle3D() == TransformStyle3DPreserve3D && !renderer()->hasReflection()); 345 m_graphicsLayer->setBackfaceVisibility(style->backfaceVisibility() == BackfaceVisibilityVisible); 346 347 RenderLayer* compAncestor = m_owningLayer->ancestorCompositingLayer(); 348 349 // We compute everything relative to the enclosing compositing layer. 350 IntRect ancestorCompositingBounds; 351 if (compAncestor) { 352 ASSERT(compAncestor->backing()); 353 ancestorCompositingBounds = compAncestor->backing()->compositedBounds(); 354 } 355 356 IntRect localCompositingBounds = compositedBounds(); 357 358 IntRect relativeCompositingBounds(localCompositingBounds); 359 int deltaX = 0, deltaY = 0; 360 m_owningLayer->convertToLayerCoords(compAncestor, deltaX, deltaY); 361 relativeCompositingBounds.move(deltaX, deltaY); 362 363 IntPoint graphicsLayerParentLocation; 364 if (compAncestor && compAncestor->backing()->hasClippingLayer()) { 365 // If the compositing ancestor has a layer to clip children, we parent in that, and therefore 366 // position relative to it. 367 IntRect clippingBox = clipBox(toRenderBox(compAncestor->renderer())); 368 graphicsLayerParentLocation = clippingBox.location(); 369 } else 370 graphicsLayerParentLocation = ancestorCompositingBounds.location(); 371 372 if (compAncestor && m_ancestorClippingLayer) { 373 // Call calculateRects to get the backgroundRect which is what is used to clip the contents of this 374 // layer. Note that we call it with temporaryClipRects = true because normally when computing clip rects 375 // for a compositing layer, rootLayer is the layer itself. 376 IntRect parentClipRect = m_owningLayer->backgroundClipRect(compAncestor, true); 377 ASSERT(parentClipRect != PaintInfo::infiniteRect()); 378 m_ancestorClippingLayer->setPosition(FloatPoint() + (parentClipRect.location() - graphicsLayerParentLocation)); 379 m_ancestorClippingLayer->setSize(parentClipRect.size()); 380 381 // backgroundRect is relative to compAncestor, so subtract deltaX/deltaY to get back to local coords. 382 IntSize rendererOffset(parentClipRect.location().x() - deltaX, parentClipRect.location().y() - deltaY); 383 m_ancestorClippingLayer->setOffsetFromRenderer(rendererOffset); 384 385 // The primary layer is then parented in, and positioned relative to this clipping layer. 386 graphicsLayerParentLocation = parentClipRect.location(); 387 } 388 389 m_graphicsLayer->setPosition(FloatPoint() + (relativeCompositingBounds.location() - graphicsLayerParentLocation)); 390 391 IntSize oldOffsetFromRenderer = m_graphicsLayer->offsetFromRenderer(); 392 m_graphicsLayer->setOffsetFromRenderer(localCompositingBounds.location() - IntPoint()); 393 394 // If the compositing layer offset changes, we need to repaint. 395 if (oldOffsetFromRenderer != m_graphicsLayer->offsetFromRenderer()) 396 m_graphicsLayer->setNeedsDisplay(); 397 398 FloatSize oldSize = m_graphicsLayer->size(); 399 FloatSize newSize = relativeCompositingBounds.size(); 400 if (oldSize != newSize) { 401 m_graphicsLayer->setSize(newSize); 402 // A bounds change will almost always require redisplay. Usually that redisplay 403 // will happen because of a repaint elsewhere, but not always: 404 // e.g. see RenderView::setMaximalOutlineSize() 405 m_graphicsLayer->setNeedsDisplay(); 406 } 407 408 // If we have a layer that clips children, position it. 409 IntRect clippingBox; 410 if (m_clippingLayer) { 411 clippingBox = clipBox(toRenderBox(renderer())); 412 m_clippingLayer->setPosition(FloatPoint() + (clippingBox.location() - localCompositingBounds.location())); 413 m_clippingLayer->setSize(clippingBox.size()); 414 m_clippingLayer->setOffsetFromRenderer(clippingBox.location() - IntPoint()); 415 } 416 417 if (m_maskLayer) { 418 if (m_maskLayer->size() != m_graphicsLayer->size()) { 419 m_maskLayer->setSize(m_graphicsLayer->size()); 420 m_maskLayer->setNeedsDisplay(); 421 } 422 m_maskLayer->setPosition(FloatPoint()); 423 } 424 425 if (m_owningLayer->hasTransform()) { 426 const IntRect borderBox = toRenderBox(renderer())->borderBoxRect(); 427 428 // Get layout bounds in the coords of compAncestor to match relativeCompositingBounds. 429 IntRect layerBounds = IntRect(deltaX, deltaY, borderBox.width(), borderBox.height()); 430 431 // Update properties that depend on layer dimensions 432 FloatPoint3D transformOrigin = computeTransformOrigin(borderBox); 433 // Compute the anchor point, which is in the center of the renderer box unless transform-origin is set. 434 FloatPoint3D anchor(relativeCompositingBounds.width() != 0.0f ? ((layerBounds.x() - relativeCompositingBounds.x()) + transformOrigin.x()) / relativeCompositingBounds.width() : 0.5f, 435 relativeCompositingBounds.height() != 0.0f ? ((layerBounds.y() - relativeCompositingBounds.y()) + transformOrigin.y()) / relativeCompositingBounds.height() : 0.5f, 436 transformOrigin.z()); 437 m_graphicsLayer->setAnchorPoint(anchor); 438 439 RenderStyle* style = renderer()->style(); 440 if (style->hasPerspective()) { 441 TransformationMatrix t = owningLayer()->perspectiveTransform(); 442 443 if (m_clippingLayer) { 444 m_clippingLayer->setChildrenTransform(t); 445 m_graphicsLayer->setChildrenTransform(TransformationMatrix()); 446 } 447 else 448 m_graphicsLayer->setChildrenTransform(t); 449 } else { 450 if (m_clippingLayer) 451 m_clippingLayer->setChildrenTransform(TransformationMatrix()); 452 else 453 m_graphicsLayer->setChildrenTransform(TransformationMatrix()); 454 } 455 } else { 456 m_graphicsLayer->setAnchorPoint(FloatPoint3D(0.5f, 0.5f, 0)); 457 } 458 459 if (m_foregroundLayer) { 460 FloatPoint foregroundPosition; 461 FloatSize foregroundSize = newSize; 462 IntSize foregroundOffset = m_graphicsLayer->offsetFromRenderer(); 463 if (m_clippingLayer) { 464 // If we have a clipping layer (which clips descendants), then the foreground layer is a child of it, 465 // so that it gets correctly sorted with children. In that case, position relative to the clipping layer. 466 foregroundSize = FloatSize(clippingBox.size()); 467 foregroundOffset = clippingBox.location() - IntPoint(); 468 } 469 470 m_foregroundLayer->setPosition(foregroundPosition); 471 m_foregroundLayer->setSize(foregroundSize); 472 m_foregroundLayer->setOffsetFromRenderer(foregroundOffset); 473 } 474 475 if (m_owningLayer->reflectionLayer() && m_owningLayer->reflectionLayer()->isComposited()) { 476 RenderLayerBacking* reflectionBacking = m_owningLayer->reflectionLayer()->backing(); 477 reflectionBacking->updateGraphicsLayerGeometry(); 478 479 // The reflection layer has the bounds of m_owningLayer->reflectionLayer(), 480 // but the reflected layer is the bounds of this layer, so we need to position it appropriately. 481 FloatRect layerBounds = compositedBounds(); 482 FloatRect reflectionLayerBounds = reflectionBacking->compositedBounds(); 483 reflectionBacking->graphicsLayer()->setReplicatedLayerPosition(FloatPoint() + (layerBounds.location() - reflectionLayerBounds.location())); 484 } 485 486 m_graphicsLayer->setContentsRect(contentsBox()); 487 updateDrawsContent(); 488 updateAfterWidgetResize(); 489 } 490 491 void RenderLayerBacking::updateInternalHierarchy() 492 { 493 // m_foregroundLayer has to be inserted in the correct order with child layers, 494 // so it's not inserted here. 495 if (m_ancestorClippingLayer) { 496 m_ancestorClippingLayer->removeAllChildren(); 497 m_graphicsLayer->removeFromParent(); 498 m_ancestorClippingLayer->addChild(m_graphicsLayer.get()); 499 } 500 501 if (m_clippingLayer) { 502 m_clippingLayer->removeFromParent(); 503 m_graphicsLayer->addChild(m_clippingLayer.get()); 504 505 // The clip for child layers does not include space for overflow controls, so they exist as 506 // siblings of the clipping layer if we have one. Normal children of this layer are set as 507 // children of the clipping layer. 508 if (m_layerForHorizontalScrollbar) { 509 m_layerForHorizontalScrollbar->removeFromParent(); 510 m_graphicsLayer->addChild(m_layerForHorizontalScrollbar.get()); 511 } 512 if (m_layerForVerticalScrollbar) { 513 m_layerForVerticalScrollbar->removeFromParent(); 514 m_graphicsLayer->addChild(m_layerForVerticalScrollbar.get()); 515 } 516 if (m_layerForScrollCorner) { 517 m_layerForScrollCorner->removeFromParent(); 518 m_graphicsLayer->addChild(m_layerForScrollCorner.get()); 519 } 520 } 521 } 522 523 void RenderLayerBacking::updateDrawsContent() 524 { 525 m_graphicsLayer->setDrawsContent(containsPaintedContent()); 526 } 527 528 // Return true if the layers changed. 529 bool RenderLayerBacking::updateClippingLayers(bool needsAncestorClip, bool needsDescendantClip) 530 { 531 bool layersChanged = false; 532 533 if (needsAncestorClip) { 534 if (!m_ancestorClippingLayer) { 535 m_ancestorClippingLayer = GraphicsLayer::create(this); 536 #ifndef NDEBUG 537 m_ancestorClippingLayer->setName("Ancestor clipping Layer"); 538 #endif 539 m_ancestorClippingLayer->setMasksToBounds(true); 540 layersChanged = true; 541 } 542 } else if (m_ancestorClippingLayer) { 543 m_ancestorClippingLayer->removeFromParent(); 544 m_ancestorClippingLayer = 0; 545 layersChanged = true; 546 } 547 548 if (needsDescendantClip) { 549 if (!m_clippingLayer) { 550 m_clippingLayer = GraphicsLayer::create(this); 551 #ifndef NDEBUG 552 m_clippingLayer->setName("Child clipping Layer"); 553 #endif 554 m_clippingLayer->setMasksToBounds(true); 555 layersChanged = true; 556 } 557 } else if (m_clippingLayer) { 558 m_clippingLayer->removeFromParent(); 559 m_clippingLayer = 0; 560 layersChanged = true; 561 } 562 563 return layersChanged; 564 } 565 566 bool RenderLayerBacking::requiresHorizontalScrollbarLayer() const 567 { 568 #if !PLATFORM(CHROMIUM) 569 if (!m_owningLayer->hasOverlayScrollbars()) 570 return false; 571 #endif 572 return m_owningLayer->horizontalScrollbar(); 573 } 574 575 bool RenderLayerBacking::requiresVerticalScrollbarLayer() const 576 { 577 #if !PLATFORM(CHROMIUM) 578 if (!m_owningLayer->hasOverlayScrollbars()) 579 return false; 580 #endif 581 return m_owningLayer->verticalScrollbar(); 582 } 583 584 bool RenderLayerBacking::requiresScrollCornerLayer() const 585 { 586 #if !PLATFORM(CHROMIUM) 587 if (!m_owningLayer->hasOverlayScrollbars()) 588 return false; 589 #endif 590 return !m_owningLayer->scrollCornerAndResizerRect().isEmpty(); 591 } 592 593 bool RenderLayerBacking::updateOverflowControlsLayers(bool needsHorizontalScrollbarLayer, bool needsVerticalScrollbarLayer, bool needsScrollCornerLayer) 594 { 595 bool layersChanged = false; 596 if (needsHorizontalScrollbarLayer) { 597 if (!m_layerForHorizontalScrollbar) { 598 m_layerForHorizontalScrollbar = GraphicsLayer::create(this); 599 #ifndef NDEBUG 600 m_layerForHorizontalScrollbar ->setName("horizontal scrollbar"); 601 #endif 602 layersChanged = true; 603 } 604 } else if (m_layerForHorizontalScrollbar) { 605 m_layerForHorizontalScrollbar.clear(); 606 layersChanged = true; 607 } 608 609 if (needsVerticalScrollbarLayer) { 610 if (!m_layerForVerticalScrollbar) { 611 m_layerForVerticalScrollbar = GraphicsLayer::create(this); 612 #ifndef NDEBUG 613 m_layerForVerticalScrollbar->setName("vertical scrollbar"); 614 #endif 615 layersChanged = true; 616 } 617 } else if (m_layerForVerticalScrollbar) { 618 m_layerForVerticalScrollbar.clear(); 619 layersChanged = true; 620 } 621 622 if (needsScrollCornerLayer) { 623 if (!m_layerForScrollCorner) { 624 m_layerForScrollCorner = GraphicsLayer::create(this); 625 #ifndef NDEBUG 626 m_layerForScrollCorner->setName("scroll corner"); 627 #endif 628 layersChanged = true; 629 } 630 } else if (m_layerForScrollCorner) { 631 m_layerForScrollCorner.clear(); 632 layersChanged = true; 633 } 634 635 return layersChanged; 636 } 637 638 bool RenderLayerBacking::updateForegroundLayer(bool needsForegroundLayer) 639 { 640 bool layerChanged = false; 641 if (needsForegroundLayer) { 642 if (!m_foregroundLayer) { 643 m_foregroundLayer = GraphicsLayer::create(this); 644 #ifndef NDEBUG 645 m_foregroundLayer->setName(nameForLayer() + " (foreground)"); 646 #endif 647 m_foregroundLayer->setDrawsContent(true); 648 m_foregroundLayer->setPaintingPhase(GraphicsLayerPaintForeground); 649 if (Frame* frame = renderer()->document()->frame()) 650 m_foregroundLayer->setContentsScale(frame->pageScaleFactor()); 651 layerChanged = true; 652 } 653 } else if (m_foregroundLayer) { 654 m_foregroundLayer->removeFromParent(); 655 m_foregroundLayer = 0; 656 layerChanged = true; 657 } 658 659 if (layerChanged) 660 m_graphicsLayer->setPaintingPhase(paintingPhaseForPrimaryLayer()); 661 662 return layerChanged; 663 } 664 665 bool RenderLayerBacking::updateMaskLayer(bool needsMaskLayer) 666 { 667 bool layerChanged = false; 668 if (needsMaskLayer) { 669 if (!m_maskLayer) { 670 m_maskLayer = GraphicsLayer::create(this); 671 #ifndef NDEBUG 672 m_maskLayer->setName("Mask"); 673 #endif 674 m_maskLayer->setDrawsContent(true); 675 m_maskLayer->setPaintingPhase(GraphicsLayerPaintMask); 676 if (Frame* frame = renderer()->document()->frame()) 677 m_maskLayer->setContentsScale(frame->pageScaleFactor()); 678 layerChanged = true; 679 } 680 } else if (m_maskLayer) { 681 m_maskLayer = 0; 682 layerChanged = true; 683 } 684 685 if (layerChanged) 686 m_graphicsLayer->setPaintingPhase(paintingPhaseForPrimaryLayer()); 687 688 return layerChanged; 689 } 690 691 GraphicsLayerPaintingPhase RenderLayerBacking::paintingPhaseForPrimaryLayer() const 692 { 693 unsigned phase = GraphicsLayerPaintBackground; 694 if (!m_foregroundLayer) 695 phase |= GraphicsLayerPaintForeground; 696 if (!m_maskLayer) 697 phase |= GraphicsLayerPaintMask; 698 699 return static_cast<GraphicsLayerPaintingPhase>(phase); 700 } 701 702 float RenderLayerBacking::compositingOpacity(float rendererOpacity) const 703 { 704 float finalOpacity = rendererOpacity; 705 706 for (RenderLayer* curr = m_owningLayer->parent(); curr; curr = curr->parent()) { 707 // We only care about parents that are stacking contexts. 708 // Recall that opacity creates stacking context. 709 if (!curr->isStackingContext()) 710 continue; 711 712 // If we found a compositing layer, we want to compute opacity 713 // relative to it. So we can break here. 714 if (curr->isComposited()) 715 break; 716 717 finalOpacity *= curr->renderer()->opacity(); 718 } 719 720 return finalOpacity; 721 } 722 723 static bool hasBorderOutlineOrShadow(const RenderStyle* style) 724 { 725 return style->hasBorder() || style->hasBorderRadius() || style->hasOutline() || style->hasAppearance() || style->boxShadow(); 726 } 727 728 static bool hasBoxDecorationsOrBackground(const RenderObject* renderer) 729 { 730 return hasBorderOutlineOrShadow(renderer->style()) || renderer->hasBackground(); 731 } 732 733 static bool hasBoxDecorationsOrBackgroundImage(const RenderStyle* style) 734 { 735 return hasBorderOutlineOrShadow(style) || style->hasBackgroundImage(); 736 } 737 738 bool RenderLayerBacking::rendererHasBackground() const 739 { 740 // FIXME: share more code here 741 if (renderer()->node() && renderer()->node()->isDocumentNode()) { 742 RenderObject* htmlObject = renderer()->firstChild(); 743 if (!htmlObject) 744 return false; 745 746 if (htmlObject->hasBackground()) 747 return true; 748 749 RenderObject* bodyObject = htmlObject->firstChild(); 750 if (!bodyObject) 751 return false; 752 753 return bodyObject->hasBackground(); 754 } 755 756 return renderer()->hasBackground(); 757 } 758 759 const Color RenderLayerBacking::rendererBackgroundColor() const 760 { 761 // FIXME: share more code here 762 if (renderer()->node() && renderer()->node()->isDocumentNode()) { 763 RenderObject* htmlObject = renderer()->firstChild(); 764 if (htmlObject->hasBackground()) 765 return htmlObject->style()->visitedDependentColor(CSSPropertyBackgroundColor); 766 767 RenderObject* bodyObject = htmlObject->firstChild(); 768 return bodyObject->style()->visitedDependentColor(CSSPropertyBackgroundColor); 769 } 770 771 return renderer()->style()->visitedDependentColor(CSSPropertyBackgroundColor); 772 } 773 774 // A "simple container layer" is a RenderLayer which has no visible content to render. 775 // It may have no children, or all its children may be themselves composited. 776 // This is a useful optimization, because it allows us to avoid allocating backing store. 777 bool RenderLayerBacking::isSimpleContainerCompositingLayer() const 778 { 779 RenderObject* renderObject = renderer(); 780 if (renderObject->isReplaced() || // replaced objects are not containers 781 renderObject->hasMask()) // masks require special treatment 782 return false; 783 784 RenderStyle* style = renderObject->style(); 785 786 // Reject anything that has a border, a border-radius or outline, 787 // or any background (color or image). 788 // FIXME: we could optimize layers for simple backgrounds. 789 if (hasBoxDecorationsOrBackground(renderObject)) 790 return false; 791 792 if (m_owningLayer->hasOverflowControls()) 793 return false; 794 795 // If we have got this far and the renderer has no children, then we're ok. 796 if (!renderObject->firstChild()) 797 return true; 798 799 if (renderObject->node() && renderObject->node()->isDocumentNode()) { 800 // Look to see if the root object has a non-simple backgound 801 RenderObject* rootObject = renderObject->document()->documentElement()->renderer(); 802 if (!rootObject) 803 return false; 804 805 style = rootObject->style(); 806 807 // Reject anything that has a border, a border-radius or outline, 808 // or is not a simple background (no background, or solid color). 809 if (hasBoxDecorationsOrBackgroundImage(style)) 810 return false; 811 812 // Now look at the body's renderer. 813 HTMLElement* body = renderObject->document()->body(); 814 RenderObject* bodyObject = (body && body->hasLocalName(bodyTag)) ? body->renderer() : 0; 815 if (!bodyObject) 816 return false; 817 818 style = bodyObject->style(); 819 820 if (hasBoxDecorationsOrBackgroundImage(style)) 821 return false; 822 823 // Check to see if all the body's children are compositing layers. 824 if (hasNonCompositingDescendants()) 825 return false; 826 827 return true; 828 } 829 830 // Check to see if all the renderer's children are compositing layers. 831 if (hasNonCompositingDescendants()) 832 return false; 833 834 return true; 835 } 836 837 // Conservative test for having no rendered children. 838 bool RenderLayerBacking::hasNonCompositingDescendants() const 839 { 840 // Some HTML can cause whitespace text nodes to have renderers, like: 841 // <div> 842 // <img src=...> 843 // </div> 844 // so test for 0x0 RenderTexts here 845 for (RenderObject* child = renderer()->firstChild(); child; child = child->nextSibling()) { 846 if (!child->hasLayer()) { 847 if (child->isRenderInline() || !child->isBox()) 848 return true; 849 850 if (toRenderBox(child)->width() > 0 || toRenderBox(child)->height() > 0) 851 return true; 852 } 853 } 854 855 if (m_owningLayer->isStackingContext()) { 856 // Use the m_hasCompositingDescendant bit to optimize? 857 if (Vector<RenderLayer*>* negZOrderList = m_owningLayer->negZOrderList()) { 858 size_t listSize = negZOrderList->size(); 859 for (size_t i = 0; i < listSize; ++i) { 860 RenderLayer* curLayer = negZOrderList->at(i); 861 if (!curLayer->isComposited()) 862 return true; 863 } 864 } 865 866 if (Vector<RenderLayer*>* posZOrderList = m_owningLayer->posZOrderList()) { 867 size_t listSize = posZOrderList->size(); 868 for (size_t i = 0; i < listSize; ++i) { 869 RenderLayer* curLayer = posZOrderList->at(i); 870 if (!curLayer->isComposited()) 871 return true; 872 } 873 } 874 } 875 876 if (Vector<RenderLayer*>* normalFlowList = m_owningLayer->normalFlowList()) { 877 size_t listSize = normalFlowList->size(); 878 for (size_t i = 0; i < listSize; ++i) { 879 RenderLayer* curLayer = normalFlowList->at(i); 880 if (!curLayer->isComposited()) 881 return true; 882 } 883 } 884 885 return false; 886 } 887 888 bool RenderLayerBacking::containsPaintedContent() const 889 { 890 if (isSimpleContainerCompositingLayer() || paintingGoesToWindow() || m_artificiallyInflatedBounds || m_owningLayer->isReflection()) 891 return false; 892 893 if (isDirectlyCompositedImage()) 894 return false; 895 896 // FIXME: we could optimize cases where the image, video or canvas is known to fill the border box entirely, 897 // and set background color on the layer in that case, instead of allocating backing store and painting. 898 #if ENABLE(VIDEO) 899 if (renderer()->isVideo() && toRenderVideo(renderer())->shouldDisplayVideo()) 900 return hasBoxDecorationsOrBackground(renderer()); 901 #endif 902 #if PLATFORM(MAC) && USE(CA) && !defined(BUILDING_ON_TIGER) && !defined(BUILDING_ON_LEOPARD) && !defined(BUILDING_ON_SNOW_LEOPARD) 903 #elif ENABLE(WEBGL) || ENABLE(ACCELERATED_2D_CANVAS) 904 if (isAcceleratedCanvas(renderer())) 905 return hasBoxDecorationsOrBackground(renderer()); 906 #endif 907 908 return true; 909 } 910 911 // An image can be directly compositing if it's the sole content of the layer, and has no box decorations 912 // that require painting. Direct compositing saves backing store. 913 bool RenderLayerBacking::isDirectlyCompositedImage() const 914 { 915 RenderObject* renderObject = renderer(); 916 917 if (!renderObject->isImage() || hasBoxDecorationsOrBackground(renderObject) || renderObject->hasClip()) 918 return false; 919 920 RenderImage* imageRenderer = toRenderImage(renderObject); 921 if (CachedImage* cachedImage = imageRenderer->cachedImage()) { 922 if (cachedImage->hasImage()) 923 return cachedImage->image()->isBitmapImage(); 924 } 925 926 return false; 927 } 928 929 void RenderLayerBacking::contentChanged(RenderLayer::ContentChangeType changeType) 930 { 931 if ((changeType == RenderLayer::ImageChanged) && isDirectlyCompositedImage()) { 932 updateImageContents(); 933 return; 934 } 935 936 if ((changeType == RenderLayer::MaskImageChanged) && m_maskLayer) { 937 // The composited layer bounds relies on box->maskClipRect(), which changes 938 // when the mask image becomes available. 939 bool isUpdateRoot = true; 940 updateAfterLayout(CompositingChildren, isUpdateRoot); 941 } 942 943 #if ENABLE(WEBGL) || ENABLE(ACCELERATED_2D_CANVAS) 944 if ((changeType == RenderLayer::CanvasChanged) && isAcceleratedCanvas(renderer())) { 945 m_graphicsLayer->setContentsNeedsDisplay(); 946 return; 947 } 948 #endif 949 } 950 951 void RenderLayerBacking::updateImageContents() 952 { 953 ASSERT(renderer()->isImage()); 954 RenderImage* imageRenderer = toRenderImage(renderer()); 955 956 CachedImage* cachedImage = imageRenderer->cachedImage(); 957 if (!cachedImage) 958 return; 959 960 Image* image = cachedImage->image(); 961 if (!image) 962 return; 963 964 // We have to wait until the image is fully loaded before setting it on the layer. 965 if (!cachedImage->isLoaded()) 966 return; 967 968 // This is a no-op if the layer doesn't have an inner layer for the image. 969 m_graphicsLayer->setContentsToImage(image); 970 971 // Image animation is "lazy", in that it automatically stops unless someone is drawing 972 // the image. So we have to kick the animation each time; this has the downside that the 973 // image will keep animating, even if its layer is not visible. 974 image->startAnimation(); 975 } 976 977 FloatPoint3D RenderLayerBacking::computeTransformOrigin(const IntRect& borderBox) const 978 { 979 RenderStyle* style = renderer()->style(); 980 981 FloatPoint3D origin; 982 origin.setX(style->transformOriginX().calcFloatValue(borderBox.width())); 983 origin.setY(style->transformOriginY().calcFloatValue(borderBox.height())); 984 origin.setZ(style->transformOriginZ()); 985 986 return origin; 987 } 988 989 FloatPoint RenderLayerBacking::computePerspectiveOrigin(const IntRect& borderBox) const 990 { 991 RenderStyle* style = renderer()->style(); 992 993 float boxWidth = borderBox.width(); 994 float boxHeight = borderBox.height(); 995 996 FloatPoint origin; 997 origin.setX(style->perspectiveOriginX().calcFloatValue(boxWidth)); 998 origin.setY(style->perspectiveOriginY().calcFloatValue(boxHeight)); 999 1000 return origin; 1001 } 1002 1003 // Return the offset from the top-left of this compositing layer at which the renderer's contents are painted. 1004 IntSize RenderLayerBacking::contentOffsetInCompostingLayer() const 1005 { 1006 return IntSize(-m_compositedBounds.x(), -m_compositedBounds.y()); 1007 } 1008 1009 IntRect RenderLayerBacking::contentsBox() const 1010 { 1011 if (!renderer()->isBox()) 1012 return IntRect(); 1013 1014 IntRect contentsRect; 1015 #if ENABLE(VIDEO) 1016 if (renderer()->isVideo()) { 1017 RenderVideo* videoRenderer = toRenderVideo(renderer()); 1018 contentsRect = videoRenderer->videoBox(); 1019 } else 1020 #endif 1021 contentsRect = toRenderBox(renderer())->contentBoxRect(); 1022 1023 IntSize contentOffset = contentOffsetInCompostingLayer(); 1024 contentsRect.move(contentOffset); 1025 return contentsRect; 1026 } 1027 1028 bool RenderLayerBacking::paintingGoesToWindow() const 1029 { 1030 if (m_owningLayer->isRootLayer()) 1031 return compositor()->rootLayerAttachment() != RenderLayerCompositor::RootLayerAttachedViaEnclosingFrame; 1032 1033 return false; 1034 } 1035 1036 void RenderLayerBacking::setContentsNeedDisplay() 1037 { 1038 if (m_graphicsLayer && m_graphicsLayer->drawsContent()) 1039 m_graphicsLayer->setNeedsDisplay(); 1040 1041 if (m_foregroundLayer && m_foregroundLayer->drawsContent()) 1042 m_foregroundLayer->setNeedsDisplay(); 1043 1044 if (m_maskLayer && m_maskLayer->drawsContent()) 1045 m_maskLayer->setNeedsDisplay(); 1046 } 1047 1048 // r is in the coordinate space of the layer's render object 1049 void RenderLayerBacking::setContentsNeedDisplayInRect(const IntRect& r) 1050 { 1051 if (m_graphicsLayer && m_graphicsLayer->drawsContent()) { 1052 IntRect layerDirtyRect = r; 1053 layerDirtyRect.move(-m_graphicsLayer->offsetFromRenderer()); 1054 m_graphicsLayer->setNeedsDisplayInRect(layerDirtyRect); 1055 } 1056 1057 if (m_foregroundLayer && m_foregroundLayer->drawsContent()) { 1058 IntRect layerDirtyRect = r; 1059 layerDirtyRect.move(-m_foregroundLayer->offsetFromRenderer()); 1060 m_foregroundLayer->setNeedsDisplayInRect(layerDirtyRect); 1061 } 1062 1063 if (m_maskLayer && m_maskLayer->drawsContent()) { 1064 IntRect layerDirtyRect = r; 1065 layerDirtyRect.move(-m_maskLayer->offsetFromRenderer()); 1066 m_maskLayer->setNeedsDisplayInRect(layerDirtyRect); 1067 } 1068 } 1069 1070 static void setClip(GraphicsContext* p, const IntRect& paintDirtyRect, const IntRect& clipRect) 1071 { 1072 if (paintDirtyRect == clipRect) 1073 return; 1074 p->save(); 1075 p->clip(clipRect); 1076 } 1077 1078 static void restoreClip(GraphicsContext* p, const IntRect& paintDirtyRect, const IntRect& clipRect) 1079 { 1080 if (paintDirtyRect == clipRect) 1081 return; 1082 p->restore(); 1083 } 1084 1085 // Share this with RenderLayer::paintLayer, which would have to be educated about GraphicsLayerPaintingPhase? 1086 void RenderLayerBacking::paintIntoLayer(RenderLayer* rootLayer, GraphicsContext* context, 1087 const IntRect& paintDirtyRect, // in the coords of rootLayer 1088 PaintBehavior paintBehavior, GraphicsLayerPaintingPhase paintingPhase, 1089 RenderObject* paintingRoot) 1090 { 1091 if (paintingGoesToWindow()) { 1092 ASSERT_NOT_REACHED(); 1093 return; 1094 } 1095 1096 m_owningLayer->updateLayerListsIfNeeded(); 1097 1098 // Calculate the clip rects we should use. 1099 IntRect layerBounds, damageRect, clipRectToApply, outlineRect; 1100 m_owningLayer->calculateRects(rootLayer, paintDirtyRect, layerBounds, damageRect, clipRectToApply, outlineRect); 1101 1102 int x = layerBounds.x(); // layerBounds is computed relative to rootLayer 1103 int y = layerBounds.y(); 1104 int tx = x - m_owningLayer->renderBoxX(); 1105 int ty = y - m_owningLayer->renderBoxY(); 1106 1107 // If this layer's renderer is a child of the paintingRoot, we render unconditionally, which 1108 // is done by passing a nil paintingRoot down to our renderer (as if no paintingRoot was ever set). 1109 // Else, our renderer tree may or may not contain the painting root, so we pass that root along 1110 // so it will be tested against as we decend through the renderers. 1111 RenderObject *paintingRootForRenderer = 0; 1112 if (paintingRoot && !renderer()->isDescendantOf(paintingRoot)) 1113 paintingRootForRenderer = paintingRoot; 1114 1115 bool shouldPaint = (m_owningLayer->hasVisibleContent() || m_owningLayer->hasVisibleDescendant()) && m_owningLayer->isSelfPaintingLayer(); 1116 1117 if (shouldPaint && (paintingPhase & GraphicsLayerPaintBackground)) { 1118 // Paint our background first, before painting any child layers. 1119 // Establish the clip used to paint our background. 1120 setClip(context, paintDirtyRect, damageRect); 1121 1122 PaintInfo info(context, damageRect, PaintPhaseBlockBackground, false, paintingRootForRenderer, 0); 1123 renderer()->paint(info, tx, ty); 1124 1125 // Our scrollbar widgets paint exactly when we tell them to, so that they work properly with 1126 // z-index. We paint after we painted the background/border, so that the scrollbars will 1127 // sit above the background/border. 1128 m_owningLayer->paintOverflowControls(context, x, y, damageRect); 1129 1130 // Restore the clip. 1131 restoreClip(context, paintDirtyRect, damageRect); 1132 #if ENABLE(ANDROID_OVERFLOW_SCROLL) 1133 // Paint the outline as part of the background phase in order for the 1134 // outline to not be a part of the scrollable content. 1135 if (!outlineRect.isEmpty()) { 1136 // Paint our own outline 1137 PaintInfo paintInfo(context, outlineRect, PaintPhaseSelfOutline, false, paintingRootForRenderer, 0); 1138 setClip(context, paintDirtyRect, outlineRect); 1139 renderer()->paint(paintInfo, tx, ty); 1140 restoreClip(context, paintDirtyRect, outlineRect); 1141 } 1142 #endif 1143 1144 // Now walk the sorted list of children with negative z-indices. Only RenderLayers without compositing layers will paint. 1145 m_owningLayer->paintList(m_owningLayer->negZOrderList(), rootLayer, context, paintDirtyRect, paintBehavior, paintingRoot, 0, 0); 1146 } 1147 1148 bool forceBlackText = paintBehavior & PaintBehaviorForceBlackText; 1149 bool selectionOnly = paintBehavior & PaintBehaviorSelectionOnly; 1150 1151 if (shouldPaint && (paintingPhase & GraphicsLayerPaintForeground)) { 1152 // Set up the clip used when painting our children. 1153 setClip(context, paintDirtyRect, clipRectToApply); 1154 PaintInfo paintInfo(context, clipRectToApply, 1155 selectionOnly ? PaintPhaseSelection : PaintPhaseChildBlockBackgrounds, 1156 forceBlackText, paintingRootForRenderer, 0); 1157 renderer()->paint(paintInfo, tx, ty); 1158 1159 if (!selectionOnly) { 1160 paintInfo.phase = PaintPhaseFloat; 1161 renderer()->paint(paintInfo, tx, ty); 1162 1163 paintInfo.phase = PaintPhaseForeground; 1164 renderer()->paint(paintInfo, tx, ty); 1165 1166 paintInfo.phase = PaintPhaseChildOutlines; 1167 renderer()->paint(paintInfo, tx, ty); 1168 } 1169 1170 // Now restore our clip. 1171 restoreClip(context, paintDirtyRect, clipRectToApply); 1172 1173 #if !ENABLE(ANDROID_OVERFLOW_SCROLL) 1174 // Do not paint the outline as part of the foreground since it will 1175 // appear inside the scrollable content. 1176 if (!outlineRect.isEmpty()) { 1177 // Paint our own outline 1178 PaintInfo paintInfo(context, outlineRect, PaintPhaseSelfOutline, false, paintingRootForRenderer, 0); 1179 setClip(context, paintDirtyRect, outlineRect); 1180 renderer()->paint(paintInfo, tx, ty); 1181 restoreClip(context, paintDirtyRect, outlineRect); 1182 } 1183 #endif 1184 1185 // Paint any child layers that have overflow. 1186 m_owningLayer->paintList(m_owningLayer->normalFlowList(), rootLayer, context, paintDirtyRect, paintBehavior, paintingRoot, 0, 0); 1187 1188 // Now walk the sorted list of children with positive z-indices. 1189 m_owningLayer->paintList(m_owningLayer->posZOrderList(), rootLayer, context, paintDirtyRect, paintBehavior, paintingRoot, 0, 0); 1190 } 1191 1192 if (shouldPaint && (paintingPhase & GraphicsLayerPaintMask)) { 1193 if (renderer()->hasMask() && !selectionOnly && !damageRect.isEmpty()) { 1194 setClip(context, paintDirtyRect, damageRect); 1195 1196 // Paint the mask. 1197 PaintInfo paintInfo(context, damageRect, PaintPhaseMask, false, paintingRootForRenderer, 0); 1198 renderer()->paint(paintInfo, tx, ty); 1199 1200 // Restore the clip. 1201 restoreClip(context, paintDirtyRect, damageRect); 1202 } 1203 } 1204 1205 ASSERT(!m_owningLayer->m_usedTransparency); 1206 } 1207 1208 static void paintScrollbar(Scrollbar* scrollbar, GraphicsContext& context, const IntRect& clip) 1209 { 1210 if (!scrollbar) 1211 return; 1212 1213 context.save(); 1214 const IntRect& scrollbarRect = scrollbar->frameRect(); 1215 context.translate(-scrollbarRect.x(), -scrollbarRect.y()); 1216 IntRect transformedClip = clip; 1217 transformedClip.move(scrollbarRect.x(), scrollbarRect.y()); 1218 scrollbar->paint(&context, transformedClip); 1219 context.restore(); 1220 } 1221 1222 // Up-call from compositing layer drawing callback. 1223 void RenderLayerBacking::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& context, GraphicsLayerPaintingPhase paintingPhase, const IntRect& clip) 1224 { 1225 if (graphicsLayer == m_graphicsLayer.get() || graphicsLayer == m_foregroundLayer.get() || graphicsLayer == m_maskLayer.get()) { 1226 InspectorInstrumentationCookie cookie = InspectorInstrumentation::willPaint(m_owningLayer->renderer()->frame(), clip); 1227 1228 IntSize offset = graphicsLayer->offsetFromRenderer(); 1229 context.translate(-offset); 1230 1231 IntRect clipRect(clip); 1232 clipRect.move(offset); 1233 1234 // The dirtyRect is in the coords of the painting root. 1235 IntRect dirtyRect = compositedBounds(); 1236 dirtyRect.intersect(clipRect); 1237 1238 #if ENABLE(ANDROID_OVERFLOW_SCROLL) 1239 // If we encounter a scrollable layer, layers inside the scrollable layer 1240 // will need their entire content recorded. 1241 if (m_owningLayer->hasOverflowParent()) 1242 dirtyRect.setSize(clip.size()); 1243 #endif 1244 1245 // We have to use the same root as for hit testing, because both methods can compute and cache clipRects. 1246 paintIntoLayer(m_owningLayer, &context, dirtyRect, PaintBehaviorNormal, paintingPhase, renderer()); 1247 1248 InspectorInstrumentation::didPaint(cookie); 1249 } else if (graphicsLayer == layerForHorizontalScrollbar()) { 1250 paintScrollbar(m_owningLayer->horizontalScrollbar(), context, clip); 1251 } else if (graphicsLayer == layerForVerticalScrollbar()) { 1252 paintScrollbar(m_owningLayer->verticalScrollbar(), context, clip); 1253 } else if (graphicsLayer == layerForScrollCorner()) { 1254 const IntRect& scrollCornerAndResizer = m_owningLayer->scrollCornerAndResizerRect(); 1255 context.save(); 1256 context.translate(-scrollCornerAndResizer.x(), -scrollCornerAndResizer.y()); 1257 IntRect transformedClip = clip; 1258 transformedClip.move(scrollCornerAndResizer.x(), scrollCornerAndResizer.y()); 1259 m_owningLayer->paintScrollCorner(&context, 0, 0, transformedClip); 1260 m_owningLayer->paintResizer(&context, 0, 0, transformedClip); 1261 context.restore(); 1262 } 1263 } 1264 1265 bool RenderLayerBacking::showDebugBorders() const 1266 { 1267 return compositor() ? compositor()->compositorShowDebugBorders() : false; 1268 } 1269 1270 bool RenderLayerBacking::showRepaintCounter() const 1271 { 1272 return compositor() ? compositor()->compositorShowRepaintCounter() : false; 1273 } 1274 1275 bool RenderLayerBacking::startAnimation(double timeOffset, const Animation* anim, const KeyframeList& keyframes) 1276 { 1277 bool hasOpacity = keyframes.containsProperty(CSSPropertyOpacity); 1278 bool hasTransform = renderer()->isBox() && keyframes.containsProperty(CSSPropertyWebkitTransform); 1279 1280 if (!hasOpacity && !hasTransform) 1281 return false; 1282 1283 KeyframeValueList transformVector(AnimatedPropertyWebkitTransform); 1284 KeyframeValueList opacityVector(AnimatedPropertyOpacity); 1285 1286 size_t numKeyframes = keyframes.size(); 1287 for (size_t i = 0; i < numKeyframes; ++i) { 1288 const KeyframeValue& currentKeyframe = keyframes[i]; 1289 const RenderStyle* keyframeStyle = currentKeyframe.style(); 1290 float key = currentKeyframe.key(); 1291 1292 if (!keyframeStyle) 1293 continue; 1294 1295 // Get timing function. 1296 RefPtr<TimingFunction> tf = keyframeStyle->hasAnimations() ? (*keyframeStyle->animations()).animation(0)->timingFunction() : 0; 1297 1298 bool isFirstOrLastKeyframe = key == 0 || key == 1; 1299 if ((hasTransform && isFirstOrLastKeyframe) || currentKeyframe.containsProperty(CSSPropertyWebkitTransform)) 1300 transformVector.insert(new TransformAnimationValue(key, &(keyframeStyle->transform()), tf)); 1301 1302 if ((hasOpacity && isFirstOrLastKeyframe) || currentKeyframe.containsProperty(CSSPropertyOpacity)) 1303 opacityVector.insert(new FloatAnimationValue(key, keyframeStyle->opacity(), tf)); 1304 } 1305 1306 bool didAnimateTransform = false; 1307 bool didAnimateOpacity = false; 1308 1309 if (hasTransform && m_graphicsLayer->addAnimation(transformVector, toRenderBox(renderer())->borderBoxRect().size(), anim, keyframes.animationName(), timeOffset)) { 1310 didAnimateTransform = true; 1311 compositor()->didStartAcceleratedAnimation(CSSPropertyWebkitTransform); 1312 } 1313 1314 if (hasOpacity && m_graphicsLayer->addAnimation(opacityVector, IntSize(), anim, keyframes.animationName(), timeOffset)) { 1315 didAnimateOpacity = true; 1316 compositor()->didStartAcceleratedAnimation(CSSPropertyOpacity); 1317 } 1318 1319 return didAnimateTransform || didAnimateOpacity; 1320 } 1321 1322 void RenderLayerBacking::animationPaused(double timeOffset, const String& animationName) 1323 { 1324 m_graphicsLayer->pauseAnimation(animationName, timeOffset); 1325 } 1326 1327 void RenderLayerBacking::animationFinished(const String& animationName) 1328 { 1329 m_graphicsLayer->removeAnimation(animationName); 1330 } 1331 1332 bool RenderLayerBacking::startTransition(double timeOffset, int property, const RenderStyle* fromStyle, const RenderStyle* toStyle) 1333 { 1334 bool didAnimateOpacity = false; 1335 bool didAnimateTransform = false; 1336 ASSERT(property != cAnimateAll); 1337 1338 if (property == (int)CSSPropertyOpacity) { 1339 const Animation* opacityAnim = toStyle->transitionForProperty(CSSPropertyOpacity); 1340 if (opacityAnim && !opacityAnim->isEmptyOrZeroDuration()) { 1341 KeyframeValueList opacityVector(AnimatedPropertyOpacity); 1342 opacityVector.insert(new FloatAnimationValue(0, compositingOpacity(fromStyle->opacity()))); 1343 opacityVector.insert(new FloatAnimationValue(1, compositingOpacity(toStyle->opacity()))); 1344 // The boxSize param is only used for transform animations (which can only run on RenderBoxes), so we pass an empty size here. 1345 if (m_graphicsLayer->addAnimation(opacityVector, IntSize(), opacityAnim, GraphicsLayer::animationNameForTransition(AnimatedPropertyOpacity), timeOffset)) { 1346 // To ensure that the correct opacity is visible when the animation ends, also set the final opacity. 1347 updateLayerOpacity(toStyle); 1348 didAnimateOpacity = true; 1349 } 1350 } 1351 } 1352 1353 if (property == (int)CSSPropertyWebkitTransform && m_owningLayer->hasTransform()) { 1354 const Animation* transformAnim = toStyle->transitionForProperty(CSSPropertyWebkitTransform); 1355 if (transformAnim && !transformAnim->isEmptyOrZeroDuration()) { 1356 KeyframeValueList transformVector(AnimatedPropertyWebkitTransform); 1357 transformVector.insert(new TransformAnimationValue(0, &fromStyle->transform())); 1358 transformVector.insert(new TransformAnimationValue(1, &toStyle->transform())); 1359 if (m_graphicsLayer->addAnimation(transformVector, toRenderBox(renderer())->borderBoxRect().size(), transformAnim, GraphicsLayer::animationNameForTransition(AnimatedPropertyWebkitTransform), timeOffset)) { 1360 // To ensure that the correct transform is visible when the animation ends, also set the final opacity. 1361 updateLayerTransform(toStyle); 1362 didAnimateTransform = true; 1363 } 1364 } 1365 } 1366 1367 if (didAnimateOpacity) 1368 compositor()->didStartAcceleratedAnimation(CSSPropertyOpacity); 1369 1370 if (didAnimateTransform) 1371 compositor()->didStartAcceleratedAnimation(CSSPropertyWebkitTransform); 1372 1373 return didAnimateOpacity || didAnimateTransform; 1374 } 1375 1376 void RenderLayerBacking::transitionPaused(double timeOffset, int property) 1377 { 1378 AnimatedPropertyID animatedProperty = cssToGraphicsLayerProperty(property); 1379 if (animatedProperty != AnimatedPropertyInvalid) 1380 m_graphicsLayer->pauseAnimation(GraphicsLayer::animationNameForTransition(animatedProperty), timeOffset); 1381 } 1382 1383 void RenderLayerBacking::transitionFinished(int property) 1384 { 1385 AnimatedPropertyID animatedProperty = cssToGraphicsLayerProperty(property); 1386 if (animatedProperty != AnimatedPropertyInvalid) 1387 m_graphicsLayer->removeAnimation(GraphicsLayer::animationNameForTransition(animatedProperty)); 1388 } 1389 1390 void RenderLayerBacking::notifyAnimationStarted(const GraphicsLayer*, double time) 1391 { 1392 renderer()->animation()->notifyAnimationStarted(renderer(), time); 1393 } 1394 1395 void RenderLayerBacking::notifySyncRequired(const GraphicsLayer*) 1396 { 1397 if (!renderer()->documentBeingDestroyed()) 1398 compositor()->scheduleLayerFlush(); 1399 } 1400 1401 // This is used for the 'freeze' API, for testing only. 1402 void RenderLayerBacking::suspendAnimations(double time) 1403 { 1404 m_graphicsLayer->suspendAnimations(time); 1405 } 1406 1407 void RenderLayerBacking::resumeAnimations() 1408 { 1409 m_graphicsLayer->resumeAnimations(); 1410 } 1411 1412 IntRect RenderLayerBacking::compositedBounds() const 1413 { 1414 return m_compositedBounds; 1415 } 1416 1417 void RenderLayerBacking::setCompositedBounds(const IntRect& bounds) 1418 { 1419 m_compositedBounds = bounds; 1420 1421 } 1422 int RenderLayerBacking::graphicsLayerToCSSProperty(AnimatedPropertyID property) 1423 { 1424 int cssProperty = CSSPropertyInvalid; 1425 switch (property) { 1426 case AnimatedPropertyWebkitTransform: 1427 cssProperty = CSSPropertyWebkitTransform; 1428 break; 1429 case AnimatedPropertyOpacity: 1430 cssProperty = CSSPropertyOpacity; 1431 break; 1432 case AnimatedPropertyBackgroundColor: 1433 cssProperty = CSSPropertyBackgroundColor; 1434 break; 1435 case AnimatedPropertyInvalid: 1436 ASSERT_NOT_REACHED(); 1437 } 1438 return cssProperty; 1439 } 1440 1441 AnimatedPropertyID RenderLayerBacking::cssToGraphicsLayerProperty(int cssProperty) 1442 { 1443 switch (cssProperty) { 1444 case CSSPropertyWebkitTransform: 1445 return AnimatedPropertyWebkitTransform; 1446 case CSSPropertyOpacity: 1447 return AnimatedPropertyOpacity; 1448 case CSSPropertyBackgroundColor: 1449 return AnimatedPropertyBackgroundColor; 1450 // It's fine if we see other css properties here; they are just not accelerated. 1451 } 1452 return AnimatedPropertyInvalid; 1453 } 1454 1455 #ifndef NDEBUG 1456 String RenderLayerBacking::nameForLayer() const 1457 { 1458 String name = renderer()->renderName(); 1459 if (Node* node = renderer()->node()) { 1460 if (node->isElementNode()) 1461 name += " " + static_cast<Element*>(node)->tagName(); 1462 if (node->hasID()) 1463 name += " \'" + static_cast<Element*>(node)->getIdAttribute() + "\'"; 1464 } 1465 1466 if (m_owningLayer->isReflection()) 1467 name += " (reflection)"; 1468 1469 return name; 1470 } 1471 #endif 1472 1473 CompositingLayerType RenderLayerBacking::compositingLayerType() const 1474 { 1475 if (m_graphicsLayer->hasContentsLayer()) 1476 return MediaCompositingLayer; 1477 1478 if (m_graphicsLayer->drawsContent()) 1479 return m_graphicsLayer->usingTiledLayer() ? TiledCompositingLayer : NormalCompositingLayer; 1480 1481 return ContainerCompositingLayer; 1482 } 1483 1484 void RenderLayerBacking::updateContentsScale(float scale) 1485 { 1486 if (m_graphicsLayer) 1487 m_graphicsLayer->setContentsScale(scale); 1488 1489 if (m_foregroundLayer) 1490 m_foregroundLayer->setContentsScale(scale); 1491 1492 if (m_maskLayer) 1493 m_maskLayer->setContentsScale(scale); 1494 } 1495 1496 } // namespace WebCore 1497 1498 #endif // USE(ACCELERATED_COMPOSITING) 1499
