src/third_party/skia/include/gpu/GrGpuResourceRef.h

   1 /*
   2  * Copyright 2014 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #ifndef GrGpuResourceRef_DEFINED
   9 #define GrGpuResourceRef_DEFINED
  10
  11 #include "GrGpuResource.h"
  12 #include "GrRenderTarget.h"
  13 #include "GrTexture.h"
  14 #include "SkRefCnt.h"
  15
  16 /**
  17  * This class is intended only for internal use in core Gr code.
  18  *
  19  * Class that wraps a resource referenced by a GrProgramElement or GrDrawState. It manages
  20  * converting refs to pending IO operations. It allows a resource ownership to be in three
  21  * states:
  22  *          1. Owns a single ref
  23  *          2. Owns a single ref and a pending IO operation (read, write, or read-write)
  24  *          3. Owns a single pending IO operation.
  25  *
  26  * It is legal to destroy the GrGpuResourceRef in any of these states. It starts in state
  27  * 1. Calling markPendingIO() converts it from state 1 to state 2. Calling removeRef() goes from
  28  * state 2 to state 3. Calling pendingIOComplete() moves from state 2 to state 1. There is no
  29  * valid way of going from state 3 back to 2 or 1.
  30  *
  31  * Like SkAutoTUnref, its constructor and setter adopt a ref from their caller.
  32  *
  33  * TODO: Once GrDODrawState no longer exists and therefore GrDrawState and GrOptDrawState no
  34  * longer share an instance of this class, attempt to make the resource owned by GrGpuResourceRef
  35  * only settable via the constructor.
  36  */
  37 class GrGpuResourceRef : SkNoncopyable {
  38 public:
  39     SK_DECLARE_INST_COUNT_ROOT(GrGpuResourceRef);
  40
  41     ~GrGpuResourceRef();
  42
  43     GrGpuResource* getResource() const { return fResource; }
  44
  45     /** Does this object own a pending read or write on the resource it is wrapping. */
  46     bool ownsPendingIO() const { return fPendingIO; }
  47
  48     /** Shortcut for calling setResource() with NULL. It cannot be called after markingPendingIO
  49         is called. */
  50     void reset();
  51
  52 protected:
  53     GrGpuResourceRef();
  54
  55     /** Adopts a ref from the caller. ioType expresses what type of IO operations will be marked as
  56         pending on the resource when markPendingIO is called. */
  57     GrGpuResourceRef(GrGpuResource*, GrIOType);
  58
  59     /** Adopts a ref from the caller. ioType expresses what type of IO operations will be marked as
  60         pending on the resource when markPendingIO is called. */
  61     void setResource(GrGpuResource*, GrIOType);
  62
  63 private:
  64     /** Called by owning GrProgramElement when the program element is first scheduled for
  65         execution. It can only be called once. */
  66     void markPendingIO() const;
  67
  68     /** Called when the program element/draw state is no longer owned by GrDrawTarget-client code.
  69         This lets the cache know that the drawing code will no longer schedule additional reads or
  70         writes to the resource using the program element or draw state. It can only be called once.
  71       */
  72     void removeRef() const;
  73
  74     /** Called to indicate that the previous pending IO is complete. Useful when the owning object
  75         still has refs, so it is not about to destroy this GrGpuResourceRef, but its previously
  76         pending executions have been complete. Can only be called if removeRef() was not previously
  77         called. */
  78     void pendingIOComplete() const;
  79
  80     friend class GrDrawState;
  81     friend class GrOptDrawState;
  82     friend class GrProgramElement;
  83
  84     GrGpuResource*  fResource;
  85     mutable bool    fOwnRef;
  86     mutable bool    fPendingIO;
  87     GrIOType        fIOType;
  88
  89     typedef SkNoncopyable INHERITED;
  90 };
  91
  92 /**
  93  * Templated version of GrGpuResourceRef to enforce type safety.
  94  */
  95 template <typename T> class GrTGpuResourceRef : public GrGpuResourceRef {
  96 public:
  97     GrTGpuResourceRef() {}
  98
  99     /** Adopts a ref from the caller. ioType expresses what type of IO operations will be marked as
 100         pending on the resource when markPendingIO is called. */
 101     GrTGpuResourceRef(T* resource, GrIOType ioType) : INHERITED(resource, ioType) { }
 102
 103     T* get() const { return static_cast<T*>(this->getResource()); }
 104
 105     /** Adopts a ref from the caller. ioType expresses what type of IO operations will be marked as
 106         pending on the resource when markPendingIO is called. */
 107     void set(T* resource, GrIOType ioType) { this->setResource(resource, ioType); }
 108
 109 private:
 110     typedef GrGpuResourceRef INHERITED;
 111 };
 112
 113 // Specializations for GrTexture and GrRenderTarget because they use virtual inheritance.
 114 template<> class GrTGpuResourceRef<GrTexture> : public GrGpuResourceRef {
 115 public:
 116     GrTGpuResourceRef() {}
 117
 118     GrTGpuResourceRef(GrTexture* texture, GrIOType ioType) : INHERITED(texture, ioType) { }
 119
 120     GrTexture* get() const {
 121         GrSurface* surface = static_cast<GrSurface*>(this->getResource());
 122         if (surface) {
 123             return surface->asTexture();
 124         } else {
 125             return NULL;
 126         }
 127     }
 128
 129     void set(GrTexture* texture, GrIOType ioType) { this->setResource(texture, ioType); }
 130
 131 private:
 132     typedef GrGpuResourceRef INHERITED;
 133 };
 134
 135 template<> class GrTGpuResourceRef<GrRenderTarget> : public GrGpuResourceRef {
 136 public:
 137     GrTGpuResourceRef() {}
 138
 139     GrTGpuResourceRef(GrRenderTarget* rt, GrIOType ioType) : INHERITED(rt, ioType) { }
 140
 141     GrRenderTarget* get() const {
 142         GrSurface* surface = static_cast<GrSurface*>(this->getResource());
 143         if (surface) {
 144             return surface->asRenderTarget();
 145         } else {
 146             return NULL;
 147         }
 148     }
 149
 150     void set(GrRenderTarget* rt, GrIOType ioType) { this->setResource(rt, ioType); }
 151
 152 private:
 153     typedef GrGpuResourceRef INHERITED;
 154 };
 155
 156 /**
 157  * This is similar to GrTGpuResourceRef but can only be in the pending IO state. It never owns a
 158  * ref.
 159  */
 160 template <typename T, GrIOType IO_TYPE> class GrPendingIOResource : SkNoncopyable {
 161 public:
 162     GrPendingIOResource(T* resource) : fResource(resource) {
 163         if (NULL != fResource) {
 164             switch (IO_TYPE) {
 165                 case kRead_GrIOType:
 166                     fResource->addPendingRead();
 167                     break;
 168                 case kWrite_GrIOType:
 169                     fResource->addPendingWrite();
 170                     break;
 171                 case kRW_GrIOType:
 172                     fResource->addPendingRead();
 173                     fResource->addPendingWrite();
 174                     break;
 175             }
 176         }
 177     }
 178
 179     ~GrPendingIOResource() {
 180         if (NULL != fResource) {
 181             switch (IO_TYPE) {
 182                 case kRead_GrIOType:
 183                     fResource->completedRead();
 184                     break;
 185                 case kWrite_GrIOType:
 186                     fResource->completedWrite();
 187                     break;
 188                 case kRW_GrIOType:
 189                     fResource->completedRead();
 190                     fResource->completedWrite();
 191                     break;
 192             }
 193         }
 194     }
 195
 196     T* get() const { return fResource; }
 197
 198 private:
 199     T* fResource;
 200 };
 201 #endif