Partially rolled forward the SkGrPixelRef changes

http://codereview.appspot.com/6354060/



git-svn-id: http://skia.googlecode.com/svn/trunk@4415 2bbb7eff-a529-9590-31e7-b0007b416f81

gyp/gpu.gyp

@@ -103,6 +103,7 @@
         '../include/gpu/SkGpuCanvas.h',
         '../include/gpu/SkGpuDevice.h',
         '../include/gpu/SkGr.h',
+        '../include/gpu/SkGrPixelRef.h',
         '../include/gpu/SkGrTexturePixelRef.h',
 
         '../include/gpu/gl/SkGLContext.h',
@@ -116,6 +117,7 @@
         '../src/gpu/SkGpuDevice.cpp',
         '../src/gpu/SkGr.cpp',
         '../src/gpu/SkGrFontScaler.cpp',
+        '../src/gpu/SkGrPixelRef.cpp',
         '../src/gpu/SkGrTexturePixelRef.cpp',
 
         '../src/gpu/gl/SkGLContext.cpp',

include/gpu/SkGrTexturePixelRef.h

@@ -11,81 +11,10 @@
 #ifndef SkGrTexturePixelRef_DEFINED
 #define SkGrTexturePixelRef_DEFINED
 
-#include "SkBitmap.h"
-#include "SkPixelRef.h"
-#include "GrTexture.h"
-#include "GrRenderTarget.h"
+#include "SkGrPixelRef.h"
 
-
-/**
- *  Common baseclass that implements onLockPixels() by calling onReadPixels().
- *  Since it has a copy, it always returns false for onLockPixelsAreWritable().
- */
-class SK_API SkROLockPixelsPixelRef_Deprecated : public SkPixelRef {
-public:
-    SkROLockPixelsPixelRef_Deprecated();
-    virtual ~SkROLockPixelsPixelRef_Deprecated();
-
-protected:
-    // override from SkPixelRef
-    virtual void* onLockPixels(SkColorTable** ptr);
-    virtual void onUnlockPixels();
-    virtual bool onLockPixelsAreWritable() const;   // return false;
-
-private:
-    SkBitmap    fBitmap;
-    typedef SkPixelRef INHERITED;
-};
-
-/**
- *  PixelRef that wraps a GrTexture
- */
-class SK_API SkGrTexturePixelRef : public SkROLockPixelsPixelRef_Deprecated {
-public:
-            SkGrTexturePixelRef(GrTexture*);
-    virtual ~SkGrTexturePixelRef();
-
-    // override from SkPixelRef
-    virtual SkGpuTexture* getTexture();
-
-    SK_DECLARE_UNFLATTENABLE_OBJECT()
-
-protected:
-    // override from SkPixelRef
-    virtual bool onReadPixels(SkBitmap* dst, const SkIRect* subset);
-
-    // override from SkPixelRef
-    virtual SkPixelRef* deepCopy(SkBitmap::Config dstConfig) SK_OVERRIDE;
-
-private:
-    GrTexture*  fTexture;
-    typedef SkROLockPixelsPixelRef_Deprecated INHERITED;
-};
-
-/**
- *  PixelRef that wraps a GrRenderTarget
- */
-class SK_API SkGrRenderTargetPixelRef : public SkROLockPixelsPixelRef_Deprecated {
-public:
-            SkGrRenderTargetPixelRef(GrRenderTarget* rt);
-    virtual ~SkGrRenderTargetPixelRef();
-
-    // override from SkPixelRef
-    virtual SkGpuTexture* getTexture();
-
-    SK_DECLARE_UNFLATTENABLE_OBJECT()
-
-protected:
-    // override from SkPixelRef
-    virtual bool onReadPixels(SkBitmap* dst, const SkIRect* subset);
-
-    // override from SkPixelRef
-    virtual SkPixelRef* deepCopy(SkBitmap::Config dstConfig) SK_OVERRIDE;
-
-private:
-    GrRenderTarget*  fRenderTarget;
-    typedef SkROLockPixelsPixelRef_Deprecated INHERITED;
-};
+typedef SkGrPixelRef SkGrTexturePixelRef;
+typedef SkGrPixelRef SkGrRenderTargetPixelRef;
 
 #endif
 

