Making GraphicsContext the owner of PlatformContext.

Source/core/platform/graphics/skia/ImageBufferSkia.cpp

 /*
  * Copyright (c) 2008, Google Inc. All rights reserved.
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
@@ skipping 48 matching lines @@
 
 using namespace std;
 
 namespace WebCore {
 
 // We pass a technically-uninitialized canvas to the platform context here since
 // the canvas initialization completes in ImageBuffer::ImageBuffer. But
 // PlatformContext doesn't actually need to use the object, and this makes all
 // the ownership easier to manage.
 ImageBufferData::ImageBufferData(const IntSize& size)
-    : m_platformContext(0)  // Canvas is set in ImageBuffer constructor.
 {
 }
 
-static SkCanvas* createAcceleratedCanvas(const IntSize& size, ImageBufferData* data)
+static SkCanvas* createAcceleratedCanvas(const IntSize& size, GraphicsContext* context, ImageBufferData* data)
 {
     RefPtr<GraphicsContext3D> context3D = SharedGraphicsContext3D::get();
     if (!context3D)
         return 0;
     GrContext* gr = context3D->grContext();
     if (!gr)
         return 0;
     gr->resetContext();
     Canvas2DLayerBridge::ThreadMode threadMode = WebKit::Platform::current()->isThreadedCompositingEnabled() ? Canvas2DLayerBridge::Threaded : Canvas2DLayerBridge::SingleThread;
     SkImage::Info info;
     info.fWidth = size.width();
     info.fHeight = size.height();
     info.fColorType = SkImage::kPMColor_ColorType;
     info.fAlphaType = SkImage::kPremul_AlphaType;
     SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(context3D->grContext(), info));
     if (!surface.get())
         return 0;
     SkDeferredCanvas* canvas = new SkDeferredCanvas(surface.get());
     data->m_layerBridge = Canvas2DLayerBridge::create(context3D.release(), canvas, threadMode);
     // If canvas buffer allocation failed, debug build will have asserted
     // For release builds, we must verify whether the device has a render target
-    data->m_platformContext.setAccelerated(true);
+    context->platformContext()->setAccelerated(true);
     return canvas;
 }
 
 static SkCanvas* createNonPlatformCanvas(const IntSize& size)
 {
     SkAutoTUnref<SkDevice> device(new SkDevice(SkBitmap::kARGB_8888_Config, size.width(), size.height()));
     SkPixelRef* pixelRef = device->accessBitmap(false).pixelRef();
     return pixelRef ? new SkCanvas(device) : 0;
 }
 
@@ skipping 23 matching lines @@
         return;
     }
 
     SkPixelRef* pixelRef = device->accessBitmap(false).pixelRef();
     if (!pixelRef) {
         success = false;
         return;
     }
 
     m_data.m_canvas = adoptPtr(new SkCanvas(device));
-    m_data.m_platformContext.setCanvas(m_data.m_canvas.get());
-    m_context = adoptPtr(new GraphicsContext(&m_data.m_platformContext));
+    m_context = adoptPtr(new GraphicsContext(m_data.m_canvas.get()));
     m_context->setShouldSmoothFonts(false);
     m_context->scale(FloatSize(m_resolutionScale, m_resolutionScale));
 
     success = true;
 }
 
 ImageBuffer::ImageBuffer(const IntSize& size, float resolutionScale, ColorSpace, RenderingMode renderingMode, bool& success)
     : m_data(size)
     , m_size(size)
     , m_logicalSize(size)
     , m_resolutionScale(resolutionScale)
 {
     OwnPtr<SkCanvas> canvas;
 
     if (renderingMode == Accelerated)
-        canvas = adoptPtr(createAcceleratedCanvas(size, &m_data));
+        canvas = adoptPtr(createAcceleratedCanvas(size, context(), &m_data));
     else if (renderingMode == UnacceleratedNonPlatformBuffer)
         canvas = adoptPtr(createNonPlatformCanvas(size));
 
     if (!canvas)
         canvas = adoptPtr(skia::TryCreateBitmapCanvas(size.width(), size.height(), false));
 
     if (!canvas) {
         success = false;
         return;
     }
 
     m_data.m_canvas = canvas.release();
-    m_data.m_platformContext.setCanvas(m_data.m_canvas.get());
-    m_context = adoptPtr(new GraphicsContext(&m_data.m_platformContext));
+    m_context = adoptPtr(new GraphicsContext(m_data.m_canvas.get()));
     m_context->setShouldSmoothFonts(false);
     m_context->scale(FloatSize(m_resolutionScale, m_resolutionScale));
 
     // Make the background transparent. It would be nice if this wasn't
     // required, but the canvas is currently filled with the magic transparency
     // color. Can we have another way to manage this?
     m_data.m_canvas->drawARGB(0, 0, 0, 0, SkXfermode::kClear_Mode);
 
     success = true;
 }
@@ skipping 16 matching lines @@
 {
     SkBitmap tmp;
     if (!bitmap.deepCopyTo(&tmp, bitmap.config()))
         bitmap.copyTo(&tmp, bitmap.config());
 
     return tmp;
 }
 
 PassRefPtr<Image> ImageBuffer::copyImage(BackingStoreCopy copyBehavior, ScaleBehavior) const
 {
-    const SkBitmap& bitmap = *m_data.m_platformContext.bitmap();
+    const SkBitmap& bitmap = *context()->platformContext()->bitmap();
     // FIXME: Start honoring ScaleBehavior to scale 2x buffers down to 1x.
     return BitmapImage::create(NativeImageSkia::create(copyBehavior == CopyBackingStore ? deepSkBitmapCopy(bitmap) : bitmap, m_resolutionScale));
 }
 
 BackingStoreCopy ImageBuffer::fastCopyImageMode()
 {
     return DontCopyBackingStore;
 }
 
 PlatformLayer* ImageBuffer::platformLayer() const
@@ skipping 35 matching lines @@
 }
 
 static bool drawNeedsCopy(GraphicsContext* src, GraphicsContext* dst)
 {
     return (src == dst);
 }
 
 void ImageBuffer::draw(GraphicsContext* context, ColorSpace styleColorSpace, const FloatRect& destRect, const FloatRect& srcRect,
     CompositeOperator op, BlendMode, bool useLowQualityScale)
 {
-    const SkBitmap& bitmap = *m_data.m_platformContext.bitmap();
+    const SkBitmap& bitmap = *context->platformContext()->bitmap();
     RefPtr<Image> image = BitmapImage::create(NativeImageSkia::create(drawNeedsCopy(m_context.get(), context) ? deepSkBitmapCopy(bitmap) : bitmap));
     context->drawImage(image.get(), styleColorSpace, destRect, srcRect, op, DoNotRespectImageOrientation, useLowQualityScale);
 }
 
 void ImageBuffer::drawPattern(GraphicsContext* context, const FloatRect& srcRect, const AffineTransform& patternTransform,
                               const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect)
 {
-    const SkBitmap& bitmap = *m_data.m_platformContext.bitmap();
+    const SkBitmap& bitmap = *context->platformContext()->bitmap();
     RefPtr<Image> image = BitmapImage::create(NativeImageSkia::create(drawNeedsCopy(m_context.get(), context) ? deepSkBitmapCopy(bitmap) : bitmap));
     image->drawPattern(context, srcRect, patternTransform, phase, styleColorSpace, op, destRect);
 }
 
 void ImageBuffer::platformTransformColorSpace(const Vector<int>& lookUpTable)
 {
     // FIXME: Disable color space conversions on accelerated canvases (for now).
-    if (m_data.m_platformContext.isAccelerated()) 
+    if (context()->platformContext()->isAccelerated())
         return;
 
     const SkBitmap& bitmap = *context()->platformContext()->bitmap();
     if (bitmap.isNull())
         return;
 
     ASSERT(bitmap.config() == SkBitmap::kARGB_8888_Config);
     SkAutoLockPixels bitmapLock(bitmap);
     for (int y = 0; y < m_size.height(); ++y) {
         uint32_t* srcRow = bitmap.getAddr32(0, y);
@@ skipping 129 matching lines @@
     Vector<char> base64Data;
     base64Encode(encodedImage, base64Data);
 
     return "data:" + mimeType + ";base64," + base64Data;
 }
 
 void ImageBufferData::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
     MemoryClassInfo info(memoryObjectInfo, this);
     info.addMember(m_canvas, "canvas");
-    info.addMember(m_platformContext, "platformContext");
     info.addMember(m_layerBridge, "layerBridge");
 }
 
 String ImageDataToDataURL(const ImageData& imageData, const String& mimeType, const double* quality)
 {
     ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
 
     Vector<char> encodedImage;
     if (!encodeImage(imageData, mimeType, quality, &encodedImage))
         return "data:,";
 
     Vector<char> base64Data;
     base64Encode(encodedImage, base64Data);
 
     return "data:" + mimeType + ";base64," + base64Data;
 }
 
 } // namespace WebCore