remove SkInstCnt

include/gpu/GrContext.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrContext_DEFINED
 #define GrContext_DEFINED
 
@@ skipping 28 matching lines @@
 class GrTestTarget;
 class GrTextBlobCache;
 class GrTextContext;
 class GrTextureParams;
 class GrVertexBuffer;
 class GrStrokeInfo;
 class GrSoftwarePathRenderer;
 
 class SK_API GrContext : public SkRefCnt {
 public:
-    SK_DECLARE_INST_COUNT(GrContext)
-
     /**
      * Creates a GrContext for a backend context.
      */
     static GrContext* Create(GrBackend, GrBackendContext, const GrContextOptions& options);
     static GrContext* Create(GrBackend, GrBackendContext);
 
     /**
      * Only defined in test apps.
      */
     static GrContext* CreateMockContext();
@@ skipping 22 matching lines @@
      * The 'info' parameter will be stored and passed to the callback function.
      */
     void addCleanUp(PFCleanUpFunc cleanUp, void* info) {
         CleanUpData* entry = fCleanUpData.push();
 
         entry->fFunc = cleanUp;
         entry->fInfo = info;
     }
 
     /**
-     * Abandons all GPU resources and assumes the underlying backend 3D API 
+     * Abandons all GPU resources and assumes the underlying backend 3D API
      * context is not longer usable. Call this if you have lost the associated
      * GPU context, and thus internal texture, buffer, etc. references/IDs are
      * now invalid. Should be called even when GrContext is no longer going to
      * be used for two reasons:
      *  1) ~GrContext will not try to free the objects in the 3D API.
      *  2) Any GrGpuResources created by this GrContext that outlive
      *     will be marked as invalid (GrGpuResource::wasDestroyed()) and
      *     when they're destroyed no 3D API calls will be made.
      * Content drawn since the last GrContext::flush() may be lost. After this
      * function is called the only valid action on the GrContext or
@@ skipping 61 matching lines @@
      * @param  config the configuration of the render target.
      * @param  dpi the display density in dots per inch.
      *
      * @return sample count that should be perform well and have good enough
      *         rendering quality for the display. Alternatively returns 0 if
      *         MSAA is not supported or recommended to be used by default.
      */
     int getRecommendedSampleCount(GrPixelConfig config, SkScalar dpi) const;
 
     /**
-     * Returns a helper object to orchestrate draws. 
+     * Returns a helper object to orchestrate draws.
      * Callers should take a ref if they rely on the GrDrawContext sticking around.
      * NULL will be returned if the context has been abandoned.
      *
      * @param  devProps the device properties (mainly defines text drawing)
      *
      * @return a draw context
      */
     GrDrawContext* drawContext(const SkSurfaceProps* surfaceProps = NULL) {
-        return fDrawingMgr.drawContext(surfaceProps);    
+        return fDrawingMgr.drawContext(surfaceProps);
     }
 
     ///////////////////////////////////////////////////////////////////////////
     // Misc.
 
     /**
      * Flags that affect flush() behavior.
      */
     enum FlushBits {
         /**
          * A client may reach a point where it has partially rendered a frame
          * through a GrContext that it knows the user will never see. This flag
          * causes the flush to skip submission of deferred content to the 3D API
          * during the flush.
          */
         kDiscard_FlushBit                    = 0x2,
     };
 
     /**
      * Call to ensure all drawing to the context has been issued to the
      * underlying 3D API.
      * @param flagsBitfield     flags that control the flushing behavior. See
      *                          FlushBits.
      */
     void flush(int flagsBitfield = 0);
 
     void flushIfNecessary() {
         if (fFlushToReduceCacheSize) {
             this->flush();
-        }    
+        }
     }
 
    /**
     * These flags can be used with the read/write pixels functions below.
     */
     enum PixelOpsFlags {
         /** The GrContext will not be flushed before the surface read or write. This means that
             the read or write may occur before previous draws have executed. */
         kDontFlush_PixelOpsFlag = 0x1,
         /** Any surface writes should be flushed to the backend 3D API after the surface operation
@@ skipping 131 matching lines @@
     /** Prints GPU stats to the string if GR_GPU_STATS == 1. */
     void dumpGpuStats(SkString*) const;
     void printGpuStats() const;
 
 private:
     GrGpu*                          fGpu;
     const GrCaps*                   fCaps;
     GrResourceCache*                fResourceCache;
     // this union exists because the inheritance of GrTextureProvider->GrResourceProvider
     // is in a private header.
-    union { 
+    union {
         GrResourceProvider*         fResourceProvider;
         GrTextureProvider*          fTextureProvider;
     };
 
     GrBatchFontCache*               fBatchFontCache;
     SkAutoTDelete<GrLayerCache>     fLayerCache;
     SkAutoTDelete<GrTextBlobCache>  fTextBlobCache;
 
     GrPathRendererChain*            fPathRendererChain;
     GrSoftwarePathRenderer*         fSoftwarePathRenderer;
@@ skipping 14 matching lines @@
     const uint32_t                  fUniqueID;
 
     GrContext(); // init must be called after the constructor.
     bool init(GrBackend, GrBackendContext, const GrContextOptions& options);
 
     // Currently the DrawingMgr stores a separate GrDrawContext for each
     // combination of text drawing options (pixel geometry x DFT use)
     // and hands the appropriate one back given the user's request.
     // All of the GrDrawContexts still land in the same GrDrawTarget!
     //
-    // In the future this class will allocate a new GrDrawContext for 
+    // In the future this class will allocate a new GrDrawContext for
     // each GrRenderTarget/GrDrawTarget and manage the DAG.
     class DrawingMgr {
     public:
         DrawingMgr() : fDrawTarget(NULL) {
             sk_bzero(fDrawContext, sizeof(fDrawContext));
         }
 
         ~DrawingMgr();
 
         void init(GrContext* context);
@@ skipping 45 matching lines @@
     /**
      * A callback similar to the above for use by the TextBlobCache
      * TODO move textblob draw calls below context so we can use the call above.
      */
     static void TextBlobCacheOverBudgetCB(void* data);
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif