Add guards to GrTextureProvider

include/gpu/GrTextureProvider.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrTextureProvider_DEFINED
 #define GrTextureProvider_DEFINED
 
 #include "GrTexture.h"
 #include "SkImageFilter.h"
 
+class GrSingleOwner;
+
 class SK_API GrTextureProvider {
 public:
     ///////////////////////////////////////////////////////////////////////////
     // Textures
 
     /**
      * Creates a new texture in the resource cache and returns it. The caller owns a
      * ref on the returned texture which must be balanced by a call to unref.
      *
      * @param desc      Description of the texture properties.
@@ skipping 11 matching lines @@
         return this->createTexture(desc, budgeted, NULL, 0);
     }
 
     /** Assigns a unique key to the texture. The texture will be findable via this key using
         findTextureByUniqueKey(). If an existing texture has this key, it's key will be removed. */
     void assignUniqueKeyToTexture(const GrUniqueKey& key, GrTexture* texture) {
         this->assignUniqueKeyToResource(key, texture);
     }
 
     /** Finds a texture by unique key. If the texture is found it is ref'ed and returned. */
-    GrTexture* findAndRefTextureByUniqueKey(const GrUniqueKey& key) {
-        GrGpuResource* resource = this->findAndRefResourceByUniqueKey(key);
-        if (resource) {
-            GrTexture* texture = static_cast<GrSurface*>(resource)->asTexture();
-            SkASSERT(texture);
-            return texture;
-        }
-        return NULL;
-    }
+    GrTexture* findAndRefTextureByUniqueKey(const GrUniqueKey& key);
 
     /**
      * Determines whether a texture is associated with the unique key. If the texture is found it
      * will not be locked or returned. This call does not affect the priority of the resource for
      * deletion.
      */
     bool existsTextureWithUniqueKey(const GrUniqueKey& key) const {
         return this->existsResourceWithUniqueKey(key);
     }
 
@@ skipping 63 matching lines @@
      * similar to wrapBackendTexture but can be used to draw into surfaces
      * that are not also textures (e.g. FBO 0 in OpenGL, or an MSAA buffer that
      * the client will resolve to a texture). Currently wrapped render targets
      * always use the kBorrow_GrWrapOwnership semantics.
      *
      * @return GrTexture object or NULL on failure.
      */
      GrRenderTarget* wrapBackendRenderTarget(const GrBackendRenderTargetDesc& desc);
 
 protected:
-    GrTextureProvider(GrGpu* gpu, GrResourceCache* cache) : fCache(cache), fGpu(gpu) {}
+    GrTextureProvider(GrGpu* gpu, GrResourceCache* cache, GrSingleOwner* singleOwner);
 
     /**
      * Assigns a unique key to a resource. If the key is associated with another resource that
      * association is removed and replaced by this resource.
      */
     void assignUniqueKeyToResource(const GrUniqueKey&, GrGpuResource*);
 
     /**
      * Finds a resource in the cache, based on the specified key. This is intended for use in
      * conjunction with addResourceToCache(). The return value will be NULL if not found. The
@@ skipping 31 matching lines @@
     const GrGpu* gpu() const { return fGpu; }
 
     bool isAbandoned() const {
         SkASSERT(SkToBool(fGpu) == SkToBool(fCache));
         return !SkToBool(fCache);
     }
 
 private:
     GrResourceCache* fCache;
     GrGpu* fGpu;
+
+    // In debug builds we guard against improper thread handling
+    SkDEBUGCODE(mutable GrSingleOwner* fSingleOwner;)
 };
 
 #endif