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