diff --git a/WebCore/kcanvas/device/quartz/KCanvasFilterQuartz.mm b/WebCore/kcanvas/device/quartz/KCanvasFilterQuartz.mm
index a8cc338..fcb4de1 100644
--- a/WebCore/kcanvas/device/quartz/KCanvasFilterQuartz.mm
+++ b/WebCore/kcanvas/device/quartz/KCanvasFilterQuartz.mm
@@ -180,7 +180,6 @@
     DeprecatedValueListIterator<KCanvasFilterEffect*> end = m_effects.end();
 
     setImageForName(inputImage, "SourceGraphic"); // input
-
     for (;it != end; it++) {
         CIFilter *filter = (*it)->getCIFilter(this);
         if (filter)
diff --git a/WebCore/kcanvas/device/quartz/KCanvasItemQuartz.mm b/WebCore/kcanvas/device/quartz/KCanvasItemQuartz.mm
index 27da08d..e8a5d13 100644
--- a/WebCore/kcanvas/device/quartz/KCanvasItemQuartz.mm
+++ b/WebCore/kcanvas/device/quartz/KCanvasItemQuartz.mm
@@ -31,7 +31,9 @@
 #import <wtf/Assertions.h>
 
 #import "KCanvasFilterQuartz.h"
+#import "KCanvasMaskerQuartz.h"
 #import "KCanvasRenderingStyle.h"
+#import "KCanvasResourcesQuartz.h"
 #import "KRenderingDeviceQuartz.h"
 #import "QuartzSupport.h"
 #import "RenderPath.h"
diff --git a/WebCore/kcanvas/device/quartz/KCanvasMaskerQuartz.h b/WebCore/kcanvas/device/quartz/KCanvasMaskerQuartz.h
index e69de29..4f7914b 100644
--- a/WebCore/kcanvas/device/quartz/KCanvasMaskerQuartz.h
+++ b/WebCore/kcanvas/device/quartz/KCanvasMaskerQuartz.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2005 Apple Computer, Inc.  All rights reserved.
+ *               2005, 2006 Alexander Kellett <lypanov@kde.org>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include "KCanvasMasker.h"
+#include "KCanvasImage.h"
+
+namespace WebCore {
+
+class KCanvasMaskerQuartz : public KCanvasMasker {
+public:
+    KCanvasMaskerQuartz() { }
+    
+    virtual void applyMask(const FloatRect& boundingBox) const;
+};
+
+}
diff --git a/WebCore/kcanvas/device/quartz/KCanvasMaskerQuartz.mm b/WebCore/kcanvas/device/quartz/KCanvasMaskerQuartz.mm
index e69de29..efecf8c 100644
--- a/WebCore/kcanvas/device/quartz/KCanvasMaskerQuartz.mm
+++ b/WebCore/kcanvas/device/quartz/KCanvasMaskerQuartz.mm
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2005, 2006 Alexander Kellett <lypanov@kde.org>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+
+#include "config.h"
+#ifdef SVG_SUPPORT
+#import "KCanvasMaskerQuartz.h"
+
+#import "SVGRenderStyle.h"
+
+#import "KCanvasResourcesQuartz.h"
+#import "KRenderingDeviceQuartz.h"
+#import "QuartzSupport.h"
+
+#import <QuartzCore/CoreImage.h>
+
+namespace WebCore {
+
+static CIImage *applyLuminanceToAlphaFilter(CIImage *inputImage)
+{
+    CIFilter *luminanceToAlpha = [CIFilter filterWithName:@"CIColorMatrix"];
+    [luminanceToAlpha setDefaults];
+    CGFloat alpha[4] = {0.2125, 0.7154, 0.0721, 0};
+    CGFloat zero[4] = {0, 0, 0, 0};
+    [luminanceToAlpha setValue:inputImage forKey:@"inputImage"];  
+    [luminanceToAlpha setValue:[CIVector vectorWithValues:zero count:4] forKey:@"inputRVector"];
+    [luminanceToAlpha setValue:[CIVector vectorWithValues:zero count:4] forKey:@"inputGVector"];
+    [luminanceToAlpha setValue:[CIVector vectorWithValues:zero count:4] forKey:@"inputBVector"];
+    [luminanceToAlpha setValue:[CIVector vectorWithValues:alpha count:4] forKey:@"inputAVector"];
+    [luminanceToAlpha setValue:[CIVector vectorWithValues:zero count:4] forKey:@"inputBiasVector"];
+    return [luminanceToAlpha valueForKey:@"outputImage"];
+}
+
+static CIImage *applyExpandAlphatoGrayscaleFilter(CIImage *inputImage)
+{
+    CIFilter *alphaToGrayscale = [CIFilter filterWithName:@"CIColorMatrix"];
+    CGFloat zero[4] = {0, 0, 0, 0};
+    [alphaToGrayscale setDefaults];
+    [alphaToGrayscale setValue:inputImage forKey:@"inputImage"];
+    [alphaToGrayscale setValue:[CIVector vectorWithValues:zero count:4] forKey:@"inputRVector"];
+    [alphaToGrayscale setValue:[CIVector vectorWithValues:zero count:4] forKey:@"inputGVector"];
+    [alphaToGrayscale setValue:[CIVector vectorWithValues:zero count:4] forKey:@"inputBVector"];
+    [alphaToGrayscale setValue:[CIVector vectorWithX:0.0 Y:0.0 Z:0.0 W:1.0] forKey:@"inputAVector"];
+    [alphaToGrayscale setValue:[CIVector vectorWithX:1.0 Y:1.0 Z:1.0 W:0.0] forKey:@"inputBiasVector"];
+    return [alphaToGrayscale valueForKey:@"outputImage"];
+}
+
+static CIImage *transformImageIntoGrayscaleMask(CIImage *inputImage)
+{
+    CIFilter *blackBackground = [CIFilter filterWithName:@"CIConstantColorGenerator"];
+    [blackBackground setValue:[CIColor colorWithRed:0.0 green:0.0 blue:0.0 alpha:1.0] forKey:@"inputColor"];
+
+    CIFilter *layerOverBlack = [CIFilter filterWithName:@"CISourceOverCompositing"];
+    [layerOverBlack setValue:[blackBackground valueForKey:@"outputImage"] forKey:@"inputBackgroundImage"];  
+    [layerOverBlack setValue:inputImage forKey:@"inputImage"];  
+
+    CIImage *luminanceAlpha = applyLuminanceToAlphaFilter([layerOverBlack valueForKey:@"outputImage"]);
+    CIImage *luminanceAsGrayscale = applyExpandAlphatoGrayscaleFilter(luminanceAlpha);
+    CIImage *alphaAsGrayscale = applyExpandAlphatoGrayscaleFilter(inputImage);
+
+    CIFilter *multipliedGrayscale = [CIFilter filterWithName:@"CIMultiplyCompositing"];
+    [multipliedGrayscale setValue:luminanceAsGrayscale forKey:@"inputBackgroundImage"];  
+    [multipliedGrayscale setValue:alphaAsGrayscale forKey:@"inputImage"];  
+    return [multipliedGrayscale valueForKey:@"outputImage"];
+}
+
+void KCanvasMaskerQuartz::applyMask(const FloatRect& boundingBox) const
+{
+    if (!m_mask)
+        return;
+    // Create grayscale bitmap context
+    int width = m_mask->size().width();
+    int height = m_mask->size().height();
+    void *imageBuffer = fastMalloc(width * height);
+    CGColorSpaceRef grayColorSpace = CGColorSpaceCreateDeviceGray();
+    CGContextRef grayscaleContext = CGBitmapContextCreate(imageBuffer, width, height, 8, width, grayColorSpace, kCGImageAlphaNone);
+    CGColorSpaceRelease(grayColorSpace);
+    CIContext *ciGrayscaleContext = [CIContext contextWithCGContext:grayscaleContext options:nil];
+
+    KCanvasImageQuartz* maskImage = static_cast<KCanvasImageQuartz*>(m_mask);
+    CIImage *grayscaleMask = transformImageIntoGrayscaleMask([CIImage imageWithCGLayer:maskImage->cgLayer()]);
+    [ciGrayscaleContext drawImage:grayscaleMask atPoint:CGPointZero fromRect:CGRectMake(0, 0, width, height)];
+
+    CGImageRef grayscaleImage = CGBitmapContextCreateImage(grayscaleContext);
+    CGContextRef cgContext = static_cast<KRenderingDeviceQuartz*>(renderingDevice())->currentCGContext();
+    CGContextClipToMask(cgContext, CGRectMake(0, 0, width, height), grayscaleImage);
+    
+    CGImageRelease(grayscaleImage);
+    CGContextRelease(grayscaleContext);
+    fastFree(imageBuffer);
+}
+
+}
+
+#endif // SVG_SUPPORT
diff --git a/WebCore/kcanvas/device/quartz/KCanvasResourcesQuartz.h b/WebCore/kcanvas/device/quartz/KCanvasResourcesQuartz.h
index e69de29..a7e9a22 100644
--- a/WebCore/kcanvas/device/quartz/KCanvasResourcesQuartz.h
+++ b/WebCore/kcanvas/device/quartz/KCanvasResourcesQuartz.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2005 Apple Computer, Inc.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#ifndef KCanvasResourcesQuartz_h
+#define KCanvasResourcesQuartz_h
+
+#include "KCanvasClipper.h"
+
+#include "KCanvasImage.h"
+#include "RenderSVGContainer.h"
+#include "AffineTransform.h"
+
+typedef struct CGContext *CGContextRef;
+typedef struct CGLayer *CGLayerRef;
+
+namespace WebCore {
+
+class KCanvasClipperQuartz : public KCanvasClipper {
+public:
+    KCanvasClipperQuartz() { }
+    
+    virtual void applyClip(const FloatRect& boundingBox) const;
+};
+
+class KCanvasImageQuartz : public KCanvasImage {
+public:
+    KCanvasImageQuartz() : m_cgLayer(0) { }
+    ~KCanvasImageQuartz();
+    void init(const Image&) { }
+    void init(IntSize size) { m_size = size; }
+    
+    CGLayerRef cgLayer();
+    void setCGLayer(CGLayerRef layer);
+
+    IntSize size() { return m_size; }
+    
+private:
+    IntSize m_size;
+    CGLayerRef m_cgLayer;
+};
+
+}
+
+#endif
diff --git a/WebCore/kcanvas/device/quartz/KCanvasResourcesQuartz.mm b/WebCore/kcanvas/device/quartz/KCanvasResourcesQuartz.mm
index e69de29..4553fc7 100644
--- a/WebCore/kcanvas/device/quartz/KCanvasResourcesQuartz.mm
+++ b/WebCore/kcanvas/device/quartz/KCanvasResourcesQuartz.mm
@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2005 Apple Computer, Inc.  All rights reserved.
+ *               2005 Alexander Kellett <lypanov@kde.org>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+
+#include "config.h"
+#ifdef SVG_SUPPORT
+#import "KCanvasResourcesQuartz.h"
+
+#import "GraphicsContext.h"
+#import "KCanvasFilterQuartz.h"
+#import "KCanvasMaskerQuartz.h"
+#import "KRenderingDeviceQuartz.h"
+#import "QuartzSupport.h"
+
+namespace WebCore {
+
+void KCanvasClipperQuartz::applyClip(const FloatRect& boundingBox) const
+{
+    KRenderingDeviceContext* context = renderingDevice()->currentContext();
+    CGContextRef cgContext = static_cast<KRenderingDeviceContextQuartz*>(context)->cgContext();
+    if (m_clipData.count() < 1)
+        return;
+
+    BOOL heterogenousClipRules = NO;
+    WindRule clipRule = m_clipData[0].windRule();
+
+    context->clearPath();
+
+    CGAffineTransform bboxTransform = CGAffineTransformMakeMapBetweenRects(CGRectMake(0,0,1,1), CGRect(boundingBox));
+
+    for (unsigned x = 0; x < m_clipData.count(); x++) {
+        KCClipData data = m_clipData[x];
+        if (data.windRule() != clipRule)
+            heterogenousClipRules = YES;
+        
+        CGPathRef clipPath = data.path.platformPath();
+
+        if (data.bboxUnits) {
+            CGMutablePathRef transformedPath = CGPathCreateMutable();
+            CGPathAddPath(transformedPath, &bboxTransform, clipPath);
+            CGContextAddPath(cgContext, transformedPath);
+            CGPathRelease(transformedPath);
+        } else
+            CGContextAddPath(cgContext, clipPath);
+    }
+
+    if (m_clipData.count()) {
+        // FIXME!
+        // We don't currently allow for heterogenous clip rules.
+        // we would have to detect such, draw to a mask, and then clip
+        // to that mask                
+        if (!CGContextIsPathEmpty(cgContext)) {
+            if (clipRule == RULE_EVENODD)
+                CGContextEOClip(cgContext);
+            else
+                CGContextClip(cgContext);
+        }
+    }
+}
+
+KCanvasImageQuartz::~KCanvasImageQuartz()
+{
+    CGLayerRelease(m_cgLayer);
+}
+
+CGLayerRef KCanvasImageQuartz::cgLayer()
+{
+    return m_cgLayer;
+}
+
+void KCanvasImageQuartz::setCGLayer(CGLayerRef layer)
+{
+    if (m_cgLayer != layer) {
+        CGLayerRelease(m_cgLayer);
+        m_cgLayer = CGLayerRetain(layer);
+    }
+}
+
+}
+#endif // SVG_SUPPORT
diff --git a/WebCore/kcanvas/device/quartz/KRenderingDeviceQuartz.h b/WebCore/kcanvas/device/quartz/KRenderingDeviceQuartz.h
index 33e6754..b53d4ba 100644
--- a/WebCore/kcanvas/device/quartz/KRenderingDeviceQuartz.h
+++ b/WebCore/kcanvas/device/quartz/KRenderingDeviceQuartz.h
@@ -65,11 +65,11 @@
     // context management.
     KRenderingDeviceContextQuartz* quartzContext() const;
     CGContextRef currentCGContext() const;
-    virtual KRenderingDeviceContext* contextForImage(SVGResourceImage*) const;
+    virtual KRenderingDeviceContext* contextForImage(KCanvasImage*) const;
 
     // Resource creation
-    virtual PassRefPtr<SVGResource> createResource(const SVGResourceType&) const;
-    virtual PassRefPtr<KRenderingPaintServer> createPaintServer(const KCPaintServerType&) const;
+    virtual KCanvasResource *createResource(const KCResourceType&) const;
+    virtual KRenderingPaintServer *createPaintServer(const KCPaintServerType&) const;
     virtual KCanvasFilterEffect *createFilterEffect(const KCFilterEffectType&) const;
     
     // filters (mostly debugging)
diff --git a/WebCore/kcanvas/device/quartz/KRenderingDeviceQuartz.mm b/WebCore/kcanvas/device/quartz/KRenderingDeviceQuartz.mm
index 8b128ec..6b4a34e 100644
--- a/WebCore/kcanvas/device/quartz/KRenderingDeviceQuartz.mm
+++ b/WebCore/kcanvas/device/quartz/KRenderingDeviceQuartz.mm
@@ -25,16 +25,14 @@
  */
 
 #include "config.h"
-
 #ifdef SVG_SUPPORT
 #import "KRenderingDeviceQuartz.h"
 
 #import "GraphicsContext.h"
-#import "SVGResourceClipper.h"
-#import "SVGResourceImage.h"
-#import "SVGResourceMarker.h"
+#include "KCanvasMarker.h"
 #import "KCanvasFilterQuartz.h"
-#import "SVGResourceMasker.h"
+#import "KCanvasMaskerQuartz.h"
+#import "KCanvasResourcesQuartz.h"
 #import "KRenderingPaintServerQuartz.h"
 #import "Logging.h"
 #import "QuartzSupport.h"
@@ -119,15 +117,16 @@
     return quartzContext()->cgContext();
 }
 
