Remove deferred clear from SkGpuDevice

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 "GrGLGLSL.h"
@@ skipping 2141 matching lines @@
         tempDrawInfo->fReadConfig = readConfig;
         return true;
     }
 
     GrRenderTarget* srcAsRT = srcSurface->asRenderTarget();
     if (!srcAsRT) {
         // For now keep assuming the draw is not a format transformation, just a draw to get to a
         // RT. We may add additional transformations below.
         ElevateDrawPreference(drawPreference, kRequireDraw_DrawPreference);
     }
-
     if (this->glCaps().rgba8888PixelsOpsAreSlow() && kRGBA_8888_GrPixelConfig == readConfig &&
         this->readPixelsSupported(kBGRA_8888_GrPixelConfig, kBGRA_8888_GrPixelConfig)) {
         tempDrawInfo->fTempSurfaceDesc.fConfig = kBGRA_8888_GrPixelConfig;
         tempDrawInfo->fSwizzle = GrSwizzle::BGRA();
         tempDrawInfo->fReadConfig = kBGRA_8888_GrPixelConfig;
         ElevateDrawPreference(drawPreference, kGpuPrefersDraw_DrawPreference);
     } else if (kMesa_GrGLDriver == this->glContext().driver() &&
                GrBytesPerPixel(readConfig) == 4 &&
                GrPixelConfigSwapRAndB(readConfig) == srcConfig &&
                this->readPixelsSupported(srcSurface, srcConfig)) {
@@ skipping 599 matching lines @@
         GL_CALL(BlendEquation(gXfermodeEquation2Blend[equation]));
         fHWBlendState.fEquation = equation;
     }
 
     if (GrBlendEquationIsAdvanced(equation)) {
         SkASSERT(this->caps()->advancedBlendEquationSupport());
         // Advanced equations have no other blend state.
         return;
     }
 
-    if (fHWBlendState.fSrcCoeff != srcCoeff ||
-        fHWBlendState.fDstCoeff != dstCoeff) {
+    if (fHWBlendState.fSrcCoeff != srcCoeff || fHWBlendState.fDstCoeff != dstCoeff) {
         GL_CALL(BlendFunc(gXfermodeCoeff2Blend[srcCoeff],
                           gXfermodeCoeff2Blend[dstCoeff]));
         fHWBlendState.fSrcCoeff = srcCoeff;
         fHWBlendState.fDstCoeff = dstCoeff;
     }
 
     if ((BlendCoeffReferencesConstant(srcCoeff) || BlendCoeffReferencesConstant(dstCoeff))) {
         GrColor blendConst = blendInfo.fBlendConstant;
         blendConst = swizzle.applyTo(blendConst);
         if (!fHWBlendState.fConstColorValid || fHWBlendState.fConstColor != blendConst) {
@@ skipping 880 matching lines @@
         case kBlend_GrXferBarrierType:
             SkASSERT(GrCaps::kAdvanced_BlendEquationSupport ==
                      this->caps()->blendEquationSupport());
             GL_CALL(BlendBarrier());
             return;
         default: break; // placate compiler warnings that kNone not handled
     }
 }
 
 GrBackendObject GrGLGpu::createTestingOnlyBackendTexture(void* pixels, int w, int h,
-                                                         GrPixelConfig config) const {
+                                                         GrPixelConfig config) {
     if (!this->caps()->isConfigTexturable(config)) {
         return false;
     }
     GrGLTextureInfo* info = new GrGLTextureInfo;
     info->fTarget = GR_GL_TEXTURE_2D;
     info->fID = 0;
     GL_CALL(GenTextures(1, &info->fID));
     GL_CALL(ActiveTexture(GR_GL_TEXTURE0));
     GL_CALL(PixelStorei(GR_GL_UNPACK_ALIGNMENT, 1));
     GL_CALL(BindTexture(info->fTarget, info->fID));
+    fHWBoundTextureUniqueIDs[0] = 0;
     GL_CALL(TexParameteri(info->fTarget, GR_GL_TEXTURE_MAG_FILTER, GR_GL_NEAREST));
     GL_CALL(TexParameteri(info->fTarget, GR_GL_TEXTURE_MIN_FILTER, GR_GL_NEAREST));
     GL_CALL(TexParameteri(info->fTarget, GR_GL_TEXTURE_WRAP_S, GR_GL_CLAMP_TO_EDGE));
     GL_CALL(TexParameteri(info->fTarget, GR_GL_TEXTURE_WRAP_T, GR_GL_CLAMP_TO_EDGE));
 
     GrGLenum internalFormat;
     GrGLenum externalFormat;
     GrGLenum externalType;
 
     if (!this->glCaps().getTexImageFormats(config, config, &internalFormat, &externalFormat,
@@ skipping 24 matching lines @@
 #else
     GrGLuint texID = reinterpret_cast<const GrGLTextureInfo*>(id)->fID;
 #endif
 
     GrGLboolean result;
     GL_CALL_RET(result, IsTexture(texID));
 
     return (GR_GL_TRUE == result);
 }
 
-void GrGLGpu::deleteTestingOnlyBackendTexture(GrBackendObject id, bool abandonTexture) const {
+void GrGLGpu::deleteTestingOnlyBackendTexture(GrBackendObject id, bool abandonTexture) {
 #ifdef SK_IGNORE_GL_TEXTURE_TARGET
     GrGLuint texID = (GrGLuint)id;
 #else
     const GrGLTextureInfo* info = reinterpret_cast<const GrGLTextureInfo*>(id);
     GrGLuint texID = info->fID;
 #endif
 
     if (!abandonTexture) {
         GL_CALL(DeleteTextures(1, &texID));
     }
@@ skipping 74 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;
 }