Changeset 235953 in webkit

Timestamp:

Sep 12, 2018, 2:27:07 PM (7 years ago)

Author:

Simon Fraser

Message:

Make GraphicsLayers ref-counted, so their tree can persist when disconnected from RenderLayerBackings
​https://bugs.webkit.org/show_bug.cgi?id=189521

Reviewed by Tim Horton.
Source/WebCore:

Make GraphicsLayer be RefCounted<GraphicsLayer>. GraphicsLayers own their children, via a Vector<Ref<GraphicsLayer>>.

RenderLayerBacking and other holders of GraphicsLayers use RefPtr<GraphicsLayer>.

All the other changes are just to adapt to the new ownership patterns.

I verified that no GraphicsLayers were leaked or abandoned after this change.

No behavior change.

• page/PageOverlayController.cpp:

(WebCore::PageOverlayController::layerWithDocumentOverlays):
(WebCore::PageOverlayController::layerWithViewOverlays):
(WebCore::PageOverlayController::installPageOverlay):
(WebCore::PageOverlayController::uninstallPageOverlay):
(WebCore::PageOverlayController::setPageOverlayNeedsDisplay):
(WebCore::PageOverlayController::didChangeViewSize):
(WebCore::PageOverlayController::didChangeDocumentSize):
(WebCore::PageOverlayController::didChangeSettings):
(WebCore::PageOverlayController::paintContents):
(WebCore::PageOverlayController::didChangeOverlayFrame):
(WebCore::PageOverlayController::didChangeOverlayBackgroundColor):

• page/PageOverlayController.h:
• page/mac/ServicesOverlayController.h:

(WebCore::ServicesOverlayController::Highlight::layer const):

• page/mac/ServicesOverlayController.mm:

(WebCore::ServicesOverlayController::Highlight::Highlight):
(WebCore::ServicesOverlayController::Highlight::invalidate):
(WebCore::ServicesOverlayController::Highlight::fadeIn):
(WebCore::ServicesOverlayController::Highlight::fadeOut):
(WebCore::ServicesOverlayController::Highlight::didFinishFadeOutAnimation):
(WebCore::ServicesOverlayController::determineActiveHighlight):

• platform/graphics/GraphicsLayer.cpp:

(WebCore::GraphicsLayer::GraphicsLayer):
(WebCore::GraphicsLayer::willBeDestroyed):
(WebCore::GraphicsLayer::setChildren):
(WebCore::GraphicsLayer::addChild):
(WebCore::GraphicsLayer::addChildAtIndex):
(WebCore::GraphicsLayer::addChildBelow):
(WebCore::GraphicsLayer::addChildAbove):
(WebCore::GraphicsLayer::replaceChild):
(WebCore::GraphicsLayer::removeAllChildren):
(WebCore::GraphicsLayer::removeFromParent):
(WebCore::GraphicsLayer::setMaskLayer):
(WebCore::GraphicsLayer::noteDeviceOrPageScaleFactorChangedIncludingDescendants):
(WebCore::GraphicsLayer::distributeOpacity):
(WebCore::GraphicsLayer::traverse):
(WebCore::dumpChildren):

• platform/graphics/GraphicsLayer.h:

(WebCore::GraphicsLayer::children const):
(WebCore::GraphicsLayer::children):
(WebCore::GraphicsLayer::maskLayer const):
(WebCore::GraphicsLayer::replicaLayer const):
(WebCore::GraphicsLayer::beingDestroyed const):
(WebCore::GraphicsLayer:: const): Deleted.

• platform/graphics/GraphicsLayerFactory.h:
• platform/graphics/ca/GraphicsLayerCA.cpp:

(WebCore::GraphicsLayer::create):
(WebCore::GraphicsLayerCA::setChildren):
(WebCore::GraphicsLayerCA::addChild):
(WebCore::GraphicsLayerCA::addChildAtIndex):
(WebCore::GraphicsLayerCA::addChildBelow):
(WebCore::GraphicsLayerCA::addChildAbove):
(WebCore::GraphicsLayerCA::replaceChild):
(WebCore::GraphicsLayerCA::setMaskLayer):
(WebCore::GraphicsLayerCA::recursiveVisibleRectChangeRequiresFlush const):
(WebCore::GraphicsLayerCA::recursiveCommitChanges):
(WebCore::GraphicsLayerCA::updateSublayerList):
(WebCore::GraphicsLayerCA::createTransformAnimationsFromKeyframes):

• platform/graphics/ca/GraphicsLayerCA.h:
• platform/graphics/texmap/GraphicsLayerTextureMapper.cpp:

(WebCore::GraphicsLayer::create):
(WebCore::GraphicsLayerTextureMapper::setChildren):
(WebCore::GraphicsLayerTextureMapper::addChild):
(WebCore::GraphicsLayerTextureMapper::addChildAtIndex):
(WebCore::GraphicsLayerTextureMapper::addChildAbove):
(WebCore::GraphicsLayerTextureMapper::addChildBelow):
(WebCore::GraphicsLayerTextureMapper::replaceChild):
(WebCore::GraphicsLayerTextureMapper::setMaskLayer):
(WebCore::GraphicsLayerTextureMapper::updateBackingStoreIncludingSubLayers):

• platform/graphics/texmap/GraphicsLayerTextureMapper.h:
• platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.cpp:

(WebCore::GraphicsLayer::create):
(WebCore::CoordinatedGraphicsLayer::setShouldUpdateVisibleRect):
(WebCore::CoordinatedGraphicsLayer::addChild):
(WebCore::CoordinatedGraphicsLayer::addChildAtIndex):
(WebCore::CoordinatedGraphicsLayer::addChildAbove):
(WebCore::CoordinatedGraphicsLayer::addChildBelow):
(WebCore::CoordinatedGraphicsLayer::replaceChild):
(WebCore::CoordinatedGraphicsLayer::setMaskLayer):
(WebCore::CoordinatedGraphicsLayer::syncPendingStateChangesIncludingSubLayers):
(WebCore::CoordinatedGraphicsLayer::updateContentBuffersIncludingSubLayers):
(WebCore::CoordinatedGraphicsLayer::setCoordinatorIncludingSubLayersIfNeeded):

• platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.h:
• platform/graphics/win/GraphicsLayerDirect2D.cpp:

(WebCore::GraphicsLayer::create):
(WebCore::GraphicsLayerDirect2D::GraphicsLayerDirect2D): Deleted.
(WebCore::GraphicsLayerDirect2D::initialize): Deleted.
(WebCore::GraphicsLayerDirect2D::~GraphicsLayerDirect2D): Deleted.
(WebCore::GraphicsLayerDirect2D::setNeedsDisplay): Deleted.
(WebCore::GraphicsLayerDirect2D::setNeedsDisplayInRect): Deleted.

• rendering/RenderLayerBacking.cpp:

(WebCore::RenderLayerBacking::createGraphicsLayer):
(WebCore::RenderLayerBacking::createPrimaryGraphicsLayer):
(WebCore::RenderLayerBacking::updateConfiguration):
(WebCore::RenderLayerBacking::updateInternalHierarchy):
(WebCore::RenderLayerBacking::updateMaskingLayer):
(WebCore::RenderLayerBacking::updateChildClippingStrategy):
(WebCore::RenderLayerBacking::updateScrollingLayers):

• rendering/RenderLayerBacking.h:
• rendering/RenderLayerCompositor.cpp:

(WebCore::RenderLayerCompositor::updateCompositingLayers):
(WebCore::RenderLayerCompositor::appendDocumentOverlayLayers):
(WebCore::RenderLayerCompositor::setCompositingParent):
(WebCore::RenderLayerCompositor::rebuildCompositingLayerTree):
(WebCore::RenderLayerCompositor::parentFrameContentLayers):
(WebCore::RenderLayerCompositor::updateLayerForTopOverhangArea):
(WebCore::RenderLayerCompositor::updateLayerForBottomOverhangArea):
(WebCore::RenderLayerCompositor::updateLayerForHeader):
(WebCore::RenderLayerCompositor::updateLayerForFooter):
(WebCore::RenderLayerCompositor::updateOverflowControlsLayers):
(WebCore::RenderLayerCompositor::ensureRootLayer):
(WebCore::RenderLayerCompositor::rootLayerAttachmentChanged):

• rendering/RenderLayerCompositor.h:

Source/WebKit:

Make GraphicsLayer be RefCounted<GraphicsLayer>. GraphicsLayers own their children, via a Vector<Ref<GraphicsLayer>>.

RenderLayerBacking and other holders of GraphicsLayers use RefPtr<GraphicsLayer>.

All the other changes are just to adapt to the new ownership patterns.

I verified that no GraphicsLayers were leaked or abandoned after this change.

• WebProcess/WebCoreSupport/WebInspectorClient.cpp:

(WebKit::WebInspectorClient::~WebInspectorClient):
(WebKit::WebInspectorClient::showPaintRect):
(WebKit::WebInspectorClient::animationEndedForLayer):

• WebProcess/WebCoreSupport/WebInspectorClient.h:
• WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeContext.h:
• WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeContext.mm:

(WebKit::RemoteLayerTreeContext::createGraphicsLayer):

• WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.h:
• WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.mm:

(WebKit::RemoteLayerTreeDrawingArea::updateRootLayers):
(WebKit::RemoteLayerTreeDrawingArea::flushLayers):

Location:

trunk/Source

Files:

