Split GrResource into GrCacheable/GrGpuObject
Before this change, an object needed to inherit from GrResource (and
thus be a GPU object) in order to live in the GrResourceCache. That
was a problem for caching items that weren't GPU objects themselves,
but owned GPU objects.
This change splits GrResource into two classes:
1. GrCacheable: The base class for objects that can live in the
GrResourceCache.
2. GrGpuObject, which inherits from GrCacheable: The base class for
objects that get tracked by GrGpu.
This change is purely a refactor; there is no change in functionality.
Change-Id: I3e8daeb1f123041f414aa306c1366e959ae9e39e
BUG=skia:
R=bsalomon@google.com
Author: cdalton@nvidia.com
Review URL: https://codereview.chromium.org/251013002
git-svn-id: http://skia.googlecode.com/svn/trunk/include@14553 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/gpu/GrCacheable.h b/gpu/GrCacheable.h
new file mode 100644
index 0000000..75dec16
--- /dev/null
+++ b/gpu/GrCacheable.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrCacheable_DEFINED
+#define GrCacheable_DEFINED
+
+#include "SkRefCnt.h"
+
+class GrResourceCacheEntry;
+
+/**
+ * Base class for objects that can be kept in the GrResourceCache.
+ */
+class GrCacheable : public SkRefCnt {
+public:
+ SK_DECLARE_INST_COUNT(GrCacheable)
+
+ /**
+ * Retrieves the amount of GPU memory used by this resource in bytes. It is
+ * approximate since we aren't aware of additional padding or copies made
+ * by the driver.
+ *
+ * @return the amount of GPU memory used in bytes
+ */
+ virtual size_t gpuMemorySize() const = 0;
+
+ /**
+ * Checks whether the GPU memory allocated to this resource is still in effect.
+ * It can become invalid if its context is destroyed or lost, in which case it
+ * should no longer count against the GrResourceCache budget.
+ *
+ * @return true if this resource is still holding GPU memory
+ * false otherwise.
+ */
+ virtual bool isValidOnGpu() const = 0;
+
+ void setCacheEntry(GrResourceCacheEntry* cacheEntry) { fCacheEntry = cacheEntry; }
+ GrResourceCacheEntry* getCacheEntry() { return fCacheEntry; }
+
+protected:
+ GrCacheable() : fCacheEntry(NULL) {}
+
+ bool isInCache() const { return NULL != fCacheEntry; }
+
+private:
+ GrResourceCacheEntry* fCacheEntry; // NULL if not in cache
+
+ typedef SkRefCnt INHERITED;
+};
+
+#endif
diff --git a/gpu/GrContext.h b/gpu/GrContext.h
index c88f469..4d0a94e 100644
--- a/gpu/GrContext.h
+++ b/gpu/GrContext.h
@@ -20,6 +20,7 @@
class GrAARectRenderer;
class GrAutoScratchTexture;
+class GrCacheable;
class GrDrawState;
class GrDrawTarget;
class GrEffect;
@@ -87,8 +88,8 @@
* buffer, etc. references/IDs are now invalid. Should be called even when
* GrContext is no longer going to be used for two reasons:
* 1) ~GrContext will not try to free the objects in the 3D API.
- * 2) If you've created GrResources that outlive the GrContext they will
- * be marked as invalid (GrResource::isValid()) and won't attempt to
+ * 2) If you've created GrGpuObjects that outlive the GrContext they will
+ * be marked as invalid (GrGpuObjects::isValid()) and won't attempt to
* free their underlying resource in the 3D API.
* Content drawn since the last GrContext::flush() may be lost.
*/
diff --git a/gpu/GrGpuObject.h b/gpu/GrGpuObject.h
new file mode 100644
index 0000000..72d2f89
--- /dev/null
+++ b/gpu/GrGpuObject.h
@@ -0,0 +1,130 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrGpuObject_DEFINED
+#define GrGpuObject_DEFINED
+
+#include "GrCacheable.h"
+#include "SkTInternalLList.h"
+
+class GrGpu;
+class GrContext;
+
+/**
+ * Base class for the GPU objects created by a GrContext.
+ */
+class GrGpuObject : public GrCacheable {
+public:
+ SK_DECLARE_INST_COUNT(GrGpuObject)
+
+ /**
+ * Frees the object in the underlying 3D API. It must be safe to call this
+ * when the object has been previously abandoned.
+ */
+ void release();
+
+ /**
+ * Removes references to objects in the underlying 3D API without freeing
+ * them. Used when the API context has been torn down before the GrContext.
+ */
+ void abandon();
+
+ /**
+ * Tests whether a object has been abandoned or released. All objects will
+ * be in this state after their creating GrContext is destroyed or has
+ * contextLost called. It's up to the client to test wasDestroyed() before
+ * attempting to use an object if it holds refs on objects across
+ * ~GrContext, freeResources with the force flag, or contextLost.
+ *
+ * @return true if the object has been released or abandoned,
+ * false otherwise.
+ */
+ bool wasDestroyed() const { return NULL == fGpu; }
+
+ /**
+ * Retrieves the context that owns the object. Note that it is possible for
+ * this to return NULL. When objects have been release()ed or abandon()ed
+ * they no longer have an owning context. Destroying a GrContext
+ * automatically releases all its resources.
+ */
+ const GrContext* getContext() const;
+ GrContext* getContext();
+
+ void incDeferredRefCount() const {
+ SkASSERT(fDeferredRefCount >= 0);
+ ++fDeferredRefCount;
+ }
+
+ void decDeferredRefCount() const {
+ SkASSERT(fDeferredRefCount > 0);
+ --fDeferredRefCount;
+ if (0 == fDeferredRefCount && this->needsDeferredUnref()) {
+ SkASSERT(this->getRefCnt() > 1);
+ this->unref();
+ }
+ }
+
+ int getDeferredRefCount() const { return fDeferredRefCount; }
+
+ void setNeedsDeferredUnref() { fFlags |= kDeferredUnref_FlagBit; }
+
+ virtual bool isValidOnGpu() const SK_OVERRIDE { return !this->wasDestroyed(); }
+
+protected:
+ /**
+ * isWrapped indicates we have wrapped a client-created backend object in a GrGpuObject. If it
+ * is true then the client is responsible for the lifetime of the underlying backend object.
+ * Otherwise, our onRelease() should free the object.
+ */
+ GrGpuObject(GrGpu* gpu, bool isWrapped);
+ virtual ~GrGpuObject();
+
+ GrGpu* getGpu() const { return fGpu; }
+
+ // Derived classes should always call their parent class' onRelease
+ // and onAbandon methods in their overrides.
+ virtual void onRelease() {};
+ virtual void onAbandon() {};
+
+ bool isWrapped() const { return kWrapped_FlagBit & fFlags; }
+ bool needsDeferredUnref() const { return SkToBool(kDeferredUnref_FlagBit & fFlags); }
+
+private:
+#ifdef SK_DEBUG
+ friend class GrGpu; // for assert in GrGpu to access getGpu
+#endif
+
+ // We're in an internal doubly linked list
+ SK_DECLARE_INTERNAL_LLIST_INTERFACE(GrGpuObject);
+
+ GrGpu* fGpu; // not reffed. The GrGpu can be deleted while there
+ // are still live GrGpuObjects. It will call
+ // release() on all such objects in its destructor.
+ mutable int fDeferredRefCount; // How many references in deferred drawing buffers.
+
+ enum Flags {
+ /**
+ * This object wraps a GPU object given to us by the user.
+ * Lifetime management is left up to the user (i.e., we will not
+ * free it).
+ */
+ kWrapped_FlagBit = 0x1,
+
+ /**
+ * This texture should be de-refed when the deferred ref count goes
+ * to zero. An object gets into this state when the resource cache
+ * is holding a ref-of-obligation (i.e., someone needs to own it but
+ * no one else wants to) but doesn't really want to keep it around.
+ */
+ kDeferredUnref_FlagBit = 0x2,
+ };
+ uint32_t fFlags;
+
+ typedef GrCacheable INHERITED;
+};
+
+#endif
diff --git a/gpu/GrRenderTarget.h b/gpu/GrRenderTarget.h
index ac3cbee..6a3f26f 100644
--- a/gpu/GrRenderTarget.h
+++ b/gpu/GrRenderTarget.h
@@ -26,7 +26,7 @@
SK_DECLARE_INST_COUNT(GrRenderTarget)
// GrResource overrides
- virtual size_t sizeInBytes() const SK_OVERRIDE;
+ virtual size_t gpuMemorySize() const SK_OVERRIDE;
// GrSurface overrides
/**
diff --git a/gpu/GrResource.h b/gpu/GrResource.h
deleted file mode 100644
index 93dec58..0000000
--- a/gpu/GrResource.h
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * Copyright 2011 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef GrResource_DEFINED
-#define GrResource_DEFINED
-
-#include "SkRefCnt.h"
-#include "SkTInternalLList.h"
-
-class GrGpu;
-class GrContext;
-class GrResourceEntry;
-
-/**
- * Base class for the GPU resources created by a GrContext.
- */
-class GrResource : public SkRefCnt {
-public:
- SK_DECLARE_INST_COUNT(GrResource)
-
- /**
- * Frees the resource in the underlying 3D API. It must be safe to call this
- * when the resource has been previously abandoned.
- */
- void release();
-
- /**
- * Removes references to objects in the underlying 3D API without freeing
- * them. Used when the API context has been torn down before the GrContext.
- */
- void abandon();
-
- /**
- * Tests whether a resource has been abandoned or released. All resources
- * will be in this state after their creating GrContext is destroyed or has
- * contextLost called. It's up to the client to test isValid() before
- * attempting to use a resource if it holds refs on resources across
- * ~GrContext, freeResources with the force flag, or contextLost.
- *
- * @return true if the resource has been released or abandoned,
- * false otherwise.
- */
- bool isValid() const { return NULL != fGpu; }
-
- /**
- * Retrieves the size of the object in GPU memory. This is approximate since
- * we aren't aware of additional padding or copies made by the driver.
- *
- * @return the size of the buffer in bytes
- */
- virtual size_t sizeInBytes() const = 0;
-
- /**
- * Retrieves the context that owns the resource. Note that it is possible
- * for this to return NULL. When resources have been release()ed or
- * abandon()ed they no longer have an owning context. Destroying a
- * GrContext automatically releases all its resources.
- */
- const GrContext* getContext() const;
- GrContext* getContext();
-
- void setCacheEntry(GrResourceEntry* cacheEntry) { fCacheEntry = cacheEntry; }
- GrResourceEntry* getCacheEntry() { return fCacheEntry; }
-
- void incDeferredRefCount() const {
- SkASSERT(fDeferredRefCount >= 0);
- ++fDeferredRefCount;
- }
-
- void decDeferredRefCount() const {
- SkASSERT(fDeferredRefCount > 0);
- --fDeferredRefCount;
- if (0 == fDeferredRefCount && this->needsDeferredUnref()) {
- SkASSERT(this->getRefCnt() > 1);
- this->unref();
- }
- }
-
- int getDeferredRefCount() const { return fDeferredRefCount; }
-
- void setNeedsDeferredUnref() { fFlags |= kDeferredUnref_FlagBit; }
-
-protected:
- /**
- * isWrapped indicates we have wrapped a client-created backend resource in a GrResource. If it
- * is true then the client is responsible for the lifetime of the underlying backend resource.
- * Otherwise, our onRelease() should free the resource.
- */
- GrResource(GrGpu* gpu, bool isWrapped);
- virtual ~GrResource();
-
- GrGpu* getGpu() const { return fGpu; }
-
- // Derived classes should always call their parent class' onRelease
- // and onAbandon methods in their overrides.
- virtual void onRelease() {};
- virtual void onAbandon() {};
-
- bool isInCache() const { return NULL != fCacheEntry; }
- bool isWrapped() const { return kWrapped_FlagBit & fFlags; }
- bool needsDeferredUnref() const { return SkToBool(kDeferredUnref_FlagBit & fFlags); }
-
-private:
-#ifdef SK_DEBUG
- friend class GrGpu; // for assert in GrGpu to access getGpu
-#endif
-
- // We're in an internal doubly linked list
- SK_DECLARE_INTERNAL_LLIST_INTERFACE(GrResource);
-
- GrGpu* fGpu; // not reffed. The GrGpu can be deleted while there
- // are still live GrResources. It will call
- // release() on all such resources in its
- // destructor.
- GrResourceEntry* fCacheEntry; // NULL if not in cache
- mutable int fDeferredRefCount; // How many references in deferred drawing buffers.
-
- enum Flags {
- /**
- * This resource wraps a GPU resource given to us by the user.
- * Lifetime management is left up to the user (i.e., we will not
- * free it).
- */
- kWrapped_FlagBit = 0x1,
-
- /**
- * This texture should be de-refed when the deferred ref count goes
- * to zero. A resource gets into this state when the resource cache
- * is holding a ref-of-obligation (i.e., someone needs to own it but
- * no one else wants to) but doesn't really want to keep it around.
- */
- kDeferredUnref_FlagBit = 0x2,
- };
- uint32_t fFlags;
-
- typedef SkRefCnt INHERITED;
-};
-
-#endif
diff --git a/gpu/GrSurface.h b/gpu/GrSurface.h
index 15e44ab..f741c77 100644
--- a/gpu/GrSurface.h
+++ b/gpu/GrSurface.h
@@ -10,14 +10,14 @@
#define GrSurface_DEFINED
#include "GrTypes.h"
-#include "GrResource.h"
+#include "GrGpuObject.h"
#include "SkRect.h"
class GrTexture;
class GrRenderTarget;
struct SkImageInfo;
-class GrSurface : public GrResource {
+class GrSurface : public GrGpuObject {
public:
SK_DECLARE_INST_COUNT(GrSurface);
@@ -144,7 +144,7 @@
GrTextureDesc fDesc;
private:
- typedef GrResource INHERITED;
+ typedef GrGpuObject INHERITED;
};
#endif // GrSurface_DEFINED
diff --git a/gpu/GrTexture.h b/gpu/GrTexture.h
index 1df9dc6..1b9f7b7 100644
--- a/gpu/GrTexture.h
+++ b/gpu/GrTexture.h
@@ -55,7 +55,7 @@
/**
* Approximate number of bytes used by the texture
*/
- virtual size_t sizeInBytes() const SK_OVERRIDE {
+ virtual size_t gpuMemorySize() const SK_OVERRIDE {
return (size_t) fDesc.fWidth *
fDesc.fHeight *
GrBytesPerPixel(fDesc.fConfig);