-KRenderingDeviceContext* KRenderingDeviceQuartz::contextForImage(SVGResourceImage *image) const
+KRenderingDeviceContext* KRenderingDeviceQuartz::contextForImage(KCanvasImage *image) const
 {
-    CGLayerRef cgLayer = image->cgLayer();
+    KCanvasImageQuartz* quartzImage = static_cast<KCanvasImageQuartz*>(image);
+    CGLayerRef cgLayer = quartzImage->cgLayer();
     if (!cgLayer) {
         // FIXME: we might not get back a layer if this is a loaded image
-        // maybe this logic should go into SVGResourceImage?
+        // maybe this logic should go into KCanvasImage?
         cgLayer = CGLayerCreateWithContext(currentCGContext(), CGSize(image->size() + IntSize(1,1)), NULL);  // FIXME + 1 is a hack
         // FIXME: we should composite the original image onto the layer...
-        image->setCGLayer(cgLayer);
+        quartzImage->setCGLayer(cgLayer);
         CGLayerRelease(cgLayer);
     }
     return new KRenderingDeviceContextQuartz(CGLayerGetContext(cgLayer));
@@ -136,7 +135,7 @@
 #pragma mark -
 #pragma mark Resource Creation
 
-PassRefPtr<KRenderingPaintServer> KRenderingDeviceQuartz::createPaintServer(const KCPaintServerType& type) const
+KRenderingPaintServer *KRenderingDeviceQuartz::createPaintServer(const KCPaintServerType& type) const
 {
     KRenderingPaintServer *newServer = NULL;
     switch(type) {
@@ -156,19 +155,19 @@
     return newServer;
 }
 
-PassRefPtr<SVGResource> KRenderingDeviceQuartz::createResource(const SVGResourceType& type) const
+KCanvasResource *KRenderingDeviceQuartz::createResource(const KCResourceType& type) const
 {
     switch (type) {
     case RS_CLIPPER:
-        return new SVGResourceClipper();
+        return new KCanvasClipperQuartz();
     case RS_MARKER:
-        return new SVGResourceMarker();
+        return new KCanvasMarker();
     case RS_IMAGE:
-        return new SVGResourceImage();
+        return new KCanvasImageQuartz();
     case RS_FILTER:
         return new KCanvasFilterQuartz();
     case RS_MASKER:
-        return new SVGResourceMasker();
+        return new KCanvasMaskerQuartz();
     }
     LOG_ERROR("Failed to create resource of type: %i", type);
     return 0;
diff --git a/WebCore/kcanvas/device/quartz/KRenderingPaintServerGradientQuartz.mm b/WebCore/kcanvas/device/quartz/KRenderingPaintServerGradientQuartz.mm
index bc2931f..93a9588 100644
--- a/WebCore/kcanvas/device/quartz/KRenderingPaintServerGradientQuartz.mm
+++ b/WebCore/kcanvas/device/quartz/KRenderingPaintServerGradientQuartz.mm
@@ -27,14 +27,16 @@
 
 
 #include "config.h"
-
 #ifdef SVG_SUPPORT
 #import "KRenderingPaintServerQuartz.h"
-#import "SVGResourceImage.h"
+
+#import "KCanvasImage.h"
+#import "KCanvasResourcesQuartz.h"
 #import "KRenderingDeviceQuartz.h"
 #import "KRenderingPaintServer.h"
 #import "QuartzSupport.h"
-#import "RenderPath.h"
+#import "RenderObject.h"
+
 #import <wtf/Assertions.h>
 
 namespace WebCore {
@@ -135,6 +137,7 @@
     : m_stopsCache(0)
     , m_stopsCount(0)
     , m_shadingCache(0)
+    , m_maskImage(0)
 {
 }
 
@@ -142,6 +145,7 @@
 {
     delete m_stopsCache;
     CGShadingRelease(m_shadingCache);
+    delete m_maskImage;
 }
 
 void KRenderingPaintServerGradientQuartz::updateQuartzGradientCache(const KRenderingPaintServerGradient *server)
@@ -216,6 +220,9 @@
     if (server->listener()) // this seems like bad design to me, should be in a common baseclass. -- ecs 8/6/05
         server->listener()->resourceNotification();
     
+    delete m_maskImage;
+    m_maskImage = 0;
+
     // FIXME: total const HACK!
     // We need a hook to call this when the gradient gets updated, before drawn.
     if (!m_shadingCache)
@@ -239,12 +246,12 @@
         CGContextSaveGState(context);
         applyStrokeStyleToContext(context, renderStyle, renderObject); // FIXME: this seems like the wrong place for this.
         if (server->isPaintingText()) {
-            m_maskImage = new SVGResourceImage();
+            m_maskImage = static_cast<KCanvasImage*>(quartzDevice->createResource(RS_IMAGE));
             int width  = 2048;
             int height = 2048; // FIXME???
             IntSize size = IntSize(width, height);
             m_maskImage->init(size);
-            KRenderingDeviceContext* maskImageContext = quartzDevice->contextForImage(m_maskImage.get());
+            KRenderingDeviceContext* maskImageContext = quartzDevice->contextForImage(m_maskImage);
             quartzDevice->pushContext(maskImageContext);
             CGContextRef maskContext = static_cast<KRenderingDeviceContextQuartz*>(maskImageContext)->cgContext();
             const_cast<RenderObject*>(renderObject)->style()->setColor(Color(255, 255, 255));
@@ -285,6 +292,7 @@
 void KRenderingPaintServerGradientQuartz::teardown(const KRenderingPaintServerGradient *server, KRenderingDeviceContext* renderingContext, const RenderObject* renderObject, KCPaintTargetType type) const
 { 
     CGShadingRef shading = m_shadingCache;
+    KCanvasImage* maskImage = m_maskImage;
     KRenderingDeviceQuartz* quartzDevice = static_cast<KRenderingDeviceQuartz*>(renderingDevice());
     CGContextRef context = quartzDevice->currentCGContext();
     RenderStyle* renderStyle = renderObject->style();
@@ -307,7 +315,8 @@
             CGColorSpaceRef grayColorSpace = CGColorSpaceCreateDeviceGray();
             CGContextRef grayscaleContext = CGBitmapContextCreate(imageBuffer, width, height, 8, width, grayColorSpace, kCGImageAlphaNone);
             CGColorSpaceRelease(grayColorSpace);
-            CGContextDrawLayerAtPoint(grayscaleContext, CGPointMake(0, 0), m_maskImage->cgLayer());
+            KCanvasImageQuartz* qMaskImage = static_cast<KCanvasImageQuartz*>(maskImage);
+            CGContextDrawLayerAtPoint(grayscaleContext, CGPointMake(0, 0), qMaskImage->cgLayer());
             CGImageRef grayscaleImage = CGBitmapContextCreateImage(grayscaleContext);
             CGContextClipToMask(context, CGRectMake(0, 0, width, height), grayscaleImage);
             CGContextRelease(grayscaleContext);
diff --git a/WebCore/kcanvas/device/quartz/KRenderingPaintServerQuartz.h b/WebCore/kcanvas/device/quartz/KRenderingPaintServerQuartz.h
index 1801990..891f402 100644
--- a/WebCore/kcanvas/device/quartz/KRenderingPaintServerQuartz.h
+++ b/WebCore/kcanvas/device/quartz/KRenderingPaintServerQuartz.h
@@ -31,7 +31,7 @@
 
 namespace WebCore {
 
-class SVGResourceImage;
+class KCanvasImage;
 
 class KRenderingPaintServerQuartzHelper {
 public:
@@ -93,7 +93,7 @@
 protected:
     void invalidateCaches();
     CGShadingRef m_shadingCache;
-    mutable RefPtr<SVGResourceImage> m_maskImage;
+    mutable KCanvasImage *m_maskImage;
 };
 
 class KRenderingPaintServerLinearGradientQuartz : public KRenderingPaintServerGradientQuartz,
diff --git a/WebCore/kcanvas/device/quartz/KRenderingPaintServerQuartz.mm b/WebCore/kcanvas/device/quartz/KRenderingPaintServerQuartz.mm
index fb6844a..7a2d243 100644
--- a/WebCore/kcanvas/device/quartz/KRenderingPaintServerQuartz.mm
+++ b/WebCore/kcanvas/device/quartz/KRenderingPaintServerQuartz.mm
@@ -27,12 +27,10 @@
 
 
 #include "config.h"
-
 #ifdef SVG_SUPPORT
-#import "SVGResourceImage.h"
 #import "KRenderingPaintServerQuartz.h"
-#import "RenderPath.h"
 #import "QuartzSupport.h"
+#import "KCanvasResourcesQuartz.h"
 #import "KRenderingDeviceQuartz.h"
 
 #import "KCanvasRenderingStyle.h"
@@ -135,7 +133,7 @@
 
 void patternCallback(void *info, CGContextRef context)
 {
-    CGLayerRef layer = reinterpret_cast<SVGResourceImage*>(info)->cgLayer();
+    CGLayerRef layer = reinterpret_cast<KCanvasImageQuartz*>(info)->cgLayer();
     CGContextDrawLayerAtPoint(context, CGPointZero, layer);
 }
 
@@ -157,7 +155,7 @@
     KRenderingDeviceContextQuartz* quartzContext = static_cast<KRenderingDeviceContextQuartz*>(renderingContext);
     CGContextRef context = quartzContext->cgContext();
 
-    RefPtr<SVGResourceImage> cell = tile();
+    KCanvasImage* cell = tile();
     if (!cell)
         return false;
 
diff --git a/WebCore/kcanvas/device/quartz/QuartzSupport.mm b/WebCore/kcanvas/device/quartz/QuartzSupport.mm
index 55f3673..a9893cc 100644
--- a/WebCore/kcanvas/device/quartz/QuartzSupport.mm
+++ b/WebCore/kcanvas/device/quartz/QuartzSupport.mm
@@ -30,8 +30,8 @@
 #import "QuartzSupport.h"
 
 #import "GraphicsContext.h"
+#import "KCanvasResourcesQuartz.h"
 #import "KCanvasRenderingStyle.h"
-#import "RenderStyle.h"
 #import "wtf/Assertions.h"
 
 #import <QuartzCore/CoreImage.h>