• WebCore/ChangeLog (modified) (1 diff)
• WebCore/page/PageOverlayController.cpp (modified) (14 diffs)
• WebCore/page/PageOverlayController.h (modified) (1 diff)
• WebCore/page/ResourceUsageOverlay.h (modified) (1 diff)
• WebCore/page/linux/ResourceUsageOverlayLinux.cpp (modified) (1 diff)
• WebCore/page/mac/ServicesOverlayController.h (modified) (2 diffs)
• WebCore/page/mac/ServicesOverlayController.mm (modified) (7 diffs)
• WebCore/platform/graphics/GraphicsLayer.cpp (modified) (14 diffs)
• WebCore/platform/graphics/GraphicsLayer.h (modified) (7 diffs)
• WebCore/platform/graphics/GraphicsLayerFactory.h (modified) (2 diffs)
• WebCore/platform/graphics/ca/GraphicsLayerCA.cpp (modified) (11 diffs)
• WebCore/platform/graphics/ca/GraphicsLayerCA.h (modified) (2 diffs)
• WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.cpp (modified) (7 diffs)
• WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.h (modified) (1 diff)
• WebCore/platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.cpp (modified) (9 diffs)
• WebCore/platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.h (modified) (2 diffs)
• WebCore/platform/graphics/win/GraphicsLayerDirect2D.cpp (modified) (1 diff)
• WebCore/rendering/RenderLayerBacking.cpp (modified) (9 diffs)
• WebCore/rendering/RenderLayerBacking.h (modified) (3 diffs)
• WebCore/rendering/RenderLayerCompositor.cpp (modified) (21 diffs)
• WebCore/rendering/RenderLayerCompositor.h (modified) (5 diffs)
• WebKit/ChangeLog (modified) (1 diff)
• WebKit/WebProcess/WebCoreSupport/WebInspectorClient.cpp (modified) (3 diffs)
• WebKit/WebProcess/WebCoreSupport/WebInspectorClient.h (modified) (1 diff)
• WebKit/WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.cpp (modified) (3 diffs)
• WebKit/WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.h (modified) (2 diffs)
• WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeContext.h (modified) (1 diff)
• WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeContext.mm (modified) (1 diff)
• WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.h (modified) (1 diff)
• WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.mm (modified) (3 diffs)
• WebKitLegacy/win/WebCoreSupport/AcceleratedCompositingContext.cpp (modified) (2 diffs)
• WebKitLegacy/win/WebCoreSupport/AcceleratedCompositingContext.h (modified) (1 diff)
• WebKitLegacy/win/WebView.cpp (modified) (1 diff)
• WebKitLegacy/win/WebView.h (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2018-09-11  Simon Fraser  <simon.fraser@apple.com>
+
+        Make GraphicsLayers ref-counted, so their tree can persist when disconnected from RenderLayerBackings
+        https://bugs.webkit.org/show_bug.cgi?id=189521
+
+        Reviewed by Tim Horton.
+        
+        Make GraphicsLayer be RefCounted<GraphicsLayer>. GraphicsLayers own their children, via a Vector<Ref<GraphicsLayer>>.
+        
+        RenderLayerBacking and other holders of GraphicsLayers use RefPtr<GraphicsLayer>.
+        
+        All the other changes are just to adapt to the new ownership patterns.
+        
+        I verified that no GraphicsLayers were leaked or abandoned after this change.
+
+        No behavior change.
+
+        * page/PageOverlayController.cpp:
+        (WebCore::PageOverlayController::layerWithDocumentOverlays):
+        (WebCore::PageOverlayController::layerWithViewOverlays):
+        (WebCore::PageOverlayController::installPageOverlay):
+        (WebCore::PageOverlayController::uninstallPageOverlay):
+        (WebCore::PageOverlayController::setPageOverlayNeedsDisplay):
+        (WebCore::PageOverlayController::didChangeViewSize):
+        (WebCore::PageOverlayController::didChangeDocumentSize):
+        (WebCore::PageOverlayController::didChangeSettings):
+        (WebCore::PageOverlayController::paintContents):
+        (WebCore::PageOverlayController::didChangeOverlayFrame):
+        (WebCore::PageOverlayController::didChangeOverlayBackgroundColor):
+        * page/PageOverlayController.h:
+        * page/mac/ServicesOverlayController.h:
+        (WebCore::ServicesOverlayController::Highlight::layer const):
+        * page/mac/ServicesOverlayController.mm:
+        (WebCore::ServicesOverlayController::Highlight::Highlight):
+        (WebCore::ServicesOverlayController::Highlight::invalidate):
+        (WebCore::ServicesOverlayController::Highlight::fadeIn):
+        (WebCore::ServicesOverlayController::Highlight::fadeOut):
+        (WebCore::ServicesOverlayController::Highlight::didFinishFadeOutAnimation):
+        (WebCore::ServicesOverlayController::determineActiveHighlight):
+        * platform/graphics/GraphicsLayer.cpp:
+        (WebCore::GraphicsLayer::GraphicsLayer):
+        (WebCore::GraphicsLayer::willBeDestroyed):
+        (WebCore::GraphicsLayer::setChildren):
+        (WebCore::GraphicsLayer::addChild):
+        (WebCore::GraphicsLayer::addChildAtIndex):
+        (WebCore::GraphicsLayer::addChildBelow):
+        (WebCore::GraphicsLayer::addChildAbove):
+        (WebCore::GraphicsLayer::replaceChild):
+        (WebCore::GraphicsLayer::removeAllChildren):
+        (WebCore::GraphicsLayer::removeFromParent):
+        (WebCore::GraphicsLayer::setMaskLayer):
+        (WebCore::GraphicsLayer::noteDeviceOrPageScaleFactorChangedIncludingDescendants):
+        (WebCore::GraphicsLayer::distributeOpacity):
+        (WebCore::GraphicsLayer::traverse):
+        (WebCore::dumpChildren):
+        * platform/graphics/GraphicsLayer.h:
+        (WebCore::GraphicsLayer::children const):
+        (WebCore::GraphicsLayer::children):
+        (WebCore::GraphicsLayer::maskLayer const):
+        (WebCore::GraphicsLayer::replicaLayer const):
+        (WebCore::GraphicsLayer::beingDestroyed const):
+        (WebCore::GraphicsLayer:: const): Deleted.
+        * platform/graphics/GraphicsLayerFactory.h:
+        * platform/graphics/ca/GraphicsLayerCA.cpp:
+        (WebCore::GraphicsLayer::create):
+        (WebCore::GraphicsLayerCA::setChildren):
+        (WebCore::GraphicsLayerCA::addChild):
+        (WebCore::GraphicsLayerCA::addChildAtIndex):
+        (WebCore::GraphicsLayerCA::addChildBelow):
+        (WebCore::GraphicsLayerCA::addChildAbove):
+        (WebCore::GraphicsLayerCA::replaceChild):
+        (WebCore::GraphicsLayerCA::setMaskLayer):
+        (WebCore::GraphicsLayerCA::recursiveVisibleRectChangeRequiresFlush const):
+        (WebCore::GraphicsLayerCA::recursiveCommitChanges):
+        (WebCore::GraphicsLayerCA::updateSublayerList):
+        (WebCore::GraphicsLayerCA::createTransformAnimationsFromKeyframes):
+        * platform/graphics/ca/GraphicsLayerCA.h:
+        * platform/graphics/texmap/GraphicsLayerTextureMapper.cpp:
+        (WebCore::GraphicsLayer::create):
+        (WebCore::GraphicsLayerTextureMapper::setChildren):
+        (WebCore::GraphicsLayerTextureMapper::addChild):
+        (WebCore::GraphicsLayerTextureMapper::addChildAtIndex):
+        (WebCore::GraphicsLayerTextureMapper::addChildAbove):
+        (WebCore::GraphicsLayerTextureMapper::addChildBelow):
+        (WebCore::GraphicsLayerTextureMapper::replaceChild):
+        (WebCore::GraphicsLayerTextureMapper::setMaskLayer):
+        (WebCore::GraphicsLayerTextureMapper::updateBackingStoreIncludingSubLayers):
+        * platform/graphics/texmap/GraphicsLayerTextureMapper.h:
+        * platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.cpp:
+        (WebCore::GraphicsLayer::create):
+        (WebCore::CoordinatedGraphicsLayer::setShouldUpdateVisibleRect):
+        (WebCore::CoordinatedGraphicsLayer::addChild):
+        (WebCore::CoordinatedGraphicsLayer::addChildAtIndex):
+        (WebCore::CoordinatedGraphicsLayer::addChildAbove):
+        (WebCore::CoordinatedGraphicsLayer::addChildBelow):
+        (WebCore::CoordinatedGraphicsLayer::replaceChild):
+        (WebCore::CoordinatedGraphicsLayer::setMaskLayer):
+        (WebCore::CoordinatedGraphicsLayer::syncPendingStateChangesIncludingSubLayers):
+        (WebCore::CoordinatedGraphicsLayer::updateContentBuffersIncludingSubLayers):
+        (WebCore::CoordinatedGraphicsLayer::setCoordinatorIncludingSubLayersIfNeeded):
+        * platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.h:
+        * platform/graphics/win/GraphicsLayerDirect2D.cpp:
+        (WebCore::GraphicsLayer::create):
+        (WebCore::GraphicsLayerDirect2D::GraphicsLayerDirect2D): Deleted.
+        (WebCore::GraphicsLayerDirect2D::initialize): Deleted.
+        (WebCore::GraphicsLayerDirect2D::~GraphicsLayerDirect2D): Deleted.
+        (WebCore::GraphicsLayerDirect2D::setNeedsDisplay): Deleted.
+        (WebCore::GraphicsLayerDirect2D::setNeedsDisplayInRect): Deleted.
+        * rendering/RenderLayerBacking.cpp:
+        (WebCore::RenderLayerBacking::createGraphicsLayer):
+        (WebCore::RenderLayerBacking::createPrimaryGraphicsLayer):
+        (WebCore::RenderLayerBacking::updateConfiguration):
+        (WebCore::RenderLayerBacking::updateInternalHierarchy):
+        (WebCore::RenderLayerBacking::updateMaskingLayer):
+        (WebCore::RenderLayerBacking::updateChildClippingStrategy):
+        (WebCore::RenderLayerBacking::updateScrollingLayers):
+        * rendering/RenderLayerBacking.h:
+        * rendering/RenderLayerCompositor.cpp:
+        (WebCore::RenderLayerCompositor::updateCompositingLayers):
+        (WebCore::RenderLayerCompositor::appendDocumentOverlayLayers):
+        (WebCore::RenderLayerCompositor::setCompositingParent):
+        (WebCore::RenderLayerCompositor::rebuildCompositingLayerTree):
+        (WebCore::RenderLayerCompositor::parentFrameContentLayers):
+        (WebCore::RenderLayerCompositor::updateLayerForTopOverhangArea):
+        (WebCore::RenderLayerCompositor::updateLayerForBottomOverhangArea):
+        (WebCore::RenderLayerCompositor::updateLayerForHeader):
+        (WebCore::RenderLayerCompositor::updateLayerForFooter):
+        (WebCore::RenderLayerCompositor::updateOverflowControlsLayers):
+        (WebCore::RenderLayerCompositor::ensureRootLayer):
+        (WebCore::RenderLayerCompositor::rootLayerAttachmentChanged):
+        * rendering/RenderLayerCompositor.h:
+
 2018-09-12  Alex Christensen  <achristensen@webkit.org>
 

trunk/Source/WebCore/page/PageOverlayController.cpp

@@ -44 +44 @@
 
 PageOverlayController::PageOverlayController(Page& page)
-    : m_initialized(false)
-    , m_page(page)
+    :  m_page(page)
 {
 }
@@ -99 +98 @@
             continue;
 
-        GraphicsLayer& layer = *overlayAndLayer.value;
-        GraphicsLayer::traverse(layer, [inWindow](GraphicsLayer& layer) {
+        auto& layer = overlayAndLayer.value;
+        GraphicsLayer::traverse(layer.get(), [inWindow](GraphicsLayer& layer) {
             layer.setIsInWindow(inWindow);
         });
-        updateOverlayGeometry(overlay, layer);
+        updateOverlayGeometry(overlay, layer.get());
         
-        if (!layer.parent())
-            m_documentOverlayRootLayer->addChild(&layer);
+        if (!layer->parent())
+            m_documentOverlayRootLayer->addChild(layer.copyRef());
     }
 
@@ -123 +122 @@
             continue;
 
-        GraphicsLayer& layer = *overlayAndLayer.value;
-        GraphicsLayer::traverse(layer, [inWindow](GraphicsLayer& layer) {
+        auto& layer = overlayAndLayer.value;
+        GraphicsLayer::traverse(layer.get(), [inWindow](GraphicsLayer& layer) {
             layer.setIsInWindow(inWindow);
         });
-        updateOverlayGeometry(overlay, layer);
+        updateOverlayGeometry(overlay, layer.get());
         
-        if (!layer.parent())
-            m_viewOverlayRootLayer->addChild(&layer);
+        if (!layer->parent())
+            m_viewOverlayRootLayer->addChild(layer.copyRef());
     }
 
@@ -145 +144 @@
     m_pageOverlays.append(&overlay);
 
-    std::unique_ptr<GraphicsLayer> layer = GraphicsLayer::create(m_page.chrome().client().graphicsLayerFactory(), *this);
+    auto layer = GraphicsLayer::create(m_page.chrome().client().graphicsLayerFactory(), *this);
     layer->setAnchorPoint(FloatPoint3D());
     layer->setBackgroundColor(overlay.backgroundColor());
     layer->setName("Overlay content");
 
-    updateSettingsForLayer(*layer);
+    updateSettingsForLayer(layer.get());
 
     switch (overlay.overlayType()) {
@@ -161 +160 @@
     }
 
-    GraphicsLayer& rawLayer = *layer;
+    auto& rawLayer = layer.get();
     m_overlayGraphicsLayers.set(&overlay, WTFMove(layer));
 
@@ -186 +185 @@
     overlay.setPage(nullptr);
 
-    m_overlayGraphicsLayers.take(&overlay)->removeFromParent();
+    if (auto optionalLayer = m_overlayGraphicsLayers.take(&overlay))
+        optionalLayer.value()->removeFromParent();
 
     bool removed = m_pageOverlays.removeFirst(&overlay);
@@ -212 +212 @@
 {
     ASSERT(m_pageOverlays.contains(&overlay));
-    GraphicsLayer& graphicsLayer = *m_overlayGraphicsLayers.get(&overlay);
-
-    if (!graphicsLayer.drawsContent()) {
-        graphicsLayer.setDrawsContent(true);
-        updateOverlayGeometry(overlay, graphicsLayer);
-    }
-
-    graphicsLayer.setNeedsDisplayInRect(dirtyRect);
+    auto* graphicsLayer = m_overlayGraphicsLayers.get(&overlay);
+
+    if (!graphicsLayer->drawsContent()) {
+        graphicsLayer->setDrawsContent(true);
+        updateOverlayGeometry(overlay, *graphicsLayer);
+    }
+
+    graphicsLayer->setNeedsDisplayInRect(dirtyRect);
 }
 
@@ -242 +242 @@
 void PageOverlayController::willDetachRootLayer()
 {
-    m_documentOverlayRootLayer = nullptr;
-    m_viewOverlayRootLayer = nullptr;
+    if (m_documentOverlayRootLayer) {
+        m_documentOverlayRootLayer->removeFromParent();
+        m_documentOverlayRootLayer = nullptr;
+    }
+
+    if (m_viewOverlayRootLayer) {
+        m_viewOverlayRootLayer->removeFromParent();
+        m_viewOverlayRootLayer = nullptr;
+    }
     m_initialized = false;
 }
@@ -251 +258 @@
     for (auto& overlayAndLayer : m_overlayGraphicsLayers) {
         if (overlayAndLayer.key->overlayType() == PageOverlay::OverlayType::View)
-            updateOverlayGeometry(*overlayAndLayer.key, *overlayAndLayer.value);
+            updateOverlayGeometry(*overlayAndLayer.key, overlayAndLayer.value.get());
     }
 }
@@ -259 +266 @@
     for (auto& overlayAndLayer : m_overlayGraphicsLayers) {
         if (overlayAndLayer.key->overlayType() == PageOverlay::OverlayType::Document)
-            updateOverlayGeometry(*overlayAndLayer.key, *overlayAndLayer.value);
+            updateOverlayGeometry(*overlayAndLayer.key, overlayAndLayer.value.get());
     }
 }
@@ -267 +274 @@
     // FIXME: We should apply these settings to all overlay sublayers recursively.
     for (auto& graphicsLayer : m_overlayGraphicsLayers.values())
-        updateSettingsForLayer(*graphicsLayer);
+        updateSettingsForLayer(graphicsLayer.get());
 }
 
