Temporary fix to remove drawrect call from GpuGL

src/gpu/gl/GrGpuGL.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 "GrGpuGL.h"
 #include "GrGLStencilBuffer.h"
@@ skipping 2387 matching lines @@
         desc->fConfig = src->config();
         desc->fOrigin = src->origin();
         desc->fFlags = kNone_GrSurfaceFlags;
     }
 }
 
 bool GrGpuGL::onCopySurface(GrSurface* dst,
                             GrSurface* src,
                             const SkIRect& srcRect,
                             const SkIPoint& dstPoint) {
-    bool inheritedCouldCopy = INHERITED::onCanCopySurface(dst, src, srcRect, dstPoint);
     bool copied = false;
-    bool wouldNeedTempFBO = false;
-    if (can_copy_texsubimage(dst, src, this, &wouldNeedTempFBO) &&
-        (!wouldNeedTempFBO || !inheritedCouldCopy)) {
+    if (can_copy_texsubimage(dst, src, this)) {
         GrGLuint srcFBO;
         GrGLIRect srcVP;
         srcFBO = this->bindSurfaceAsFBO(src, GR_GL_FRAMEBUFFER, &srcVP);
         GrGLTexture* dstTex = static_cast<GrGLTexture*>(dst->asTexture());
         SkASSERT(dstTex);
         // We modified the bound FBO
         fHWBoundRenderTargetUniqueID = SK_InvalidUniqueID;
         GrGLIRect srcGLRect;
         srcGLRect.setRelativeTo(srcVP,
                                 srcRect.fLeft,
@@ skipping 11 matching lines @@
             dstY = dstPoint.fY;
         }
         GL_CALL(CopyTexSubImage2D(GR_GL_TEXTURE_2D, 0,
                                   dstPoint.fX, dstY,
                                   srcGLRect.fLeft, srcGLRect.fBottom,
                                   srcGLRect.fWidth, srcGLRect.fHeight));
         copied = true;
         if (srcFBO) {
             GL_CALL(DeleteFramebuffers(1, &srcFBO));
         }
-    } else if (can_blit_framebuffer(dst, src, this, &wouldNeedTempFBO) &&
-               (!wouldNeedTempFBO || !inheritedCouldCopy)) {
+    } else if (can_blit_framebuffer(dst, src, this)) {
         SkIRect dstRect = SkIRect::MakeXYWH(dstPoint.fX, dstPoint.fY,
                                             srcRect.width(), srcRect.height());
         bool selfOverlap = false;
         if (dst->surfacePriv().isSameAs(src)) {
             selfOverlap = SkIRect::IntersectsNoEmptyCheck(dstRect, srcRect);
         }
 
         if (!selfOverlap) {
             GrGLuint dstFBO;
             GrGLuint srcFBO;
@@ skipping 42 matching lines @@
                                     GR_GL_COLOR_BUFFER_BIT, GR_GL_NEAREST));
             if (dstFBO) {
                 GL_CALL(DeleteFramebuffers(1, &dstFBO));
             }
             if (srcFBO) {
                 GL_CALL(DeleteFramebuffers(1, &srcFBO));
             }
             copied = true;
         }
     }
-    if (!copied && inheritedCouldCopy) {
-        copied = INHERITED::onCopySurface(dst, src, srcRect, dstPoint);
-        SkASSERT(copied);
-    }
     return copied;
 }
 
 bool GrGpuGL::onCanCopySurface(GrSurface* dst,
                                GrSurface* src,
                                const SkIRect& srcRect,
                                const SkIPoint& dstPoint) {
-    // This mirrors the logic in onCopySurface.
-    if (can_copy_texsubimage(dst, src, this)) {
+    // This mirrors the logic in onCopySurface.  We prefer our base makes the copy if we need to

[bsalomon, 2014/10/31 19:43:01]

Is this preference known to be valid?

+    // create a temp fbo
+    bool wouldNeedTempFBO = false;
+    if (can_copy_texsubimage(dst, src, this, &wouldNeedTempFBO) && !wouldNeedTempFBO) {
         return true;
     }
-    if (can_blit_framebuffer(dst, src, this)) {
+    if (can_blit_framebuffer(dst, src, this, &wouldNeedTempFBO) && !wouldNeedTempFBO) {
         if (dst->surfacePriv().isSameAs(src)) {
             SkIRect dstRect = SkIRect::MakeXYWH(dstPoint.fX, dstPoint.fY,
                                                 srcRect.width(), srcRect.height());
             if(!SkIRect::IntersectsNoEmptyCheck(dstRect, srcRect)) {
                 return true;
             }
         } else {
             return true;
         }
     }
-    return INHERITED::onCanCopySurface(dst, src, srcRect, dstPoint);
+    return false;
 }
 
 void GrGpuGL::didAddGpuTraceMarker() {
     if (this->caps()->gpuTracingSupport()) {
         const GrTraceMarkerSet& markerArray = this->getActiveTraceMarkers();
         SkString markerString = markerArray.toStringLast();
         GL_CALL(PushGroupMarker(0, markerString.c_str()));
     }
 }
 
@@ skipping 29 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }