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

src/gpu/gl/GrGLGpu.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLGpu.h"
 #include "GrGLBuffer.h"
 #include "GrGLGLSL.h"
@@ skipping 2131 matching lines @@
     this->handleDirtyContext();
 
     // Index buffer state is tied to the vertex array.
     if (kIndex_GrBufferType == type) {
         this->bindVertexArray(0);
     }
 
     SkASSERT(type >= 0 && type <= kLast_GrBufferType);
     auto& bufferState = fHWBufferState[type];
 
-    if (buffer->getUniqueID() != bufferState.fBoundBufferUniqueID) {
+    if (buffer->uniqueID() != bufferState.fBoundBufferUniqueID) {
         if (buffer->isCPUBacked()) {
             if (!bufferState.fBufferZeroKnownBound) {
                 GL_CALL(BindBuffer(bufferState.fGLTarget, 0));
             }
         } else {
             const GrGLBuffer* glBuffer = static_cast<const GrGLBuffer*>(buffer);
             GL_CALL(BindBuffer(bufferState.fGLTarget, glBuffer->bufferID()));
         }
         bufferState.fBufferZeroKnownBound = buffer->isCPUBacked();
-        bufferState.fBoundBufferUniqueID = buffer->getUniqueID();
+        bufferState.fBoundBufferUniqueID = buffer->uniqueID();
     }
 
     return bufferState.fGLTarget;
 }
 
 void GrGLGpu::notifyBufferReleased(const GrGLBuffer* buffer) {
     if (buffer->hasAttachedToTexture()) {
         // Detach this buffer from any textures to ensure the underlying memory is freed.
-        uint32_t uniqueID = buffer->getUniqueID();
+        uint32_t uniqueID = buffer->uniqueID();
         for (int i = fHWMaxUsedBufferTextureUnit; i >= 0; --i) {
             auto& buffTex = fHWBufferTextures[i];
             if (uniqueID != buffTex.fAttachedBufferUniqueID) {
                 continue;
             }
             if (i == fHWMaxUsedBufferTextureUnit) {
                 --fHWMaxUsedBufferTextureUnit;
             }
 
             this->setTextureUnit(i);
@@ skipping 467 matching lines @@
         SkASSERT(fMSAAEnabled != kYes_TriState);
         GL_CALL(Enable(GR_GL_SHADER_PIXEL_LOCAL_STORAGE));
         this->stampPLSSetupRect(SkRect::MakeXYWH(-100.0f, -100.0f, 0.01f, 0.01f));
         GL_CALL(Disable(GR_GL_SHADER_PIXEL_LOCAL_STORAGE));
     }
 }
 
 void GrGLGpu::flushRenderTarget(GrGLRenderTarget* target, const SkIRect* bounds, bool disableSRGB) {
     SkASSERT(target);
 
-    uint32_t rtID = target->getUniqueID();
+    uint32_t rtID = target->uniqueID();
     if (fHWBoundRenderTargetUniqueID != rtID) {
         fStats.incRenderTargetBinds();
         GL_CALL(BindFramebuffer(GR_GL_FRAMEBUFFER, target->renderFBOID()));
 #ifdef SK_DEBUG
         // don't do this check in Chromium -- this is causing
         // lots of repeated command buffer flushes when the compositor is
         // rendering with Ganesh, which is really slow; even too slow for
         // Debug mode.
         if (kChromium_GrGLDriver != this->glContext().driver()) {
             GrGLenum status;
@@ skipping 501 matching lines @@
 #endif
 
     // If we created a rt/tex and rendered to it without using a texture and now we're texturing
     // from the rt it will still be the last bound texture, but it needs resolving. So keep this
     // out of the "last != next" check.
     GrGLRenderTarget* texRT = static_cast<GrGLRenderTarget*>(texture->asRenderTarget());
     if (texRT) {
         this->onResolveRenderTarget(texRT);
     }
 
-    uint32_t textureID = texture->getUniqueID();
+    uint32_t textureID = texture->uniqueID();
     GrGLenum target = texture->target();
     if (fHWBoundTextureUniqueIDs[unitIdx] != textureID) {
         this->setTextureUnit(unitIdx);
         GL_CALL(BindTexture(target, texture->textureID()));
         fHWBoundTextureUniqueIDs[unitIdx] = textureID;
     }
 
     ResetTimestamp timestamp;
     const GrGLTexture::TexParams& oldTexParams = texture->getCachedTexParams(&timestamp);
     bool setAll = timestamp < this->getResetTimestamp();
@@ skipping 97 matching lines @@
                 return;
             }
         }
 
         this->setTextureUnit(unitIdx);
         GL_CALL(BindTexture(GR_GL_TEXTURE_BUFFER, buffTex.fTextureID));
 
         buffTex.fKnownBound = true;
     }
 
-    if (buffer->getUniqueID() != buffTex.fAttachedBufferUniqueID ||
+    if (buffer->uniqueID() != buffTex.fAttachedBufferUniqueID ||
         buffTex.fTexelConfig != texelConfig) {
 
         this->setTextureUnit(unitIdx);
         GL_CALL(TexBuffer(GR_GL_TEXTURE_BUFFER,
                           this->glCaps().configSizedInternalFormat(texelConfig),
                           buffer->bufferID()));
 
         buffTex.fTexelConfig = texelConfig;
-        buffTex.fAttachedBufferUniqueID = buffer->getUniqueID();
+        buffTex.fAttachedBufferUniqueID = buffer->uniqueID();
 
         if (this->glCaps().textureSwizzleSupport() &&
             this->glCaps().configSwizzle(texelConfig) != buffTex.fSwizzle) {
             GrGLenum glSwizzle[4];
             get_tex_param_swizzle(texelConfig, this->glCaps(), glSwizzle);
             this->setTextureSwizzle(unitIdx, GR_GL_TEXTURE_BUFFER, glSwizzle);
             buffTex.fSwizzle = this->glCaps().configSwizzle(texelConfig);
         }
 
         buffer->setHasAttachedToTexture();
@@ skipping 1350 matching lines @@
         if (GR_GL_TEXTURE_EXTERNAL == glTexture->target() ||
             GR_GL_TEXTURE_RECTANGLE == glTexture->target()) {
             copyParams->fFilter = GrTextureParams::kNone_FilterMode;
             copyParams->fWidth = texture->width();
             copyParams->fHeight = texture->height();
             return true;
         }
     }
     return false;
 }