@@ -360 +367 @@
 {
     for (auto& overlayAndGraphicsLayer : m_overlayGraphicsLayers) {
-        if (overlayAndGraphicsLayer.value.get() != graphicsLayer)
+        if (overlayAndGraphicsLayer.value.ptr() != graphicsLayer)
             continue;
 
@@ -384 +391 @@
 {
     ASSERT(m_pageOverlays.contains(&overlay));
-    updateOverlayGeometry(overlay, *m_overlayGraphicsLayers.get(&overlay));
+    if (auto* layer = m_overlayGraphicsLayers.get(&overlay))
+        updateOverlayGeometry(overlay, *layer);
 }
 
@@ -390 +398 @@
 {
     ASSERT(m_pageOverlays.contains(&overlay));
-    m_overlayGraphicsLayers.get(&overlay)->setBackgroundColor(overlay.backgroundColor());
+    if (auto* layer = m_overlayGraphicsLayers.get(&overlay))
+        layer->setBackgroundColor(overlay.backgroundColor());
 }
 

trunk/Source/WebCore/page/PageOverlayController.h

@@ -93 +93 @@
     void tiledBackingUsageChanged(const GraphicsLayer*, bool) override;
 
-    std::unique_ptr<GraphicsLayer> m_documentOverlayRootLayer;
-    std::unique_ptr<GraphicsLayer> m_viewOverlayRootLayer;
-    bool m_initialized;
+    Page& m_page;
+    RefPtr<GraphicsLayer> m_documentOverlayRootLayer;
+    RefPtr<GraphicsLayer> m_viewOverlayRootLayer;
 
-    HashMap<PageOverlay*, std::unique_ptr<GraphicsLayer>> m_overlayGraphicsLayers;
+    HashMap<PageOverlay*, Ref<GraphicsLayer>> m_overlayGraphicsLayers;
     Vector<RefPtr<PageOverlay>> m_pageOverlays;
-    Page& m_page;
+    bool m_initialized { false };
 };
 

trunk/Source/WebCore/page/ResourceUsageOverlay.h

@@ -84 +84 @@
 
 #if OS(LINUX)
-    std::unique_ptr<GraphicsLayer> m_paintLayer;
+    RefPtr<GraphicsLayer> m_paintLayer;
     std::unique_ptr<GraphicsLayerClient> m_overlayPainter;
 #endif

trunk/Source/WebCore/page/linux/ResourceUsageOverlayLinux.cpp

@@ -138 +138 @@
     m_paintLayer->setBackgroundColor(Color(0.0f, 0.0f, 0.0f, 0.8f));
     m_paintLayer->setDrawsContent(true);
-    overlay().layer().addChild(m_paintLayer.get());
+    overlay().layer().addChild(*m_paintLayer);
 
     ResourceUsageThread::addObserver(this, [this] (const ResourceUsageData& data) {

trunk/Source/WebCore/page/mac/ServicesOverlayController.h

@@ -64 +64 @@
         DDHighlightRef ddHighlight() const { return m_ddHighlight.get(); }
         Range& range() const { return m_range.get(); }
-        GraphicsLayer* layer() const { return m_graphicsLayer.get(); }
+        GraphicsLayer& layer() const { return m_graphicsLayer.get(); }
 
         enum {
@@ -88 +88 @@
         void didFinishFadeOutAnimation();
 
+        ServicesOverlayController* m_controller;
         RetainPtr<DDHighlightRef> m_ddHighlight;
         Ref<Range> m_range;
-        std::unique_ptr<GraphicsLayer> m_graphicsLayer;
+        Ref<GraphicsLayer> m_graphicsLayer;
         Type m_type;
-        ServicesOverlayController* m_controller;
     };
 

trunk/Source/WebCore/page/mac/ServicesOverlayController.mm

@@ -67 +67 @@
 
 ServicesOverlayController::Highlight::Highlight(ServicesOverlayController& controller, Type type, RetainPtr<DDHighlightRef> ddHighlight, Ref<WebCore::Range>&& range)
-    : m_range(WTFMove(range))
+    : m_controller(&controller)
+    , m_range(WTFMove(range))
+    , m_graphicsLayer(GraphicsLayer::create(controller.page().chrome().client().graphicsLayerFactory(), *this))
     , m_type(type)
-    , m_controller(&controller)
 {
     ASSERT(ddHighlight);
 
-    auto& page = controller.page();
-    m_graphicsLayer = GraphicsLayer::create(page.chrome().client().graphicsLayerFactory(), *this);
     m_graphicsLayer->setDrawsContent(true);
 
@@ -81 +80 @@
     // Set directly on the PlatformCALayer so that when we leave the 'from' value implicit
     // in our animations, we get the right initial value regardless of flush timing.
-    downcast<GraphicsLayerCA>(*layer()).platformCALayer()->setOpacity(0);
+    downcast<GraphicsLayerCA>(layer()).platformCALayer()->setOpacity(0);
 
     controller.didCreateHighlight(this);
@@ -114 +113 @@
 void ServicesOverlayController::Highlight::invalidate()
 {
-    layer()->removeFromParent();
+    layer().removeFromParent();
     m_controller = nullptr;
 }
@@ -159 +158 @@
 
     RefPtr<PlatformCAAnimation> platformAnimation = PlatformCAAnimationCocoa::create(animation.get());
-    downcast<GraphicsLayerCA>(*layer()).platformCALayer()->addAnimationForKey("FadeHighlightIn", *platformAnimation);
+    downcast<GraphicsLayerCA>(layer()).platformCALayer()->addAnimationForKey("FadeHighlightIn", *platformAnimation);
 }
 
@@ -177 +176 @@
 
     RefPtr<PlatformCAAnimation> platformAnimation = PlatformCAAnimationCocoa::create(animation.get());
-    downcast<GraphicsLayerCA>(*layer()).platformCALayer()->addAnimationForKey("FadeHighlightOut", *platformAnimation);
+    downcast<GraphicsLayerCA>(layer()).platformCALayer()->addAnimationForKey("FadeHighlightOut", *platformAnimation);
     [CATransaction commit];
 }
@@ -189 +188 @@
         return;
 
-    layer()->removeFromParent();
+    layer().removeFromParent();
 }
 
@@ -715 +714 @@
 
         if (m_activeHighlight) {
-            m_servicesOverlay->layer().addChild(m_activeHighlight->layer());
+            Ref<GraphicsLayer> highlightLayer = m_activeHighlight->layer();
+            m_servicesOverlay->layer().addChild(WTFMove(highlightLayer));
             m_activeHighlight->fadeIn();
         }

trunk/Source/WebCore/platform/graphics/GraphicsLayer.cpp

@@ -114 +114 @@
     : m_client(client)
     , m_type(type)
+    , m_beingDestroyed(false)
     , m_contentsOpaque(false)
     , m_supportsSubpixelAntialiasedText(false)
@@ -144 +145 @@
 void GraphicsLayer::willBeDestroyed()
 {
+    m_beingDestroyed = true;
 #ifndef NDEBUG
     m_client.verifyNotPainting();
@@ -178 +180 @@
 }
 
-bool GraphicsLayer::setChildren(const Vector<GraphicsLayer*>& newChildren)
+bool GraphicsLayer::setChildren(Vector<Ref<GraphicsLayer>>&& newChildren)
 {
     // If the contents of the arrays are the same, nothing to do.
@@ -185 +187 @@
 
     removeAllChildren();
-    
+
     size_t listSize = newChildren.size();
     for (size_t i = 0; i < listSize; ++i)
-        addChild(newChildren[i]);
+        addChild(WTFMove(newChildren[i]));
     
     return true;
 }
 
-void GraphicsLayer::addChild(GraphicsLayer* childLayer)
-{
-    ASSERT(childLayer != this);
+void GraphicsLayer::addChild(Ref<GraphicsLayer>&& childLayer)
+{
+    ASSERT(childLayer.ptr() != this);
     
     if (childLayer->parent())
@@ -201 +203 @@
 
     childLayer->setParent(this);
-    m_children.append(childLayer);
-}
-
-void GraphicsLayer::addChildAtIndex(GraphicsLayer* childLayer, int index)
-{
-    ASSERT(childLayer != this);
+    m_children.append(WTFMove(childLayer));
+}
+
+void GraphicsLayer::addChildAtIndex(Ref<GraphicsLayer>&& childLayer, int index)
+{
+    ASSERT(childLayer.ptr() != this);
 
     if (childLayer->parent())
@@ -212 +214 @@
 
     childLayer->setParent(this);
-    m_children.insert(index, childLayer);
-}
-
-void GraphicsLayer::addChildBelow(GraphicsLayer* childLayer, GraphicsLayer* sibling)
-{
-    ASSERT(childLayer != this);
+    m_children.insert(index, WTFMove(childLayer));
+}
+
+void GraphicsLayer::addChildBelow(Ref<GraphicsLayer>&& childLayer, GraphicsLayer* sibling)
+{
+    ASSERT(childLayer.ptr() != this);
     childLayer->removeFromParent();
+
+    childLayer->setParent(this);
+
+    for (unsigned i = 0; i < m_children.size(); i++) {
+        if (sibling == m_children[i].ptr()) {
+            m_children.insert(i, WTFMove(childLayer));
+            return;
+        }
+    }
+
+    m_children.append(WTFMove(childLayer));
+}
+
+void GraphicsLayer::addChildAbove(Ref<GraphicsLayer>&& childLayer, GraphicsLayer* sibling)
+{
+    childLayer->removeFromParent();
+    ASSERT(childLayer.ptr() != this);
+
+    childLayer->setParent(this);
+
+    for (unsigned i = 0; i < m_children.size(); i++) {
+        if (sibling == m_children[i].ptr()) {
+            m_children.insert(i + 1, WTFMove(childLayer));
+            return;
+        }
+    }
+
+    m_children.append(WTFMove(childLayer));
+}
+
+bool GraphicsLayer::replaceChild(GraphicsLayer* oldChild, Ref<GraphicsLayer>&& newChild)
+{
+    ASSERT(!newChild->parent());
+    
+    GraphicsLayer* rawNewChild = newChild.ptr();
 
     bool found = false;
     for (unsigned i = 0; i < m_children.size(); i++) {
-        if (sibling == m_children[i]) {
-            m_children.insert(i, childLayer);
+        if (oldChild == m_children[i].ptr()) {
+            m_children[i] = WTFMove(newChild);
             found = true;
             break;
         }
     }
-
-    childLayer->setParent(this);
-
-    if (!found)
-        m_children.append(childLayer);
-}
-
-void GraphicsLayer::addChildAbove(GraphicsLayer* childLayer, GraphicsLayer* sibling)
-{
-    childLayer->removeFromParent();
-    ASSERT(childLayer != this);
-
-    bool found = false;
-    for (unsigned i = 0; i < m_children.size(); i++) {
-        if (sibling == m_children[i]) {
-            m_children.insert(i+1, childLayer);
-            found = true;
-            break;
-        }
-    }
-
-    childLayer->setParent(this);
-
-    if (!found)
-        m_children.append(childLayer);
-}
-
-bool GraphicsLayer::replaceChild(GraphicsLayer* oldChild, GraphicsLayer* newChild)
-{
-    ASSERT(!newChild->parent());
-    bool found = false;
-    for (unsigned i = 0; i < m_children.size(); i++) {
-        if (oldChild == m_children[i]) {
-            m_children[i] = newChild;
-            found = true;
-            break;
-        }
-    }
     if (found) {
-        oldChild->setParent(0);
-
-        newChild->removeFromParent();
-        newChild->setParent(this);
+        oldChild->setParent(nullptr);
+
+        rawNewChild->removeFromParent();
+        rawNewChild->setParent(this);
         return true;
     }
@@ -279 +278 @@
 {
     while (m_children.size()) {
-        GraphicsLayer* curLayer = m_children[0];
+        GraphicsLayer* curLayer = m_children[0].ptr();
         ASSERT(curLayer->parent());
         curLayer->removeFromParent();
+        // curLayer may be destroyed here.
     }
 }
@@ -288 +288 @@
 {
     if (m_parent) {
-        m_parent->m_children.removeFirst(this);
+        GraphicsLayer* parent = m_parent;
         setParent(nullptr);
+        parent->m_children.removeFirstMatching([this](auto& layer) {
+            return layer.ptr() == this;
+        });
+        // |this| may be destroyed here.
     }
 }
@@ -319 +323 @@
 }
 
-void GraphicsLayer::setMaskLayer(GraphicsLayer* layer)
+void GraphicsLayer::setMaskLayer(RefPtr<GraphicsLayer>&& layer)
 {
     if (layer == m_maskLayer)
@@ -333 +337 @@
     }
     
-    m_maskLayer = layer;
+    m_maskLayer = WTFMove(layer);
 }
 
@@ -382 +386 @@
         m_replicaLayer->noteDeviceOrPageScaleFactorChangedIncludingDescendants();
 
-    const Vector<GraphicsLayer*>& childLayers = children();
-    size_t numChildren = childLayers.size();
-    for (size_t i = 0; i < numChildren; ++i)
-        childLayers[i]->noteDeviceOrPageScaleFactorChangedIncludingDescendants();
+    for (auto& layer : children())
+        layer->noteDeviceOrPageScaleFactorChangedIncludingDescendants();
 }
 
@@ -535 +537 @@
     
     if (preserves3D()) {
-        size_t numChildren = children().size();
-        for (size_t i = 0; i < numChildren; ++i)
-            children()[i]->distributeOpacity(accumulatedOpacity);
+        for (auto& layer : children())
+            layer->distributeOpacity(accumulatedOpacity);
     }
 }
@@ -694 +695 @@
     traversalFunc(layer);
 
-    for (auto* childLayer : layer.children())
-        traverse(*childLayer, traversalFunc);
+    for (auto& childLayer : layer.children())
+        traverse(childLayer.get(), traversalFunc);
 
     if (auto* replicaLayer = layer.replicaLayer())
@@ -718 +719 @@
 }
 
