Refugee from Dead Machine 4: MDB Monster

include/gpu/GrGpuResource.h

 /*
  * 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 GrGpuResource_DEFINED
 #define GrGpuResource_DEFINED
 
 #include "GrResourceKey.h"
 #include "GrTypesPriv.h"
 #include "SkData.h"
 
+#include "GrDrawContext.h"
+
 class GrContext;
+class GrDrawContext;
 class GrGpu;
 class GrResourceCache;
 class SkTraceMemoryDump;
+class GrRenderTarget;
+class GrSurface;
+class GrDrawTarget;
+class GrGpuResource;
+
+extern GrDrawTarget* getLastDT6(GrGpuResource* rt);
+
+// Due to header woes
+extern void addRequiredDep(GrDrawTarget* dst, GrDrawTarget* src);
 
 /**
  * Base class for GrGpuResource. Handles the various types of refs we need. Separated out as a base
  * class to isolate the ref-cnting behavior and provide friendship without exposing all of
  * GrGpuResource.
  *
  * Gpu resources can have three types of refs:
  *   1) Normal ref (+ by ref(), - by unref()): These are used by code that is issuing draw calls
  *      that read and write the resource via GrDrawTarget and by any object that must own a
  *      GrGpuResource and is itself owned (directly or indirectly) by Skia-client code.
@@ skipping 58 matching lines @@
 
     bool isPurgeable() const { return !this->internalHasRef() && !this->internalHasPendingIO(); }
 
     bool internalHasPendingRead() const { return SkToBool(fPendingReads); }
     bool internalHasPendingWrite() const { return SkToBool(fPendingWrites); }
     bool internalHasPendingIO() const { return SkToBool(fPendingWrites | fPendingReads); }
 
     bool internalHasRef() const { return SkToBool(fRefCnt); }
 
 private:
-    void addPendingRead() const {
+    void addPendingRead(const DERIVED* dst) const {
+        const DERIVED* src = static_cast<const DERIVED*>(this);
+        if ((const_cast<DERIVED*>(src))->arrgh()) {
+            SkASSERT(dst);
+            SkASSERT((const_cast<DERIVED*>(dst))->arrgh());
+
+            GrDrawTarget* dstDT = getLastDT6(const_cast<DERIVED*>(dst));
+            GrDrawTarget* srcDT = getLastDT6(const_cast<DERIVED*>(src));
+
+            SkASSERT(dstDT || !srcDT);
+
+            if (src->fromRawPixels2()) { 
+                // adding a read on uploaded content
+                SkASSERT(!srcDT);
+            } else {
+                // adding a read on rendered content
+                if (srcDT) {
+                    SkASSERT(dstDT);
+
+                    if (dstDT == srcDT) {
+                        // self-read - presumably for dst reads
+                    } else {
+                        addRequiredDep(dstDT, srcDT);
+                    }
+                }
+            }
+        }
+
         this->validate();
         ++fPendingReads;
     }
 
     void completedRead() const {
         this->validate();
         --fPendingReads;
         this->didRemoveRefOrPendingIO(kPendingRead_CntType);
     }
 
     void addPendingWrite() const {
         this->validate();
         ++fPendingWrites;
     }
 
     void completedWrite() const {
         this->validate();
         --fPendingWrites;
         this->didRemoveRefOrPendingIO(kPendingWrite_CntType);
     }
 
 private:
     void didRemoveRefOrPendingIO(CntType cntTypeRemoved) const {
         if (0 == fPendingReads && 0 == fPendingWrites && 0 == fRefCnt) {
             static_cast<const DERIVED*>(this)->notifyAllCntsAreZero(cntTypeRemoved);
         }
     }
 
+public:
     mutable int32_t fRefCnt;
     mutable int32_t fPendingReads;
     mutable int32_t fPendingWrites;
 
     // This class is used to manage conversion of refs to pending reads/writes.
     friend class GrGpuResourceRef;
     friend class GrResourceCache; // to check IO ref counts.
 
     template <typename, GrIOType> friend class GrPendingIOResource;
 };
 
+
 /**
  * Base class for objects that can be kept in the GrResourceCache.
  */
 class SK_API GrGpuResource : public GrIORef<GrGpuResource> {
 public:
+    enum Type2 {
+        kSurface,
+        kOther
+    };
 
+public:
+
+    Type2 type1() const { return fType1; }
+    virtual GrRenderTarget* arrgh() = 0;
+
+private:
+    // fFromRawPixels2, fException & fException2 are just for the alternate testing system
+    mutable bool fFromRawPixels2;
+    mutable bool fException;  // there are often textures from raw data which do not have a key
+public:
+    mutable bool fException2; // yuv textures have a key but have been rendered to
+                              // as have CMM alpha masks
+
+    void validate() const {
+        if (fException) {
+            SkASSERT(fFromRawPixels2);
+        }
+        if (!fFromRawPixels2) {
+            SkASSERT(!fException);  // can't be an exception w/o being from raw pixels
+        }    
+    }
+
+    bool fromRawPixels2() const {
+        this->validate();
+        return fFromRawPixels2;
+    }
+
+    void setFromRawPixels(bool fromRawPixels) const {
+        this->validate();
+
+        fFromRawPixels2 = fromRawPixels;
+
+        this->validate();
+    }
+
+    bool exception() const { return fException; }
+
+    void setException(bool exception) {
+        this->validate();
+        fException = exception;
+        this->validate();
+    }
 
     enum LifeCycle {
         /**
          * The resource is cached and owned by Skia. Resources with this status may be kept alive
          * by the cache as either scratch or unique resources even when there are no refs to them.
          * The cache may release them whenever there are no refs.
          */
         kCached_LifeCycle,
 
         /**
@@ skipping 105 matching lines @@
      * Typically, subclasses should not need to override this, and should only
      * need to override setMemoryBacking.
      **/
     virtual void dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const;
 
 protected:
     // This must be called by every GrGpuObject. It should be called once the object is fully
     // initialized (i.e. not in a base class constructor).
     void registerWithCache();
 
-    GrGpuResource(GrGpu*, LifeCycle);
+    GrGpuResource(GrGpu*, LifeCycle, Type2);
     virtual ~GrGpuResource();
 
     GrGpu* getGpu() const { return fGpu; }
 
     /** Overridden to free GPU resources in the backend API. */
     virtual void onRelease() { }
     /** Overridden to abandon any internal handles, ptrs, etc to backend API resources.
         This may be called when the underlying 3D context is no longer valid and so no
         backend API calls should be made. */
     virtual void onAbandon() { }
@@ skipping 60 matching lines @@
     // This is not ref'ed but abandon() or release() will be called before the GrGpu object
     // is destroyed. Those calls set will this to NULL.
     GrGpu*                      fGpu;
     mutable size_t              fGpuMemorySize;
 
     LifeCycle                   fLifeCycle;
     const uint32_t              fUniqueID;
 
     SkAutoTUnref<const SkData>  fData;
 
+    Type2                 fType1;
+
     typedef GrIORef<GrGpuResource> INHERITED;
     friend class GrIORef<GrGpuResource>; // to access notifyAllCntsAreZero and notifyRefCntIsZero.
 };
 
 #endif