GrResourceCache2 manages scratch texture.

src/gpu/GrInOrderDrawBuffer.h

 /*
  * 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 GrInOrderDrawBuffer_DEFINED
 #define GrInOrderDrawBuffer_DEFINED
 
@@ skipping 91 matching lines @@
     public:
         Draw(const DrawInfo& info, const GrVertexBuffer* vb, const GrIndexBuffer* ib)
             : DrawInfo(info)
             , fVertexBuffer(vb)
             , fIndexBuffer(ib) {}
 
         const GrVertexBuffer* vertexBuffer() const { return fVertexBuffer.get(); }
         const GrIndexBuffer* indexBuffer() const { return fIndexBuffer.get(); }
 
     private:
-        GrPendingIOResource<const GrVertexBuffer, GrIORef::kRead_IOType>    fVertexBuffer;
-        GrPendingIOResource<const GrIndexBuffer, GrIORef::kRead_IOType>     fIndexBuffer;
+        GrPendingIOResource<const GrVertexBuffer, kRead_GrIOType>    fVertexBuffer;
+        GrPendingIOResource<const GrIndexBuffer, kRead_GrIOType>     fIndexBuffer;
     };
 
     struct StencilPath : public ::SkNoncopyable {
         StencilPath(const GrPath* path) : fPath(path) {}
 
         const GrPath* path() const { return fPath.get(); }
 
         SkPath::FillType fFill;
 
     private:
-        GrPendingIOResource<const GrPath, GrIORef::kRead_IOType>   fPath;
+        GrPendingIOResource<const GrPath, kRead_GrIOType>   fPath;
     };
 
     struct DrawPath : public ::SkNoncopyable {
         DrawPath(const GrPath* path) : fPath(path) {}
 
         const GrPath* path() const { return fPath.get(); }
 
         SkPath::FillType        fFill;
         GrDeviceCoordTexture    fDstCopy;
 
     private:
-        GrPendingIOResource<const GrPath, GrIORef::kRead_IOType> fPath;
+        GrPendingIOResource<const GrPath, kRead_GrIOType> fPath;
     };
 
     struct DrawPaths : public ::SkNoncopyable {
         DrawPaths(const GrPathRange* pathRange)
             : fPathRange(pathRange) {}
 
         ~DrawPaths() {
             if (fTransforms) {
                 SkDELETE_ARRAY(fTransforms);
             }
             if (fIndices) {
                 SkDELETE_ARRAY(fIndices);
             }
         }
 
         const GrPathRange* pathRange() const { return fPathRange.get();  }
 
         uint32_t*               fIndices;
         size_t                  fCount;
         float*                  fTransforms;
         PathTransformType       fTransformsType;
         SkPath::FillType        fFill;
         GrDeviceCoordTexture    fDstCopy;
 
     private:
-        GrPendingIOResource<const GrPathRange, GrIORef::kRead_IOType> fPathRange;
+        GrPendingIOResource<const GrPathRange, kRead_GrIOType> fPathRange;
     };
 
     // This is also used to record a discard by setting the color to GrColor_ILLEGAL
     struct Clear : public ::SkNoncopyable {
         Clear(GrRenderTarget* rt) : fRenderTarget(rt) {}
         ~Clear() { }
         GrRenderTarget* renderTarget() const { return fRenderTarget.get(); }
 
         SkIRect fRect;
         GrColor fColor;
         bool    fCanIgnoreRect;
 
     private:
-        GrPendingIOResource<GrRenderTarget, GrIORef::kWrite_IOType> fRenderTarget;
+        GrPendingIOResource<GrRenderTarget, kWrite_GrIOType> fRenderTarget;
     };
 
     struct CopySurface : public ::SkNoncopyable {
         CopySurface(GrSurface* dst, GrSurface* src) : fDst(dst), fSrc(src) {}
 
         GrSurface* dst() const { return fDst.get(); }
         GrSurface* src() const { return fSrc.get(); }
 
         SkIPoint    fDstPoint;
         SkIRect     fSrcRect;
 
     private:
-        GrPendingIOResource<GrSurface, GrIORef::kWrite_IOType> fDst;
-        GrPendingIOResource<GrSurface, GrIORef::kRead_IOType> fSrc;
+        GrPendingIOResource<GrSurface, kWrite_GrIOType> fDst;
+        GrPendingIOResource<GrSurface, kRead_GrIOType> fSrc;
     };
 
     struct Clip : public ::SkNoncopyable {
         SkClipStack fStack;
         SkIPoint    fOrigin;
     };
 
     // overrides from GrDrawTarget
     virtual void onDraw(const DrawInfo&) SK_OVERRIDE;
     virtual void onDrawRect(const SkRect& rect,
@@ skipping 124 matching lines @@
     typedef SkSTArray<kGeoPoolStatePreAllocCnt, GeometryPoolState> GeoPoolStateStack;
 
     GeoPoolStateStack                                   fGeoPoolStateStack;
     bool                                                fFlushing;
     uint32_t                                            fDrawID;
 
     typedef GrDrawTarget INHERITED;
 };
 
 #endif