Refactoring ImageBuffer to decouple it from Canvas2DLayerBridge

Source/platform/graphics/GraphicsContext.cpp

 /*
  * Copyright (C) 2003, 2004, 2005, 2006, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Google 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
@@ skipping 14 matching lines @@
  */
 
 #include "config.h"
 #include "platform/graphics/GraphicsContext.h"
 
 #include "platform/geometry/IntRect.h"
 #include "platform/geometry/RoundedRect.h"
 #include "platform/graphics/BitmapImage.h"
 #include "platform/graphics/DisplayList.h"
 #include "platform/graphics/Gradient.h"
+#include "platform/graphics/ImageBuffer.h"
 #include "platform/text/BidiResolver.h"
 #include "platform/text/TextRunIterator.h"
 #include "platform/weborigin/KURL.h"
 #include "third_party/skia/include/core/SkAnnotation.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/core/SkRRect.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 #include "third_party/skia/include/effects/SkBlurMaskFilter.h"
 #include "third_party/skia/include/effects/SkCornerPathEffect.h"
 #include "third_party/skia/include/effects/SkLumaColorFilter.h"
+#include "third_party/skia/include/gpu/GrRenderTarget.h"
+#include "third_party/skia/include/gpu/GrTexture.h"
 #include "wtf/Assertions.h"
 #include "wtf/MathExtras.h"
 
 #if OS(MACOSX)
 #include <ApplicationServices/ApplicationServices.h>
 #endif
 
 using namespace std;
 using blink::WebBlendMode;
 
 namespace WebCore {
 
+namespace {
+
+class CompatibleImageBufferSurface : public ImageBufferSurface {
+    WTF_MAKE_NONCOPYABLE(CompatibleImageBufferSurface); WTF_MAKE_FAST_ALLOCATED;
+public:
+    CompatibleImageBufferSurface(PassRefPtr<SkBaseDevice> device, const IntSize& size, OpacityMode opacityMode)
+        : ImageBufferSurface(size, opacityMode)
+    {
+        m_canvas = adoptPtr(new SkCanvas(device.get())); // Takes a ref on device
+    }
+    virtual ~CompatibleImageBufferSurface() { }
+
+    virtual SkCanvas* canvas() const OVERRIDE { return m_canvas.get(); }
+    virtual bool isValid() const OVERRIDE { return m_canvas; }
+    virtual bool isAccelerated() const OVERRIDE { return isValid() && m_canvas->getTopDevice()->accessRenderTarget(); }
+    virtual Platform3DObject getBackingTexture() const OVERRIDE
+    {
+        ASSERT(isAccelerated());
+        GrRenderTarget* renderTarget = m_canvas->getTopDevice()->accessRenderTarget();
+        if (renderTarget) {
+            return renderTarget->asTexture()->getTextureHandle();
+        }
+        return 0;
+    };
+
+private:
+    OwnPtr<SkCanvas> m_canvas;
+};
+
+} // unnamed namespace
+
 struct GraphicsContext::DeferredSaveState {
     DeferredSaveState(unsigned mask, int count) : m_flags(mask), m_restoreCount(count) { }
 
     unsigned m_flags;
     int m_restoreCount;
 };
 
 struct GraphicsContext::RecordingState {
     RecordingState(SkCanvas* currentCanvas, const SkMatrix& currentMatrix, PassRefPtr<DisplayList> displayList)
         : m_savedCanvas(currentCanvas)
@@ skipping 39 matching lines @@
 {
     TRACE_EVENT0("skia", "GraphicsContext::bitmap");
     return &m_canvas->getDevice()->accessBitmap(false);
 }
 
 const SkBitmap& GraphicsContext::layerBitmap(AccessMode access) const
 {
     return m_canvas->getTopDevice()->accessBitmap(access == ReadWrite);
 }
 
-SkBaseDevice* GraphicsContext::createCompatibleDevice(const IntSize& size, bool hasAlpha) const
-{
-    if (paintingDisabled())
-        return 0;
-
-    return m_canvas->createCompatibleDevice(SkBitmap::kARGB_8888_Config, size.width(), size.height(), !hasAlpha);
-}
-
 void GraphicsContext::save()
 {
     if (paintingDisabled())
         return;
 
     m_stateStack.append(m_state->clone());
     m_state = m_stateStack.last().get();
 
     m_saveStateStack.append(DeferredSaveState(m_deferredSaveFlags, m_canvas->getSaveCount()));
     m_deferredSaveFlags |= SkCanvas::kMatrixClip_SaveFlag;
@@ skipping 982 matching lines @@
         setImageInterpolationQuality(previousInterpolationQuality);
     } else {
         image->drawTiled(this, dest, srcRect, tileScaleFactor, hRule, vRule, op);
     }
 }
 
 void GraphicsContext::drawImageBuffer(ImageBuffer* image, const IntPoint& p, CompositeOperator op, WebBlendMode blendMode)
 {
     if (!image)
         return;
-    drawImageBuffer(image, FloatRect(IntRect(p, image->logicalSize())), FloatRect(FloatPoint(), FloatSize(image->logicalSize())), op, blendMode);
+    drawImageBuffer(image, FloatRect(IntRect(p, image->size())), FloatRect(FloatPoint(), FloatSize(image->size())), op, blendMode);
 }
 
 void GraphicsContext::drawImageBuffer(ImageBuffer* image, const IntRect& r, CompositeOperator op, WebBlendMode blendMode, bool useLowQualityScale)
 {
     if (!image)
         return;
-    drawImageBuffer(image, FloatRect(r), FloatRect(FloatPoint(), FloatSize(image->logicalSize())), op, blendMode, useLowQualityScale);
+    drawImageBuffer(image, FloatRect(r), FloatRect(FloatPoint(), FloatSize(image->size())), op, blendMode, useLowQualityScale);
 }
 
 void GraphicsContext::drawImageBuffer(ImageBuffer* image, const IntPoint& dest, const IntRect& srcRect, CompositeOperator op, WebBlendMode blendMode)
 {
     drawImageBuffer(image, FloatRect(IntRect(dest, srcRect.size())), FloatRect(srcRect), op, blendMode);
 }
 
 void GraphicsContext::drawImageBuffer(ImageBuffer* image, const IntRect& dest, const IntRect& srcRect, CompositeOperator op, WebBlendMode blendMode, bool useLowQualityScale)
 {
     drawImageBuffer(image, FloatRect(dest), FloatRect(srcRect), op, blendMode, useLowQualityScale);
 }
 
 void GraphicsContext::drawImageBuffer(ImageBuffer* image, const FloatRect& dest)
 {
     if (!image)
         return;
-    drawImageBuffer(image, dest, FloatRect(IntRect(IntPoint(), image->logicalSize())));
+    drawImageBuffer(image, dest, FloatRect(IntRect(IntPoint(), image->size())));
 }
 
 void GraphicsContext::drawImageBuffer(ImageBuffer* image, const FloatRect& dest, const FloatRect& src, CompositeOperator op, WebBlendMode blendMode, bool useLowQualityScale)
 {
     if (paintingDisabled() || !image)
         return;
 
     if (useLowQualityScale) {
         InterpolationQuality previousInterpolationQuality = imageInterpolationQuality();
         setImageInterpolationQuality(InterpolationLow);
@@ skipping 530 matching lines @@
             p1.setX(p1.x() + 0.5f);
             p2.setX(p2.x() + 0.5f);
         } else {
             // We're a horizontal line. Adjust our y.
             p1.setY(p1.y() + 0.5f);
             p2.setY(p2.y() + 0.5f);
         }
     }
 }
 
-PassOwnPtr<ImageBuffer> GraphicsContext::createCompatibleBuffer(const IntSize& size, bool hasAlpha) const
+PassOwnPtr<ImageBuffer> GraphicsContext::createCompatibleBuffer(const IntSize& size, OpacityMode opacityMode) const
 {
     // Make the buffer larger if the context's transform is scaling it so we need a higher
     // resolution than one pixel per unit. Also set up a corresponding scale factor on the
     // graphics context.
 
     AffineTransform transform = getCTM(DefinitelyIncludeDeviceScale);
     IntSize scaledSize(static_cast<int>(ceil(size.width() * transform.xScale())), static_cast<int>(ceil(size.height() * transform.yScale())));
 
-    OwnPtr<ImageBuffer> buffer = ImageBuffer::createCompatibleBuffer(scaledSize, 1, this, hasAlpha);
-    if (!buffer)
+    RefPtr<SkBaseDevice> device = adoptRef(m_canvas->getTopDevice()->createCompatibleDevice(SkBitmap::kARGB_8888_Config, size.width(), size.height(), opacityMode == Opaque));
+    if (!device)
         return nullptr;
+    OwnPtr<ImageBufferSurface> surface = adoptPtr(new CompatibleImageBufferSurface(device.release(), scaledSize, opacityMode));
+    ASSERT(surface->isValid());
+    OwnPtr<ImageBuffer> buffer = adoptPtr(new ImageBuffer(surface.release()));
 
     buffer->context()->scale(FloatSize(static_cast<float>(scaledSize.width()) / size.width(),
         static_cast<float>(scaledSize.height()) / size.height()));
 
     return buffer.release();
 }
 
 void GraphicsContext::addCornerArc(SkPath* path, const SkRect& rect, const IntSize& size, int startAngle)
 {
     SkIRect ir;
@@ skipping 239 matching lines @@
 
 void GraphicsContext::didDrawTextInRect(const SkRect& textRect)
 {
     if (m_trackTextRegion) {
         TRACE_EVENT0("skia", "PlatformContextSkia::trackTextRegion");
         m_textRegion.join(textRect);
     }
 }
 
 }