Have GrSurfaceProxys and GrGpuResources draw from the same pool of unique ids

include/gpu/GrGpuResource.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGpuResource_DEFINED
 #define GrGpuResource_DEFINED
 
@@ skipping 162 matching lines @@
             SkASSERT(kInvalidGpuMemorySize != fGpuMemorySize);
         }
         return fGpuMemorySize;
     }
 
     /**
      * Gets an id that is unique for this GrGpuResource object. It is static in that it does
      * not change when the content of the GrGpuResource object changes. This will never return
      * 0.
      */
-    uint32_t getUniqueID() const { return fUniqueID; }
+    uint32_t uniqueID() const { return fUniqueID; }
 
     /** Returns the current unique key for the resource. It will be invalid if the resource has no
         associated unique key. */
     const GrUniqueKey& getUniqueKey() const { return fUniqueKey; }
 
     /**
      * Internal-only helper class used for manipulations of the resource by the cache.
      */
     class CacheAccess;
     inline CacheAccess cacheAccess();
@@ skipping 16 matching lines @@
      */
     void abandon();
 
     /**
      * Dumps memory usage information for this GrGpuResource to traceMemoryDump.
      * Typically, subclasses should not need to override this, and should only
      * need to override setMemoryBacking.
      **/
     virtual void dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const;
 
+    static uint32_t CreateUniqueID();
+
 protected:
     // This must be called by every non-wrapped GrGpuObject. It should be called once the object is
     // fully initialized (i.e. only from the constructors of the final class).
     void registerWithCache(SkBudgeted);
 
     // This must be called by every GrGpuObject that references any wrapped backend objects. It
     // should be called once the object is fully initialized (i.e. only from the constructors of the
     // final class).
     void registerWithCacheWrapped();
 
@@ skipping 42 matching lines @@
     void removeUniqueKey();
     void notifyAllCntsAreZero(CntType) const;
     bool notifyRefCountIsZero() const;
     void removeScratchKey();
     void makeBudgeted();
     void makeUnbudgeted();
 
 #ifdef SK_DEBUG
     friend class GrGpu; // for assert in GrGpu to access getGpu
 #endif
-
-    static uint32_t CreateUniqueID();
-
     // An index into a heap when this resource is purgeable or an array when not. This is maintained
     // by the cache.
     int                         fCacheArrayIndex;
     // This value reflects how recently this resource was accessed in the cache. This is maintained
     // by the cache.
     uint32_t                    fTimestamp;
 
     static const size_t kInvalidGpuMemorySize = ~static_cast<size_t>(0);
     GrScratchKey                fScratchKey;
     GrUniqueKey                 fUniqueKey;
 
     // This is not ref'ed but abandon() or release() will be called before the GrGpu object
     // is destroyed. Those calls set will this to NULL.
     GrGpu*                      fGpu;
     mutable size_t              fGpuMemorySize;
 
     SkBudgeted                  fBudgeted;
     bool                        fRefsWrappedObjects;
     const uint32_t              fUniqueID;
 
     typedef GrIORef<GrGpuResource> INHERITED;
     friend class GrIORef<GrGpuResource>; // to access notifyAllCntsAreZero and notifyRefCntIsZero.
 };
 
 #endif