-static void dumpChildren(TextStream& ts, const Vector<GraphicsLayer*>& children, unsigned& totalChildCount, LayerTreeAsTextBehavior behavior)
+static void dumpChildren(TextStream& ts, const Vector<Ref<GraphicsLayer>>& children, unsigned& totalChildCount, LayerTreeAsTextBehavior behavior)
 {
     totalChildCount += children.size();
-    for (auto* child : children) {
-        if ((behavior & LayerTreeAsTextDebug) || !child->client().shouldSkipLayerInDump(child, behavior)) {
+    for (auto& child : children) {
+        if ((behavior & LayerTreeAsTextDebug) || !child->client().shouldSkipLayerInDump(child.ptr(), behavior)) {
             TextStream::IndentScope indentScope(ts);
             child->dumpLayer(ts, behavior);

trunk/Source/WebCore/platform/graphics/GraphicsLayer.h

@@ -231 +231 @@
 // which may have associated transformation and animations.
 
-class GraphicsLayer {
-    WTF_MAKE_NONCOPYABLE(GraphicsLayer); WTF_MAKE_FAST_ALLOCATED;
+class GraphicsLayer : public RefCounted<GraphicsLayer> {
+    WTF_MAKE_FAST_ALLOCATED;
 public:
     enum class Type : uint8_t {
@@ -240 +240 @@
         Shape
     };
-    
-    WEBCORE_EXPORT static std::unique_ptr<GraphicsLayer> create(GraphicsLayerFactory*, GraphicsLayerClient&, Type = Type::Normal);
+
+    WEBCORE_EXPORT static Ref<GraphicsLayer> create(GraphicsLayerFactory*, GraphicsLayerClient&, Type = Type::Normal);
     
     WEBCORE_EXPORT virtual ~GraphicsLayer();
@@ -264 +264 @@
     bool hasAncestor(GraphicsLayer*) const;
     
-    const Vector<GraphicsLayer*>& children() const { return m_children; }
+    const Vector<Ref<GraphicsLayer>>& children() const { return m_children; }
+    Vector<Ref<GraphicsLayer>>& children() { return m_children; }
+
     // Returns true if the child list changed.
-    WEBCORE_EXPORT virtual bool setChildren(const Vector<GraphicsLayer*>&);
+    WEBCORE_EXPORT virtual bool setChildren(Vector<Ref<GraphicsLayer>>&&);
+
+    // Add child layers. If the child is already parented, it will be removed from its old parent.
+    WEBCORE_EXPORT virtual void addChild(Ref<GraphicsLayer>&&);
+    WEBCORE_EXPORT virtual void addChildAtIndex(Ref<GraphicsLayer>&&, int index);
+    WEBCORE_EXPORT virtual void addChildAbove(Ref<GraphicsLayer>&&, GraphicsLayer* sibling);
+    WEBCORE_EXPORT virtual void addChildBelow(Ref<GraphicsLayer>&&, GraphicsLayer* sibling);
+    WEBCORE_EXPORT virtual bool replaceChild(GraphicsLayer* oldChild, Ref<GraphicsLayer>&& newChild);
+
+    WEBCORE_EXPORT void removeAllChildren();
+    WEBCORE_EXPORT virtual void removeFromParent();
+
+    // The parent() of a maskLayer is set to the layer being masked.
+    GraphicsLayer* maskLayer() const { return m_maskLayer.get(); }
+    virtual void setMaskLayer(RefPtr<GraphicsLayer>&&);
+
+    void setIsMaskLayer(bool isMask) { m_isMaskLayer = isMask; }
+    bool isMaskLayer() const { return m_isMaskLayer; }
+    
+    // The given layer will replicate this layer and its children; the replica renders behind this layer.
+    WEBCORE_EXPORT virtual void setReplicatedByLayer(GraphicsLayer*);
+    // Whether this layer is being replicated by another layer.
+    bool isReplicated() const { return m_replicaLayer; }
+    // The layer that replicates this layer (if any).
+    GraphicsLayer* replicaLayer() const { return m_replicaLayer.get(); }
+
+    const FloatPoint& replicatedLayerPosition() const { return m_replicatedLayerPosition; }
+    void setReplicatedLayerPosition(const FloatPoint& p) { m_replicatedLayerPosition = p; }
+
+    enum ShouldSetNeedsDisplay {
+        DontSetNeedsDisplay,
+        SetNeedsDisplay
+    };
+
+    // Offset is origin of the renderer minus origin of the graphics layer.
+    FloatSize offsetFromRenderer() const { return m_offsetFromRenderer; }
+    void setOffsetFromRenderer(const FloatSize&, ShouldSetNeedsDisplay = SetNeedsDisplay);
+
+    // The position of the layer (the location of its top-left corner in its parent)
+    const FloatPoint& position() const { return m_position; }
+    virtual void setPosition(const FloatPoint& p) { m_approximatePosition = std::nullopt; m_position = p; }
+
+    // approximatePosition, if set, overrides position() and is used during coverage rect computation.
+    FloatPoint approximatePosition() const { return m_approximatePosition ? m_approximatePosition.value() : m_position; }
+    virtual void setApproximatePosition(const FloatPoint& p) { m_approximatePosition = p; }
+
+    // For platforms that move underlying platform layers on a different thread for scrolling; just update the GraphicsLayer state.
+    virtual void syncPosition(const FloatPoint& p) { m_position = p; }
+
+    // Anchor point: (0, 0) is top left, (1, 1) is bottom right. The anchor point
+    // affects the origin of the transforms.
+    const FloatPoint3D& anchorPoint() const { return m_anchorPoint; }
+    virtual void setAnchorPoint(const FloatPoint3D& p) { m_anchorPoint = p; }
+
+    // The size of the layer.
+    const FloatSize& size() const { return m_size; }
+    WEBCORE_EXPORT virtual void setSize(const FloatSize&);
+
+    // The boundOrigin affects the offset at which content is rendered, and sublayers are positioned.
+    const FloatPoint& boundsOrigin() const { return m_boundsOrigin; }
+    virtual void setBoundsOrigin(const FloatPoint& origin) { m_boundsOrigin = origin; }
+
+    // For platforms that move underlying platform layers on a different thread for scrolling; just update the GraphicsLayer state.
+    virtual void syncBoundsOrigin(const FloatPoint& origin) { m_boundsOrigin = origin; }
+
+    const TransformationMatrix& transform() const;
+    virtual void setTransform(const TransformationMatrix&);
+    bool hasNonIdentityTransform() const { return m_transform && !m_transform->isIdentity(); }
+
+    const TransformationMatrix& childrenTransform() const;
+    virtual void setChildrenTransform(const TransformationMatrix&);
+    bool hasNonIdentityChildrenTransform() const { return m_childrenTransform && !m_childrenTransform->isIdentity(); }
+
+    bool preserves3D() const { return m_preserves3D; }
+    virtual void setPreserves3D(bool b) { m_preserves3D = b; }
+    
+    bool masksToBounds() const { return m_masksToBounds; }
+    virtual void setMasksToBounds(bool b) { m_masksToBounds = b; }
+    
+    bool drawsContent() const { return m_drawsContent; }
+    virtual void setDrawsContent(bool b) { m_drawsContent = b; }
+
+    bool contentsAreVisible() const { return m_contentsVisible; }
+    virtual void setContentsVisible(bool b) { m_contentsVisible = b; }
+
+    bool userInteractionEnabled() const { return m_userInteractionEnabled; }
+    virtual void setUserInteractionEnabled(bool b) { m_userInteractionEnabled = b; }
+    
+    bool acceleratesDrawing() const { return m_acceleratesDrawing; }
+    virtual void setAcceleratesDrawing(bool b) { m_acceleratesDrawing = b; }
+
+    bool usesDisplayListDrawing() const { return m_usesDisplayListDrawing; }
+    virtual void setUsesDisplayListDrawing(bool b) { m_usesDisplayListDrawing = b; }
+
+    bool needsBackdrop() const { return !m_backdropFilters.isEmpty(); }
+
+    // The color used to paint the layer background. Pass an invalid color to remove it.
+    // Note that this covers the entire layer. Use setContentsToSolidColor() if the color should
+    // only cover the contentsRect.
+    const Color& backgroundColor() const { return m_backgroundColor; }
+    WEBCORE_EXPORT virtual void setBackgroundColor(const Color&);
+
+    // opaque means that we know the layer contents have no alpha
+    bool contentsOpaque() const { return m_contentsOpaque; }
+    virtual void setContentsOpaque(bool b) { m_contentsOpaque = b; }
+
+    bool supportsSubpixelAntialiasedText() const { return m_supportsSubpixelAntialiasedText; }
+    virtual void setSupportsSubpixelAntialiasedText(bool b) { m_supportsSubpixelAntialiasedText = b; }
+
+    bool backfaceVisibility() const { return m_backfaceVisibility; }
+    virtual void setBackfaceVisibility(bool b) { m_backfaceVisibility = b; }
+
+    float opacity() const { return m_opacity; }
+    virtual void setOpacity(float opacity) { m_opacity = opacity; }
+
+    const FilterOperations& filters() const { return m_filters; }
+    // Returns true if filter can be rendered by the compositor.
+    virtual bool setFilters(const FilterOperations& filters) { m_filters = filters; return true; }
+
+    const FilterOperations& backdropFilters() const { return m_backdropFilters; }
+    virtual bool setBackdropFilters(const FilterOperations& filters) { m_backdropFilters = filters; return true; }
+
+    virtual void setBackdropFiltersRect(const FloatRoundedRect& backdropFiltersRect) { m_backdropFiltersRect = backdropFiltersRect; }
+    const FloatRoundedRect& backdropFiltersRect() const { return m_backdropFiltersRect; }
+
+#if ENABLE(CSS_COMPOSITING)
+    BlendMode blendMode() const { return m_blendMode; }
+    virtual void setBlendMode(BlendMode blendMode) { m_blendMode = blendMode; }
+#endif
+
+    // Some GraphicsLayers paint only the foreground or the background content
+    GraphicsLayerPaintingPhase paintingPhase() const { return m_paintingPhase; }
+    void setPaintingPhase(GraphicsLayerPaintingPhase phase) { m_paintingPhase = phase; }
+
+    enum ShouldClipToLayer {
+        DoNotClipToLayer,
+        ClipToLayer
+    };
+
+    virtual void setNeedsDisplay() = 0;
+    // mark the given rect (in layer coords) as needing dispay. Never goes deep.
+    virtual void setNeedsDisplayInRect(const FloatRect&, ShouldClipToLayer = ClipToLayer) = 0;
+
+    virtual void setContentsNeedsDisplay() { };
+
+    // The tile phase is relative to the GraphicsLayer bounds.
+    virtual void setContentsTilePhase(const FloatSize& p) { m_contentsTilePhase = p; }
+    FloatSize contentsTilePhase() const { return m_contentsTilePhase; }
+
+    virtual void setContentsTileSize(const FloatSize& s) { m_contentsTileSize = s; }
+    FloatSize contentsTileSize() const { return m_contentsTileSize; }
+    bool hasContentsTiling() const { return !m_contentsTileSize.isEmpty(); }
+
+    // Set that the position/size of the contents (image or video).
+    FloatRect contentsRect() const { return m_contentsRect; }
+    virtual void setContentsRect(const FloatRect& r) { m_contentsRect = r; }
+
+    // Set a rounded rect that will be used to clip the layer contents.
+    FloatRoundedRect contentsClippingRect() const { return m_contentsClippingRect; }
+    virtual void setContentsClippingRect(const FloatRoundedRect& roundedRect) { m_contentsClippingRect = roundedRect; }
+
+    // Set a rounded rect that is used to clip this layer and its descendants (implies setting masksToBounds).
+    // Returns false if the platform can't support this rounded clip, and we should fall back to painting a mask.
+    FloatRoundedRect maskToBoundsRect() const { return m_masksToBoundsRect; };
+    virtual bool setMasksToBoundsRect(const FloatRoundedRect& roundedRect) { m_masksToBoundsRect = roundedRect; return false; }
+
+    Path shapeLayerPath() const;
+    virtual void setShapeLayerPath(const Path&);
+
+    WindRule shapeLayerWindRule() const;
+    virtual void setShapeLayerWindRule(WindRule);
+
+    // Transitions are identified by a special animation name that cannot clash with a keyframe identifier.
+    static String animationNameForTransition(AnimatedPropertyID);
+
+    // Return true if the animation is handled by the compositing system. If this returns
+    // false, the animation will be run by CSSAnimationController.
+    // These methods handle both transitions and keyframe animations.
+    virtual bool addAnimation(const KeyframeValueList&, const FloatSize& /*boxSize*/, const Animation*, const String& /*animationName*/, double /*timeOffset*/)  { return false; }
+    virtual void pauseAnimation(const String& /*animationName*/, double /*timeOffset*/) { }
+    virtual void seekAnimation(const String& /*animationName*/, double /*timeOffset*/) { }
+    virtual void removeAnimation(const String& /*animationName*/) { }
+
+    WEBCORE_EXPORT virtual void suspendAnimations(MonotonicTime);
+    WEBCORE_EXPORT virtual void resumeAnimations();
+
+    // Layer contents
+    virtual void setContentsToImage(Image*) { }
+    virtual bool shouldDirectlyCompositeImage(Image*) const { return true; }
+#if PLATFORM(IOS)
+    virtual PlatformLayer* contentsLayerForMedia() const { return 0; }
+#endif
 
     enum class ContentsLayerPurpose : uint8_t {
@@ -277 +470 @@
     };
 
-    // Add child layers. If the child is already parented, it will be removed from its old parent.
-    WEBCORE_EXPORT virtual void addChild(GraphicsLayer*);
-    WEBCORE_EXPORT virtual void addChildAtIndex(GraphicsLayer*, int index);
-    WEBCORE_EXPORT virtual void addChildAbove(GraphicsLayer*, GraphicsLayer* sibling);
-    WEBCORE_EXPORT virtual void addChildBelow(GraphicsLayer*, GraphicsLayer* sibling);
-    WEBCORE_EXPORT virtual bool replaceChild(GraphicsLayer* oldChild, GraphicsLayer* newChild);
-
-    WEBCORE_EXPORT void removeAllChildren();
-    WEBCORE_EXPORT virtual void removeFromParent();
-
-    // The parent() of a maskLayer is set to the layer being masked.
-    GraphicsLayer* maskLayer() const { return m_maskLayer; }
-    virtual void setMaskLayer(GraphicsLayer*);
-
-    void setIsMaskLayer(bool isMask) { m_isMaskLayer = isMask; }
-    bool isMaskLayer() const { return m_isMaskLayer; }
-    
-    // The given layer will replicate this layer and its children; the replica renders behind this layer.
-    WEBCORE_EXPORT virtual void setReplicatedByLayer(GraphicsLayer*);
-    // Whether this layer is being replicated by another layer.
-    bool isReplicated() const { return m_replicaLayer; }
-    // The layer that replicates this layer (if any).
-    GraphicsLayer* replicaLayer() const { return m_replicaLayer; }
-
-    const FloatPoint& replicatedLayerPosition() const { return m_replicatedLayerPosition; }
-    void setReplicatedLayerPosition(const FloatPoint& p) { m_replicatedLayerPosition = p; }
-
-    enum ShouldSetNeedsDisplay {
-        DontSetNeedsDisplay,
-        SetNeedsDisplay
-    };
-
-    // Offset is origin of the renderer minus origin of the graphics layer.
-    FloatSize offsetFromRenderer() const { return m_offsetFromRenderer; }
-    void setOffsetFromRenderer(const FloatSize&, ShouldSetNeedsDisplay = SetNeedsDisplay);
-
-    // The position of the layer (the location of its top-left corner in its parent)
-    const FloatPoint& position() const { return m_position; }
-    virtual void setPosition(const FloatPoint& p) { m_approximatePosition = std::nullopt; m_position = p; }
-
-    // approximatePosition, if set, overrides position() and is used during coverage rect computation.
-    FloatPoint approximatePosition() const { return m_approximatePosition ? m_approximatePosition.value() : m_position; }
-    virtual void setApproximatePosition(const FloatPoint& p) { m_approximatePosition = p; }
-
-    // For platforms that move underlying platform layers on a different thread for scrolling; just update the GraphicsLayer state.
-    virtual void syncPosition(const FloatPoint& p) { m_position = p; }
-
-    // Anchor point: (0, 0) is top left, (1, 1) is bottom right. The anchor point
-    // affects the origin of the transforms.
-    const FloatPoint3D& anchorPoint() const { return m_anchorPoint; }
-    virtual void setAnchorPoint(const FloatPoint3D& p) { m_anchorPoint = p; }
-
-    // The size of the layer.
-    const FloatSize& size() const { return m_size; }
-    WEBCORE_EXPORT virtual void setSize(const FloatSize&);
-
-    // The boundOrigin affects the offset at which content is rendered, and sublayers are positioned.
-    const FloatPoint& boundsOrigin() const { return m_boundsOrigin; }
-    virtual void setBoundsOrigin(const FloatPoint& origin) { m_boundsOrigin = origin; }
-
-    // For platforms that move underlying platform layers on a different thread for scrolling; just update the GraphicsLayer state.
-    virtual void syncBoundsOrigin(const FloatPoint& origin) { m_boundsOrigin = origin; }
-
-    const TransformationMatrix& transform() const;
-    virtual void setTransform(const TransformationMatrix&);
-    bool hasNonIdentityTransform() const { return m_transform && !m_transform->isIdentity(); }
-
-    const TransformationMatrix& childrenTransform() const;
-    virtual void setChildrenTransform(const TransformationMatrix&);
-    bool hasNonIdentityChildrenTransform() const { return m_childrenTransform && !m_childrenTransform->isIdentity(); }
-
-    bool preserves3D() const { return m_preserves3D; }
-    virtual void setPreserves3D(bool b) { m_preserves3D = b; }
-    
-    bool masksToBounds() const { return m_masksToBounds; }
-    virtual void setMasksToBounds(bool b) { m_masksToBounds = b; }
-    
-    bool drawsContent() const { return m_drawsContent; }
-    virtual void setDrawsContent(bool b) { m_drawsContent = b; }
-
-    bool contentsAreVisible() const { return m_contentsVisible; }
-    virtual void setContentsVisible(bool b) { m_contentsVisible = b; }
-
-    bool userInteractionEnabled() const { return m_userInteractionEnabled; }
-    virtual void setUserInteractionEnabled(bool b) { m_userInteractionEnabled = b; }
-    
-    bool acceleratesDrawing() const { return m_acceleratesDrawing; }
-    virtual void setAcceleratesDrawing(bool b) { m_acceleratesDrawing = b; }
-
-    bool usesDisplayListDrawing() const { return m_usesDisplayListDrawing; }
-    virtual void setUsesDisplayListDrawing(bool b) { m_usesDisplayListDrawing = b; }
-
-    bool needsBackdrop() const { return !m_backdropFilters.isEmpty(); }
-
-    // The color used to paint the layer background. Pass an invalid color to remove it.
-    // Note that this covers the entire layer. Use setContentsToSolidColor() if the color should
-    // only cover the contentsRect.
-    const Color& backgroundColor() const { return m_backgroundColor; }
-    WEBCORE_EXPORT virtual void setBackgroundColor(const Color&);
-
-    // opaque means that we know the layer contents have no alpha
-    bool contentsOpaque() const { return m_contentsOpaque; }
-    virtual void setContentsOpaque(bool b) { m_contentsOpaque = b; }
-
-    bool supportsSubpixelAntialiasedText() const { return m_supportsSubpixelAntialiasedText; }
-    virtual void setSupportsSubpixelAntialiasedText(bool b) { m_supportsSubpixelAntialiasedText = b; }
-
-    bool backfaceVisibility() const { return m_backfaceVisibility; }
-    virtual void setBackfaceVisibility(bool b) { m_backfaceVisibility = b; }
-
-    float opacity() const { return m_opacity; }
-    virtual void setOpacity(float opacity) { m_opacity = opacity; }
-
-    const FilterOperations& filters() const { return m_filters; }
-    // Returns true if filter can be rendered by the compositor.
-    virtual bool setFilters(const FilterOperations& filters) { m_filters = filters; return true; }
-
-    const FilterOperations& backdropFilters() const { return m_backdropFilters; }
-    virtual bool setBackdropFilters(const FilterOperations& filters) { m_backdropFilters = filters; return true; }
-
-    virtual void setBackdropFiltersRect(const FloatRoundedRect& backdropFiltersRect) { m_backdropFiltersRect = backdropFiltersRect; }
-    const FloatRoundedRect& backdropFiltersRect() const { return m_backdropFiltersRect; }
-
-#if ENABLE(CSS_COMPOSITING)
-    BlendMode blendMode() const { return m_blendMode; }
-    virtual void setBlendMode(BlendMode blendMode) { m_blendMode = blendMode; }
-#endif
-
-    // Some GraphicsLayers paint only the foreground or the background content
-    GraphicsLayerPaintingPhase paintingPhase() const { return m_paintingPhase; }
-    void setPaintingPhase(GraphicsLayerPaintingPhase phase) { m_paintingPhase = phase; }
-
-    enum ShouldClipToLayer {
-        DoNotClipToLayer,
-        ClipToLayer
-    };
-
-    virtual void setNeedsDisplay() = 0;
-    // mark the given rect (in layer coords) as needing dispay. Never goes deep.
-    virtual void setNeedsDisplayInRect(const FloatRect&, ShouldClipToLayer = ClipToLayer) = 0;
-
-    virtual void setContentsNeedsDisplay() { };
-
-    // The tile phase is relative to the GraphicsLayer bounds.
-    virtual void setContentsTilePhase(const FloatSize& p) { m_contentsTilePhase = p; }
-    FloatSize contentsTilePhase() const { return m_contentsTilePhase; }
-
-    virtual void setContentsTileSize(const FloatSize& s) { m_contentsTileSize = s; }
-    FloatSize contentsTileSize() const { return m_contentsTileSize; }
-    bool hasContentsTiling() const { return !m_contentsTileSize.isEmpty(); }
-
-    // Set that the position/size of the contents (image or video).
-    FloatRect contentsRect() const { return m_contentsRect; }
-    virtual void setContentsRect(const FloatRect& r) { m_contentsRect = r; }
-
-    // Set a rounded rect that will be used to clip the layer contents.
-    FloatRoundedRect contentsClippingRect() const { return m_contentsClippingRect; }
-    virtual void setContentsClippingRect(const FloatRoundedRect& roundedRect) { m_contentsClippingRect = roundedRect; }
-
-    // Set a rounded rect that is used to clip this layer and its descendants (implies setting masksToBounds).
-    // Returns false if the platform can't support this rounded clip, and we should fall back to painting a mask.
-    FloatRoundedRect maskToBoundsRect() const { return m_masksToBoundsRect; };
-    virtual bool setMasksToBoundsRect(const FloatRoundedRect& roundedRect) { m_masksToBoundsRect = roundedRect; return false; }
-
-    Path shapeLayerPath() const;
-    virtual void setShapeLayerPath(const Path&);
-
-    WindRule shapeLayerWindRule() const;
-    virtual void setShapeLayerWindRule(WindRule);
-
-    // Transitions are identified by a special animation name that cannot clash with a keyframe identifier.
-    static String animationNameForTransition(AnimatedPropertyID);
-
-    // Return true if the animation is handled by the compositing system. If this returns
-    // false, the animation will be run by CSSAnimationController.
-    // These methods handle both transitions and keyframe animations.
-    virtual bool addAnimation(const KeyframeValueList&, const FloatSize& /*boxSize*/, const Animation*, const String& /*animationName*/, double /*timeOffset*/)  { return false; }
-    virtual void pauseAnimation(const String& /*animationName*/, double /*timeOffset*/) { }
-    virtual void seekAnimation(const String& /*animationName*/, double /*timeOffset*/) { }
-    virtual void removeAnimation(const String& /*animationName*/) { }
-
-    WEBCORE_EXPORT virtual void suspendAnimations(MonotonicTime);
-    WEBCORE_EXPORT virtual void resumeAnimations();
-
-    // Layer contents
-    virtual void setContentsToImage(Image*) { }
-    virtual bool shouldDirectlyCompositeImage(Image*) const { return true; }
-#if PLATFORM(IOS)
-    virtual PlatformLayer* contentsLayerForMedia() const { return 0; }
-#endif
     // Pass an invalid color to remove the contents layer.
     virtual void setContentsToSolidColor(const Color&) { }
@@ -592 +595 @@
     // Should be called from derived class destructors. Should call willBeDestroyed() on super.
     WEBCORE_EXPORT virtual void willBeDestroyed();
+    bool beingDestroyed() const { return m_beingDestroyed; }
 
     // This method is used by platform GraphicsLayer classes to clear the filters
@@ -657 +661 @@
     CompositingCoordinatesOrientation m_contentsOrientation { CompositingCoordinatesOrientation::TopDown }; // affects orientation of layer contents
 
+    bool m_beingDestroyed : 1;
     bool m_contentsOpaque : 1;
     bool m_supportsSubpixelAntialiasedText : 1;
@@ -676 +681 @@
     int m_repaintCount { 0 };
 
-    Vector<GraphicsLayer*> m_children;
+    Vector<Ref<GraphicsLayer>> m_children;
     GraphicsLayer* m_parent { nullptr };
 
-    GraphicsLayer* m_maskLayer { nullptr }; // Reference to mask layer. We don't own this.
-
-    GraphicsLayer* m_replicaLayer { nullptr }; // A layer that replicates this layer. We only allow one, for now.
+    RefPtr<GraphicsLayer> m_maskLayer { nullptr }; // Reference to mask layer.
+
+    RefPtr<GraphicsLayer> m_replicaLayer { nullptr }; // A layer that replicates this layer. We only allow one, for now.
                                    // The replica is not parented; this is the primary reference to it.
     GraphicsLayer* m_replicatedLayer { nullptr }; // For a replica layer, a reference to the original layer.

trunk/Source/WebCore/platform/graphics/GraphicsLayerFactory.h

@@ -24 +24 @@
  */
 
-#ifndef GraphicsLayerFactory_h
-#define GraphicsLayerFactory_h
+#pragma once
 
 #include "GraphicsLayer.h"
@@ -36 +35 @@
     virtual ~GraphicsLayerFactory() = default;
 
-    virtual std::unique_ptr<GraphicsLayer> createGraphicsLayer(GraphicsLayer::Type, GraphicsLayerClient&) = 0;
+    virtual Ref<GraphicsLayer> createGraphicsLayer(GraphicsLayer::Type, GraphicsLayerClient&) = 0;
 };
 
 } // namespace WebCore
-
-#endif // GraphicsLayerFactory_h

trunk/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp

@@ -340 +340 @@
 }
 
-std::unique_ptr<GraphicsLayer> GraphicsLayer::create(GraphicsLayerFactory* factory, GraphicsLayerClient& client, Type layerType)
-{
-    std::unique_ptr<GraphicsLayer> graphicsLayer;
-    if (!factory)
-        graphicsLayer = std::make_unique<GraphicsLayerCA>(layerType, client);
-    else
-        graphicsLayer = factory->createGraphicsLayer(layerType, client);
-
-    graphicsLayer->initialize(layerType);
-
-    return graphicsLayer;
+Ref<GraphicsLayer> GraphicsLayer::create(GraphicsLayerFactory* factory, GraphicsLayerClient& client, Type layerType)
+{
+    if (factory) {
+        auto layer = factory->createGraphicsLayer(layerType, client);
+        layer->initialize(layerType);
+        return layer;
+    }
+    
+    auto layer = adoptRef(*new GraphicsLayerCA(layerType, client));
+    layer->initialize(layerType);
+    return WTFMove(layer);
 }
 
@@ -506 +506 @@
 }
 
-bool GraphicsLayerCA::setChildren(const Vector<GraphicsLayer*>& children)
-{
-    bool childrenChanged = GraphicsLayer::setChildren(children);
+bool GraphicsLayerCA::setChildren(Vector<Ref<GraphicsLayer>>&& children)
+{
+    bool childrenChanged = GraphicsLayer::setChildren(WTFMove(children));
     if (childrenChanged)
         noteSublayersChanged();
@@ -515 +515 @@
 }
 
-void GraphicsLayerCA::addChild(GraphicsLayer* childLayer)
-{
-    GraphicsLayer::addChild(childLayer);
+void GraphicsLayerCA::addChild(Ref<GraphicsLayer>&& childLayer)
+{
+    GraphicsLayer::addChild(WTFMove(childLayer));
     noteSublayersChanged();
 }
 
-void GraphicsLayerCA::addChildAtIndex(GraphicsLayer* childLayer, int index)
-{
-    GraphicsLayer::addChildAtIndex(childLayer, index);
+void GraphicsLayerCA::addChildAtIndex(Ref<GraphicsLayer>&& childLayer, int index)
+{
+    GraphicsLayer::addChildAtIndex(WTFMove(childLayer), index);
     noteSublayersChanged();
 }
 
-void GraphicsLayerCA::addChildBelow(GraphicsLayer* childLayer, GraphicsLayer* sibling)
-{
-    GraphicsLayer::addChildBelow(childLayer, sibling);
+void GraphicsLayerCA::addChildBelow(Ref<GraphicsLayer>&& childLayer, GraphicsLayer* sibling)
+{
+    GraphicsLayer::addChildBelow(WTFMove(childLayer), sibling);
     noteSublayersChanged();
 }
 
-void GraphicsLayerCA::addChildAbove(GraphicsLayer* childLayer, GraphicsLayer* sibling)
-{
-    GraphicsLayer::addChildAbove(childLayer, sibling);
+void GraphicsLayerCA::addChildAbove(Ref<GraphicsLayer>&& childLayer, GraphicsLayer* sibling)
+{
+    GraphicsLayer::addChildAbove(WTFMove(childLayer), sibling);
     noteSublayersChanged();
 }
 
-bool GraphicsLayerCA::replaceChild(GraphicsLayer* oldChild, GraphicsLayer* newChild)
-{
-    if (GraphicsLayer::replaceChild(oldChild, newChild)) {
+bool GraphicsLayerCA::replaceChild(GraphicsLayer* oldChild, Ref<GraphicsLayer>&& newChild)
+{
+    if (GraphicsLayer::replaceChild(oldChild, WTFMove(newChild))) {
         noteSublayersChanged();
         return true;
@@ -555 +555 @@
 }
 
-void GraphicsLayerCA::setMaskLayer(GraphicsLayer* layer)
+void GraphicsLayerCA::setMaskLayer(RefPtr<GraphicsLayer>&& layer)
 {
     if (layer == m_maskLayer)
         return;
 
-    GraphicsLayer::setMaskLayer(layer);
+    GraphicsLayer::setMaskLayer(WTFMove(layer));
     noteLayerPropertyChanged(MaskLayerChanged);
 
@@ -1301 +1301 @@
 
     if (m_maskLayer) {
-        GraphicsLayerCA& maskLayerCA = downcast<GraphicsLayerCA>(*m_maskLayer);
+        auto& maskLayerCA = downcast<GraphicsLayerCA>(*m_maskLayer);
         if (maskLayerCA.recursiveVisibleRectChangeRequiresFlush(childCommitState, localState))
             return true;
     }
 
-    const Vector<GraphicsLayer*>& childLayers = children();
-    size_t numChildren = childLayers.size();
-    
-    for (size_t i = 0; i < numChildren; ++i) {
-        GraphicsLayerCA& currentChild = downcast<GraphicsLayerCA>(*childLayers[i]);
+    for (const auto& layer : children()) {
+        const auto& currentChild = downcast<GraphicsLayerCA>(layer.get());
         if (currentChild.recursiveVisibleRectChangeRequiresFlush(childCommitState, localState))
             return true;
@@ -1573 +1570 @@
     childCommitState.ancestorIsViewportConstrained |= m_isViewportConstrained;
 
-    if (GraphicsLayerCA* maskLayer = downcast<GraphicsLayerCA>(m_maskLayer)) {
+    if (GraphicsLayerCA* maskLayer = downcast<GraphicsLayerCA>(m_maskLayer.get())) {
         maskLayer->setVisibleAndCoverageRects(rects, m_isViewportConstrained || commitState.ancestorIsViewportConstrained);
         maskLayer->commitLayerChangesBeforeSublayers(childCommitState, pageScaleFactor, baseRelativePosition);
     }
 
-    const Vector<GraphicsLayer*>& childLayers = children();
-    size_t numChildren = childLayers.size();
-
     bool hasDescendantsWithRunningTransformAnimations = false;
     
-    for (size_t i = 0; i < numChildren; ++i) {
-        GraphicsLayerCA& currentChild = downcast<GraphicsLayerCA>(*childLayers[i]);
+    for (auto& layer : children()) {
+        auto& currentChild = downcast<GraphicsLayerCA>(layer.get());
         currentChild.recursiveCommitChanges(childCommitState, localState, pageScaleFactor, baseRelativePosition, affectedByPageScale);
 
@@ -1591 +1585 @@
     }
 
-    if (GraphicsLayerCA* replicaLayer = downcast<GraphicsLayerCA>(m_replicaLayer))
+    if (GraphicsLayerCA* replicaLayer = downcast<GraphicsLayerCA>(m_replicaLayer.get()))
         replicaLayer->recursiveCommitChanges(childCommitState, localState, pageScaleFactor, baseRelativePosition, affectedByPageScale);
 
-    if (GraphicsLayerCA* maskLayer = downcast<GraphicsLayerCA>(m_maskLayer))
+    if (GraphicsLayerCA* maskLayer = downcast<GraphicsLayerCA>(m_maskLayer.get()))
         maskLayer->commitLayerChangesAfterSublayers(childCommitState);
 
@@ -1929 +1923 @@
     }
     
-    const Vector<GraphicsLayer*>& childLayers = children();
-    size_t numChildren = childLayers.size();
-    for (size_t i = 0; i < numChildren; ++i) {
-        GraphicsLayerCA& currentChild = downcast<GraphicsLayerCA>(*childLayers[i]);
+    for (const auto& layer : children()) {
+        const auto& currentChild = downcast<GraphicsLayerCA>(layer.get());
         PlatformCALayer* childLayer = currentChild.layerForSuperlayer();
         childListForSublayers.append(childLayer);
@@ -3978 +3970 @@
     }
 
-    const Vector<GraphicsLayer*>& childLayers = children();
+    auto& childLayers = children();
     Vector<RefPtr<PlatformCALayer>> clonalSublayers;
 
@@ -4028 +4020 @@
         replicaState.push(ReplicaState::ChildBranch);
 
-        for (auto* childLayer : childLayers) {
-            GraphicsLayerCA& childLayerCA = downcast<GraphicsLayerCA>(*childLayer);
+        for (auto& childLayer : childLayers) {
+            GraphicsLayerCA& childLayerCA = downcast<GraphicsLayerCA>(childLayer.get());
             if (auto platformLayer = childLayerCA.fetchCloneLayers(replicaRoot, replicaState, IntermediateCloneLevel))
                 clonalSublayers.append(WTFMove(platformLayer));
@@ -4193 +4185 @@
 void GraphicsLayerCA::noteLayerPropertyChanged(LayerChangeFlags flags, ScheduleFlushOrNot scheduleFlush)
 {
+    if (beingDestroyed())
+        return;
+
     bool hadUncommittedChanges = !!m_uncommittedChanges;
     bool oldCanThrottleLayerFlush = canThrottleLayerFlush();

trunk/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.h

@@ -50 +50 @@
 class GraphicsLayerCA : public GraphicsLayer, public PlatformCALayerClient {
 public:
-
     WEBCORE_EXPORT explicit GraphicsLayerCA(Type, GraphicsLayerClient&);
     WEBCORE_EXPORT virtual ~GraphicsLayerCA();
@@ -63 +62 @@
     PlatformCALayer* platformCALayer() const { return primaryLayer(); }
 
-    WEBCORE_EXPORT bool setChildren(const Vector<GraphicsLayer*>&) override;
-    WEBCORE_EXPORT void addChild(GraphicsLayer*) override;
-    WEBCORE_EXPORT void addChildAtIndex(GraphicsLayer*, int index) override;
-    WEBCORE_EXPORT void addChildAbove(GraphicsLayer*, GraphicsLayer* sibling) override;
-    WEBCORE_EXPORT void addChildBelow(GraphicsLayer*, GraphicsLayer* sibling) override;
-    WEBCORE_EXPORT bool replaceChild(GraphicsLayer* oldChild, GraphicsLayer* newChild) override;
+    WEBCORE_EXPORT bool setChildren(Vector<Ref<GraphicsLayer>>&&) override;
+    WEBCORE_EXPORT void addChild(Ref<GraphicsLayer>&&) override;
+    WEBCORE_EXPORT void addChildAtIndex(Ref<GraphicsLayer>&&, int index) override;
+    WEBCORE_EXPORT void addChildAbove(Ref<GraphicsLayer>&&, GraphicsLayer* sibling) override;
+    WEBCORE_EXPORT void addChildBelow(Ref<GraphicsLayer>&&, GraphicsLayer* sibling) override;
+    WEBCORE_EXPORT bool replaceChild(GraphicsLayer* oldChild, Ref<GraphicsLayer>&& newChild) override;
 
     WEBCORE_EXPORT void removeFromParent() override;
 
-    WEBCORE_EXPORT void setMaskLayer(GraphicsLayer*) override;
+    WEBCORE_EXPORT void setMaskLayer(RefPtr<GraphicsLayer>&&) override;
     WEBCORE_EXPORT void setReplicatedLayer(GraphicsLayer*) override;
 

trunk/Source/WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.cpp

@@ -30 +30 @@
 namespace WebCore {
 
-std::unique_ptr<GraphicsLayer> GraphicsLayer::create(GraphicsLayerFactory* factory, GraphicsLayerClient& client, Type layerType)
+Ref<GraphicsLayer> GraphicsLayer::create(GraphicsLayerFactory* factory, GraphicsLayerClient& client, Type layerType)
 {
     if (!factory)
-        return std::make_unique<GraphicsLayerTextureMapper>(layerType, client);
+        return adoptRef(*new GraphicsLayerTextureMapper(layerType, client));
 
     return factory->createGraphicsLayer(layerType, client);
@@ -94 +94 @@
 }
 
-bool GraphicsLayerTextureMapper::setChildren(const Vector<GraphicsLayer*>& children)
-{
-    if (GraphicsLayer::setChildren(children)) {
+bool GraphicsLayerTextureMapper::setChildren(Vector<Ref<GraphicsLayer>>&& children)
+{
+    if (GraphicsLayer::setChildren(WTFMove(children))) {
         notifyChange(ChildrenChange);
         return true;
@@ -103 +103 @@
 }
 
-void GraphicsLayerTextureMapper::addChild(GraphicsLayer* layer)
+void GraphicsLayerTextureMapper::addChild(Ref<GraphicsLayer>&& layer)
 {
     notifyChange(ChildrenChange);
-    GraphicsLayer::addChild(layer);
-}
-
-void GraphicsLayerTextureMapper::addChildAtIndex(GraphicsLayer* layer, int index)
-{
-    GraphicsLayer::addChildAtIndex(layer, index);
+    GraphicsLayer::addChild(WTFMove(layer));
+}
+
+void GraphicsLayerTextureMapper::addChildAtIndex(Ref<GraphicsLayer>&& layer, int index)
+{
+    GraphicsLayer::addChildAtIndex(WTFMove(layer), index);
     notifyChange(ChildrenChange);
 }
 
-void GraphicsLayerTextureMapper::addChildAbove(GraphicsLayer* layer, GraphicsLayer* sibling)
-{
-    GraphicsLayer::addChildAbove(layer, sibling);
+void GraphicsLayerTextureMapper::addChildAbove(Ref<GraphicsLayer>&& layer, GraphicsLayer* sibling)
+{
+    GraphicsLayer::addChildAbove(WTFMove(layer), sibling);
     notifyChange(ChildrenChange);
 }
 
-void GraphicsLayerTextureMapper::addChildBelow(GraphicsLayer* layer, GraphicsLayer* sibling)
-{
-    GraphicsLayer::addChildBelow(layer, sibling);
+void GraphicsLayerTextureMapper::addChildBelow(Ref<GraphicsLayer>&& layer, GraphicsLayer* sibling)
+{
+    GraphicsLayer::addChildBelow(WTFMove(layer), sibling);
     notifyChange(ChildrenChange);
 }
 
-bool GraphicsLayerTextureMapper::replaceChild(GraphicsLayer* oldChild, GraphicsLayer* newChild)
-{
-    if (GraphicsLayer::replaceChild(oldChild, newChild)) {
+bool GraphicsLayerTextureMapper::replaceChild(GraphicsLayer* oldChild, Ref<GraphicsLayer>&& newChild)
+{
+    if (GraphicsLayer::replaceChild(oldChild, WTFMove(newChild))) {
         notifyChange(ChildrenChange);
         return true;
@@ -136 +136 @@
 }
 
-void GraphicsLayerTextureMapper::setMaskLayer(GraphicsLayer* value)
+void GraphicsLayerTextureMapper::setMaskLayer(RefPtr<GraphicsLayer>&& value)
 {
     if (value == maskLayer())
         return;
-    GraphicsLayer::setMaskLayer(value);
+
+    GraphicsLayer* rawLayer = value.get();
+    GraphicsLayer::setMaskLayer(WTFMove(value));
     notifyChange(MaskLayerChange);
 
-    if (!value)
-        return;
-    value->setSize(size());
-    value->setContentsVisible(contentsAreVisible());
+    if (!rawLayer)
+        return;
+    rawLayer->setSize(size());
+    rawLayer->setContentsVisible(contentsAreVisible());
 }
 
@@ -392 +394 @@
         return;
 
-    if (m_changeMask & ChildrenChange)
-        m_layer.setChildren(children());
+    if (m_changeMask & ChildrenChange) {
+        Vector<GraphicsLayer*> rawChildren;
+        rawChildren.reserveInitialCapacity(children().size());
+        for (auto& layer : children())
+            rawChildren.uncheckedAppend(layer.ptr());
+        m_layer.setChildren(rawChildren);
+    }
 
     if (m_changeMask & MaskLayerChange)
@@ -478 +485 @@
     if (replicaLayer())
         replicaLayer()->flushCompositingState(rect);
-    for (auto* child : children())
+    for (auto& child : children())
         child->flushCompositingState(rect);
 }
@@ -493 +500 @@
     if (replicaLayer())
         downcast<GraphicsLayerTextureMapper>(*replicaLayer()).updateBackingStoreIfNeeded();
-    for (auto* child : children())
-        downcast<GraphicsLayerTextureMapper>(*child).updateBackingStoreIncludingSubLayers();
+    for (auto& child : children())
+        downcast<GraphicsLayerTextureMapper>(child.get()).updateBackingStoreIncludingSubLayers();
 }
 

trunk/Source/WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.h

@@ -40 +40 @@
 
     // GraphicsLayer
-    bool setChildren(const Vector<GraphicsLayer*>&) override;
-    void addChild(GraphicsLayer*) override;
-    void addChildAtIndex(GraphicsLayer*, int index) override;
-    void addChildAbove(GraphicsLayer*, GraphicsLayer* sibling) override;
-    void addChildBelow(GraphicsLayer*, GraphicsLayer* sibling) override;
-    bool replaceChild(GraphicsLayer* oldChild, GraphicsLayer* newChild) override;
+    bool setChildren(Vector<Ref<GraphicsLayer>>&&) override;
+    void addChild(Ref<GraphicsLayer>&&) override;
+    void addChildAtIndex(Ref<GraphicsLayer>&&, int index) override;
+    void addChildAbove(Ref<GraphicsLayer>&&, GraphicsLayer* sibling) override;
+    void addChildBelow(Ref<GraphicsLayer>&&, GraphicsLayer* sibling) override;
+    bool replaceChild(GraphicsLayer* oldChild, Ref<GraphicsLayer>&& newChild) override;
 
-    void setMaskLayer(GraphicsLayer*) override;
+    void setMaskLayer(RefPtr<GraphicsLayer>&&) override;
     void setReplicatedByLayer(GraphicsLayer*) override;
     void setPosition(const FloatPoint&) override;

trunk/Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.cpp

@@ -47 +47 @@
 namespace WebCore {
 
-std::unique_ptr<GraphicsLayer> GraphicsLayer::create(GraphicsLayerFactory* factory, GraphicsLayerClient& client, Type layerType)
+Ref<GraphicsLayer> GraphicsLayer::create(GraphicsLayerFactory* factory, GraphicsLayerClient& client, Type layerType)
 {
     if (!factory)
-        return std::make_unique<CoordinatedGraphicsLayer>(layerType, client);
+        return adoptRef(*new CoordinatedGraphicsLayer(layerType, client));
 
     return factory->createGraphicsLayer(layerType, client);
@@ -98 +98 @@
     m_shouldUpdateVisibleRect = true;
     for (auto& child : children())
-        downcast<CoordinatedGraphicsLayer>(*child).setShouldUpdateVisibleRect();
+        downcast<CoordinatedGraphicsLayer>(child.get()).setShouldUpdateVisibleRect();
     if (replicaLayer())
         downcast<CoordinatedGraphicsLayer>(*replicaLayer()).setShouldUpdateVisibleRect();
@@ -159 +159 @@
 }
 
-bool CoordinatedGraphicsLayer::setChildren(const Vector<GraphicsLayer*>& children)
-{
-    bool ok = GraphicsLayer::setChildren(children);
+bool CoordinatedGraphicsLayer::setChildren(Vector<Ref<GraphicsLayer>>&& children)
+{
+    bool ok = GraphicsLayer::setChildren(WTFMove(children));
     if (!ok)
         return false;
@@ -168 +168 @@
 }
 
-void CoordinatedGraphicsLayer::addChild(GraphicsLayer* layer)
-{
-    GraphicsLayer::addChild(layer);
-    downcast<CoordinatedGraphicsLayer>(*layer).setCoordinatorIncludingSubLayersIfNeeded(m_coordinator);
+void CoordinatedGraphicsLayer::addChild(Ref<GraphicsLayer>&& layer)
+{
+    GraphicsLayer* rawLayer = layer.ptr();
+    GraphicsLayer::addChild(WTFMove(layer));
+    downcast<CoordinatedGraphicsLayer>(*rawLayer).setCoordinatorIncludingSubLayersIfNeeded(m_coordinator);
     didChangeChildren();
 }
 
-void CoordinatedGraphicsLayer::addChildAtIndex(GraphicsLayer* layer, int index)
-{
-    GraphicsLayer::addChildAtIndex(layer, index);
-    downcast<CoordinatedGraphicsLayer>(*layer).setCoordinatorIncludingSubLayersIfNeeded(m_coordinator);
+void CoordinatedGraphicsLayer::addChildAtIndex(Ref<GraphicsLayer>&& layer, int index)
+{
+    GraphicsLayer* rawLayer = layer.ptr();
+    GraphicsLayer::addChildAtIndex(WTFMove(layer), index);
+    downcast<CoordinatedGraphicsLayer>(*rawLayer).setCoordinatorIncludingSubLayersIfNeeded(m_coordinator);
     didChangeChildren();
 }
 
-void CoordinatedGraphicsLayer::addChildAbove(GraphicsLayer* layer, GraphicsLayer* sibling)
-{
-    GraphicsLayer::addChildAbove(layer, sibling);
-    downcast<CoordinatedGraphicsLayer>(*layer).setCoordinatorIncludingSubLayersIfNeeded(m_coordinator);
+void CoordinatedGraphicsLayer::addChildAbove(Ref<GraphicsLayer>&& layer, GraphicsLayer* sibling)
+{
+    GraphicsLayer* rawLayer = layer.ptr();
+    GraphicsLayer::addChildAbove(WTFMove(layer), sibling);
+    downcast<CoordinatedGraphicsLayer>(*rawLayer).setCoordinatorIncludingSubLayersIfNeeded(m_coordinator);
     didChangeChildren();
 }
 
-void CoordinatedGraphicsLayer::addChildBelow(GraphicsLayer* layer, GraphicsLayer* sibling)
-{
-    GraphicsLayer::addChildBelow(layer, sibling);
-    downcast<CoordinatedGraphicsLayer>(*layer).setCoordinatorIncludingSubLayersIfNeeded(m_coordinator);
+void CoordinatedGraphicsLayer::addChildBelow(Ref<GraphicsLayer>&& layer, GraphicsLayer* sibling)
+{
+    GraphicsLayer* rawLayer = layer.ptr();
+    GraphicsLayer::addChildBelow(WTFMove(layer), sibling);
+    downcast<CoordinatedGraphicsLayer>(*rawLayer).setCoordinatorIncludingSubLayersIfNeeded(m_coordinator);
     didChangeChildren();
 }
 
-bool CoordinatedGraphicsLayer::replaceChild(GraphicsLayer* oldChild, GraphicsLayer* newChild)
-{
-    bool ok = GraphicsLayer::replaceChild(oldChild, newChild);
+bool CoordinatedGraphicsLayer::replaceChild(GraphicsLayer* oldChild, Ref<GraphicsLayer>&& newChild)
+{
+    GraphicsLayer* rawLayer = newChild.ptr();
+    bool ok = GraphicsLayer::replaceChild(oldChild, WTFMove(newChild));
     if (!ok)
         return false;
-    downcast<CoordinatedGraphicsLayer>(*newChild).setCoordinatorIncludingSubLayersIfNeeded(m_coordinator);
+    downcast<CoordinatedGraphicsLayer>(*rawLayer).setCoordinatorIncludingSubLayersIfNeeded(m_coordinator);
     didChangeChildren();
     return true;
@@ -496 +501 @@
 }
 
-void CoordinatedGraphicsLayer::setMaskLayer(GraphicsLayer* layer)
+void CoordinatedGraphicsLayer::setMaskLayer(RefPtr<GraphicsLayer>&& layer)
 {
     if (layer == maskLayer())
         return;
 
-    GraphicsLayer::setMaskLayer(layer);
-
-    if (!layer)
-        return;
-
-    layer->setSize(size());
-    layer->setContentsVisible(contentsAreVisible());
+    GraphicsLayer* rawLayer = layer.get();
+    GraphicsLayer::setMaskLayer(WTFMove(layer));
+
+    if (!rawLayer)
+        return;
+
+    rawLayer->setSize(size());
+    rawLayer->setContentsVisible(contentsAreVisible());
 
     m_nicosia.delta.maskChanged = true;
@@ -733 +739 @@
                 if (localDelta.childrenChanged) {
                     state.children = WTF::map(children(),
-                        [](auto* child)
+                        [](auto& child)
                         {
-                            return downcast<CoordinatedGraphicsLayer>(child)->m_nicosia.layer;
+                            return downcast<CoordinatedGraphicsLayer>(child.get()).m_nicosia.layer;
                         });
                 }
@@ -785 +791 @@
 
     for (auto& child : children())
-        downcast<CoordinatedGraphicsLayer>(*child).syncPendingStateChangesIncludingSubLayers();
+        downcast<CoordinatedGraphicsLayer>(child.get()).syncPendingStateChangesIncludingSubLayers();
 }
 
@@ -838 +844 @@
 
     for (auto& child : children())
-        downcast<CoordinatedGraphicsLayer>(*child).updateContentBuffersIncludingSubLayers();
+        downcast<CoordinatedGraphicsLayer>(child.get()).updateContentBuffersIncludingSubLayers();
 }
 
@@ -1008 +1014 @@
     coordinator->attachLayer(this);
     for (auto& child : children())
-        downcast<CoordinatedGraphicsLayer>(*child).setCoordinatorIncludingSubLayersIfNeeded(coordinator);
+        downcast<CoordinatedGraphicsLayer>(child.get()).setCoordinatorIncludingSubLayersIfNeeded(coordinator);
 }
 

trunk/Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.h

@@ -64 +64 @@
 
     // Reimplementations from GraphicsLayer.h.
-    bool setChildren(const Vector<GraphicsLayer*>&) override;
-    void addChild(GraphicsLayer*) override;
-    void addChildAtIndex(GraphicsLayer*, int) override;
-    void addChildAbove(GraphicsLayer*, GraphicsLayer*) override;
-    void addChildBelow(GraphicsLayer*, GraphicsLayer*) override;
-    bool replaceChild(GraphicsLayer*, GraphicsLayer*) override;
+    bool setChildren(Vector<Ref<GraphicsLayer>>&&) override;
+    void addChild(Ref<GraphicsLayer>&&) override;
+    void addChildAtIndex(Ref<GraphicsLayer>&&, int) override;
+    void addChildAbove(Ref<GraphicsLayer>&&, GraphicsLayer*) override;
+    void addChildBelow(Ref<GraphicsLayer>&&, GraphicsLayer*) override;
+    bool replaceChild(GraphicsLayer*, Ref<GraphicsLayer>&&) override;
     void removeFromParent() override;
     void setPosition(const FloatPoint&) override;
@@ -92 +92 @@
     bool shouldDirectlyCompositeImage(Image*) const override;
     void setContentsToPlatformLayer(PlatformLayer*, ContentsLayerPurpose) override;
-    void setMaskLayer(GraphicsLayer*) override;
+    void setMaskLayer(RefPtr<GraphicsLayer>&&) override;
     void setReplicatedByLayer(GraphicsLayer*) override;
     void setNeedsDisplay() override;

trunk/Source/WebCore/platform/graphics/win/GraphicsLayerDirect2D.cpp

@@ -47 +47 @@
 namespace WebCore {
 
-
-std::unique_ptr<GraphicsLayer> GraphicsLayer::create(GraphicsLayerFactory* factory, GraphicsLayerClient& client, Type layerType)
+Ref<GraphicsLayer> GraphicsLayer::create(GraphicsLayerFactory* factory, GraphicsLayerClient& client, Type layerType)
 {
-    std::unique_ptr<GraphicsLayer> graphicsLayer;
-    if (!factory)
-        graphicsLayer = std::make_unique<GraphicsLayerDirect2D>(layerType, client);
-    else
-        graphicsLayer = factory->createGraphicsLayer(layerType, client);
-
-    graphicsLayer->initialize(layerType);
-
-    return graphicsLayer;
+    if (factory) {
+        auto layer = factory->createGraphicsLayer(layerType, client);
+        layer->initialize(layerType);
+        return layer;
+    }
+    
+    auto layer = adoptRef(*new GraphicsLayerCA(layerType, client);
+    layer->initialize(layerType);
+    return layer;
 }
 

trunk/Source/WebCore/rendering/RenderLayerBacking.cpp

@@ -255 +255 @@
 }
 
-std::unique_ptr<GraphicsLayer> RenderLayerBacking::createGraphicsLayer(const String& name, GraphicsLayer::Type layerType)
+Ref<GraphicsLayer> RenderLayerBacking::createGraphicsLayer(const String& name, GraphicsLayer::Type layerType)
 {
     auto* graphicsLayerFactory = renderer().page().chrome().client().graphicsLayerFactory();
 
-    std::unique_ptr<GraphicsLayer> graphicsLayer = GraphicsLayer::create(graphicsLayerFactory, *this, layerType);
+    auto graphicsLayer = GraphicsLayer::create(graphicsLayerFactory, *this, layerType);
 
     graphicsLayer->setName(name);
@@ -402 +402 @@
     if (m_isFrameLayerWithTiledBacking) {
         m_childContainmentLayer = createGraphicsLayer("Page TiledBacking containment");
-        m_graphicsLayer->addChild(m_childContainmentLayer.get());
+        m_graphicsLayer->addChild(*m_childContainmentLayer);
     }
 
@@ -710 +710 @@
     if (auto* flatteningLayer = tileCacheFlatteningLayer()) {
         if (layerConfigChanged || flatteningLayer->parent() != m_graphicsLayer.get())
-            m_graphicsLayer->addChild(flatteningLayer);
+            m_graphicsLayer->addChild(*flatteningLayer);
     }
 
@@ -1303 +1303 @@
         m_contentsContainmentLayer->removeAllChildren();
         if (m_ancestorClippingLayer)
-            m_ancestorClippingLayer->addChild(m_contentsContainmentLayer.get());
+            m_ancestorClippingLayer->addChild(*m_contentsContainmentLayer);
     }
     
     if (m_backgroundLayer)
-        m_contentsContainmentLayer->addChild(m_backgroundLayer.get());
+        m_contentsContainmentLayer->addChild(*m_backgroundLayer);
 
     if (m_contentsContainmentLayer)
-        m_contentsContainmentLayer->addChild(m_graphicsLayer.get());
+        m_contentsContainmentLayer->addChild(*m_graphicsLayer);
     else if (m_ancestorClippingLayer)
-        m_ancestorClippingLayer->addChild(m_graphicsLayer.get());
+        m_ancestorClippingLayer->addChild(*m_graphicsLayer);
 
     if (m_childContainmentLayer) {
         m_childContainmentLayer->removeFromParent();
-        m_graphicsLayer->addChild(m_childContainmentLayer.get());
+        m_graphicsLayer->addChild(*m_childContainmentLayer);
     }
 
@@ -1322 +1322 @@
         auto* superlayer = m_childContainmentLayer ? m_childContainmentLayer.get() : m_graphicsLayer.get();
         m_scrollingLayer->removeFromParent();
-        superlayer->addChild(m_scrollingLayer.get());
+        superlayer->addChild(*m_scrollingLayer);
     }
 
@@ -1330 +1330 @@
     if (m_layerForHorizontalScrollbar) {
         m_layerForHorizontalScrollbar->removeFromParent();
-        m_graphicsLayer->addChild(m_layerForHorizontalScrollbar.get());
+        m_graphicsLayer->addChild(*m_layerForHorizontalScrollbar);
     }
     if (m_layerForVerticalScrollbar) {
         m_layerForVerticalScrollbar->removeFromParent();
-        m_graphicsLayer->addChild(m_layerForVerticalScrollbar.get());
+        m_graphicsLayer->addChild(*m_layerForVerticalScrollbar);
     }
     if (m_layerForScrollCorner) {
         m_layerForScrollCorner->removeFromParent();
-        m_graphicsLayer->addChild(m_layerForScrollCorner.get());
+        m_graphicsLayer->addChild(*m_layerForScrollCorner);
     }
 }
@@ -1691 +1691 @@
             m_maskLayer->setPaintingPhase(maskPhases);
             layerChanged = true;
-            m_graphicsLayer->setMaskLayer(m_maskLayer.get());
+            m_graphicsLayer->setMaskLayer(m_maskLayer.copyRef());
         }
     } else if (m_maskLayer) {
@@ -1722 +1722 @@
                 m_childClippingMaskLayer->setDrawsContent(true);
                 m_childClippingMaskLayer->setPaintingPhase(GraphicsLayerPaintChildClippingMask);
-                clippingLayer()->setMaskLayer(m_childClippingMaskLayer.get());
+                clippingLayer()->setMaskLayer(m_childClippingMaskLayer.copyRef());
             }
         }
@@ -1755 +1755 @@
             paintPhase |= GraphicsLayerPaintForeground;
         m_scrollingContentsLayer->setPaintingPhase(paintPhase);
-        m_scrollingLayer->addChild(m_scrollingContentsLayer.get());
+        m_scrollingLayer->addChild(*m_scrollingContentsLayer);
     } else {
         compositor().willRemoveScrollingLayerWithBacking(m_owningLayer, *this);

trunk/Source/WebCore/rendering/RenderLayerBacking.h

@@ -137 +137 @@
     void setIsScrollCoordinatedWithViewportConstrainedRole(bool);
 
-    bool hasMaskLayer() const { return m_maskLayer != 0; }
+    bool hasMaskLayer() const { return m_maskLayer; }
     bool hasChildClippingMaskLayer() const { return m_childClippingMaskLayer != nullptr; }
 
@@ -268 +268 @@
     LayoutRect compositedBoundsIncludingMargin() const;
     
-    std::unique_ptr<GraphicsLayer> createGraphicsLayer(const String&, GraphicsLayer::Type = GraphicsLayer::Type::Normal);
+    Ref<GraphicsLayer> createGraphicsLayer(const String&, GraphicsLayer::Type = GraphicsLayer::Type::Normal);
 
     RenderLayerModelObject& renderer() const { return m_owningLayer.renderer(); }
@@ -356 +356 @@
     RenderLayer& m_owningLayer;
 
-    std::unique_ptr<GraphicsLayer> m_ancestorClippingLayer; // Only used if we are clipped by an ancestor which is not a stacking context.
-    std::unique_ptr<GraphicsLayer> m_contentsContainmentLayer; // Only used if we have a background layer; takes the transform.
-    std::unique_ptr<GraphicsLayer> m_graphicsLayer;
-    std::unique_ptr<GraphicsLayer> m_foregroundLayer; // Only used in cases where we need to draw the foreground separately.
-    std::unique_ptr<GraphicsLayer> m_backgroundLayer; // Only used in cases where we need to draw the background separately.
-    std::unique_ptr<GraphicsLayer> m_childContainmentLayer; // Only used if we have clipping on a stacking context with compositing children, or if the layer has a tile cache.
-    std::unique_ptr<GraphicsLayer> m_maskLayer; // Only used if we have a mask and/or clip-path.
-    std::unique_ptr<GraphicsLayer> m_childClippingMaskLayer; // Only used if we have to clip child layers or accelerated contents with border radius or clip-path.
-
-    std::unique_ptr<GraphicsLayer> m_layerForHorizontalScrollbar;
-    std::unique_ptr<GraphicsLayer> m_layerForVerticalScrollbar;
-    std::unique_ptr<GraphicsLayer> m_layerForScrollCorner;
-
-    std::unique_ptr<GraphicsLayer> m_scrollingLayer; // Only used if the layer is using composited scrolling.
-    std::unique_ptr<GraphicsLayer> m_scrollingContentsLayer; // Only used if the layer is using composited scrolling.
+    RefPtr<GraphicsLayer> m_ancestorClippingLayer; // Only used if we are clipped by an ancestor which is not a stacking context.
+    RefPtr<GraphicsLayer> m_contentsContainmentLayer; // Only used if we have a background layer; takes the transform.
+    RefPtr<GraphicsLayer> m_graphicsLayer;
+    RefPtr<GraphicsLayer> m_foregroundLayer; // Only used in cases where we need to draw the foreground separately.
+    RefPtr<GraphicsLayer> m_backgroundLayer; // Only used in cases where we need to draw the background separately.
+    RefPtr<GraphicsLayer> m_childContainmentLayer; // Only used if we have clipping on a stacking context with compositing children, or if the layer has a tile cache.
+    RefPtr<GraphicsLayer> m_maskLayer; // Only used if we have a mask and/or clip-path.
+    RefPtr<GraphicsLayer> m_childClippingMaskLayer; // Only used if we have to clip child layers or accelerated contents with border radius or clip-path.
+
+    RefPtr<GraphicsLayer> m_layerForHorizontalScrollbar;
+    RefPtr<GraphicsLayer> m_layerForVerticalScrollbar;
+    RefPtr<GraphicsLayer> m_layerForScrollCorner;
+
+    RefPtr<GraphicsLayer> m_scrollingLayer; // Only used if the layer is using composited scrolling.
+    RefPtr<GraphicsLayer> m_scrollingContentsLayer; // Only used if the layer is using composited scrolling.
 
     LayoutRect m_compositedBounds;

trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp

@@ -759 +759 @@
     if (needHierarchyUpdate) {
         // Update the hierarchy of the compositing layers.
-        Vector<GraphicsLayer*> childList;
+        Vector<Ref<GraphicsLayer>> childList;
         rebuildCompositingLayerTree(*updateRoot, childList, 0);
 
@@ -770 +770 @@
                 destroyRootLayer();
             else if (m_rootContentLayer)
-                m_rootContentLayer->setChildren(childList);
+                m_rootContentLayer->setChildren(WTFMove(childList));
         }
         
@@ -803 +803 @@
 }
 
-void RenderLayerCompositor::appendDocumentOverlayLayers(Vector<GraphicsLayer*>& childList)
+void RenderLayerCompositor::appendDocumentOverlayLayers(Vector<Ref<GraphicsLayer>>& childList)
 {
     if (!isMainFrameCompositor() || !m_compositing)
         return;
 
-    childList.append(&page().pageOverlayController().layerWithDocumentOverlays());
+    Ref<GraphicsLayer> overlayHost = page().pageOverlayController().layerWithDocumentOverlays();
+    childList.append(WTFMove(overlayHost));
 }
 
@@ -1524 +1525 @@
         auto* hostedLayer = childLayer.backing()->childForSuperlayers();
         
-        hostingLayer->addChild(hostedLayer);
+        hostingLayer->addChild(*hostedLayer);
     } else
         childLayer.backing()->childForSuperlayers()->removeFromParent();
@@ -1546 +1547 @@
 #endif
 
-void RenderLayerCompositor::rebuildCompositingLayerTree(RenderLayer& layer, Vector<GraphicsLayer*>& childLayersOfEnclosingLayer, int depth)
+void RenderLayerCompositor::rebuildCompositingLayerTree(RenderLayer& layer, Vector<Ref<GraphicsLayer>>& childLayersOfEnclosingLayer, int depth)
 {
     // Make the layer compositing if necessary, and set up clipping and content layers.
@@ -1582 +1583 @@
     // If this layer has backing, then we are collecting its children, otherwise appending
     // to the compositing child list of an enclosing layer.
-    Vector<GraphicsLayer*> layerChildren;
-    Vector<GraphicsLayer*>& childList = layerBacking ? layerChildren : childLayersOfEnclosingLayer;
+    Vector<Ref<GraphicsLayer>> layerChildren;
+    auto& childList = layerBacking ? layerChildren : childLayersOfEnclosingLayer;
 
 #if !ASSERT_DISABLED
@@ -1595 +1596 @@
         // If a negative z-order child is compositing, we get a foreground layer which needs to get parented.
         if (layerBacking && layerBacking->foregroundLayer())
-            childList.append(layerBacking->foregroundLayer());
+            childList.append(*layerBacking->foregroundLayer());
     }
 
@@ -1614 +1615 @@
 
         if (!parented)
-            layerBacking->parentForSublayers()->setChildren(layerChildren);
+            layerBacking->parentForSublayers()->setChildren(WTFMove(layerChildren));
 
         // If the layer has a clipping layer the overflow controls layers will be siblings of the clipping layer.
@@ -1621 +1622 @@
             if (auto* overflowControlLayer = layerBacking->layerForHorizontalScrollbar()) {
                 overflowControlLayer->removeFromParent();
-                layerBacking->parentForSublayers()->addChild(overflowControlLayer);
+                layerBacking->parentForSublayers()->addChild(*overflowControlLayer);
             }
 
             if (auto* overflowControlLayer = layerBacking->layerForVerticalScrollbar()) {
                 overflowControlLayer->removeFromParent();
-                layerBacking->parentForSublayers()->addChild(overflowControlLayer);
+                layerBacking->parentForSublayers()->addChild(*overflowControlLayer);
             }
 
             if (auto* overflowControlLayer = layerBacking->layerForScrollCorner()) {
                 overflowControlLayer->removeFromParent();
-                layerBacking->parentForSublayers()->addChild(overflowControlLayer);
+                layerBacking->parentForSublayers()->addChild(*overflowControlLayer);
             }
         }
 
-        childLayersOfEnclosingLayer.append(layerBacking->childForSuperlayers());
+        childLayersOfEnclosingLayer.append(*layerBacking->childForSuperlayers());
     }
     
@@ -1810 +1811 @@
     auto* hostingLayer = backing->parentForSublayers();
     auto* rootLayer = innerCompositor->rootGraphicsLayer();
-    if (hostingLayer->children().size() != 1 || hostingLayer->children()[0] != rootLayer) {
+    if (hostingLayer->children().size() != 1 || hostingLayer->children()[0].ptr() != rootLayer) {
         hostingLayer->removeAllChildren();
-        hostingLayer->addChild(rootLayer);
+        hostingLayer->addChild(*rootLayer);
     }
     return true;
@@ -3047 +3048 @@
         m_layerForTopOverhangArea = GraphicsLayer::create(graphicsLayerFactory(), *this);
         m_layerForTopOverhangArea->setName("top overhang");
-        m_scrollLayer->addChildBelow(m_layerForTopOverhangArea.get(), m_rootContentLayer.get());
+        m_scrollLayer->addChildBelow(*m_layerForTopOverhangArea, m_rootContentLayer.get());
     }
 
@@ -3069 +3070 @@
         m_layerForBottomOverhangArea = GraphicsLayer::create(graphicsLayerFactory(), *this);
         m_layerForBottomOverhangArea->setName("bottom overhang");
-        m_scrollLayer->addChildBelow(m_layerForBottomOverhangArea.get(), m_rootContentLayer.get());
+        m_scrollLayer->addChildBelow(*m_layerForBottomOverhangArea, m_rootContentLayer.get());
     }
 
@@ -3098 +3099 @@
         m_layerForHeader = GraphicsLayer::create(graphicsLayerFactory(), *this);
         m_layerForHeader->setName("header");
-        m_scrollLayer->addChildAbove(m_layerForHeader.get(), m_rootContentLayer.get());
+        m_scrollLayer->addChildAbove(*m_layerForHeader, m_rootContentLayer.get());
         m_renderView.frameView().addPaintPendingMilestones(DidFirstFlushForHeaderLayer);
     }
@@ -3136 +3137 @@
         m_layerForFooter = GraphicsLayer::create(graphicsLayerFactory(), *this);
         m_layerForFooter->setName("footer");
-        m_scrollLayer->addChildAbove(m_layerForFooter.get(), m_rootContentLayer.get());
+        m_scrollLayer->addChildAbove(*m_layerForFooter, m_rootContentLayer.get());
     }
 
@@ -3259 +3260 @@
             // We want the overhang areas layer to be positioned below the frame contents,
             // so insert it below the clip layer.
-            m_overflowControlsHostLayer->addChildBelow(m_layerForOverhangAreas.get(), m_clipLayer.get());
+            m_overflowControlsHostLayer->addChildBelow(*m_layerForOverhangAreas, m_clipLayer.get());
         }
     } else if (m_layerForOverhangAreas) {
@@ -3275 +3276 @@
             m_contentShadowLayer->setCustomAppearance(GraphicsLayer::CustomAppearance::ScrollingShadow);
 
-            m_scrollLayer->addChildBelow(m_contentShadowLayer.get(), m_rootContentLayer.get());
+            m_scrollLayer->addChildBelow(*m_contentShadowLayer, m_rootContentLayer.get());
         }
     } else if (m_contentShadowLayer) {
@@ -3292 +3293 @@
             m_layerForHorizontalScrollbar->setAcceleratesDrawing(acceleratedDrawingEnabled());
 #endif
-            m_overflowControlsHostLayer->addChild(m_layerForHorizontalScrollbar.get());
+            m_overflowControlsHostLayer->addChild(*m_layerForHorizontalScrollbar);
 
             if (auto* scrollingCoordinator = this->scrollingCoordinator())
@@ -3314 +3315 @@
             m_layerForVerticalScrollbar->setAcceleratesDrawing(acceleratedDrawingEnabled());
 #endif
-            m_overflowControlsHostLayer->addChild(m_layerForVerticalScrollbar.get());
+            m_overflowControlsHostLayer->addChild(*m_layerForVerticalScrollbar);
 
             if (auto* scrollingCoordinator = this->scrollingCoordinator())
@@ -3336 +3337 @@
             m_layerForScrollCorner->setAcceleratesDrawing(acceleratedDrawingEnabled());
 #endif
-            m_overflowControlsHostLayer->addChild(m_layerForScrollCorner.get());
+            m_overflowControlsHostLayer->addChild(*m_layerForScrollCorner);
         }
     } else if (m_layerForScrollCorner) {
@@ -3388 +3389 @@
 
             // Hook them up
-            m_overflowControlsHostLayer->addChild(m_clipLayer.get());
-            m_clipLayer->addChild(m_scrollLayer.get());
-            m_scrollLayer->addChild(m_rootContentLayer.get());
+            m_overflowControlsHostLayer->addChild(*m_clipLayer);
+            m_clipLayer->addChild(*m_scrollLayer);
+            m_scrollLayer->addChild(*m_rootContentLayer);
 
             m_clipLayer->setSize(m_renderView.frameView().sizeForVisibleContent());
@@ -3561 +3562 @@
         return;
 
-    m_rootContentLayer->addChild(&page().pageOverlayController().layerWithDocumentOverlays());
+    Ref<GraphicsLayer> overlayHost = page().pageOverlayController().layerWithDocumentOverlays();
+    m_rootContentLayer->addChild(WTFMove(overlayHost));
 }
 

trunk/Source/WebCore/rendering/RenderLayerCompositor.h

@@ -377 +377 @@
 
     // Recurses down the tree, parenting descendant compositing layers and collecting an array of child layers for the current compositing layer.
-    void rebuildCompositingLayerTree(RenderLayer&, Vector<GraphicsLayer*>& childGraphicsLayersOfEnclosingLayer, int depth);
+    void rebuildCompositingLayerTree(RenderLayer&, Vector<Ref<GraphicsLayer>>& childGraphicsLayersOfEnclosingLayer, int depth);
 
     // Recurses down the tree, updating layer geometry only.
@@ -389 +389 @@
     bool isRunningTransformAnimation(RenderLayerModelObject&) const;
 
-    void appendDocumentOverlayLayers(Vector<GraphicsLayer*>&);
+    void appendDocumentOverlayLayers(Vector<Ref<GraphicsLayer>>&);
     bool hasAnyAdditionalCompositedLayers(const RenderLayer& rootLayer) const;
 
@@ -489 +489 @@
 private:
     RenderView& m_renderView;
-    std::unique_ptr<GraphicsLayer> m_rootContentLayer;
+    RefPtr<GraphicsLayer> m_rootContentLayer;
     Timer m_updateCompositingLayersTimer;
 
@@ -525 +525 @@
 
     // Enclosing clipping layer for iframe content
-    std::unique_ptr<GraphicsLayer> m_clipLayer;
-    std::unique_ptr<GraphicsLayer> m_scrollLayer;
+    RefPtr<GraphicsLayer> m_clipLayer;
+    RefPtr<GraphicsLayer> m_scrollLayer;
 
 #if PLATFORM(IOS)
@@ -536 +536 @@
 
     // Enclosing layer for overflow controls and the clipping layer
-    std::unique_ptr<GraphicsLayer> m_overflowControlsHostLayer;
+    RefPtr<GraphicsLayer> m_overflowControlsHostLayer;
 
     // Layers for overflow controls
-    std::unique_ptr<GraphicsLayer> m_layerForHorizontalScrollbar;
-    std::unique_ptr<GraphicsLayer> m_layerForVerticalScrollbar;
-    std::unique_ptr<GraphicsLayer> m_layerForScrollCorner;
+    RefPtr<GraphicsLayer> m_layerForHorizontalScrollbar;
+    RefPtr<GraphicsLayer> m_layerForVerticalScrollbar;
+    RefPtr<GraphicsLayer> m_layerForScrollCorner;
 #if ENABLE(RUBBER_BANDING)
-    std::unique_ptr<GraphicsLayer> m_layerForOverhangAreas;
-    std::unique_ptr<GraphicsLayer> m_contentShadowLayer;
-    std::unique_ptr<GraphicsLayer> m_layerForTopOverhangArea;
-    std::unique_ptr<GraphicsLayer> m_layerForBottomOverhangArea;
-    std::unique_ptr<GraphicsLayer> m_layerForHeader;
-    std::unique_ptr<GraphicsLayer> m_layerForFooter;
+    RefPtr<GraphicsLayer> m_layerForOverhangAreas;
+    RefPtr<GraphicsLayer> m_contentShadowLayer;
+    RefPtr<GraphicsLayer> m_layerForTopOverhangArea;
+    RefPtr<GraphicsLayer> m_layerForBottomOverhangArea;
+    RefPtr<GraphicsLayer> m_layerForHeader;
+    RefPtr<GraphicsLayer> m_layerForFooter;
 #endif
 

trunk/Source/WebKit/ChangeLog

@@ +1 @@
+2018-09-11  Simon Fraser  <simon.fraser@apple.com>
+
+        Make GraphicsLayers ref-counted, so their tree can persist when disconnected from RenderLayerBackings
+        https://bugs.webkit.org/show_bug.cgi?id=189521
+
+        Reviewed by Tim Horton.
+
+        Make GraphicsLayer be RefCounted<GraphicsLayer>. GraphicsLayers own their children, via a Vector<Ref<GraphicsLayer>>.
+        
+        RenderLayerBacking and other holders of GraphicsLayers use RefPtr<GraphicsLayer>.
+        
+        All the other changes are just to adapt to the new ownership patterns.
+        
+        I verified that no GraphicsLayers were leaked or abandoned after this change.
+
+        * WebProcess/WebCoreSupport/WebInspectorClient.cpp:
+        (WebKit::WebInspectorClient::~WebInspectorClient):
+        (WebKit::WebInspectorClient::showPaintRect):
+        (WebKit::WebInspectorClient::animationEndedForLayer):
+        * WebProcess/WebCoreSupport/WebInspectorClient.h:
+        * WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeContext.h:
+        * WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeContext.mm:
+        (WebKit::RemoteLayerTreeContext::createGraphicsLayer):
+        * WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.h:
+        * WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.mm:
+        (WebKit::RemoteLayerTreeDrawingArea::updateRootLayers):
+        (WebKit::RemoteLayerTreeDrawingArea::flushLayers):
+
 2018-09-12  Chris Dumez  <cdumez@apple.com>
 

trunk/Source/WebKit/WebProcess/WebCoreSupport/WebInspectorClient.cpp

@@ -67 +67 @@
 WebInspectorClient::~WebInspectorClient()
 {
-    for (auto layer : m_paintRectLayers) {
+    for (auto& layer : m_paintRectLayers)
         layer->removeFromParent();
-        delete layer;
-    }
+    
+    m_paintRectLayers.clear();
 
     if (m_paintRectOverlay && m_page->corePage())
@@ -153 +153 @@
         m_paintIndicatorLayerClient = std::make_unique<RepaintIndicatorLayerClient>(*this);
 
-    std::unique_ptr<GraphicsLayer> paintLayer = GraphicsLayer::create(m_page->drawingArea()->graphicsLayerFactory(), *m_paintIndicatorLayerClient);
+    auto paintLayer = GraphicsLayer::create(m_page->drawingArea()->graphicsLayerFactory(), *m_paintIndicatorLayerClient);
     
     paintLayer->setName("paint rect");
@@ -166 +166 @@
     fadeKeyframes.insert(std::make_unique<FloatAnimationValue>(0.25, 0));
     
-    RefPtr<Animation> opacityAnimation = Animation::create();
+    auto opacityAnimation = Animation::create();
     opacityAnimation->setDuration(0.25);
 
-    paintLayer->addAnimation(fadeKeyframes, FloatSize(), opacityAnimation.get(), "opacity"_s, 0);
-    
-    m_paintRectLayers.add(paintLayer.get());
+    paintLayer->addAnimation(fadeKeyframes, FloatSize(), opacityAnimation.ptr(), "opacity"_s, 0);
+    
+    GraphicsLayer& rawLayer = paintLayer.get();
+    m_paintRectLayers.add(WTFMove(paintLayer));
 
     GraphicsLayer& overlayRootLayer = m_paintRectOverlay->layer();
-    overlayRootLayer.addChild(paintLayer.release());
+    overlayRootLayer.addChild(rawLayer);
 }
 
 void WebInspectorClient::animationEndedForLayer(const GraphicsLayer* layer)
 {
-    const_cast<GraphicsLayer*>(layer)->removeFromParent();
-    m_paintRectLayers.remove(const_cast<GraphicsLayer*>(layer));
-    delete layer;
+    GraphicsLayer* nonConstLayer = const_cast<GraphicsLayer*>(layer);
+    nonConstLayer->removeFromParent();
+    m_paintRectLayers.remove(*nonConstLayer);
 }
 

trunk/Source/WebKit/WebProcess/WebCoreSupport/WebInspectorClient.h

@@ -85 +85 @@
     RefPtr<WebCore::PageOverlay> m_paintRectOverlay;
     std::unique_ptr<RepaintIndicatorLayerClient> m_paintIndicatorLayerClient;
-    HashSet<WebCore::GraphicsLayer*> m_paintRectLayers; // Ideally this would be HashSet<std::unique_ptr<GraphicsLayer>> but that doesn't work yet. webkit.org/b/136166
+    HashSet<Ref<WebCore::GraphicsLayer>> m_paintRectLayers;
 };
 

trunk/Source/WebKit/WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.cpp

@@ -86 +86 @@
     m_rootCompositingLayer = graphicsLayer;
     if (m_rootCompositingLayer)
-        m_rootLayer->addChildAtIndex(m_rootCompositingLayer, 0);
+        m_rootLayer->addChildAtIndex(*m_rootCompositingLayer, 0);
 }
 
@@ -99 +99 @@
     m_overlayCompositingLayer = graphicsLayer;
     if (m_overlayCompositingLayer)
-        m_rootLayer->addChild(m_overlayCompositingLayer);
+        m_rootLayer->addChild(*m_overlayCompositingLayer);
 }
 
@@ -232 +232 @@
 }
 
-std::unique_ptr<GraphicsLayer> CompositingCoordinator::createGraphicsLayer(GraphicsLayer::Type layerType, GraphicsLayerClient& client)
-{
-    CoordinatedGraphicsLayer* layer = new CoordinatedGraphicsLayer(layerType, client);
+Ref<GraphicsLayer> CompositingCoordinator::createGraphicsLayer(GraphicsLayer::Type layerType, GraphicsLayerClient& client)
+{
+    auto layer = adoptRef(*new CoordinatedGraphicsLayer(layerType, client));
     layer->setCoordinator(this);
     m_nicosia.state.layers.add(layer->compositionLayer());
-    m_registeredLayers.add(layer->id(), layer);
+    m_registeredLayers.add(layer->id(), layer.ptr());
     layer->setNeedsVisibleRectAdjustment();
-    notifyFlushRequired(layer);
-    return std::unique_ptr<GraphicsLayer>(layer);
+    notifyFlushRequired(layer.ptr());
+    return WTFMove(layer);
 }
 

trunk/Source/WebKit/WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.h

@@ -104 +104 @@
 
     // GraphicsLayerFactory
-    std::unique_ptr<WebCore::GraphicsLayer> createGraphicsLayer(WebCore::GraphicsLayer::Type, WebCore::GraphicsLayerClient&) override;
+    Ref<WebCore::GraphicsLayer> createGraphicsLayer(WebCore::GraphicsLayer::Type, WebCore::GraphicsLayerClient&) override;
 
     void initializeRootCompositingLayerIfNeeded();
@@ -115 +115 @@
     CompositingCoordinator::Client& m_client;
 
-    std::unique_ptr<WebCore::GraphicsLayer> m_rootLayer;
+    RefPtr<WebCore::GraphicsLayer> m_rootLayer;
     WebCore::GraphicsLayer* m_rootCompositingLayer { nullptr };
     WebCore::GraphicsLayer* m_overlayCompositingLayer { nullptr };

trunk/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeContext.h

@@ -75 +75 @@
 private:
     // WebCore::GraphicsLayerFactory
-    std::unique_ptr<WebCore::GraphicsLayer> createGraphicsLayer(WebCore::GraphicsLayer::Type, WebCore::GraphicsLayerClient&) override;
+    Ref<WebCore::GraphicsLayer> createGraphicsLayer(WebCore::GraphicsLayer::Type, WebCore::GraphicsLayerClient&) override;
 
     WebPage& m_webPage;

trunk/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeContext.mm

@@ -110 +110 @@
 }
 
-std::unique_ptr<GraphicsLayer> RemoteLayerTreeContext::createGraphicsLayer(WebCore::GraphicsLayer::Type layerType, GraphicsLayerClient& client)
+Ref<GraphicsLayer> RemoteLayerTreeContext::createGraphicsLayer(WebCore::GraphicsLayer::Type layerType, GraphicsLayerClient& client)
 {
-    return std::make_unique<GraphicsLayerCARemote>(layerType, client, *this);
+    return adoptRef(*new GraphicsLayerCARemote(layerType, client, *this));
 }
 

trunk/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.h

@@ -138 +138 @@
 
     std::unique_ptr<RemoteLayerTreeContext> m_remoteLayerTreeContext;
-    std::unique_ptr<WebCore::GraphicsLayer> m_rootLayer;
+    Ref<WebCore::GraphicsLayer> m_rootLayer;
 
     WebCore::IntSize m_viewSize;

trunk/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.mm

@@ -116 +116 @@
 void RemoteLayerTreeDrawingArea::updateRootLayers()
 {
-    Vector<GraphicsLayer*> children;
+    Vector<Ref<GraphicsLayer>> children;
     if (m_contentLayer) {
-        children.append(m_contentLayer);
+        children.append(*m_contentLayer);
         if (m_viewOverlayRootLayer)
-            children.append(m_viewOverlayRootLayer);
-    }
-
-    m_rootLayer->setChildren(children);
+            children.append(*m_viewOverlayRootLayer);
+    }
+
+    m_rootLayer->setChildren(WTFMove(children));
 }
 
@@ -319 +319 @@
 void RemoteLayerTreeDrawingArea::flushLayers()
 {
-    if (!m_rootLayer)
-        return;
-
     if (m_isFlushingSuspended) {
         m_hasDeferredFlush = true;
@@ -367 +364 @@
     layerTransaction.setCallbackIDs(WTFMove(m_pendingCallbackIDs));
     m_remoteLayerTreeContext->setNextFlushIsForImmediatePaint(m_nextFlushIsForImmediatePaint);
-    m_remoteLayerTreeContext->buildTransaction(layerTransaction, *downcast<GraphicsLayerCARemote>(*m_rootLayer).platformCALayer());
+    m_remoteLayerTreeContext->buildTransaction(layerTransaction, *downcast<GraphicsLayerCARemote>(m_rootLayer.get()).platformCALayer());
     m_remoteLayerTreeContext->setNextFlushIsForImmediatePaint(false);
     backingStoreCollection.willCommitLayerTree(layerTransaction);

trunk/Source/WebKitLegacy/win/WebCoreSupport/AcceleratedCompositingContext.cpp

@@ -98 +98 @@
 #endif
 
-    m_rootLayer->addChild(m_nonCompositedContentLayer.get());
+    m_rootLayer->addChild(*m_nonCompositedContentLayer);
     m_nonCompositedContentLayer->setNeedsDisplay();
 
@@ -212 +212 @@
 
     m_nonCompositedContentLayer->removeAllChildren();
-    m_nonCompositedContentLayer->addChild(graphicsLayer);
+    m_nonCompositedContentLayer->addChild(*graphicsLayer);
 
     stopAnyPendingLayerFlush();

trunk/Source/WebKitLegacy/win/WebCoreSupport/AcceleratedCompositingContext.h

@@ -72 +72 @@
     std::unique_ptr<WebCore::GLContext> m_context;
     HWND m_window;
-    std::unique_ptr<WebCore::GraphicsLayer> m_rootLayer;
-    std::unique_ptr<WebCore::GraphicsLayer> m_nonCompositedContentLayer;
+    RefPtr<WebCore::GraphicsLayer> m_rootLayer;
+    RefPtr<WebCore::GraphicsLayer> m_nonCompositedContentLayer;
     std::unique_ptr<WebCore::TextureMapper> m_textureMapper;
     WebCore::TextureMapperFPSCounter m_fpsCounter;

trunk/Source/WebKitLegacy/win/WebView.cpp

@@ -7146 +7146 @@
     if (!m_backingLayer)
         return;
-    m_backingLayer->addChild(layer);
+
+    if (layer)
+        m_backingLayer->addChild(*layer);
+    else
+        m_backingLayer->removeAllChildren();
+
 #elif USE(TEXTURE_MAPPER_GL)
     if (!m_acceleratedCompositingContext)

trunk/Source/WebKitLegacy/win/WebView.h

@@ -706 +706 @@
 #if USE(CA)
     RefPtr<WebCore::CACFLayerTreeHost> m_layerTreeHost;
-    std::unique_ptr<WebCore::GraphicsLayer> m_backingLayer;
+    RefPtr<WebCore::GraphicsLayer> m_backingLayer;
 #elif USE(TEXTURE_MAPPER_GL)
     std::unique_ptr<AcceleratedCompositingContext> m_acceleratedCompositingContext;