Home | History | Annotate | Download | only in win 
      1 /*
      2  * Copyright (C) 2009 Apple Inc. All rights reserved.
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions
      6  * are met:
      7  * 1. Redistributions of source code must retain the above copyright
      8  *    notice, this list of conditions and the following disclaimer.
      9  * 2. Redistributions in binary form must reproduce the above copyright
     10  *    notice, this list of conditions and the following disclaimer in the
     11  *    documentation and/or other materials provided with the distribution.
     12  *
     13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
     14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
     17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
     21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     24  */
     25 
     26 #include "config.h"
     27 
     28 #if USE(ACCELERATED_COMPOSITING)
     29 
     30 #include "GraphicsLayerCACF.h"
     31 
     32 #include "FloatConversion.h"
     33 #include "FloatRect.h"
     34 #include "Font.h"
     35 #include "FontSelector.h"
     36 #include "Image.h"
     37 #include "PlatformString.h"
     38 #include "SystemTime.h"
     39 #include "WebLayer.h"
     40 #include "WebTiledLayer.h"
     41 #include <wtf/CurrentTime.h>
     42 #include <wtf/StringExtras.h>
     43 #include <wtf/text/CString.h>
     44 
     45 using namespace std;
     46 
     47 namespace WebCore {
     48 
     49 // The threshold width or height above which a tiled layer will be used. This should be
     50 // large enough to avoid tiled layers for most GraphicsLayers, but less than the D3D
     51 // texture size limit on all supported hardware.
     52 static const int cMaxPixelDimension = 2000;
     53 
     54 // The width and height of a single tile in a tiled layer. Should be large enough to
     55 // avoid lots of small tiles (and therefore lots of drawing callbacks), but small enough
     56 // to keep the overall tile cost low.
     57 static const int cTiledLayerTileSize = 512;
     58 
     59 static inline void copyTransform(CATransform3D& toT3D, const TransformationMatrix& t)
     60 {
     61     toT3D.m11 = narrowPrecisionToFloat(t.m11());
     62     toT3D.m12 = narrowPrecisionToFloat(t.m12());
     63     toT3D.m13 = narrowPrecisionToFloat(t.m13());
     64     toT3D.m14 = narrowPrecisionToFloat(t.m14());
     65     toT3D.m21 = narrowPrecisionToFloat(t.m21());
     66     toT3D.m22 = narrowPrecisionToFloat(t.m22());
     67     toT3D.m23 = narrowPrecisionToFloat(t.m23());
     68     toT3D.m24 = narrowPrecisionToFloat(t.m24());
     69     toT3D.m31 = narrowPrecisionToFloat(t.m31());
     70     toT3D.m32 = narrowPrecisionToFloat(t.m32());
     71     toT3D.m33 = narrowPrecisionToFloat(t.m33());
     72     toT3D.m34 = narrowPrecisionToFloat(t.m34());
     73     toT3D.m41 = narrowPrecisionToFloat(t.m41());
     74     toT3D.m42 = narrowPrecisionToFloat(t.m42());
     75     toT3D.m43 = narrowPrecisionToFloat(t.m43());
     76     toT3D.m44 = narrowPrecisionToFloat(t.m44());
     77 }
     78 
     79 TransformationMatrix CAToTransform3D(const CATransform3D& fromT3D)
     80 {
     81     return TransformationMatrix(
     82         fromT3D.m11,
     83         fromT3D.m12,
     84         fromT3D.m13,
     85         fromT3D.m14,
     86         fromT3D.m21,
     87         fromT3D.m22,
     88         fromT3D.m23,
     89         fromT3D.m24,
     90         fromT3D.m31,
     91         fromT3D.m32,
     92         fromT3D.m33,
     93         fromT3D.m34,
     94         fromT3D.m41,
     95         fromT3D.m42,
     96         fromT3D.m43,
     97         fromT3D.m44);
     98 }
     99 
    100 static void setLayerBorderColor(WKCACFLayer* layer, const Color& color)
    101 {
    102     layer->setBorderColor(cachedCGColor(color, ColorSpaceDeviceRGB));
    103 }
    104 
    105 static void clearBorderColor(WKCACFLayer* layer)
    106 {
    107     layer->setBorderColor(0);
    108 }
    109 
    110 static void setLayerBackgroundColor(WKCACFLayer* layer, const Color& color)
    111 {
    112     layer->setBackgroundColor(cachedCGColor(color, ColorSpaceDeviceRGB));
    113 }
    114 
    115 static void clearLayerBackgroundColor(WKCACFLayer* layer)
    116 {
    117     layer->setBackgroundColor(0);
    118 }
    119 
    120 PassOwnPtr<GraphicsLayer> GraphicsLayer::create(GraphicsLayerClient* client)
    121 {
    122     return new GraphicsLayerCACF(client);
    123 }
    124 
    125 GraphicsLayerCACF::GraphicsLayerCACF(GraphicsLayerClient* client)
    126     : GraphicsLayer(client)
    127     , m_contentsLayerPurpose(NoContentsLayer)
    128     , m_contentsLayerHasBackgroundColor(false)
    129 {
    130     m_layer = WebLayer::create(WKCACFLayer::Layer, this);
    131 
    132     updateDebugIndicators();
    133 }
    134 
    135 GraphicsLayerCACF::~GraphicsLayerCACF()
    136 {
    137     // clean up the WK layer
    138     if (m_layer)
    139         m_layer->removeFromSuperlayer();
    140 
    141     if (m_contentsLayer)
    142         m_contentsLayer->removeFromSuperlayer();
    143 
    144     if (m_transformLayer)
    145         m_transformLayer->removeFromSuperlayer();
    146 }
    147 
    148 void GraphicsLayerCACF::setName(const String& name)
    149 {
    150     String longName = String::format("CALayer(%p) GraphicsLayer(%p) ", m_layer.get(), this) + name;
    151     GraphicsLayer::setName(longName);
    152 
    153     m_layer->setName(longName);
    154 }
    155 
    156 bool GraphicsLayerCACF::setChildren(const Vector<GraphicsLayer*>& children)
    157 {
    158     bool childrenChanged = GraphicsLayer::setChildren(children);
    159     // FIXME: GraphicsLayer::setChildren calls addChild() for each sublayer, which
    160     // will end up calling updateSublayerList() N times.
    161     if (childrenChanged)
    162         updateSublayerList();
    163 
    164     return childrenChanged;
    165 }
    166 
    167 void GraphicsLayerCACF::addChild(GraphicsLayer* childLayer)
    168 {
    169     GraphicsLayer::addChild(childLayer);
    170     updateSublayerList();
    171 }
    172 
    173 void GraphicsLayerCACF::addChildAtIndex(GraphicsLayer* childLayer, int index)
    174 {
    175     GraphicsLayer::addChildAtIndex(childLayer, index);
    176     updateSublayerList();
    177 }
    178 
    179 void GraphicsLayerCACF::addChildBelow(GraphicsLayer* childLayer, GraphicsLayer* sibling)
    180 {
    181     GraphicsLayer::addChildBelow(childLayer, sibling);
    182     updateSublayerList();
    183 }
    184 
    185 void GraphicsLayerCACF::addChildAbove(GraphicsLayer* childLayer, GraphicsLayer *sibling)
    186 {
    187     GraphicsLayer::addChildAbove(childLayer, sibling);
    188     updateSublayerList();
    189 }
    190 
    191 bool GraphicsLayerCACF::replaceChild(GraphicsLayer* oldChild, GraphicsLayer* newChild)
    192 {
    193     if (GraphicsLayer::replaceChild(oldChild, newChild)) {
    194         updateSublayerList();
    195         return true;
    196     }
    197     return false;
    198 }
    199 
    200 void GraphicsLayerCACF::removeFromParent()
    201 {
    202     GraphicsLayer::removeFromParent();
    203     layerForSuperlayer()->removeFromSuperlayer();
    204 }
    205 
    206 void GraphicsLayerCACF::setPosition(const FloatPoint& point)
    207 {
    208     GraphicsLayer::setPosition(point);
    209     updateLayerPosition();
    210 }
    211 
    212 void GraphicsLayerCACF::setAnchorPoint(const FloatPoint3D& point)
    213 {
    214     if (point == m_anchorPoint)
    215         return;
    216 
    217     GraphicsLayer::setAnchorPoint(point);
    218     updateAnchorPoint();
    219 }
    220 
    221 void GraphicsLayerCACF::setSize(const FloatSize& size)
    222 {
    223     if (size == m_size)
    224         return;
    225 
    226     GraphicsLayer::setSize(size);
    227     updateLayerSize();
    228 }
    229 
    230 void GraphicsLayerCACF::setTransform(const TransformationMatrix& t)
    231 {
    232     if (t == m_transform)
    233         return;
    234 
    235     GraphicsLayer::setTransform(t);
    236     updateTransform();
    237 }
    238 
    239 void GraphicsLayerCACF::setChildrenTransform(const TransformationMatrix& t)
    240 {
    241     if (t == m_childrenTransform)
    242         return;
    243 
    244     GraphicsLayer::setChildrenTransform(t);
    245     updateChildrenTransform();
    246 }
    247 
    248 void GraphicsLayerCACF::setPreserves3D(bool preserves3D)
    249 {
    250     if (preserves3D == m_preserves3D)
    251         return;
    252 
    253     GraphicsLayer::setPreserves3D(preserves3D);
    254     updateLayerPreserves3D();
    255 }
    256 
    257 void GraphicsLayerCACF::setMasksToBounds(bool masksToBounds)
    258 {
    259     if (masksToBounds == m_masksToBounds)
    260         return;
    261 
    262     GraphicsLayer::setMasksToBounds(masksToBounds);
    263     updateMasksToBounds();
    264 }
    265 
    266 void GraphicsLayerCACF::setDrawsContent(bool drawsContent)
    267 {
    268     if (drawsContent == m_drawsContent)
    269         return;
    270 
    271     GraphicsLayer::setDrawsContent(drawsContent);
    272     updateLayerDrawsContent();
    273 }
    274 
    275 void GraphicsLayerCACF::setBackgroundColor(const Color& color)
    276 {
    277     if (m_backgroundColorSet && m_backgroundColor == color)
    278         return;
    279 
    280     GraphicsLayer::setBackgroundColor(color);
    281 
    282     m_contentsLayerHasBackgroundColor = true;
    283     updateLayerBackgroundColor();
    284 }
    285 
    286 void GraphicsLayerCACF::clearBackgroundColor()
    287 {
    288     if (!m_backgroundColorSet)
    289         return;
    290 
    291     GraphicsLayer::clearBackgroundColor();
    292     clearLayerBackgroundColor(m_contentsLayer.get());
    293 }
    294 
    295 void GraphicsLayerCACF::setContentsOpaque(bool opaque)
    296 {
    297     if (m_contentsOpaque == opaque)
    298         return;
    299 
    300     GraphicsLayer::setContentsOpaque(opaque);
    301     updateContentsOpaque();
    302 }
    303 
    304 void GraphicsLayerCACF::setBackfaceVisibility(bool visible)
    305 {
    306     if (m_backfaceVisibility == visible)
    307         return;
    308 
    309     GraphicsLayer::setBackfaceVisibility(visible);
    310     updateBackfaceVisibility();
    311 }
    312 
    313 void GraphicsLayerCACF::setOpacity(float opacity)
    314 {
    315     float clampedOpacity = max(min(opacity, 1.0f), 0.0f);
    316 
    317     if (m_opacity == clampedOpacity)
    318         return;
    319 
    320     GraphicsLayer::setOpacity(clampedOpacity);
    321     primaryLayer()->setOpacity(opacity);
    322 }
    323 
    324 void GraphicsLayerCACF::setNeedsDisplay()
    325 {
    326     if (drawsContent())
    327         m_layer->setNeedsDisplay();
    328 }
    329 
    330 void GraphicsLayerCACF::setNeedsDisplayInRect(const FloatRect& rect)
    331 {
    332     if (drawsContent()) {
    333         CGRect cgRect = rect;
    334         m_layer->setNeedsDisplay(&cgRect);
    335     }
    336 }
    337 
    338 void GraphicsLayerCACF::setContentsRect(const IntRect& rect)
    339 {
    340     if (rect == m_contentsRect)
    341         return;
    342 
    343     GraphicsLayer::setContentsRect(rect);
    344     updateContentsRect();
    345 }
    346 
    347 void GraphicsLayerCACF::setContentsToImage(Image* image)
    348 {
    349     bool childrenChanged = false;
    350 
    351     if (image) {
    352         m_pendingContentsImage = image->nativeImageForCurrentFrame();
    353         m_contentsLayerPurpose = ContentsLayerForImage;
    354         if (!m_contentsLayer)
    355             childrenChanged = true;
    356     } else {
    357         m_pendingContentsImage = 0;
    358         m_contentsLayerPurpose = NoContentsLayer;
    359         if (m_contentsLayer)
    360             childrenChanged = true;
    361     }
    362 
    363     updateContentsImage();
    364 
    365     // This has to happen after updateContentsImage
    366     if (childrenChanged)
    367         updateSublayerList();
    368 }
    369 
    370 void GraphicsLayerCACF::setContentsToMedia(PlatformLayer* mediaLayer)
    371 {
    372     if (mediaLayer == m_contentsLayer)
    373         return;
    374 
    375     m_contentsLayer = mediaLayer;
    376     m_contentsLayerPurpose = mediaLayer ? ContentsLayerForMedia : NoContentsLayer;
    377 
    378     updateContentsMedia();
    379 
    380     // This has to happen after updateContentsMedia
    381     updateSublayerList();
    382 }
    383 
    384 PlatformLayer* GraphicsLayerCACF::hostLayerForSublayers() const
    385 {
    386     return m_transformLayer ? m_transformLayer.get() : m_layer.get();
    387 }
    388 
    389 PlatformLayer* GraphicsLayerCACF::layerForSuperlayer() const
    390 {
    391     return m_transformLayer ? m_transformLayer.get() : m_layer.get();
    392 }
    393 
    394 PlatformLayer* GraphicsLayerCACF::platformLayer() const
    395 {
    396     return primaryLayer();
    397 }
    398 
    399 void GraphicsLayerCACF::setDebugBackgroundColor(const Color& color)
    400 {
    401     if (color.isValid())
    402         setLayerBackgroundColor(m_layer.get(), color);
    403     else
    404         clearLayerBackgroundColor(m_layer.get());
    405 }
    406 
    407 void GraphicsLayerCACF::setDebugBorder(const Color& color, float borderWidth)
    408 {
    409     if (color.isValid()) {
    410         setLayerBorderColor(m_layer.get(), color);
    411         m_layer->setBorderWidth(borderWidth);
    412     } else {
    413         clearBorderColor(m_layer.get());
    414         m_layer->setBorderWidth(0);
    415     }
    416 }
    417 
    418 bool GraphicsLayerCACF::requiresTiledLayer(const FloatSize& size) const
    419 {
    420     if (!m_drawsContent)
    421         return false;
    422 
    423     // FIXME: catch zero-size height or width here (or earlier)?
    424     return size.width() > cMaxPixelDimension || size.height() > cMaxPixelDimension;
    425 }
    426 
    427 void GraphicsLayerCACF::swapFromOrToTiledLayer(bool useTiledLayer)
    428 {
    429     if (useTiledLayer == m_usingTiledLayer)
    430         return;
    431 
    432     CGSize tileSize = CGSizeMake(cTiledLayerTileSize, cTiledLayerTileSize);
    433 
    434     RefPtr<WKCACFLayer> oldLayer = m_layer;
    435     if (useTiledLayer)
    436         m_layer = WebTiledLayer::create(tileSize, this);
    437     else
    438         m_layer = WebLayer::create(WKCACFLayer::Layer, this);
    439 
    440     m_usingTiledLayer = useTiledLayer;
    441 
    442     m_layer->adoptSublayers(oldLayer.get());
    443     if (oldLayer->superlayer())
    444         oldLayer->superlayer()->replaceSublayer(oldLayer.get(), m_layer.get());
    445 
    446     updateLayerPosition();
    447     updateLayerSize();
    448     updateAnchorPoint();
    449     updateTransform();
    450     updateChildrenTransform();
    451     updateMasksToBounds();
    452     updateContentsOpaque();
    453     updateBackfaceVisibility();
    454     updateLayerBackgroundColor();
    455 
    456     updateOpacityOnLayer();
    457 
    458 #ifndef NDEBUG
    459     String name = String::format("CALayer(%p) GraphicsLayer(%p) %s", m_layer.get(), this, m_usingTiledLayer ? "[Tiled Layer] " : "") + m_name;
    460     m_layer->setName(name);
    461 #endif
    462 
    463     // need to tell new layer to draw itself
    464     setNeedsDisplay();
    465 
    466     updateDebugIndicators();
    467 }
    468 
    469 GraphicsLayer::CompositingCoordinatesOrientation GraphicsLayerCACF::defaultContentsOrientation() const
    470 {
    471     return CompositingCoordinatesTopDown;
    472 }
    473 
    474 void GraphicsLayerCACF::updateSublayerList()
    475 {
    476     Vector<RefPtr<WKCACFLayer> > newSublayers;
    477 
    478     if (m_transformLayer) {
    479         // Add the primary layer first. Even if we have negative z-order children, the primary layer always comes behind.
    480         newSublayers.append(m_layer.get());
    481     } else if (m_contentsLayer) {
    482         // FIXME: add the contents layer in the correct order with negative z-order children.
    483         // This does not cause visible rendering issues because currently contents layers are only used
    484         // for replaced elements that don't have children.
    485         newSublayers.append(m_contentsLayer.get());
    486     }
    487 
    488     const Vector<GraphicsLayer*>& childLayers = children();
    489     size_t numChildren = childLayers.size();
    490     for (size_t i = 0; i < numChildren; ++i) {
    491         GraphicsLayerCACF* curChild = static_cast<GraphicsLayerCACF*>(childLayers[i]);
    492 
    493         WKCACFLayer* childLayer = curChild->layerForSuperlayer();
    494         newSublayers.append(childLayer);
    495     }
    496 
    497     for (int i = 0; i < newSublayers.size(); ++i)
    498         newSublayers[i]->removeFromSuperlayer();
    499 
    500     if (m_transformLayer) {
    501         m_transformLayer->setSublayers(newSublayers);
    502 
    503         if (m_contentsLayer) {
    504             // If we have a transform layer, then the contents layer is parented in the
    505             // primary layer (which is itself a child of the transform layer).
    506             m_layer->removeAllSublayers();
    507             m_layer->addSublayer(m_contentsLayer);
    508         }
    509     } else
    510         m_layer->setSublayers(newSublayers);
    511 }
    512 
    513 void GraphicsLayerCACF::updateLayerPosition()
    514 {
    515     // Position is offset on the layer by the layer anchor point.
    516     CGPoint posPoint = CGPointMake(m_position.x() + m_anchorPoint.x() * m_size.width(),
    517                                    m_position.y() + m_anchorPoint.y() * m_size.height());
    518 
    519     primaryLayer()->setPosition(posPoint);
    520 }
    521 
    522 void GraphicsLayerCACF::updateLayerSize()
    523 {
    524     CGRect rect = CGRectMake(0, 0, m_size.width(), m_size.height());
    525     if (m_transformLayer) {
    526         m_transformLayer->setBounds(rect);
    527         // The anchor of the contents layer is always at 0.5, 0.5, so the position is center-relative.
    528         CGPoint centerPoint = CGPointMake(m_size.width() / 2.0f, m_size.height() / 2.0f);
    529         m_layer->setPosition(centerPoint);
    530     }
    531 
    532     bool needTiledLayer = requiresTiledLayer(m_size);
    533     if (needTiledLayer != m_usingTiledLayer)
    534         swapFromOrToTiledLayer(needTiledLayer);
    535 
    536     m_layer->setBounds(rect);
    537 
    538     // Note that we don't resize m_contentsLayer. It's up the caller to do that.
    539 
    540     // if we've changed the bounds, we need to recalculate the position
    541     // of the layer, taking anchor point into account.
    542     updateLayerPosition();
    543 }
    544 
    545 void GraphicsLayerCACF::updateAnchorPoint()
    546 {
    547     primaryLayer()->setAnchorPoint(FloatPoint(m_anchorPoint.x(), m_anchorPoint.y()));
    548     primaryLayer()->setAnchorPointZ(m_anchorPoint.z());
    549     updateLayerPosition();
    550 }
    551 
    552 void GraphicsLayerCACF::updateTransform()
    553 {
    554     CATransform3D transform;
    555     copyTransform(transform, m_transform);
    556     primaryLayer()->setTransform(transform);
    557 }
    558 
    559 void GraphicsLayerCACF::updateChildrenTransform()
    560 {
    561     CATransform3D transform;
    562     copyTransform(transform, m_childrenTransform);
    563     primaryLayer()->setSublayerTransform(transform);
    564 }
    565 
    566 void GraphicsLayerCACF::updateMasksToBounds()
    567 {
    568     m_layer->setMasksToBounds(m_masksToBounds);
    569     updateDebugIndicators();
    570 }
    571 
    572 void GraphicsLayerCACF::updateContentsOpaque()
    573 {
    574     m_layer->setOpaque(m_contentsOpaque);
    575 }
    576 
    577 void GraphicsLayerCACF::updateBackfaceVisibility()
    578 {
    579     m_layer->setDoubleSided(m_backfaceVisibility);
    580 }
    581 
    582 void GraphicsLayerCACF::updateLayerPreserves3D()
    583 {
    584     if (m_preserves3D && !m_transformLayer) {
    585         // Create the transform layer.
    586         m_transformLayer = WebLayer::create(WKCACFLayer::TransformLayer, this);
    587 
    588 #ifndef NDEBUG
    589         m_transformLayer->setName(String().format("Transform Layer CATransformLayer(%p) GraphicsLayer(%p)", m_transformLayer.get(), this));
    590 #endif
    591         // Copy the position from this layer.
    592         updateLayerPosition();
    593         updateLayerSize();
    594         updateAnchorPoint();
    595         updateTransform();
    596         updateChildrenTransform();
    597 
    598         CGPoint point = CGPointMake(m_size.width() / 2.0f, m_size.height() / 2.0f);
    599         m_layer->setPosition(point);
    600 
    601         m_layer->setAnchorPoint(CGPointMake(0.5f, 0.5f));
    602         m_layer->setTransform(CATransform3DIdentity);
    603 
    604         // Set the old layer to opacity of 1. Further down we will set the opacity on the transform layer.
    605         m_layer->setOpacity(1);
    606 
    607         // Move this layer to be a child of the transform layer.
    608         if (m_layer->superlayer())
    609             m_layer->superlayer()->replaceSublayer(m_layer.get(), m_transformLayer.get());
    610         m_transformLayer->addSublayer(m_layer.get());
    611 
    612         updateSublayerList();
    613     } else if (!m_preserves3D && m_transformLayer) {
    614         // Relace the transformLayer in the parent with this layer.
    615         m_layer->removeFromSuperlayer();
    616         m_transformLayer->superlayer()->replaceSublayer(m_transformLayer.get(), m_layer.get());
    617 
    618         // Release the transform layer.
    619         m_transformLayer = 0;
    620 
    621         updateLayerPosition();
    622         updateLayerSize();
    623         updateAnchorPoint();
    624         updateTransform();
    625         updateChildrenTransform();
    626 
    627         updateSublayerList();
    628     }
    629 
    630     updateOpacityOnLayer();
    631 }
    632 
    633 void GraphicsLayerCACF::updateLayerDrawsContent()
    634 {
    635     bool needTiledLayer = requiresTiledLayer(m_size);
    636     if (needTiledLayer != m_usingTiledLayer)
    637         swapFromOrToTiledLayer(needTiledLayer);
    638 
    639     if (m_drawsContent)
    640         m_layer->setNeedsDisplay();
    641     else
    642         m_layer->setContents(0);
    643 
    644     updateDebugIndicators();
    645 }
    646 
    647 void GraphicsLayerCACF::updateLayerBackgroundColor()
    648 {
    649     if (!m_contentsLayer)
    650         return;
    651 
    652     // We never create the contents layer just for background color yet.
    653     if (m_backgroundColorSet)
    654         setLayerBackgroundColor(m_contentsLayer.get(), m_backgroundColor);
    655     else
    656         clearLayerBackgroundColor(m_contentsLayer.get());
    657 }
    658 
    659 void GraphicsLayerCACF::updateContentsImage()
    660 {
    661     if (m_pendingContentsImage) {
    662         if (!m_contentsLayer.get()) {
    663             RefPtr<WKCACFLayer> imageLayer = WebLayer::create(WKCACFLayer::Layer, this);
    664 #ifndef NDEBUG
    665             imageLayer->setName("Image Layer");
    666 #endif
    667             setupContentsLayer(imageLayer.get());
    668             m_contentsLayer = imageLayer;
    669             // m_contentsLayer will be parented by updateSublayerList
    670         }
    671 
    672         // FIXME: maybe only do trilinear if the image is being scaled down,
    673         // but then what if the layer size changes?
    674         m_contentsLayer->setMinificationFilter(WKCACFLayer::Trilinear);
    675         m_contentsLayer->setContents(m_pendingContentsImage.get());
    676         m_pendingContentsImage = 0;
    677 
    678         updateContentsRect();
    679     } else {
    680         // No image.
    681         // m_contentsLayer will be removed via updateSublayerList.
    682         m_contentsLayer = 0;
    683     }
    684 }
    685 
    686 void GraphicsLayerCACF::updateContentsMedia()
    687 {
    688     // Media layer was set as m_contentsLayer, and will get parented in updateSublayerList().
    689     if (m_contentsLayer) {
    690         setupContentsLayer(m_contentsLayer.get());
    691         updateContentsRect();
    692     }
    693 }
    694 
    695 void GraphicsLayerCACF::updateContentsRect()
    696 {
    697     if (!m_contentsLayer)
    698         return;
    699 
    700     CGPoint point = CGPointMake(m_contentsRect.x(),
    701                                 m_contentsRect.y());
    702     CGRect rect = CGRectMake(0.0f,
    703                              0.0f,
    704                              m_contentsRect.width(),
    705                              m_contentsRect.height());
    706 
    707     m_contentsLayer->setPosition(point);
    708     m_contentsLayer->setBounds(rect);
    709 }
    710 
    711 void GraphicsLayerCACF::setupContentsLayer(WKCACFLayer* contentsLayer)
    712 {
    713     if (contentsLayer == m_contentsLayer)
    714         return;
    715 
    716     if (m_contentsLayer) {
    717         m_contentsLayer->removeFromSuperlayer();
    718         m_contentsLayer = 0;
    719     }
    720 
    721     if (contentsLayer) {
    722         m_contentsLayer = contentsLayer;
    723 
    724         if (defaultContentsOrientation() == CompositingCoordinatesBottomUp) {
    725             CATransform3D flipper = {
    726                 1.0f, 0.0f, 0.0f, 0.0f,
    727                 0.0f, -1.0f, 0.0f, 0.0f,
    728                 0.0f, 0.0f, 1.0f, 0.0f,
    729                 0.0f, 0.0f, 0.0f, 1.0f};
    730             m_contentsLayer->setTransform(flipper);
    731             m_contentsLayer->setAnchorPoint(CGPointMake(0.0f, 1.0f));
    732         } else
    733             m_contentsLayer->setAnchorPoint(CGPointMake(0.0f, 0.0f));
    734 
    735         // Insert the content layer first. Video elements require this, because they have
    736         // shadow content that must display in front of the video.
    737         m_layer->insertSublayer(m_contentsLayer.get(), 0);
    738 
    739         updateContentsRect();
    740 
    741         if (showDebugBorders()) {
    742             setLayerBorderColor(m_contentsLayer.get(), Color(0, 0, 128, 180));
    743             m_contentsLayer->setBorderWidth(1.0f);
    744         }
    745     }
    746     updateDebugIndicators();
    747 }
    748 
    749 // This function simply mimics the operation of GraphicsLayerCA
    750 void GraphicsLayerCACF::updateOpacityOnLayer()
    751 {
    752     primaryLayer()->setOpacity(m_opacity);
    753 }
    754 
    755 } // namespace WebCore
    756 
    757 #endif // USE(ACCELERATED_COMPOSITING)
    758