Skip temp texture when config conversion test has already failed.

src/gpu/GrContext.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 "GrContext.h"
 
@@ skipping 327 matching lines @@
         return false;
     }
 
     bool applyPremulToSrc = false;
     if (kUnpremul_PixelOpsFlag & pixelOpsFlags) {
         if (!GrPixelConfigIs8888(srcConfig)) {
             return false;
         }
         applyPremulToSrc = true;
     }
-    GrGpu::DrawPreference drawPreference = applyPremulToSrc ?
-                                            GrGpu::kCallerPrefersDraw_DrawPreference :
-                                            GrGpu::kNoDraw_DrawPreference;
+
+    GrGpu::DrawPreference drawPreference = GrGpu::kNoDraw_DrawPreference;
+    // Don't prefer to draw for the conversion (and thereby access a texture from the cache) when
+    // we've already determined that there isn't a roundtrip preserving conversion processor pair.
+    if (applyPremulToSrc && !this->didFailPMUPMConversionTest()) {
+        drawPreference = GrGpu::kCallerPrefersDraw_DrawPreference;
+    }
+
     GrGpu::WritePixelTempDrawInfo tempDrawInfo;
     if (!fGpu->getWritePixelsInfo(surface, width, height, rowBytes, srcConfig, &drawPreference,
                                   &tempDrawInfo)) {
         return false;
     }
 
     if (!(kDontFlush_PixelOpsFlag & pixelOpsFlags) && surface->surfacePriv().hasPendingIO()) {
         this->flush();
     }
 
@@ skipping 108 matching lines @@
     if (!(kDontFlush_PixelOpsFlag & flags) && src->surfacePriv().hasPendingWrite()) {
         this->flush();
     }
 
     bool unpremul = SkToBool(kUnpremul_PixelOpsFlag & flags);
     if (unpremul && !GrPixelConfigIs8888(dstConfig)) {
         // The unpremul flag is only allowed for 8888 configs.
         return false;
     }
 
-    GrGpu::DrawPreference drawPreference = unpremul ? GrGpu::kCallerPrefersDraw_DrawPreference :
-                                                      GrGpu::kNoDraw_DrawPreference;
+    GrGpu::DrawPreference drawPreference = GrGpu::kNoDraw_DrawPreference;
+    // Don't prefer to draw for the conversion (and thereby access a texture from the cache) when
+    // we've already determined that there isn't a roundtrip preserving conversion processor pair.
+    if (unpremul && !this->didFailPMUPMConversionTest()) {
+        drawPreference = GrGpu::kCallerPrefersDraw_DrawPreference;
+    }
+
     GrGpu::ReadPixelTempDrawInfo tempDrawInfo;
     if (!fGpu->getReadPixelsInfo(src, width, height, rowBytes, dstConfig, &drawPreference,
                                  &tempDrawInfo)) {
         return false;
     }
 
     SkAutoTUnref<GrRenderTarget> rtToRead(SkSafeRef(src->asRenderTarget()));
     bool didTempDraw = false;
     if (GrGpu::kNoDraw_DrawPreference != drawPreference) {
         GrTextureProvider::ScratchTexMatch match = GrTextureProvider::kApprox_ScratchTexMatch;
@@ skipping 221 matching lines @@
     GrConfigConversionEffect::PMConversion upmToPM =
         static_cast<GrConfigConversionEffect::PMConversion>(fUPMToPMConversion);
     if (GrConfigConversionEffect::kNone_PMConversion != upmToPM) {
         return GrConfigConversionEffect::Create(procDataManager, texture, swapRAndB, upmToPM,
                                                 matrix);
     } else {
         return NULL;
     }
 }
 
+bool GrContext::didFailPMUPMConversionTest() const {
+    // The PM<->UPM tests fail or succeed together so we only need to check one.
+    return fDidTestPMConversions &&
+           GrConfigConversionEffect::kNone_PMConversion == fPMToUPMConversion;
+}
+
 //////////////////////////////////////////////////////////////////////////////
 
 void GrContext::getResourceCacheLimits(int* maxTextures, size_t* maxTextureBytes) const {
     if (maxTextures) {
         *maxTextures = fResourceCache->getMaxResourceCount();
     }
     if (maxTextureBytes) {
         *maxTextureBytes = fResourceCache->getMaxResourceBytes();
     }
 }
 
 void GrContext::setResourceCacheLimits(int maxTextures, size_t maxTextureBytes) {
     fResourceCache->setLimits(maxTextures, maxTextureBytes);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 void GrContext::addGpuTraceMarker(const GrGpuTraceMarker* marker) {
     fGpu->addGpuTraceMarker(marker);
 }
 
 void GrContext::removeGpuTraceMarker(const GrGpuTraceMarker* marker) {
     fGpu->removeGpuTraceMarker(marker);
 }