src/gpu/SkGrPixelRef.cpp

@@ -71,12 +71,15 @@ static SkGrPixelRef* copyToTexturePixelRef(GrTexture* texture,
 
     context->copyTexture(texture, dst->asRenderTarget());
 
+    // TODO: figure out if this is responsible for Chrome canvas errors
+#if 0
     // The render texture we have created (to perform the copy) isn't fully
     // functional (since it doesn't have a stencil buffer). Release it here
     // so the caller doesn't try to render to it.
     // TODO: we can undo this release when dynamic stencil buffer attach/
     // detach has been implemented
     dst->releaseRenderTarget();
+#endif
 
     SkGrPixelRef* pixelRef = new SkGrPixelRef(dst);
     GrSafeUnref(dst);
@@ -86,10 +89,15 @@ static SkGrPixelRef* copyToTexturePixelRef(GrTexture* texture,
 ///////////////////////////////////////////////////////////////////////////////
 
 SkGrPixelRef::SkGrPixelRef(GrSurface* surface) {
+    // TODO: figure out if this is responsible for Chrome canvas errors
+#if 0
     // The GrTexture has a ref to the GrRenderTarget but not vice versa.
     // If the GrTexture exists take a ref to that (rather than the render
     // target)
     fSurface = surface->asTexture();
+#else
+    fSurface = NULL;
+#endif
     if (NULL == fSurface) {
         fSurface = surface;
     }

src/gpu/SkGrTexturePixelRef.cpp

@@ -9,172 +9,3 @@
 
 
 #include "SkGrTexturePixelRef.h"
-#include "GrContext.h"
-#include "GrTexture.h"
-#include "SkGr.h"
-#include "SkRect.h"
-
-// since we call lockPixels recursively on fBitmap, we need a distinct mutex,
-// to avoid deadlock with the default one provided by SkPixelRef.
-SK_DECLARE_STATIC_MUTEX(gROLockPixelsPixelRefMutex);
-
-SkROLockPixelsPixelRef_Deprecated::SkROLockPixelsPixelRef_Deprecated() 
-    : INHERITED(&gROLockPixelsPixelRefMutex) {
-}
-
-SkROLockPixelsPixelRef_Deprecated::~SkROLockPixelsPixelRef_Deprecated() {
-}
-
-void* SkROLockPixelsPixelRef_Deprecated::onLockPixels(SkColorTable** ctable) {
-    if (ctable) {
-        *ctable = NULL;
-    }
-    fBitmap.reset();
-//    SkDebugf("---------- calling readpixels in support of lockpixels\n");
-    if (!this->onReadPixels(&fBitmap, NULL)) {
-        SkDebugf("SkROLockPixelsPixelRef::onLockPixels failed!\n");
-        return NULL;
-    }
-    fBitmap.lockPixels();
-    return fBitmap.getPixels();
-}
-
-void SkROLockPixelsPixelRef_Deprecated::onUnlockPixels() {
-    fBitmap.unlockPixels();
-}
-
-bool SkROLockPixelsPixelRef_Deprecated::onLockPixelsAreWritable() const {
-    return false;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-static SkGrTexturePixelRef* copyToTexturePixelRef(GrTexture* texture,
-                                                  SkBitmap::Config dstConfig) {
-    if (NULL == texture) {
-        return NULL;
-    }
-    GrContext* context = texture->getContext();
-    if (NULL == context) {
-        return NULL;
-    }
-    GrTextureDesc desc;
-
-    desc.fWidth  = texture->width();
-    desc.fHeight = texture->height();
-    desc.fFlags = kRenderTarget_GrTextureFlagBit | kNoStencil_GrTextureFlagBit;
-    desc.fConfig = SkGr::BitmapConfig2PixelConfig(dstConfig);
-
-    GrTexture* dst = context->createUncachedTexture(desc, NULL, 0);
-    if (NULL == dst) {
-        return NULL;
-    }
-
-    context->copyTexture(texture, dst->asRenderTarget());
-    SkGrTexturePixelRef* pixelRef = new SkGrTexturePixelRef(dst);
-    GrSafeUnref(dst);
-    return pixelRef;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-SkGrTexturePixelRef::SkGrTexturePixelRef(GrTexture* tex) {
-    fTexture = tex;
-    GrSafeRef(tex);
-}
-
-SkGrTexturePixelRef::~SkGrTexturePixelRef() {
-    GrSafeUnref(fTexture);
-}
-
-SkGpuTexture* SkGrTexturePixelRef::getTexture() {
-    return (SkGpuTexture*)fTexture;
-}
-
-SkPixelRef* SkGrTexturePixelRef::deepCopy(SkBitmap::Config dstConfig) {
-    return copyToTexturePixelRef(fTexture, dstConfig);
-}
-
-bool SkGrTexturePixelRef::onReadPixels(SkBitmap* dst, const SkIRect* subset) {
-    if (NULL != fTexture && fTexture->isValid()) {
-        int left, top, width, height;
-        if (NULL != subset) {
-            left = subset->fLeft;
-            width = subset->width();
-            top = subset->fTop;
-            height = subset->height();
-        } else {
-            left = 0;
-            width = fTexture->width();
-            top = 0;
-            height = fTexture->height();
-        }
-        dst->setConfig(SkBitmap::kARGB_8888_Config, width, height);
-        dst->allocPixels();
-        SkAutoLockPixels al(*dst);
-        void* buffer = dst->getPixels();
-        return fTexture->readPixels(left, top, width, height,
-                                    kSkia8888_PM_GrPixelConfig,
-                                    buffer, dst->rowBytes());
-    } else {
-        return false;
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-SkGrRenderTargetPixelRef::SkGrRenderTargetPixelRef(GrRenderTarget* rt) {
-    fRenderTarget = rt;
-    GrSafeRef(fRenderTarget);
-}
-
-SkGrRenderTargetPixelRef::~SkGrRenderTargetPixelRef() {
-    GrSafeUnref(fRenderTarget);
-}
-
-SkGpuTexture* SkGrRenderTargetPixelRef::getTexture() { 
-    if (NULL != fRenderTarget) {
-        return (SkGpuTexture*) fRenderTarget->asTexture();
-    }
-    return NULL;
-}
-
-SkPixelRef* SkGrRenderTargetPixelRef::deepCopy(SkBitmap::Config dstConfig) {
-    if (NULL == fRenderTarget) {
-        return NULL;
-    }
-    // Note that when copying an SkGrRenderTargetPixelRef, we actually 
-    // return an SkGrTexturePixelRef instead.  This is because
-    // SkGrRenderTargetPixelRef is usually created in conjunction with
-    // GrTexture owned elsewhere (e.g., SkGpuDevice), and cannot live
-    // independently of that texture.  SkGrTexturePixelRef, on the other
-    // hand, owns its own GrTexture, and is thus self-contained.
-    return copyToTexturePixelRef(fRenderTarget->asTexture(), dstConfig);
-}
-
-bool SkGrRenderTargetPixelRef::onReadPixels(SkBitmap* dst, const SkIRect* subset) {
-    if (NULL != fRenderTarget && fRenderTarget->isValid()) {
-        int left, top, width, height;
-        if (NULL != subset) {
-            left = subset->fLeft;
-            width = subset->width();
-            top = subset->fTop;
-            height = subset->height();
-        } else {
-            left = 0;
-            width = fRenderTarget->width();
-            top = 0;
-            height = fRenderTarget->height();
-        }
-        dst->setConfig(SkBitmap::kARGB_8888_Config, width, height);
-        dst->allocPixels();
-        SkAutoLockPixels al(*dst);
-        void* buffer = dst->getPixels();
-        return fRenderTarget->readPixels(left, top, width, height,
-                                         kSkia8888_PM_GrPixelConfig,
-                                         buffer, dst->rowBytes());
-    } else {
-        return false;
-    }
-}
-