Source/WebCore/rendering/RenderLayerCompositor.cpp

   1 /*
   2  * Copyright (C) 2009, 2010 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 #include "RenderLayerCompositor.h"
  30
  31 #include "AnimationController.h"
  32 #include "CanvasRenderingContext.h"
  33 #include "CSSPropertyNames.h"
  34 #include "Chrome.h"
  35 #include "ChromeClient.h"
  36 #include "Frame.h"
  37 #include "FrameView.h"
  38 #include "GraphicsLayer.h"
  39 #include "HTMLCanvasElement.h"
  40 #include "HTMLIFrameElement.h"
  41 #include "HTMLNames.h"
  42 #include "HitTestResult.h"
  43 #include "NodeList.h"
  44 #include "Page.h"
  45 #include "RenderApplet.h"
  46 #include "RenderEmbeddedObject.h"
  47 #include "RenderFullScreen.h"
  48 #include "RenderIFrame.h"
  49 #include "RenderLayerBacking.h"
  50 #include "RenderReplica.h"
  51 #include "RenderVideo.h"
  52 #include "RenderView.h"
  53 #include "Settings.h"
  54
  55 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
  56 #include "HTMLMediaElement.h"
  57 #endif
  58
  59 #if PROFILE_LAYER_REBUILD
  60 #include <wtf/CurrentTime.h>
  61 #endif
  62
  63 #ifndef NDEBUG
  64 #include "RenderTreeAsText.h"
  65 #endif
  66
  67 #if ENABLE(3D_RENDERING)
  68 // This symbol is used to determine from a script whether 3D rendering is enabled (via 'nm').
  69 bool WebCoreHas3DRendering = true;
  70 #endif
  71
  72 namespace WebCore {
  73
  74 using namespace HTMLNames;
  75
  76 struct CompositingState {
  77     CompositingState(RenderLayer* compAncestor)
  78         : m_compositingAncestor(compAncestor)
  79         , m_subtreeIsCompositing(false)
  80 #if ENABLE(COMPOSITED_FIXED_ELEMENTS)
  81         , m_fixedSibling(false)
  82 #endif
  83 #ifndef NDEBUG
  84         , m_depth(0)
  85 #endif
  86     {
  87     }
  88
  89     RenderLayer* m_compositingAncestor;
  90     bool m_subtreeIsCompositing;
  91 #if ENABLE(COMPOSITED_FIXED_ELEMENTS)
  92     bool m_fixedSibling;
  93 #endif
  94 #ifndef NDEBUG
  95     int m_depth;
  96 #endif
  97 };
  98
  99 RenderLayerCompositor::RenderLayerCompositor(RenderView* renderView)
 100     : m_renderView(renderView)
 101     , m_rootPlatformLayer(0)
 102     , m_updateCompositingLayersTimer(this, &RenderLayerCompositor::updateCompositingLayersTimerFired)
 103     , m_hasAcceleratedCompositing(true)
 104     , m_compositingTriggers(static_cast<ChromeClient::CompositingTriggerFlags>(ChromeClient::AllTriggers))
 105     , m_showDebugBorders(false)
 106     , m_showRepaintCounter(false)
 107     , m_compositingConsultsOverlap(true)
 108     , m_compositingDependsOnGeometry(false)
 109     , m_compositing(false)
 110     , m_compositingLayersNeedRebuild(false)
 111     , m_flushingLayers(false)
 112     , m_forceCompositingMode(false)
 113     , m_rootLayerAttachment(RootLayerUnattached)
 114 #if PROFILE_LAYER_REBUILD
 115     , m_rootLayerUpdateCount(0)
 116 #endif // PROFILE_LAYER_REBUILD
 117 {
 118     Settings* settings = m_renderView->document()->settings();
 119
 120     // Even when forcing compositing mode, ignore child frames, or this will trigger
 121     // layer creation from the enclosing RenderIFrame.
 122     ASSERT(m_renderView->document()->frame());
 123     if (settings && settings->forceCompositingMode() && settings->acceleratedCompositingEnabled()
 124         && !m_renderView->document()->frame()->tree()->parent()) {
 125         m_forceCompositingMode = true;
 126         enableCompositingMode();
 127     }
 128 }
 129
 130 RenderLayerCompositor::~RenderLayerCompositor()
 131 {
 132     ASSERT(m_rootLayerAttachment == RootLayerUnattached);
 133 }
 134
 135 void RenderLayerCompositor::enableCompositingMode(bool enable /* = true */)
 136 {
 137     if (enable != m_compositing) {
 138         m_compositing = enable;
 139
 140         if (m_compositing) {
 141             ensureRootPlatformLayer();
 142             notifyIFramesOfCompositingChange();
 143         } else
 144             destroyRootPlatformLayer();
 145     }
 146 }
 147
 148 void RenderLayerCompositor::cacheAcceleratedCompositingFlags()
 149 {
 150     bool hasAcceleratedCompositing = false;
 151     bool showDebugBorders = false;
 152     bool showRepaintCounter = false;
 153
 154     if (Settings* settings = m_renderView->document()->settings()) {
 155         hasAcceleratedCompositing = settings->acceleratedCompositingEnabled();
 156         showDebugBorders = settings->showDebugBorders();
 157         showRepaintCounter = settings->showRepaintCounter();
 158     }
 159
 160     // We allow the chrome to override the settings, in case the page is rendered
 161     // on a chrome that doesn't allow accelerated compositing.
 162     if (hasAcceleratedCompositing) {
 163         Frame* frame = m_renderView->frameView()->frame();
 164         Page* page = frame ? frame->page() : 0;
 165         if (page) {
 166             ChromeClient* chromeClient = page->chrome()->client();
 167             m_compositingTriggers = chromeClient->allowedCompositingTriggers();
 168             hasAcceleratedCompositing = m_compositingTriggers;
 169         }
 170     }
 171
 172     if (hasAcceleratedCompositing != m_hasAcceleratedCompositing || showDebugBorders != m_showDebugBorders || showRepaintCounter != m_showRepaintCounter)
 173         setCompositingLayersNeedRebuild();
 174
 175     m_hasAcceleratedCompositing = hasAcceleratedCompositing;
 176     m_showDebugBorders = showDebugBorders;
 177     m_showRepaintCounter = showRepaintCounter;
 178 }
 179
 180 bool RenderLayerCompositor::canRender3DTransforms() const
 181 {
 182     return hasAcceleratedCompositing() && (m_compositingTriggers & ChromeClient::ThreeDTransformTrigger);
 183 }
 184
 185 void RenderLayerCompositor::setCompositingLayersNeedRebuild(bool needRebuild)
 186 {
 187     if (inCompositingMode())
 188         m_compositingLayersNeedRebuild = needRebuild;
 189 }
 190
 191 void RenderLayerCompositor::scheduleLayerFlush()
 192 {
 193     Frame* frame = m_renderView->frameView()->frame();
 194     Page* page = frame ? frame->page() : 0;
 195     if (!page)
 196         return;
 197
 198     page->chrome()->client()->scheduleCompositingLayerSync();
 199 }
 200
 201 void RenderLayerCompositor::flushPendingLayerChanges()
 202 {
 203     ASSERT(!m_flushingLayers);
 204     m_flushingLayers = true;
 205
 206     // FIXME: FrameView::syncCompositingStateRecursive() calls this for each
 207     // frame, so when compositing layers are connected between frames, we'll
 208     // end up syncing subframe's layers multiple times.
 209     // https://bugs.webkit.org/show_bug.cgi?id=52489
 210     if (GraphicsLayer* rootLayer = rootPlatformLayer())
 211         rootLayer->syncCompositingState();
 212
 213     ASSERT(m_flushingLayers);
 214     m_flushingLayers = false;
 215 }
 216
 217 RenderLayerCompositor* RenderLayerCompositor::enclosingCompositorFlushingLayers() const
 218 {
 219     if (!m_renderView->frameView())
 220         return 0;
 221
 222     for (Frame* frame = m_renderView->frameView()->frame(); frame; frame = frame->tree()->parent()) {
 223         RenderLayerCompositor* compositor = frame->contentRenderer() ? frame->contentRenderer()->compositor() : 0;
 224         if (compositor->isFlushingLayers())
 225             return compositor;
 226     }
 227
 228     return 0;
 229 }
 230
 231 void RenderLayerCompositor::scheduleCompositingLayerUpdate()
 232 {
 233     if (!m_updateCompositingLayersTimer.isActive())
 234         m_updateCompositingLayersTimer.startOneShot(0);
 235 }
 236
 237 bool RenderLayerCompositor::compositingLayerUpdatePending() const
 238 {
 239     return m_updateCompositingLayersTimer.isActive();
 240 }
 241
 242 void RenderLayerCompositor::updateCompositingLayersTimerFired(Timer<RenderLayerCompositor>*)
 243 {
 244     updateCompositingLayers();
 245 }
 246
 247 void RenderLayerCompositor::updateCompositingLayers(CompositingUpdateType updateType, RenderLayer* updateRoot)
 248 {
 249     m_updateCompositingLayersTimer.stop();
 250
 251     if (!m_compositingDependsOnGeometry && !m_compositing)
 252         return;
 253
 254     bool checkForHierarchyUpdate = m_compositingDependsOnGeometry;
 255     bool needGeometryUpdate = false;
 256
 257     switch (updateType) {
 258     case CompositingUpdateAfterLayoutOrStyleChange:
 259     case CompositingUpdateOnPaitingOrHitTest:
 260         checkForHierarchyUpdate = true;
 261         break;
 262     case CompositingUpdateOnScroll:
 263         if (m_compositingConsultsOverlap)
 264             checkForHierarchyUpdate = true; // Overlap can change with scrolling, so need to check for hierarchy updates.
 265
 266         needGeometryUpdate = true;
 267         break;
 268     }
 269
 270     if (!checkForHierarchyUpdate && !needGeometryUpdate)
 271         return;
 272
 273     bool needHierarchyUpdate = m_compositingLayersNeedRebuild;
 274     if (!updateRoot || m_compositingConsultsOverlap) {
 275         // Only clear the flag if we're updating the entire hierarchy.
 276         m_compositingLayersNeedRebuild = false;
 277         updateRoot = rootRenderLayer();
 278     }
 279
 280 #if PROFILE_LAYER_REBUILD
 281     ++m_rootLayerUpdateCount;
 282
 283     double startTime = WTF::currentTime();
 284 #endif
 285
 286     if (checkForHierarchyUpdate) {
 287         // Go through the layers in presentation order, so that we can compute which RenderLayers need compositing layers.
 288         // FIXME: we could maybe do this and the hierarchy udpate in one pass, but the parenting logic would be more complex.
 289         CompositingState compState(updateRoot);
 290         bool layersChanged = false;
 291         if (m_compositingConsultsOverlap) {
 292             OverlapMap overlapTestRequestMap;
 293             computeCompositingRequirements(updateRoot, &overlapTestRequestMap, compState, layersChanged);
 294         } else
 295             computeCompositingRequirements(updateRoot, 0, compState, layersChanged);
 296
 297         needHierarchyUpdate |= layersChanged;
 298     }
 299
 300     if (needHierarchyUpdate) {
 301         // Update the hierarchy of the compositing layers.
 302         CompositingState compState(updateRoot);
 303         Vector<GraphicsLayer*> childList;
 304         rebuildCompositingLayerTree(updateRoot, compState, childList);
 305
 306         // Host the document layer in the RenderView's root layer.
 307         if (updateRoot == rootRenderLayer()) {
 308             if (childList.isEmpty())
 309                 destroyRootPlatformLayer();
 310             else
 311                 m_rootPlatformLayer->setChildren(childList);
 312         }
 313     } else if (needGeometryUpdate) {
 314         // We just need to do a geometry update. This is only used for position:fixed scrolling;
 315         // most of the time, geometry is updated via RenderLayer::styleChanged().
 316         updateLayerTreeGeometry(updateRoot);
 317     }
 318
 319 #if PROFILE_LAYER_REBUILD
 320     double endTime = WTF::currentTime();
 321     if (updateRoot == rootRenderLayer())
 322         fprintf(stderr, "Update %d: computeCompositingRequirements for the world took %fms\n",
 323                     m_rootLayerUpdateCount, 1000.0 * (endTime - startTime));
 324 #endif
 325     ASSERT(updateRoot || !m_compositingLayersNeedRebuild);
 326
 327     if (!hasAcceleratedCompositing())
 328         enableCompositingMode(false);
 329 }
 330
 331 bool RenderLayerCompositor::updateBacking(RenderLayer* layer, CompositingChangeRepaint shouldRepaint)
 332 {
 333     bool layerChanged = false;
 334
 335     if (needsToBeComposited(layer)) {
 336         enableCompositingMode();
 337
 338         // 3D transforms turn off the testing of overlap.
 339         if (requiresCompositingForTransform(layer->renderer()))
 340             setCompositingConsultsOverlap(false);
 341 #if ENABLE(ANDROID_OVERFLOW_SCROLL)
 342         // If we are a child of a scrollable layer, ignore the overlap from the
 343         // scrollable layer as it can cause child layers to become composited
 344         // siblings and will not scroll with the main content layer.
 345         if (layer->hasOverflowParent())
 346             setCompositingConsultsOverlap(false);
 347 #endif
 348
 349         if (!layer->backing()) {
 350
 351             // If we need to repaint, do so before making backing
 352             if (shouldRepaint == CompositingChangeRepaintNow)
 353                 repaintOnCompositingChange(layer);
 354
 355             layer->ensureBacking();
 356
 357 #if PLATFORM(MAC) && USE(CA)
 358             if (m_renderView->document()->settings()->acceleratedDrawingEnabled())
 359                 layer->backing()->graphicsLayer()->setAcceleratesDrawing(true);
 360             else if (layer->renderer()->isCanvas()) {
 361                 HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(layer->renderer()->node());
 362                 if (canvas->renderingContext() && canvas->renderingContext()->isAccelerated())
 363                     layer->backing()->graphicsLayer()->setAcceleratesDrawing(true);
 364             }
 365 #endif
 366             layerChanged = true;
 367         }
 368     } else {
 369         if (layer->backing()) {
 370             // If we're removing backing on a reflection, clear the source GraphicsLayer's pointer to
 371             // its replica GraphicsLayer. In practice this should never happen because reflectee and reflection
 372             // are both either composited, or not composited.
 373             if (layer->isReflection()) {
 374                 RenderLayer* sourceLayer = toRenderBoxModelObject(layer->renderer()->parent())->layer();
 375                 if (RenderLayerBacking* backing = sourceLayer->backing()) {
 376                     ASSERT(backing->graphicsLayer()->replicaLayer() == layer->backing()->graphicsLayer());
 377                     backing->graphicsLayer()->setReplicatedByLayer(0);
 378                 }
 379             }
 380
 381             layer->clearBacking();
 382             layerChanged = true;
 383
 384             // The layer's cached repaints rects are relative to the repaint container, so change when
 385             // compositing changes; we need to update them here.
 386             layer->computeRepaintRects();
 387
 388             // If we need to repaint, do so now that we've removed the backing
 389             if (shouldRepaint == CompositingChangeRepaintNow)
 390                 repaintOnCompositingChange(layer);
 391         }
 392     }
 393
 394 #if ENABLE(VIDEO)
 395     if (layerChanged && layer->renderer()->isVideo()) {
 396         // If it's a video, give the media player a chance to hook up to the layer.
 397         RenderVideo* video = toRenderVideo(layer->renderer());
 398         video->acceleratedRenderingStateChanged();
 399     }
 400 #endif
 401
 402     if (layerChanged && layer->renderer()->isRenderPart()) {
 403         RenderLayerCompositor* innerCompositor = frameContentsCompositor(toRenderPart(layer->renderer()));
 404         if (innerCompositor && innerCompositor->inCompositingMode())
 405             innerCompositor->updateRootLayerAttachment();
 406     }
 407
 408     return layerChanged;
 409 }
 410
 411 bool RenderLayerCompositor::updateLayerCompositingState(RenderLayer* layer, CompositingChangeRepaint shouldRepaint)
 412 {
 413     bool layerChanged = updateBacking(layer, shouldRepaint);
 414
 415     // See if we need content or clipping layers. Methods called here should assume
 416     // that the compositing state of descendant layers has not been updated yet.
 417     if (layer->backing() && layer->backing()->updateGraphicsLayerConfiguration())
 418         layerChanged = true;
 419
 420     return layerChanged;
 421 }
 422
 423 void RenderLayerCompositor::repaintOnCompositingChange(RenderLayer* layer)
 424 {
 425     // If the renderer is not attached yet, no need to repaint.
 426     if (layer->renderer() != m_renderView && !layer->renderer()->parent())
 427         return;
 428
 429     RenderBoxModelObject* repaintContainer = layer->renderer()->containerForRepaint();
 430     if (!repaintContainer)
 431         repaintContainer = m_renderView;
 432
 433     layer->repaintIncludingNonCompositingDescendants(repaintContainer);
 434     if (repaintContainer == m_renderView) {
 435         // The contents of this layer may be moving between the window
 436         // and a GraphicsLayer, so we need to make sure the window system
 437         // synchronizes those changes on the screen.
 438         m_renderView->frameView()->setNeedsOneShotDrawingSynchronization();
 439     }
 440 }
 441
 442 // The bounds of the GraphicsLayer created for a compositing layer is the union of the bounds of all the descendant
 443 // RenderLayers that are rendered by the composited RenderLayer.
 444 IntRect RenderLayerCompositor::calculateCompositedBounds(const RenderLayer* layer, const RenderLayer* ancestorLayer)
 445 {
 446     if (!canBeComposited(layer))
 447         return IntRect();
 448
 449     IntRect boundingBoxRect = layer->localBoundingBox();
 450     if (layer->renderer()->isRoot()) {
 451         // If the root layer becomes composited (e.g. because some descendant with negative z-index is composited),
 452         // then it has to be big enough to cover the viewport in order to display the background. This is akin
 453         // to the code in RenderBox::paintRootBoxFillLayers().
 454         if (m_renderView->frameView()) {
 455             int rw = m_renderView->frameView()->contentsWidth();
 456             int rh = m_renderView->frameView()->contentsHeight();
 457
 458             boundingBoxRect.setWidth(max(boundingBoxRect.width(), rw - boundingBoxRect.x()));
 459             boundingBoxRect.setHeight(max(boundingBoxRect.height(), rh - boundingBoxRect.y()));
 460         }
 461     }
 462
 463     IntRect unionBounds = boundingBoxRect;
 464
 465     if (layer->renderer()->hasOverflowClip() || layer->renderer()->hasMask()) {
 466         int ancestorRelX = 0, ancestorRelY = 0;
 467         layer->convertToLayerCoords(ancestorLayer, ancestorRelX, ancestorRelY);
 468         boundingBoxRect.move(ancestorRelX, ancestorRelY);
 469         return boundingBoxRect;
 470     }
 471
 472     if (RenderLayer* reflection = layer->reflectionLayer()) {
 473         if (!reflection->isComposited()) {
 474             IntRect childUnionBounds = calculateCompositedBounds(reflection, layer);
 475             unionBounds.unite(childUnionBounds);
 476         }
 477     }
 478
 479     ASSERT(layer->isStackingContext() || (!layer->m_posZOrderList || layer->m_posZOrderList->size() == 0));
 480
 481     if (Vector<RenderLayer*>* negZOrderList = layer->negZOrderList()) {
 482         size_t listSize = negZOrderList->size();
 483         for (size_t i = 0; i < listSize; ++i) {
 484             RenderLayer* curLayer = negZOrderList->at(i);
 485             if (!curLayer->isComposited()) {
 486                 IntRect childUnionBounds = calculateCompositedBounds(curLayer, layer);
 487                 unionBounds.unite(childUnionBounds);
 488             }
 489         }
 490     }
 491
 492     if (Vector<RenderLayer*>* posZOrderList = layer->posZOrderList()) {
 493         size_t listSize = posZOrderList->size();
 494         for (size_t i = 0; i < listSize; ++i) {
 495             RenderLayer* curLayer = posZOrderList->at(i);
 496             if (!curLayer->isComposited()) {
 497                 IntRect childUnionBounds = calculateCompositedBounds(curLayer, layer);
 498                 unionBounds.unite(childUnionBounds);
 499             }
 500         }
 501     }
 502
 503     if (Vector<RenderLayer*>* normalFlowList = layer->normalFlowList()) {
 504         size_t listSize = normalFlowList->size();
 505         for (size_t i = 0; i < listSize; ++i) {
 506             RenderLayer* curLayer = normalFlowList->at(i);
 507             if (!curLayer->isComposited()) {
 508                 IntRect curAbsBounds = calculateCompositedBounds(curLayer, layer);
 509                 unionBounds.unite(curAbsBounds);
 510             }
 511         }
 512     }
 513
 514     if (layer->paintsWithTransform(PaintBehaviorNormal)) {
 515         TransformationMatrix* affineTrans = layer->transform();
 516         boundingBoxRect = affineTrans->mapRect(boundingBoxRect);
 517         unionBounds = affineTrans->mapRect(unionBounds);
 518     }
 519
 520     int ancestorRelX = 0, ancestorRelY = 0;
 521     layer->convertToLayerCoords(ancestorLayer, ancestorRelX, ancestorRelY);
 522     unionBounds.move(ancestorRelX, ancestorRelY);
 523
 524     return unionBounds;
 525 }
 526
 527 void RenderLayerCompositor::layerWasAdded(RenderLayer* /*parent*/, RenderLayer* /*child*/)
 528 {
 529     setCompositingLayersNeedRebuild();
 530 }
 531
 532 void RenderLayerCompositor::layerWillBeRemoved(RenderLayer* parent, RenderLayer* child)
 533 {
 534     if (!child->isComposited() || parent->renderer()->documentBeingDestroyed())
 535         return;
 536
 537     setCompositingParent(child, 0);
 538
 539     RenderLayer* compLayer = parent->enclosingCompositingLayer();
 540     if (compLayer) {
 541         ASSERT(compLayer->backing());
 542         IntRect compBounds = child->backing()->compositedBounds();
 543
 544         int offsetX = 0, offsetY = 0;
 545         child->convertToLayerCoords(compLayer, offsetX, offsetY);
 546         compBounds.move(offsetX, offsetY);
 547
 548         compLayer->setBackingNeedsRepaintInRect(compBounds);
 549
 550         // The contents of this layer may be moving from a GraphicsLayer to the window,
 551         // so we need to make sure the window system synchronizes those changes on the screen.
 552         m_renderView->frameView()->setNeedsOneShotDrawingSynchronization();
 553     }
 554
 555     setCompositingLayersNeedRebuild();
 556 }
 557
 558 RenderLayer* RenderLayerCompositor::enclosingNonStackingClippingLayer(const RenderLayer* layer) const
 559 {
 560     for (RenderLayer* curr = layer->parent(); curr != 0; curr = curr->parent()) {
 561         if (curr->isStackingContext())
 562             return 0;
 563
 564         if (curr->renderer()->hasOverflowClip() || curr->renderer()->hasClip())
 565             return curr;
 566     }
 567     return 0;
 568 }
 569
 570 void RenderLayerCompositor::addToOverlapMap(OverlapMap& overlapMap, RenderLayer* layer, IntRect& layerBounds, bool& boundsComputed)
 571 {
 572     if (layer->isRootLayer())
 573         return;
 574
 575     if (!boundsComputed) {
 576         layerBounds = layer->renderer()->localToAbsoluteQuad(FloatRect(layer->localBoundingBox())).enclosingBoundingBox();
 577         // Empty rects never intersect, but we need them to for the purposes of overlap testing.
 578         if (layerBounds.isEmpty())
 579             layerBounds.setSize(IntSize(1, 1));
 580         boundsComputed = true;
 581     }
 582
 583     overlapMap.add(layer, layerBounds);
 584 }
 585
 586 bool RenderLayerCompositor::overlapsCompositedLayers(OverlapMap& overlapMap, const IntRect& layerBounds)
 587 {
 588     RenderLayerCompositor::OverlapMap::const_iterator end = overlapMap.end();
 589     for (RenderLayerCompositor::OverlapMap::const_iterator it = overlapMap.begin(); it != end; ++it) {
 590         const IntRect& bounds = it->second;
 591         if (layerBounds.intersects(bounds)) {
 592 #if ENABLE(COMPOSITED_FIXED_ELEMENTS)
 593             RenderLayer* intersectedLayer = it->first;
 594             if (intersectedLayer && intersectedLayer->isFixed()) {
 595                 if (bounds.contains(layerBounds)) {
 596                     continue;
 597                 }
 598             }
 599 #endif
 600             return true;
 601         }
 602     }
 603
 604     return false;
 605 }
 606
 607 //  Recurse through the layers in z-index and overflow order (which is equivalent to painting order)
 608 //  For the z-order children of a compositing layer:
 609 //      If a child layers has a compositing layer, then all subsequent layers must
 610 //      be compositing in order to render above that layer.
 611 //
 612 //      If a child in the negative z-order list is compositing, then the layer itself
 613 //      must be compositing so that its contents render over that child.
 614 //      This implies that its positive z-index children must also be compositing.
 615 //
 616 void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* layer, OverlapMap* overlapMap, struct CompositingState& compositingState, bool& layersChanged)
 617 {
 618     layer->updateLayerPosition();
 619     layer->updateZOrderLists();
 620     layer->updateNormalFlowList();
 621
 622     // Clear the flag
 623     layer->setHasCompositingDescendant(false);
 624
 625     bool mustOverlapCompositedLayers = compositingState.m_subtreeIsCompositing;
 626
 627     bool haveComputedBounds = false;
 628     IntRect absBounds;
 629     if (overlapMap && !overlapMap->isEmpty()) {
 630         // If we're testing for overlap, we only need to composite if we overlap something that is already composited.
 631         absBounds = layer->renderer()->localToAbsoluteQuad(FloatRect(layer->localBoundingBox())).enclosingBoundingBox();
 632         // Empty rects never intersect, but we need them to for the purposes of overlap testing.
 633         if (absBounds.isEmpty())
 634             absBounds.setSize(IntSize(1, 1));
 635         haveComputedBounds = true;
 636         mustOverlapCompositedLayers = overlapsCompositedLayers(*overlapMap, absBounds);
 637     }
 638
 639     layer->setMustOverlapCompositedLayers(mustOverlapCompositedLayers);
 640
 641     // The children of this layer don't need to composite, unless there is
 642     // a compositing layer among them, so start by inheriting the compositing
 643     // ancestor with m_subtreeIsCompositing set to false.
 644     CompositingState childState(compositingState.m_compositingAncestor);
 645 #ifndef NDEBUG
 646     ++childState.m_depth;
 647 #endif
 648
 649     bool willBeComposited = needsToBeComposited(layer);
 650
 651 #if ENABLE(COMPOSITED_FIXED_ELEMENTS)
 652     // If we are a fixed layer, signal it to our siblings
 653     if (willBeComposited && layer->isFixed())
 654         compositingState.m_fixedSibling = true;
 655
 656     if (!willBeComposited && compositingState.m_fixedSibling) {
 657         layer->setMustOverlapCompositedLayers(true);
 658         willBeComposited = true;
 659     }
 660 #endif
 661     if (willBeComposited) {
 662         // Tell the parent it has compositing descendants.
 663         compositingState.m_subtreeIsCompositing = true;
 664         // This layer now acts as the ancestor for kids.
 665         childState.m_compositingAncestor = layer;
 666         if (overlapMap)
 667             addToOverlapMap(*overlapMap, layer, absBounds, haveComputedBounds);
 668     }
 669
 670 #if ENABLE(VIDEO)
 671     // Video is special. It's a replaced element with a content layer, but has shadow content
 672     // for the controller that must render in front. Without this, the controls fail to show
 673     // when the video element is a stacking context (e.g. due to opacity or transform).
 674     if (willBeComposited && layer->renderer()->isVideo())
 675         childState.m_subtreeIsCompositing = true;
 676 #endif
 677
 678     if (layer->isStackingContext()) {
 679         ASSERT(!layer->m_zOrderListsDirty);
 680         if (Vector<RenderLayer*>* negZOrderList = layer->negZOrderList()) {
 681             size_t listSize = negZOrderList->size();
 682 #if ENABLE(COMPOSITED_FIXED_ELEMENTS)
 683             childState.m_fixedSibling = false;
 684
 685             // For the negative z-order, if we have a fixed layer
 686             // we need to make all the siblings composited layers.
 687             // Otherwise a negative layer (below the fixed layer) could
 688             // still be drawn onto a higher z-order layer (e.g. the body)
 689             // if not immediately intersecting with our fixed layer.
 690             // So it's not enough here to only set m_fixedSibling for
 691             // subsequent siblings as we do for the normal flow
 692             // and positive z-order.
 693             for (size_t j = 0; j < listSize; ++j) {
 694                 if ((negZOrderList->at(j))->isFixed() &&
 695                     needsToBeComposited(negZOrderList->at(j))) {
 696                     childState.m_fixedSibling = true;
 697                     break;
 698                 }
 699             }
 700 #endif
 701
 702             for (size_t i = 0; i < listSize; ++i) {
 703                 RenderLayer* curLayer = negZOrderList->at(i);
 704                 computeCompositingRequirements(curLayer, overlapMap, childState, layersChanged);
 705
 706                 // If we have to make a layer for this child, make one now so we can have a contents layer
 707                 // (since we need to ensure that the -ve z-order child renders underneath our contents).
 708                 if (!willBeComposited && childState.m_subtreeIsCompositing) {
 709                     // make layer compositing
 710                     layer->setMustOverlapCompositedLayers(true);
 711                     childState.m_compositingAncestor = layer;
 712                     if (overlapMap)
 713                         addToOverlapMap(*overlapMap, layer, absBounds, haveComputedBounds);
 714                     willBeComposited = true;
 715                 }
 716             }
 717         }
 718     }
 719
 720     ASSERT(!layer->m_normalFlowListDirty);
 721     if (Vector<RenderLayer*>* normalFlowList = layer->normalFlowList()) {
 722         size_t listSize = normalFlowList->size();
 723 #if ENABLE(COMPOSITED_FIXED_ELEMENTS)
 724         childState.m_fixedSibling = false;
 725 #endif
 726         for (size_t i = 0; i < listSize; ++i) {
 727             RenderLayer* curLayer = normalFlowList->at(i);
 728             computeCompositingRequirements(curLayer, overlapMap, childState, layersChanged);
 729         }
 730     }
 731
 732     if (layer->isStackingContext()) {
 733         if (Vector<RenderLayer*>* posZOrderList = layer->posZOrderList()) {
 734             size_t listSize = posZOrderList->size();
 735 #if ENABLE(COMPOSITED_FIXED_ELEMENTS)
 736             childState.m_fixedSibling = false;
 737 #endif
 738             for (size_t i = 0; i < listSize; ++i) {
 739                 RenderLayer* curLayer = posZOrderList->at(i);
 740                 computeCompositingRequirements(curLayer, overlapMap, childState, layersChanged);
 741             }
 742         }
 743     }
 744
 745     // If we just entered compositing mode, the root will have become composited (as long as accelerated compositing is enabled).
 746     if (layer->isRootLayer()) {
 747         if (inCompositingMode() && m_hasAcceleratedCompositing)
 748             willBeComposited = true;
 749     }
 750
 751     ASSERT(willBeComposited == needsToBeComposited(layer));
 752
 753     // If we have a software transform, and we have layers under us, we need to also
 754     // be composited. Also, if we have opacity < 1, then we need to be a layer so that
 755     // the child layers are opaque, then rendered with opacity on this layer.
 756     if (!willBeComposited && canBeComposited(layer) && childState.m_subtreeIsCompositing && requiresCompositingWhenDescendantsAreCompositing(layer->renderer())) {
 757         layer->setMustOverlapCompositedLayers(true);
 758         if (overlapMap)
 759             addToOverlapMap(*overlapMap, layer, absBounds, haveComputedBounds);
 760         willBeComposited = true;
 761     }
 762
 763     ASSERT(willBeComposited == needsToBeComposited(layer));
 764     if (layer->reflectionLayer())
 765         layer->reflectionLayer()->setMustOverlapCompositedLayers(willBeComposited);
 766
 767     // Subsequent layers in the parent stacking context also need to composite.
 768     if (childState.m_subtreeIsCompositing)
 769         compositingState.m_subtreeIsCompositing = true;
 770
 771     // Set the flag to say that this SC has compositing children.
 772     layer->setHasCompositingDescendant(childState.m_subtreeIsCompositing);
 773
 774     // setHasCompositingDescendant() may have changed the answer to needsToBeComposited() when clipping,
 775     // so test that again.
 776     if (!willBeComposited && canBeComposited(layer) && clipsCompositingDescendants(layer)) {
 777         if (overlapMap)
 778             addToOverlapMap(*overlapMap, layer, absBounds, haveComputedBounds);
 779         willBeComposited = true;
 780     }
 781
 782     // If we're back at the root, and no other layers need to be composited, and the root layer itself doesn't need
 783     // to be composited, then we can drop out of compositing mode altogether.
 784     if (layer->isRootLayer() && !childState.m_subtreeIsCompositing && !requiresCompositingLayer(layer) && !m_forceCompositingMode) {
 785         enableCompositingMode(false);
 786         willBeComposited = false;
 787     }
 788
 789     // If the layer is going into compositing mode, repaint its old location.
 790     ASSERT(willBeComposited == needsToBeComposited(layer));
 791     if (!layer->isComposited() && willBeComposited)
 792         repaintOnCompositingChange(layer);
 793
 794     // Update backing now, so that we can use isComposited() reliably during tree traversal in rebuildCompositingLayerTree().
 795     if (updateBacking(layer, CompositingChangeRepaintNow))
 796         layersChanged = true;
 797
 798     if (layer->reflectionLayer() && updateLayerCompositingState(layer->reflectionLayer(), CompositingChangeRepaintNow))
 799         layersChanged = true;
 800 }
 801
 802 void RenderLayerCompositor::setCompositingParent(RenderLayer* childLayer, RenderLayer* parentLayer)
 803 {
 804     ASSERT(!parentLayer || childLayer->ancestorCompositingLayer() == parentLayer);
 805     ASSERT(childLayer->isComposited());
 806
 807     // It's possible to be called with a parent that isn't yet composited when we're doing
 808     // partial updates as required by painting or hit testing. Just bail in that case;
 809     // we'll do a full layer update soon.
 810     if (!parentLayer || !parentLayer->isComposited())
 811         return;
 812
 813     if (parentLayer) {
 814         GraphicsLayer* hostingLayer = parentLayer->backing()->parentForSublayers();
 815         GraphicsLayer* hostedLayer = childLayer->backing()->childForSuperlayers();
 816
 817         hostingLayer->addChild(hostedLayer);
 818     } else
 819         childLayer->backing()->childForSuperlayers()->removeFromParent();
 820 }
 821
 822 void RenderLayerCompositor::removeCompositedChildren(RenderLayer* layer)
 823 {
 824     ASSERT(layer->isComposited());
 825
 826     GraphicsLayer* hostingLayer = layer->backing()->parentForSublayers();
 827     hostingLayer->removeAllChildren();
 828 }
 829
 830 #if ENABLE(VIDEO)
 831 bool RenderLayerCompositor::canAccelerateVideoRendering(RenderVideo* o) const
 832 {
 833     if (!m_hasAcceleratedCompositing)
 834         return false;
 835
 836     return o->supportsAcceleratedRendering();
 837 }
 838 #endif
 839
 840 void RenderLayerCompositor::rebuildCompositingLayerTree(RenderLayer* layer, const CompositingState& compositingState, Vector<GraphicsLayer*>& childLayersOfEnclosingLayer)
 841 {
 842     // Make the layer compositing if necessary, and set up clipping and content layers.
 843     // Note that we can only do work here that is independent of whether the descendant layers
 844     // have been processed. computeCompositingRequirements() will already have done the repaint if necessary.
 845
 846     RenderLayerBacking* layerBacking = layer->backing();
 847     if (layerBacking) {
 848         // The compositing state of all our children has been updated already, so now
 849         // we can compute and cache the composited bounds for this layer.
 850         layerBacking->updateCompositedBounds();
 851
 852         if (RenderLayer* reflection = layer->reflectionLayer()) {
 853             if (reflection->backing())
 854                 reflection->backing()->updateCompositedBounds();
 855         }
 856
 857         layerBacking->updateGraphicsLayerConfiguration();
 858         layerBacking->updateGraphicsLayerGeometry();
 859
 860         if (!layer->parent())
 861             updateRootLayerPosition();
 862     }
 863
 864     // If this layer has backing, then we are collecting its children, otherwise appending
 865     // to the compositing child list of an enclosing layer.
 866     Vector<GraphicsLayer*> layerChildren;
 867     Vector<GraphicsLayer*>& childList = layerBacking ? layerChildren : childLayersOfEnclosingLayer;
 868
 869     CompositingState childState = compositingState;
 870     if (layer->isComposited())
 871         childState.m_compositingAncestor = layer;
 872
 873 #ifndef NDEBUG
 874     ++childState.m_depth;
 875 #endif
 876
 877     // The children of this stacking context don't need to composite, unless there is
 878     // a compositing layer among them, so start by assuming false.
 879     childState.m_subtreeIsCompositing = false;
 880
 881     if (layer->isStackingContext()) {
 882         ASSERT(!layer->m_zOrderListsDirty);
 883
 884         if (Vector<RenderLayer*>* negZOrderList = layer->negZOrderList()) {
 885             size_t listSize = negZOrderList->size();
 886             for (size_t i = 0; i < listSize; ++i) {
 887                 RenderLayer* curLayer = negZOrderList->at(i);
 888                 rebuildCompositingLayerTree(curLayer, childState, childList);
 889             }
 890         }
 891
 892         // If a negative z-order child is compositing, we get a foreground layer which needs to get parented.
 893         if (layerBacking && layerBacking->foregroundLayer())
 894             childList.append(layerBacking->foregroundLayer());
 895     }
 896
 897     ASSERT(!layer->m_normalFlowListDirty);
 898     if (Vector<RenderLayer*>* normalFlowList = layer->normalFlowList()) {
 899         size_t listSize = normalFlowList->size();
 900         for (size_t i = 0; i < listSize; ++i) {
 901             RenderLayer* curLayer = normalFlowList->at(i);
 902             rebuildCompositingLayerTree(curLayer, childState, childList);
 903         }
 904     }
 905
 906     if (layer->isStackingContext()) {
 907         if (Vector<RenderLayer*>* posZOrderList = layer->posZOrderList()) {
 908             size_t listSize = posZOrderList->size();
 909             for (size_t i = 0; i < listSize; ++i) {
 910                 RenderLayer* curLayer = posZOrderList->at(i);
 911                 rebuildCompositingLayerTree(curLayer, childState, childList);
 912             }
 913         }
 914     }
 915
 916     if (layerBacking) {
 917         bool parented = false;
 918         if (layer->renderer()->isRenderPart())
 919             parented = parentFrameContentLayers(toRenderPart(layer->renderer()));
 920
 921         // If the layer has a clipping layer the overflow controls layers will be siblings of the clipping layer.
 922         // Otherwise, the overflow control layers are normal children.
 923         if (!layerBacking->hasClippingLayer()) {
 924             if (GraphicsLayer* overflowControlLayer = layerBacking->layerForHorizontalScrollbar()) {
 925                 overflowControlLayer->removeFromParent();
 926                 layerChildren.append(overflowControlLayer);
 927             }
 928
 929             if (GraphicsLayer* overflowControlLayer = layerBacking->layerForVerticalScrollbar()) {
 930                 overflowControlLayer->removeFromParent();
 931                 layerChildren.append(overflowControlLayer);
 932             }
 933
 934             if (GraphicsLayer* overflowControlLayer = layerBacking->layerForScrollCorner()) {
 935                 overflowControlLayer->removeFromParent();
 936                 layerChildren.append(overflowControlLayer);
 937             }
 938         }
 939
 940         if (!parented)
 941             layerBacking->parentForSublayers()->setChildren(layerChildren);
 942
 943 #if ENABLE(FULLSCREEN_API)
 944         // For the sake of clients of the full screen renderer, don't reparent
 945         // the full screen layer out from under them if they're in the middle of
 946         // animating.
 947         if (layer->renderer()->isRenderFullScreen() && toRenderFullScreen(layer->renderer())->isAnimating())
 948             return;
 949 #endif
 950         childLayersOfEnclosingLayer.append(layerBacking->childForSuperlayers());
 951     }
 952 }
 953
 954 void RenderLayerCompositor::frameViewDidChangeLocation(const IntPoint& contentsOffset)
 955 {
 956     if (m_overflowControlsHostLayer)
 957         m_overflowControlsHostLayer->setPosition(contentsOffset);
 958 }
 959
 960 void RenderLayerCompositor::frameViewDidChangeSize()
 961 {
 962     if (m_clipLayer) {
 963         FrameView* frameView = m_renderView->frameView();
 964         m_clipLayer->setSize(frameView->visibleContentRect(false /* exclude scrollbars */).size());
 965
 966         IntPoint scrollPosition = frameView->scrollPosition();
 967         m_scrollLayer->setPosition(FloatPoint(-scrollPosition.x(), -scrollPosition.y()));
 968         updateOverflowControlsLayers();
 969     }
 970 }
 971
 972 void RenderLayerCompositor::frameViewDidScroll(const IntPoint& scrollPosition)
 973 {
 974     if (m_scrollLayer)
 975         m_scrollLayer->setPosition(FloatPoint(-scrollPosition.x(), -scrollPosition.y()));
 976 }
 977
 978 String RenderLayerCompositor::layerTreeAsText(bool showDebugInfo)
 979 {
 980     if (compositingLayerUpdatePending())
 981         updateCompositingLayers();
 982
 983     if (!m_rootPlatformLayer)
 984         return String();
 985
 986     // We skip dumping the scroll and clip layers to keep layerTreeAsText output
 987     // similar between platforms.
 988     return m_rootPlatformLayer->layerTreeAsText(showDebugInfo ? LayerTreeAsTextDebug : LayerTreeAsTextBehaviorNormal);
 989 }
 990
 991 RenderLayerCompositor* RenderLayerCompositor::frameContentsCompositor(RenderPart* renderer)
 992 {
 993     if (!renderer->node()->isFrameOwnerElement())
 994         return 0;
 995
 996     HTMLFrameOwnerElement* element = static_cast<HTMLFrameOwnerElement*>(renderer->node());
 997     if (Document* contentDocument = element->contentDocument()) {
 998         if (RenderView* view = contentDocument->renderView())
 999             return view->compositor();
1000     }
1001     return 0;
1002 }
1003
1004 bool RenderLayerCompositor::parentFrameContentLayers(RenderPart* renderer)
1005 {
1006     RenderLayerCompositor* innerCompositor = frameContentsCompositor(renderer);
1007     if (!innerCompositor || !innerCompositor->inCompositingMode() || innerCompositor->rootLayerAttachment() != RootLayerAttachedViaEnclosingFrame)
1008         return false;
1009
1010     RenderLayer* layer = renderer->layer();
1011     if (!layer->isComposited())
1012         return false;
1013
1014     RenderLayerBacking* backing = layer->backing();
1015     GraphicsLayer* hostingLayer = backing->parentForSublayers();
1016     GraphicsLayer* rootLayer = innerCompositor->rootPlatformLayer();
1017     if (hostingLayer->children().size() != 1 || hostingLayer->children()[0] != rootLayer) {
1018         hostingLayer->removeAllChildren();
1019         hostingLayer->addChild(rootLayer);
1020     }
1021     return true;
1022 }
1023
1024 // This just updates layer geometry without changing the hierarchy.
1025 void RenderLayerCompositor::updateLayerTreeGeometry(RenderLayer* layer)
1026 {
1027     if (RenderLayerBacking* layerBacking = layer->backing()) {
1028         // The compositing state of all our children has been updated already, so now
1029         // we can compute and cache the composited bounds for this layer.
1030         layerBacking->updateCompositedBounds();
1031
1032         if (RenderLayer* reflection = layer->reflectionLayer()) {
1033             if (reflection->backing())
1034                 reflection->backing()->updateCompositedBounds();
1035         }
1036
1037         layerBacking->updateGraphicsLayerConfiguration();
1038         layerBacking->updateGraphicsLayerGeometry();
1039
1040         if (!layer->parent())
1041             updateRootLayerPosition();
1042     }
1043
1044     if (layer->isStackingContext()) {
1045         ASSERT(!layer->m_zOrderListsDirty);
1046
1047         if (Vector<RenderLayer*>* negZOrderList = layer->negZOrderList()) {
1048             size_t listSize = negZOrderList->size();
1049             for (size_t i = 0; i < listSize; ++i)
1050                 updateLayerTreeGeometry(negZOrderList->at(i));
1051         }
1052     }
1053
1054     ASSERT(!layer->m_normalFlowListDirty);
1055     if (Vector<RenderLayer*>* normalFlowList = layer->normalFlowList()) {
1056         size_t listSize = normalFlowList->size();
1057         for (size_t i = 0; i < listSize; ++i)
1058             updateLayerTreeGeometry(normalFlowList->at(i));
1059     }
1060
1061     if (layer->isStackingContext()) {
1062         if (Vector<RenderLayer*>* posZOrderList = layer->posZOrderList()) {
1063             size_t listSize = posZOrderList->size();
1064             for (size_t i = 0; i < listSize; ++i)
1065                 updateLayerTreeGeometry(posZOrderList->at(i));
1066         }
1067     }
1068 }
1069
1070 // Recurs down the RenderLayer tree until its finds the compositing descendants of compositingAncestor and updates their geometry.
1071 void RenderLayerCompositor::updateCompositingDescendantGeometry(RenderLayer* compositingAncestor, RenderLayer* layer, RenderLayerBacking::UpdateDepth updateDepth)
1072 {
1073     if (layer != compositingAncestor) {
1074         if (RenderLayerBacking* layerBacking = layer->backing()) {
1075             layerBacking->updateCompositedBounds();
1076
1077             if (RenderLayer* reflection = layer->reflectionLayer()) {
1078                 if (reflection->backing())
1079                     reflection->backing()->updateCompositedBounds();
1080             }
1081
1082             layerBacking->updateGraphicsLayerGeometry();
1083             if (updateDepth == RenderLayerBacking::CompositingChildren)
1084                 return;
1085         }
1086     }
1087
1088     if (layer->reflectionLayer())
1089         updateCompositingDescendantGeometry(compositingAncestor, layer->reflectionLayer(), updateDepth);
1090
1091     if (!layer->hasCompositingDescendant())
1092         return;
1093
1094     if (layer->isStackingContext()) {
1095         if (Vector<RenderLayer*>* negZOrderList = layer->negZOrderList()) {
1096             size_t listSize = negZOrderList->size();
1097             for (size_t i = 0; i < listSize; ++i)
1098                 updateCompositingDescendantGeometry(compositingAncestor, negZOrderList->at(i), updateDepth);
1099         }
1100     }
1101
1102     if (Vector<RenderLayer*>* normalFlowList = layer->normalFlowList()) {
1103         size_t listSize = normalFlowList->size();
1104         for (size_t i = 0; i < listSize; ++i)
1105             updateCompositingDescendantGeometry(compositingAncestor, normalFlowList->at(i), updateDepth);
1106     }
1107
1108     if (layer->isStackingContext()) {
1109         if (Vector<RenderLayer*>* posZOrderList = layer->posZOrderList()) {
1110             size_t listSize = posZOrderList->size();
1111             for (size_t i = 0; i < listSize; ++i)
1112                 updateCompositingDescendantGeometry(compositingAncestor, posZOrderList->at(i), updateDepth);
1113         }
1114     }
1115 }
1116
1117
1118 void RenderLayerCompositor::repaintCompositedLayersAbsoluteRect(const IntRect& absRect)
1119 {
1120     recursiveRepaintLayerRect(rootRenderLayer(), absRect);
1121 }
1122
1123 void RenderLayerCompositor::recursiveRepaintLayerRect(RenderLayer* layer, const IntRect& rect)
1124 {
1125     // FIXME: This method does not work correctly with transforms.
1126     if (layer->isComposited())
1127         layer->setBackingNeedsRepaintInRect(rect);
1128
1129     if (layer->hasCompositingDescendant()) {
1130         if (Vector<RenderLayer*>* negZOrderList = layer->negZOrderList()) {
1131             size_t listSize = negZOrderList->size();
1132             for (size_t i = 0; i < listSize; ++i) {
1133                 RenderLayer* curLayer = negZOrderList->at(i);
1134                 int x = 0;
1135                 int y = 0;
1136                 curLayer->convertToLayerCoords(layer, x, y);
1137                 IntRect childRect(rect);
1138                 childRect.move(-x, -y);
1139                 recursiveRepaintLayerRect(curLayer, childRect);
1140             }
1141         }
1142
1143         if (Vector<RenderLayer*>* posZOrderList = layer->posZOrderList()) {
1144             size_t listSize = posZOrderList->size();
1145             for (size_t i = 0; i < listSize; ++i) {
1146                 RenderLayer* curLayer = posZOrderList->at(i);
1147                 int x = 0;
1148                 int y = 0;
1149                 curLayer->convertToLayerCoords(layer, x, y);
1150                 IntRect childRect(rect);
1151                 childRect.move(-x, -y);
1152                 recursiveRepaintLayerRect(curLayer, childRect);
1153             }
1154         }
1155     }
1156     if (Vector<RenderLayer*>* normalFlowList = layer->normalFlowList()) {
1157         size_t listSize = normalFlowList->size();
1158         for (size_t i = 0; i < listSize; ++i) {
1159             RenderLayer* curLayer = normalFlowList->at(i);
1160             int x = 0;
1161             int y = 0;
1162             curLayer->convertToLayerCoords(layer, x, y);
1163             IntRect childRect(rect);
1164             childRect.move(-x, -y);
1165             recursiveRepaintLayerRect(curLayer, childRect);
1166         }
1167     }
1168 }
1169
1170 RenderLayer* RenderLayerCompositor::rootRenderLayer() const
1171 {
1172     return m_renderView->layer();
1173 }
1174
1175 GraphicsLayer* RenderLayerCompositor::rootPlatformLayer() const
1176 {
1177     if (m_overflowControlsHostLayer)
1178         return m_overflowControlsHostLayer.get();
1179     return m_rootPlatformLayer.get();
1180 }
1181
1182 void RenderLayerCompositor::didMoveOnscreen()
1183 {
1184     if (!inCompositingMode() || m_rootLayerAttachment != RootLayerUnattached)
1185         return;
1186
1187     RootLayerAttachment attachment = shouldPropagateCompositingToEnclosingFrame() ? RootLayerAttachedViaEnclosingFrame : RootLayerAttachedViaChromeClient;
1188     attachRootPlatformLayer(attachment);
1189 }
1190
1191 void RenderLayerCompositor::willMoveOffscreen()
1192 {
1193     if (!inCompositingMode() || m_rootLayerAttachment == RootLayerUnattached)
1194         return;
1195
1196     detachRootPlatformLayer();
1197 }
1198
1199 void RenderLayerCompositor::updateRootLayerPosition()
1200 {
1201     if (m_rootPlatformLayer) {
1202         m_rootPlatformLayer->setSize(FloatSize(m_renderView->docWidth(), m_renderView->docHeight()));
1203         m_rootPlatformLayer->setPosition(FloatPoint(m_renderView->docLeft(), m_renderView->docTop()));
1204     }
1205     if (m_clipLayer) {
1206         FrameView* frameView = m_renderView->frameView();
1207         m_clipLayer->setSize(frameView->visibleContentRect(false /* exclude scrollbars */).size());
1208     }
1209 }
1210
1211 void RenderLayerCompositor::didStartAcceleratedAnimation(CSSPropertyID property)
1212 {
1213     // If an accelerated animation or transition runs, we have to turn off overlap checking because
1214     // we don't do layout for every frame, but we have to ensure that the layering is
1215     // correct between the animating object and other objects on the page.
1216     if (property == CSSPropertyWebkitTransform)
1217         setCompositingConsultsOverlap(false);
1218 }
1219
1220 bool RenderLayerCompositor::has3DContent() const
1221 {
1222     return layerHas3DContent(rootRenderLayer());
1223 }
1224
1225 bool RenderLayerCompositor::allowsIndependentlyCompositedFrames(const FrameView* view)
1226 {
1227 #if PLATFORM(MAC)
1228     // frames are only independently composited in Mac pre-WebKit2.
1229     return view->platformWidget();
1230 #endif
1231     return false;
1232 }
1233
1234 bool RenderLayerCompositor::shouldPropagateCompositingToEnclosingFrame() const
1235 {
1236 #if PLATFORM(ANDROID)
1237     if (enclosingFrameElement() && !allowsIndependentlyCompositedFrames(m_renderView->frameView()))
1238         return true;
1239 #endif
1240     // Parent document content needs to be able to render on top of a composited frame, so correct behavior
1241     // is to have the parent document become composited too. However, this can cause problems on platforms that
1242     // use native views for frames (like Mac), so disable that behavior on those platforms for now.
1243     HTMLFrameOwnerElement* ownerElement = enclosingFrameElement();
1244     RenderObject* renderer = ownerElement ? ownerElement->renderer() : 0;
1245
1246     // If we are the top-level frame, don't propagate.
1247     if (!ownerElement)
1248         return false;
1249
1250     if (!allowsIndependentlyCompositedFrames(m_renderView->frameView()))
1251         return true;
1252
1253     if (!renderer || !renderer->isRenderPart())
1254         return false;
1255
1256     // On Mac, only propagate compositing if the frame is overlapped in the parent
1257     // document, or the parent is already compositing, or the main frame is scaled.
1258     Frame* frame = m_renderView->frameView()->frame();
1259     Page* page = frame ? frame->page() : 0;
1260     if (page->mainFrame()->pageScaleFactor() != 1)
1261         return true;
1262
1263     RenderPart* frameRenderer = toRenderPart(renderer);
1264     if (frameRenderer->widget()) {
1265         ASSERT(frameRenderer->widget()->isFrameView());
1266         FrameView* view = static_cast<FrameView*>(frameRenderer->widget());
1267         if (view->isOverlappedIncludingAncestors() || view->hasCompositingAncestor())
1268             return true;
1269     }
1270
1271     return false;
1272 }
1273
1274 HTMLFrameOwnerElement* RenderLayerCompositor::enclosingFrameElement() const
1275 {
1276     if (HTMLFrameOwnerElement* ownerElement = m_renderView->document()->ownerElement())
1277         return (ownerElement->hasTagName(iframeTag) || ownerElement->hasTagName(frameTag) || ownerElement->hasTagName(objectTag)) ? ownerElement : 0;
1278
1279     return 0;
1280 }
1281
1282 bool RenderLayerCompositor::needsToBeComposited(const RenderLayer* layer) const
1283 {
1284     if (!canBeComposited(layer))
1285         return false;
1286
1287     // The root layer always has a compositing layer, but it may not have backing.
1288     return requiresCompositingLayer(layer) || layer->mustOverlapCompositedLayers() || (inCompositingMode() && layer->isRootLayer());
1289 }
1290
1291 #if PLATFORM(ANDROID)
1292 bool RenderLayerCompositor::requiresCompositingForAndroidLayers(const RenderLayer* layer) const
1293 {
1294 #if ENABLE(ANDROID_OVERFLOW_SCROLL)
1295     if (layer->hasOverflowScroll())
1296         return true;
1297     if (layer->isRootLayer() && m_renderView->frameView()->hasOverflowScroll())
1298         return true;
1299 #endif
1300 #if ENABLE(COMPOSITED_FIXED_ELEMENTS)
1301
1302     // Enable composited layers (for fixed elements)
1303     if (layer->isFixed())
1304         return true;
1305 #endif
1306     return false;
1307 }
1308 #endif
1309
1310 // Note: this specifies whether the RL needs a compositing layer for intrinsic reasons.
1311 // Use needsToBeComposited() to determine if a RL actually needs a compositing layer.
1312 // static
1313 bool RenderLayerCompositor::requiresCompositingLayer(const RenderLayer* layer) const
1314 {
1315     RenderObject* renderer = layer->renderer();
1316     // The compositing state of a reflection should match that of its reflected layer.
1317     if (layer->isReflection()) {
1318         renderer = renderer->parent(); // The RenderReplica's parent is the object being reflected.
1319         layer = toRenderBoxModelObject(renderer)->layer();
1320     }
1321     return requiresCompositingForTransform(renderer)
1322 #if PLATFORM(ANDROID)
1323              || requiresCompositingForAndroidLayers(layer)
1324 #endif
1325              || requiresCompositingForVideo(renderer)
1326              || requiresCompositingForCanvas(renderer)
1327              || requiresCompositingForPlugin(renderer)
1328              || requiresCompositingForFrame(renderer)
1329              || (canRender3DTransforms() && renderer->style()->backfaceVisibility() == BackfaceVisibilityHidden)
1330              || clipsCompositingDescendants(layer)
1331              || requiresCompositingForAnimation(renderer)
1332              || requiresCompositingForFullScreen(renderer);
1333 }
1334
1335 bool RenderLayerCompositor::canBeComposited(const RenderLayer* layer) const
1336 {
1337     return m_hasAcceleratedCompositing && layer->isSelfPaintingLayer();
1338 }
1339
1340 // Return true if the given layer has some ancestor in the RenderLayer hierarchy that clips,
1341 // up to the enclosing compositing ancestor. This is required because compositing layers are parented
1342 // according to the z-order hierarchy, yet clipping goes down the renderer hierarchy.
1343 // Thus, a RenderLayer can be clipped by a RenderLayer that is an ancestor in the renderer hierarchy,
1344 // but a sibling in the z-order hierarchy.
1345 bool RenderLayerCompositor::clippedByAncestor(RenderLayer* layer) const
1346 {
1347     if (!layer->isComposited() || !layer->parent())
1348         return false;
1349
1350     RenderLayer* compositingAncestor = layer->ancestorCompositingLayer();
1351     if (!compositingAncestor)
1352         return false;
1353
1354     // If the compositingAncestor clips, that will be taken care of by clipsCompositingDescendants(),
1355     // so we only care about clipping between its first child that is our ancestor (the computeClipRoot),
1356     // and layer.
1357     RenderLayer* computeClipRoot = 0;
1358     RenderLayer* curr = layer;
1359     while (curr) {
1360         RenderLayer* next = curr->parent();
1361         if (next == compositingAncestor) {
1362             computeClipRoot = curr;
1363             break;
1364         }
1365         curr = next;
1366     }
1367
1368     if (!computeClipRoot || computeClipRoot == layer)
1369         return false;
1370
1371     IntRect backgroundRect = layer->backgroundClipRect(computeClipRoot, true);
1372     return backgroundRect != PaintInfo::infiniteRect();
1373 }
1374
1375 // Return true if the given layer is a stacking context and has compositing child
1376 // layers that it needs to clip. In this case we insert a clipping GraphicsLayer
1377 // into the hierarchy between this layer and its children in the z-order hierarchy.
1378 bool RenderLayerCompositor::clipsCompositingDescendants(const RenderLayer* layer) const
1379 {
1380 #if ENABLE(ANDROID_OVERFLOW_SCROLL)
1381     if (layer->hasOverflowScroll())
1382         return false;
1383 #endif
1384     return layer->hasCompositingDescendant() &&
1385            (layer->renderer()->hasOverflowClip() || layer->renderer()->hasClip());
1386 }
1387
1388 bool RenderLayerCompositor::requiresCompositingForTransform(RenderObject* renderer) const
1389 {
1390     if (!(m_compositingTriggers & ChromeClient::ThreeDTransformTrigger))
1391         return false;
1392
1393     RenderStyle* style = renderer->style();
1394     // Note that we ask the renderer if it has a transform, because the style may have transforms,
1395     // but the renderer may be an inline that doesn't suppport them.
1396     return renderer->hasTransform() && (style->transform().has3DOperation() || style->transformStyle3D() == TransformStyle3DPreserve3D || style->hasPerspective());
1397 }
1398
1399 bool RenderLayerCompositor::requiresCompositingForVideo(RenderObject* renderer) const
1400 {
1401     if (!(m_compositingTriggers & ChromeClient::VideoTrigger))
1402         return false;
1403 #if ENABLE(VIDEO)
1404     if (renderer->isVideo()) {
1405         RenderVideo* video = toRenderVideo(renderer);
1406         return video->shouldDisplayVideo() && canAccelerateVideoRendering(video);
1407     }
1408 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
1409     else if (renderer->isRenderPart()) {
1410         if (!m_hasAcceleratedCompositing)
1411             return false;
1412
1413         Node* node = renderer->node();
1414         if (!node || (!node->hasTagName(HTMLNames::videoTag) && !node->hasTagName(HTMLNames::audioTag)))
1415             return false;
1416
1417         HTMLMediaElement* mediaElement = static_cast<HTMLMediaElement*>(node);
1418         return mediaElement->player() ? mediaElement->player()->supportsAcceleratedRendering() : false;
1419     }
1420 #endif // ENABLE(PLUGIN_PROXY_FOR_VIDEO)
1421 #else
1422     UNUSED_PARAM(renderer);
1423 #endif
1424     return false;
1425 }
1426
1427 bool RenderLayerCompositor::requiresCompositingForCanvas(RenderObject* renderer) const
1428 {
1429     if (!(m_compositingTriggers & ChromeClient::CanvasTrigger))
1430         return false;
1431
1432     if (renderer->isCanvas()) {
1433         HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(renderer->node());
1434         return canvas->renderingContext() && canvas->renderingContext()->isAccelerated();
1435     }
1436     return false;
1437 }
1438
1439 bool RenderLayerCompositor::requiresCompositingForPlugin(RenderObject* renderer) const
1440 {
1441     if (!(m_compositingTriggers & ChromeClient::PluginTrigger))
1442         return false;
1443
1444     bool composite = (renderer->isEmbeddedObject() && toRenderEmbeddedObject(renderer)->allowsAcceleratedCompositing())
1445                   || (renderer->isApplet() && toRenderApplet(renderer)->allowsAcceleratedCompositing());
1446     if (!composite)
1447         return false;
1448
1449     m_compositingDependsOnGeometry = true;
1450
1451     RenderWidget* pluginRenderer = toRenderWidget(renderer);
1452     // If we can't reliably know the size of the plugin yet, don't change compositing state.
1453     if (pluginRenderer->needsLayout())
1454         return pluginRenderer->hasLayer() && pluginRenderer->layer()->isComposited();
1455
1456     // Don't go into compositing mode if height or width are zero, or size is 1x1.
1457     IntRect contentBox = pluginRenderer->contentBoxRect();
1458     return contentBox.height() * contentBox.width() > 1;
1459 }
1460
1461 bool RenderLayerCompositor::requiresCompositingForFrame(RenderObject* renderer) const
1462 {
1463     if (!renderer->isRenderPart())
1464         return false;
1465
1466     RenderPart* frameRenderer = toRenderPart(renderer);
1467
1468     if (!frameRenderer->requiresAcceleratedCompositing())
1469         return false;
1470
1471     m_compositingDependsOnGeometry = true;
1472
1473     RenderLayerCompositor* innerCompositor = frameContentsCompositor(frameRenderer);
1474     if (!innerCompositor || !innerCompositor->shouldPropagateCompositingToEnclosingFrame())
1475         return false;
1476
1477     // If we can't reliably know the size of the iframe yet, don't change compositing state.
1478     if (renderer->needsLayout())
1479         return frameRenderer->hasLayer() && frameRenderer->layer()->isComposited();
1480
1481     // Don't go into compositing mode if height or width are zero.
1482     IntRect contentBox = frameRenderer->contentBoxRect();
1483     return contentBox.height() * contentBox.width() > 0;
1484 }
1485
1486 bool RenderLayerCompositor::requiresCompositingForAnimation(RenderObject* renderer) const
1487 {
1488     if (!(m_compositingTriggers & ChromeClient::AnimationTrigger))
1489         return false;
1490
1491     if (AnimationController* animController = renderer->animation()) {
1492         return (animController->isRunningAnimationOnRenderer(renderer, CSSPropertyOpacity) && inCompositingMode())
1493             || animController->isRunningAnimationOnRenderer(renderer, CSSPropertyWebkitTransform);
1494     }
1495     return false;
1496 }
1497
1498 bool RenderLayerCompositor::requiresCompositingWhenDescendantsAreCompositing(RenderObject* renderer) const
1499 {
1500     return renderer->hasTransform() || renderer->isTransparent() || renderer->hasMask() || renderer->hasReflection();
1501 }
1502
1503 bool RenderLayerCompositor::requiresCompositingForFullScreen(RenderObject* renderer) const
1504 {
1505 #if ENABLE(FULLSCREEN_API)
1506     return renderer->isRenderFullScreen() && toRenderFullScreen(renderer)->isAnimating();
1507 #else
1508     UNUSED_PARAM(renderer);
1509     return false;
1510 #endif
1511 }
1512
1513 // If an element has negative z-index children, those children render in front of the
1514 // layer background, so we need an extra 'contents' layer for the foreground of the layer
1515 // object.
1516 bool RenderLayerCompositor::needsContentsCompositingLayer(const RenderLayer* layer) const
1517 {
1518     return (layer->m_negZOrderList && layer->m_negZOrderList->size() > 0);
1519 }
1520
1521 bool RenderLayerCompositor::requiresScrollLayer(RootLayerAttachment attachment) const
1522 {
1523 #if PLATFORM(ANDROID)
1524     // Recently, RenderLayerCompositor is changed to be a subclass of
1525     // GraphicsLayerClient, and it is used for iframe.
1526     // http://trac.webkit.org/changeset/75262
1527     // We have our own support for iframe, before we embrace this new approach,
1528     // we will disable it.
1529     // TODO: Investigate how to utilize this way to support iframe.
1530     return false;
1531 #endif
1532     // We need to handle our own scrolling if we're:
1533     return !m_renderView->frameView()->platformWidget() // viewless (i.e. non-Mac, or Mac in WebKit2)
1534         || attachment == RootLayerAttachedViaEnclosingFrame; // a composited frame on Mac
1535 }
1536
1537 static void paintScrollbar(Scrollbar* scrollbar, GraphicsContext& context, const IntRect& clip)
1538 {
1539     if (!scrollbar)
1540         return;
1541
1542     context.save();
1543     const IntRect& scrollbarRect = scrollbar->frameRect();
1544     context.translate(-scrollbarRect.x(), -scrollbarRect.y());
1545     IntRect transformedClip = clip;
1546     transformedClip.move(scrollbarRect.x(), scrollbarRect.y());
1547     scrollbar->paint(&context, transformedClip);
1548     context.restore();
1549 }
1550
1551 void RenderLayerCompositor::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& context, GraphicsLayerPaintingPhase, const IntRect& clip)
1552 {
1553     if (graphicsLayer == layerForHorizontalScrollbar())
1554         paintScrollbar(m_renderView->frameView()->horizontalScrollbar(), context, clip);
1555     else if (graphicsLayer == layerForVerticalScrollbar())
1556         paintScrollbar(m_renderView->frameView()->verticalScrollbar(), context, clip);
1557     else if (graphicsLayer == layerForScrollCorner()) {
1558         const IntRect& scrollCorner = m_renderView->frameView()->scrollCornerRect();
1559         context.save();
1560         context.translate(-scrollCorner.x(), -scrollCorner.y());
1561         IntRect transformedClip = clip;
1562         transformedClip.move(scrollCorner.x(), scrollCorner.y());
1563         m_renderView->frameView()->paintScrollCorner(&context, transformedClip);
1564         context.restore();
1565     }
1566 }
1567
1568 static bool shouldCompositeOverflowControls(ScrollView* view)
1569 {
1570     if (view->platformWidget())
1571         return false;
1572 #if !PLATFORM(CHROMIUM)
1573     if (!view->hasOverlayScrollbars())
1574         return false;
1575 #endif
1576     return true;
1577 }
1578
1579 bool RenderLayerCompositor::requiresHorizontalScrollbarLayer() const
1580 {
1581     ScrollView* view = m_renderView->frameView();
1582     return shouldCompositeOverflowControls(view) && view->horizontalScrollbar();
1583 }
1584
1585 bool RenderLayerCompositor::requiresVerticalScrollbarLayer() const
1586 {
1587     ScrollView* view = m_renderView->frameView();
1588     return shouldCompositeOverflowControls(view) && view->verticalScrollbar();
1589 }
1590
1591 bool RenderLayerCompositor::requiresScrollCornerLayer() const
1592 {
1593     ScrollView* view = m_renderView->frameView();
1594     return shouldCompositeOverflowControls(view) && view->isScrollCornerVisible();
1595 }
1596
1597 void RenderLayerCompositor::updateOverflowControlsLayers()
1598 {
1599     bool layersChanged = false;
1600
1601     if (requiresHorizontalScrollbarLayer()) {
1602         m_layerForHorizontalScrollbar = GraphicsLayer::create(this);
1603 #ifndef NDEBUG
1604         m_layerForHorizontalScrollbar->setName("horizontal scrollbar");
1605 #endif
1606         m_overflowControlsHostLayer->addChild(m_layerForHorizontalScrollbar.get());
1607         layersChanged = true;
1608     } else if (m_layerForHorizontalScrollbar) {
1609         m_layerForHorizontalScrollbar->removeFromParent();
1610         m_layerForHorizontalScrollbar = 0;
1611         layersChanged = true;
1612     }
1613
1614     if (requiresVerticalScrollbarLayer()) {
1615         m_layerForVerticalScrollbar = GraphicsLayer::create(this);
1616 #ifndef NDEBUG
1617         m_layerForVerticalScrollbar->setName("vertical scrollbar");
1618 #endif
1619         m_overflowControlsHostLayer->addChild(m_layerForVerticalScrollbar.get());
1620         layersChanged = true;
1621     } else if (m_layerForVerticalScrollbar) {
1622         m_layerForVerticalScrollbar->removeFromParent();
1623         m_layerForVerticalScrollbar = 0;
1624         layersChanged = true;
1625     }
1626
1627     if (requiresScrollCornerLayer()) {
1628         m_layerForScrollCorner = GraphicsLayer::create(this);
1629 #ifndef NDEBUG
1630         m_layerForScrollCorner->setName("scroll corner");
1631 #endif
1632         m_overflowControlsHostLayer->addChild(m_layerForScrollCorner.get());
1633         layersChanged = true;
1634     } else if (m_layerForScrollCorner) {
1635         m_layerForScrollCorner->removeFromParent();
1636         m_layerForScrollCorner = 0;
1637         layersChanged = true;
1638     }
1639
1640     if (layersChanged)
1641         m_renderView->frameView()->positionScrollbarLayers();
1642 }
1643
1644 void RenderLayerCompositor::ensureRootPlatformLayer()
1645 {
1646     RootLayerAttachment expectedAttachment = shouldPropagateCompositingToEnclosingFrame() ? RootLayerAttachedViaEnclosingFrame : RootLayerAttachedViaChromeClient;
1647     if (expectedAttachment == m_rootLayerAttachment)
1648          return;
1649
1650     if (!m_rootPlatformLayer) {
1651         m_rootPlatformLayer = GraphicsLayer::create(0);
1652 #ifndef NDEBUG
1653         m_rootPlatformLayer->setName("Root platform");
1654 #endif
1655         m_rootPlatformLayer->setSize(FloatSize(m_renderView->maxXLayoutOverflow(), m_renderView->maxYLayoutOverflow()));
1656         m_rootPlatformLayer->setPosition(FloatPoint());
1657
1658         // Need to clip to prevent transformed content showing outside this frame
1659         m_rootPlatformLayer->setMasksToBounds(true);
1660     }
1661
1662     if (requiresScrollLayer(expectedAttachment)) {
1663         if (!m_overflowControlsHostLayer) {
1664             ASSERT(!m_scrollLayer);
1665             ASSERT(!m_clipLayer);
1666
1667             // Create a layer to host the clipping layer and the overflow controls layers.
1668             m_overflowControlsHostLayer = GraphicsLayer::create(0);
1669 #ifndef NDEBUG
1670             m_overflowControlsHostLayer->setName("overflow controls host");
1671 #endif
1672
1673             // Create a clipping layer if this is an iframe
1674             m_clipLayer = GraphicsLayer::create(this);
1675 #ifndef NDEBUG
1676             m_clipLayer->setName("iframe Clipping");
1677 #endif
1678             m_clipLayer->setMasksToBounds(true);
1679
1680             m_scrollLayer = GraphicsLayer::create(this);
1681 #ifndef NDEBUG
1682             m_scrollLayer->setName("iframe scrolling");
1683 #endif
1684
1685             // Hook them up
1686             m_overflowControlsHostLayer->addChild(m_clipLayer.get());
1687             m_clipLayer->addChild(m_scrollLayer.get());
1688             m_scrollLayer->addChild(m_rootPlatformLayer.get());
1689
1690             frameViewDidChangeSize();
1691             frameViewDidScroll(m_renderView->frameView()->scrollPosition());
1692         }
1693     } else {
1694         if (m_overflowControlsHostLayer) {
1695             m_overflowControlsHostLayer = 0;
1696             m_clipLayer = 0;
1697             m_scrollLayer = 0;
1698         }
1699     }
1700
1701     // Check to see if we have to change the attachment
1702     if (m_rootLayerAttachment != RootLayerUnattached)
1703         detachRootPlatformLayer();
1704
1705     attachRootPlatformLayer(expectedAttachment);
1706 }
1707
1708 void RenderLayerCompositor::destroyRootPlatformLayer()
1709 {
1710     if (!m_rootPlatformLayer)
1711         return;
1712
1713     detachRootPlatformLayer();
1714
1715     if (m_layerForHorizontalScrollbar) {
1716         m_layerForHorizontalScrollbar->removeFromParent();
1717         m_layerForHorizontalScrollbar = 0;
1718         if (Scrollbar* horizontalScrollbar = m_renderView->frameView()->verticalScrollbar())
1719             m_renderView->frameView()->invalidateScrollbar(horizontalScrollbar, IntRect(IntPoint(0, 0), horizontalScrollbar->frameRect().size()));
1720     }
1721
1722     if (m_layerForVerticalScrollbar) {
1723         m_layerForVerticalScrollbar->removeFromParent();
1724         m_layerForVerticalScrollbar = 0;
1725         if (Scrollbar* verticalScrollbar = m_renderView->frameView()->verticalScrollbar())
1726             m_renderView->frameView()->invalidateScrollbar(verticalScrollbar, IntRect(IntPoint(0, 0), verticalScrollbar->frameRect().size()));
1727     }
1728
1729     if (m_layerForScrollCorner) {
1730         m_layerForScrollCorner = 0;
1731         m_renderView->frameView()->invalidateScrollCorner();
1732     }
1733
1734     if (m_overflowControlsHostLayer) {
1735         m_overflowControlsHostLayer = 0;
1736         m_clipLayer = 0;
1737         m_scrollLayer = 0;
1738     }
1739     ASSERT(!m_scrollLayer);
1740     m_rootPlatformLayer = 0;
1741 }
1742
1743 void RenderLayerCompositor::attachRootPlatformLayer(RootLayerAttachment attachment)
1744 {
1745     if (!m_rootPlatformLayer)
1746         return;
1747
1748     switch (attachment) {
1749         case RootLayerUnattached:
1750             ASSERT_NOT_REACHED();
1751             break;
1752         case RootLayerAttachedViaChromeClient: {
1753             Frame* frame = m_renderView->frameView()->frame();
1754             Page* page = frame ? frame->page() : 0;
1755             if (!page)
1756                 return;
1757
1758             page->chrome()->client()->attachRootGraphicsLayer(frame, rootPlatformLayer());
1759             break;
1760         }
1761         case RootLayerAttachedViaEnclosingFrame: {
1762             // The layer will get hooked up via RenderLayerBacking::updateGraphicsLayerConfiguration()
1763             // for the frame's renderer in the parent document.
1764             scheduleNeedsStyleRecalc(m_renderView->document()->ownerElement());
1765             break;
1766         }
1767     }
1768
1769     m_rootLayerAttachment = attachment;
1770     rootLayerAttachmentChanged();
1771 }
1772
1773 void RenderLayerCompositor::detachRootPlatformLayer()
1774 {
1775     if (!m_rootPlatformLayer || m_rootLayerAttachment == RootLayerUnattached)
1776         return;
1777
1778     switch (m_rootLayerAttachment) {
1779     case RootLayerAttachedViaEnclosingFrame: {
1780         // The layer will get unhooked up via RenderLayerBacking::updateGraphicsLayerConfiguration()
1781         // for the frame's renderer in the parent document.
1782         if (m_overflowControlsHostLayer)
1783             m_overflowControlsHostLayer->removeFromParent();
1784         else
1785             m_rootPlatformLayer->removeFromParent();
1786
1787         if (HTMLFrameOwnerElement* ownerElement = m_renderView->document()->ownerElement())
1788             scheduleNeedsStyleRecalc(ownerElement);
1789         break;
1790     }
1791     case RootLayerAttachedViaChromeClient: {
1792         Frame* frame = m_renderView->frameView()->frame();
1793         Page* page = frame ? frame->page() : 0;
1794         if (!page)
1795             return;
1796
1797         page->chrome()->client()->attachRootGraphicsLayer(frame, 0);
1798     }
1799     break;
1800     case RootLayerUnattached:
1801         break;
1802     }
1803
1804     m_rootLayerAttachment = RootLayerUnattached;
1805     rootLayerAttachmentChanged();
1806 }
1807
1808 void RenderLayerCompositor::updateRootLayerAttachment()
1809 {
1810     ensureRootPlatformLayer();
1811 }
1812
1813 void RenderLayerCompositor::rootLayerAttachmentChanged()
1814 {
1815     // The attachment can affect whether the RenderView layer's paintingGoesToWindow() behavior,
1816     // so call updateGraphicsLayerGeometry() to udpate that.
1817     RenderLayer* layer = m_renderView->layer();
1818     if (RenderLayerBacking* backing = layer ? layer->backing() : 0)
1819         backing->updateDrawsContent();
1820 }
1821
1822 static void needsStyleRecalcCallback(Node* node)
1823 {
1824     node->setNeedsStyleRecalc(SyntheticStyleChange);
1825 }
1826
1827 void RenderLayerCompositor::scheduleNeedsStyleRecalc(Element* element)
1828 {
1829     if (ContainerNode::postAttachCallbacksAreSuspended())
1830         ContainerNode::queuePostAttachCallback(needsStyleRecalcCallback, element);
1831     else
1832         element->setNeedsStyleRecalc(SyntheticStyleChange);
1833 }
1834
1835 // IFrames are special, because we hook compositing layers together across iframe boundaries
1836 // when both parent and iframe content are composited. So when this frame becomes composited, we have
1837 // to use a synthetic style change to get the iframes into RenderLayers in order to allow them to composite.
1838 void RenderLayerCompositor::notifyIFramesOfCompositingChange()
1839 {
1840     Frame* frame = m_renderView->frameView() ? m_renderView->frameView()->frame() : 0;
1841     if (!frame)
1842         return;
1843
1844     for (Frame* child = frame->tree()->firstChild(); child; child = child->tree()->traverseNext(frame)) {
1845         if (child->document() && child->document()->ownerElement())
1846             scheduleNeedsStyleRecalc(child->document()->ownerElement());
1847     }
1848
1849     // Compositing also affects the answer to RenderIFrame::requiresAcceleratedCompositing(), so
1850     // we need to schedule a style recalc in our parent document.
1851     if (HTMLFrameOwnerElement* ownerElement = m_renderView->document()->ownerElement())
1852         scheduleNeedsStyleRecalc(ownerElement);
1853 }
1854
1855 bool RenderLayerCompositor::layerHas3DContent(const RenderLayer* layer) const
1856 {
1857     const RenderStyle* style = layer->renderer()->style();
1858
1859     if (style &&
1860         (style->transformStyle3D() == TransformStyle3DPreserve3D ||
1861          style->hasPerspective() ||
1862          style->transform().has3DOperation()))
1863         return true;
1864
1865     if (layer->isStackingContext()) {
1866         if (Vector<RenderLayer*>* negZOrderList = layer->negZOrderList()) {
1867             size_t listSize = negZOrderList->size();
1868             for (size_t i = 0; i < listSize; ++i) {
1869                 RenderLayer* curLayer = negZOrderList->at(i);
1870                 if (layerHas3DContent(curLayer))
1871                     return true;
1872             }
1873         }
1874
1875         if (Vector<RenderLayer*>* posZOrderList = layer->posZOrderList()) {
1876             size_t listSize = posZOrderList->size();
1877             for (size_t i = 0; i < listSize; ++i) {
1878                 RenderLayer* curLayer = posZOrderList->at(i);
1879                 if (layerHas3DContent(curLayer))
1880                     return true;
1881             }
1882         }
1883     }
1884
1885     if (Vector<RenderLayer*>* normalFlowList = layer->normalFlowList()) {
1886         size_t listSize = normalFlowList->size();
1887         for (size_t i = 0; i < listSize; ++i) {
1888             RenderLayer* curLayer = normalFlowList->at(i);
1889             if (layerHas3DContent(curLayer))
1890                 return true;
1891         }
1892     }
1893     return false;
1894 }
1895
1896 void RenderLayerCompositor::updateContentsScale(float scale, RenderLayer* layer)
1897 {
1898     if (!layer)
1899         layer = rootRenderLayer();
1900
1901     layer->updateContentsScale(scale);
1902
1903     if (layer->isStackingContext()) {
1904         if (Vector<RenderLayer*>* negZOrderList = layer->negZOrderList()) {
1905             size_t listSize = negZOrderList->size();
1906             for (size_t i = 0; i < listSize; ++i)
1907                 updateContentsScale(scale, negZOrderList->at(i));
1908         }
1909
1910         if (Vector<RenderLayer*>* posZOrderList = layer->posZOrderList()) {
1911             size_t listSize = posZOrderList->size();
1912             for (size_t i = 0; i < listSize; ++i)
1913                 updateContentsScale(scale, posZOrderList->at(i));
1914         }
1915     }
1916
1917     if (Vector<RenderLayer*>* normalFlowList = layer->normalFlowList()) {
1918         size_t listSize = normalFlowList->size();
1919         for (size_t i = 0; i < listSize; ++i)
1920             updateContentsScale(scale, normalFlowList->at(i));
1921     }
1922 }
1923
1924 } // namespace WebCore
1925
1926 #endif // USE(ACCELERATED_COMPOSITING)