Merge GrGpuObject and GrCacheable.

src/gpu/GrStencilAndCoverTextContext.cpp

 /*
  * 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 "GrStencilAndCoverTextContext.h"
 #include "GrDrawTarget.h"
 #include "GrGpu.h"
 #include "GrPath.h"
 #include "GrPathRange.h"
 #include "SkAutoKern.h"
 #include "SkDraw.h"
 #include "SkDrawProcs.h"
 #include "SkGlyphCache.h"
 #include "SkGpuDevice.h"
 #include "SkPath.h"
 #include "SkTextMapStateProc.h"
 
-class GrStencilAndCoverTextContext::GlyphPathRange : public GrCacheable {
+class GrStencilAndCoverTextContext::GlyphPathRange : public GrGpuObject {
     static const int kMaxGlyphCount = 1 << 16; // Glyph IDs are uint16_t's
     static const int kGlyphGroupSize = 16; // Glyphs get tracked in groups of 16
 
 public:
     static GlyphPathRange* Create(GrContext* context,
                                   SkGlyphCache* cache,
                                   const SkStrokeRec& stroke) {
         static const GrCacheID::Domain gGlyphPathRangeDomain = GrCacheID::GenerateDomain();
 
         GrCacheID::Key key;
@@ skipping 36 matching lines @@
             const SkGlyph& skGlyph = cache->getGlyphIDMetrics(id);
             if (const SkPath* skPath = cache->findPath(skGlyph)) {
                 fPathRange->initAt(id, *skPath);
             } // GrGpu::drawPaths will silently ignore undefined paths.
         }
 
         fLoadedGlyphs[groupByte] |= groupBit;
         this->didChangeGpuMemorySize();
     }
 
-    // GrCacheable overrides
+    // GrGpuObject overrides
     virtual size_t gpuMemorySize() const SK_OVERRIDE { return fPathRange->gpuMemorySize(); }
-    virtual bool isValidOnGpu() const SK_OVERRIDE { return fPathRange->isValidOnGpu(); }
 
 private:
     GlyphPathRange(GrContext* context, const SkDescriptor& desc, const SkStrokeRec& stroke)
-        : fDesc(desc.copy())
+        : INHERITED(context->getGpu(), false)
+        , fDesc(desc.copy())
         // We reserve a range of kMaxGlyphCount paths because of fallbacks fonts. We
         // can't know exactly how many glyphs we might need without preloading every
         // fallback, which we don't want to do at this point.
         , fPathRange(context->getGpu()->createPathRange(kMaxGlyphCount, stroke)) {
         memset(fLoadedGlyphs, 0, sizeof(fLoadedGlyphs));
     }
 
     ~GlyphPathRange() {
+        this->release();
         SkDescriptor::Free(fDesc);
     }
 
+    virtual void onRelease() SK_OVERRIDE {
+        INHERITED::onRelease();
+        fPathRange.reset(NULL);
+    }
+
+    virtual void onAbandon() SK_OVERRIDE {
+        INHERITED::onAbandon();
+        fPathRange->abandon();
+        fPathRange.reset(NULL);
+    }
+
+
     static const int kMaxGroupCount = (kMaxGlyphCount + (kGlyphGroupSize - 1)) / kGlyphGroupSize;
     SkDescriptor* const fDesc;
     uint8_t fLoadedGlyphs[(kMaxGroupCount + 7) >> 3]; // One bit per glyph group
     SkAutoTUnref<GrPathRange> fPathRange;
 
-    typedef GrCacheable INHERITED;
+    typedef GrGpuObject INHERITED;
 };
 
 
 GrStencilAndCoverTextContext::GrStencilAndCoverTextContext(
     GrContext* context, const SkDeviceProperties& properties)
     : GrTextContext(context, properties)
     , fStroke(SkStrokeRec::kFill_InitStyle)
     , fPendingGlyphCount(0) {
 }
 
@@ skipping 293 matching lines @@
     fGlyphCache = NULL;
 
     fDrawTarget->drawState()->stencil()->setDisabled();
     fStateRestore.set(NULL);
     if (fNeedsDeviceSpaceGlyphs) {
         fContext->setMatrix(fGlyphTransform);
     }
     GrTextContext::finish();
 }