Add GrProgramElement base class for GrEffect with deferred exec ref.

BUG=skia:2889
R=robertphillips@google.com

Author: bsalomon@google.com

Review URL: https://codereview.chromium.org/537773004

2 files changed, 139 insertions, 0 deletions

diff --git a/src/gpu/GrProgramElement.cpp b/src/gpu/GrProgramElement.cpp
new file mode 100644
index 0000000000..e14a85b5f4
--- /dev/null
+++ b/src/gpu/GrProgramElement.cpp
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+
+#include "GrProgramElement.h"
+#include "GrProgramResource.h"
+
+void GrProgramElement::convertRefToPendingExecution() const {
+    // This function makes it so that all the GrProgramResources own a single ref to their
+    // underlying GrGpuResource if there are any refs to the GrProgramElement and a single
+    // pending read/write if there are any pending executions of the GrProgramElement. The
+    // GrProgramResource will give up its single ref and/or pending read/write in its destructor.
+    SkASSERT(fRefCnt > 0);
+    if (0 == fPendingExecutions) {
+        for (int i = 0; i < fProgramResources.count(); ++i) {
+            fProgramResources[i]->markPendingIO();
+        }
+    }
+    ++fPendingExecutions;
+    this->unref();
+    if (0 == fRefCnt) {
+        for (int i = 0; i < fProgramResources.count(); ++i) {
+            fProgramResources[i]->removeRef();
+        }
+    }
+}
diff --git a/src/gpu/GrProgramResource.cpp b/src/gpu/GrProgramResource.cpp
new file mode 100644
index 0000000000..08975ae041
--- /dev/null
+++ b/src/gpu/GrProgramResource.cpp
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "GrProgramResource.h"
+#include "GrGpuResource.h"
+
+GrProgramResource::GrProgramResource() {
+    fResource = NULL;
+    fOwnRef = false;
+    fPendingIO = false;
+    fIOType = kNone_IOType;
+}
+
+GrProgramResource::GrProgramResource(GrGpuResource* resource, IOType ioType) {
+    fResource = NULL;
+    fOwnRef = false;
+    fPendingIO = false;
+    this->setResource(resource, ioType);
+}
+
+GrProgramResource::~GrProgramResource() {
+    if (fOwnRef) {
+        SkASSERT(NULL != fResource);
+        fResource->unref();
+    }
+    if (fPendingIO) {
+        switch (fIOType) {
+            case kNone_IOType:
+                SkFAIL("Shouldn't get here if fIOType is kNone.");
+                break;
+            case kRead_IOType:
+                fResource->completedRead();
+                break;
+            case kWrite_IOType:
+                fResource->completedWrite();
+                break;
+            case kRW_IOType:
+                fResource->completedRead();
+                fResource->completedWrite();
+                break;
+        }
+    }
+}
+
+void GrProgramResource::reset() {
+    SkASSERT(!fPendingIO);
+    SkASSERT((NULL != fResource) == fOwnRef);
+    if (fOwnRef) {
+        fResource->unref();
+        fOwnRef = false;
+        fResource = NULL;
+        fIOType = kNone_IOType;
+    }
+}
+
+void GrProgramResource::setResource(GrGpuResource* resource, IOType ioType) {
+    SkASSERT(!fPendingIO);
+    SkASSERT((NULL != fResource) == fOwnRef);
+    SkSafeUnref(fResource);
+    if (NULL == resource) {
+        fResource = NULL;
+        fOwnRef = false;
+        fIOType = kNone_IOType;
+    } else {
+        SkASSERT(kNone_IOType != ioType);
+        fResource = resource;
+        fOwnRef = true;
+        fIOType = ioType;
+    }
+}
+
+void GrProgramResource::markPendingIO() const {
+    // This should only be called once, when the owning GrProgramElement gets its first
+    // pendingExecution ref.
+    SkASSERT(!fPendingIO);
+    SkASSERT(NULL != fResource);
+    fPendingIO = true;
+    switch (fIOType) {
+        case kNone_IOType:
+            SkFAIL("GrProgramResource with neither reads nor writes?");
+            break;
+        case kRead_IOType:
+            fResource->addPendingRead();
+            break;
+        case kWrite_IOType:
+            fResource->addPendingWrite();
+            break;
+        case kRW_IOType:
+            fResource->addPendingRead();
+            fResource->addPendingWrite();
+            break;
+
+    }
+}
+
+void GrProgramResource::removeRef() const {
+    // This should only be called once, when the owners last ref goes away and
+    // there is a pending execution.
+    SkASSERT(fOwnRef);
+    SkASSERT(fPendingIO);
+    SkASSERT(kNone_IOType != fIOType);
+    SkASSERT(NULL != fResource);
+    fResource->unref();
+    fOwnRef = false;
+}