Remove SkAutoTUnref and SkAutoTDelete from public includes.

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 42 matching lines @@
     static GrContext* Create(GrBackend, GrBackendContext, const GrContextOptions& options);
     static GrContext* Create(GrBackend, GrBackendContext);
 
     /**
      * Only defined in test apps.
      */
     static GrContext* CreateMockContext();
 
     virtual ~GrContext();
 
-    GrContextThreadSafeProxy* threadSafeProxy();
+    sk_sp<GrContextThreadSafeProxy> threadSafeProxy();
 
     /**
      * The GrContext normally assumes that no outsider is setting state
      * within the underlying 3D API's context/device/whatever. This call informs
      * the context that the state was modified and it should resend. Shouldn't
      * be called frequently for good performance.
      * The flag bits, state, is dpendent on which backend is used by the
      * context, either GL or D3D (possible in future).
      */
     void resetContext(uint32_t state = kAll_GrBackendState);
@@ skipping 246 matching lines @@
     /**
      * An ID associated with this context, guaranteed to be unique.
      */
     uint32_t uniqueID() { return fUniqueID; }
 
     ///////////////////////////////////////////////////////////////////////////
     // Functions intended for internal use only.
     GrGpu* getGpu() { return fGpu; }
     const GrGpu* getGpu() const { return fGpu; }
     GrBatchFontCache* getBatchFontCache() { return fBatchFontCache; }
-    GrTextBlobCache* getTextBlobCache() { return fTextBlobCache; }
+    GrTextBlobCache* getTextBlobCache() { return fTextBlobCache.get(); }
     bool abandoned() const;
     GrResourceProvider* resourceProvider() { return fResourceProvider; }
     const GrResourceProvider* resourceProvider() const { return fResourceProvider; }
     GrResourceCache* getResourceCache() { return fResourceCache; }
 
     // Called by tests that draw directly to the context via GrDrawContext
     void getTestTarget(GrTestTarget*, sk_sp<GrDrawContext>);
 
     /** Reset GPU stats */
     void resetGpuStats() const ;
@@ skipping 35 matching lines @@
     GrGpu*                                  fGpu;
     const GrCaps*                           fCaps;
     GrResourceCache*                        fResourceCache;
     // this union exists because the inheritance of GrTextureProvider->GrResourceProvider
     // is in a private header.
     union {
         GrResourceProvider*                 fResourceProvider;
         GrTextureProvider*                  fTextureProvider;
     };
 
-    SkAutoTUnref<GrContextThreadSafeProxy>  fThreadSafeProxy;
+    sk_sp<GrContextThreadSafeProxy>         fThreadSafeProxy;
 
     GrBatchFontCache*                       fBatchFontCache;
-    SkAutoTDelete<GrTextBlobCache>          fTextBlobCache;
+    std::unique_ptr<GrTextBlobCache>        fTextBlobCache;
 
     bool                                    fDidTestPMConversions;
     int                                     fPMToUPMConversion;
     int                                     fUPMToPMConversion;
     // The sw backend may call GrContext::readSurfacePixels on multiple threads
     // We may transfer the responsibilty for using a mutex to the sw backend
     // when there are fewer code paths that lead to a readSurfacePixels call
     // from the sw backend. readSurfacePixels is reentrant in one case - when performing
     // the PM conversions test. To handle this we do the PM conversions test outside
     // of fReadPixelsMutex and use a separate mutex to guard it. When it re-enters
@@ skipping 11 matching lines @@
 
     struct CleanUpData {
         PFCleanUpFunc fFunc;
         void*         fInfo;
     };
 
     SkTDArray<CleanUpData>                  fCleanUpData;
 
     const uint32_t                          fUniqueID;
 
-    SkAutoTDelete<GrDrawingManager>         fDrawingManager;
+    std::unique_ptr<GrDrawingManager>       fDrawingManager;
 
     GrAuditTrail                            fAuditTrail;
 
     // TODO: have the GrClipStackClip use drawContexts and rm this friending
     friend class GrContextPriv;
 
     GrContext(); // init must be called after the constructor.
     bool init(GrBackend, GrBackendContext, const GrContextOptions& options);
 
     void initMockContext();
@@ skipping 24 matching lines @@
 
     typedef SkRefCnt INHERITED;
 };
 
 /**
  * Can be used to perform actions related to the generating GrContext in a thread safe manner. The
  * proxy does not access the 3D API (e.g. OpenGL) that backs the generating GrContext.
  */
 class GrContextThreadSafeProxy : public SkRefCnt {
 private:
-    GrContextThreadSafeProxy(const GrCaps* caps, uint32_t uniqueID)
-        : fCaps(SkRef(caps))
+    GrContextThreadSafeProxy(sk_sp<const GrCaps> caps, uint32_t uniqueID)
+        : fCaps(std::move(caps))
         , fContextUniqueID(uniqueID) {}
 
-    SkAutoTUnref<const GrCaps>  fCaps;
-    uint32_t                    fContextUniqueID;
+    sk_sp<const GrCaps> fCaps;
+    uint32_t            fContextUniqueID;
 
     friend class GrContext;
     friend class SkImage;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif