Refactoring ImageBuffer to decouple it from Canvas2DLayerBridge

Source/core/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 26 matching lines @@
 #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(SkCanvas* canvas, const IntSize& size, OpacityMode opacityMode)
+        : ImageBufferSurface(size, opacityMode, 1.0f)
+    {
+        RefPtr<SkBaseDevice> device = adoptRef(canvas->createCompatibleDevice(SkBitmap::kARGB_8888_Config, size.width(), size.height(), opacityMode == Opaque));

[Stephen White, 2013/12/04 21:18:40]

It's a little confusing to have a canvas that's passed-in, but is not the one
that's stored in m_canvas. I think we should pass in the device instead, and
have the caller call createCompatibleDevice.

+        if (!device)
+            return;
+        m_canvas = adoptPtr(new SkCanvas(device.get()));
+    }
+    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 1557 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)
+    OwnPtr<ImageBufferSurface> surface = adoptPtr(new CompatibleImageBufferSurface(m_canvas, scaledSize, opacityMode));
+    if (!surface->isValid())
         return nullptr;
+    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 240 matching lines @@
 
 void GraphicsContext::didDrawTextInRect(const SkRect& textRect)
 {
     if (m_trackTextRegion) {
         TRACE_EVENT0("skia", "PlatformContextSkia::trackTextRegion");
         m_textRegion.join(textRect);
     }
 }
 
 }