Refugee from Dead Machine 4: MDB Monster

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"
 #include "GrContextOptions.h"
 #include "GrDrawingManager.h"
 #include "GrDrawContext.h"
 #include "GrLayerCache.h"
 #include "GrResourceCache.h"
 #include "GrResourceProvider.h"
 #include "GrSoftwarePathRenderer.h"
 #include "GrSurfacePriv.h"
 #include "GrTextBlobCache.h"
 
 #include "SkConfig8888.h"
 #include "SkGrPriv.h"
 
 #include "effects/GrConfigConversionEffect.h"
 
+class GrDrawTarget;
+
 #define ASSERT_OWNED_RESOURCE(R) SkASSERT(!(R) || (R)->getContext() == this)
 #define RETURN_IF_ABANDONED if (fDrawingManager->abandoned()) { return; }
 #define RETURN_FALSE_IF_ABANDONED if (fDrawingManager->abandoned()) { return false; }
 #define RETURN_NULL_IF_ABANDONED if (fDrawingManager->abandoned()) { return nullptr; }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrContext* GrContext::Create(GrBackend backend, GrBackendContext backendContext) {
     GrContextOptions defaultOptions;
     return Create(backend, backendContext, defaultOptions);
@@ skipping 76 matching lines @@
     delete fResourceProvider;
     delete fResourceCache;
     delete fBatchFontCache;
 
     fGpu->unref();
     fCaps->unref();
 }
 
 void GrContext::abandonContext() {
     fResourceProvider->abandon();
+
+    fDrawingManager->abandon();
     // abandon first to so destructors
     // don't try to free the resources in the API.
     fResourceCache->abandonAll();
 
     fGpu->contextAbandoned();
 
-    fDrawingManager->abandon();
-
     fBatchFontCache->freeAll();
     fLayerCache->freeAll();
     fTextBlobCache->freeAll();
 }
 
 void GrContext::resetContext(uint32_t state) {
     fGpu->markContextDirty(state);
 }
 
 void GrContext::freeGpuResources() {
     this->flush();
 
+    //fDrawingMgr.purgeResources1();
+
     fBatchFontCache->freeAll();
     fLayerCache->freeAll();
 
     fDrawingManager->freeGpuResources();
 
     fResourceCache->purgeAllUnlocked();
 }
 
 void GrContext::getResourceCacheUsage(int* resourceCount, size_t* resourceBytes) const {
     if (resourceCount) {
@@ skipping 52 matching lines @@
 
     SkDstPixelInfo dstPI;
     dstPI.fColorType = srcPI.fColorType;
     dstPI.fAlphaType = kPremul_SkAlphaType;
     dstPI.fPixels = outPixels;
     dstPI.fRowBytes = outRowBytes;
 
     return srcPI.convertPixelsTo(&dstPI, width, height);
 }
 
-bool GrContext::writeSurfacePixels(GrSurface* surface,
+bool GrContext::writeSurfacePixels(GrDrawContext* surfaceDC, GrSurface* surface,
                                    int left, int top, int width, int height,
                                    GrPixelConfig srcConfig, const void* buffer, size_t rowBytes,
                                    uint32_t pixelOpsFlags) {
     RETURN_FALSE_IF_ABANDONED
     ASSERT_OWNED_RESOURCE(surface);
     SkASSERT(surface);
 
     this->testPMConversionsIfNecessary(pixelOpsFlags);
 
     // Trim the params here so that if we wind up making a temporary surface it can be as small as
@@ skipping 44 matching lines @@
     SkAutoSTMalloc<48 * 48, uint32_t> tmpPixels(0);
 #else
     SkAutoSTMalloc<128 * 128, uint32_t> tmpPixels(0);
 #endif
     if (tempTexture) {
         SkAutoTUnref<const GrFragmentProcessor> fp;
         SkMatrix textureMatrix;
         textureMatrix.setIDiv(tempTexture->width(), tempTexture->height());
         GrPaint paint;
         if (applyPremulToSrc) {
-            fp.reset(this->createUPMToPMEffect(tempTexture, tempDrawInfo.fSwapRAndB,
-                                               textureMatrix));
+            fp.reset(this->createUPMToPMEffect(tempTexture,
+                                               tempDrawInfo.fSwapRAndB, textureMatrix, surface->asRenderTarget()));
             // If premultiplying was the only reason for the draw, fall back to a straight write.
             if (!fp) {
                 if (GrGpu::kCallerPrefersDraw_DrawPreference == drawPreference) {
                     tempTexture.reset(nullptr);
                 }
             } else {
                 applyPremulToSrc = false;
             }
         }
         if (tempTexture) {
+            GrRenderTarget* renderTarget = surface->asRenderTarget();
+            SkASSERT(renderTarget);
             if (!fp) {
-                fp.reset(GrConfigConversionEffect::Create(tempTexture, tempDrawInfo.fSwapRAndB,
-                    GrConfigConversionEffect::kNone_PMConversion, textureMatrix));
+                fp.reset(GrConfigConversionEffect::Create(
+                    tempTexture, tempDrawInfo.fSwapRAndB,
+                    GrConfigConversionEffect::kNone_PMConversion, textureMatrix, renderTarget));
                 if (!fp) {
                     return false;
                 }
             }
-            GrRenderTarget* renderTarget = surface->asRenderTarget();
-            SkASSERT(renderTarget);
             if (tempTexture->surfacePriv().hasPendingIO()) {
                 this->flush();
             }
             if (applyPremulToSrc) {
                 size_t tmpRowBytes = 4 * width;
                 tmpPixels.reset(width * height);
                 if (!sw_convert_to_premul(srcConfig, width, height, rowBytes, buffer, tmpRowBytes,
                                           tmpPixels.get())) {
                     return false;
                 }
                 rowBytes = tmpRowBytes;
                 buffer = tmpPixels.get();
                 applyPremulToSrc = false;
             }
             if (!fGpu->writePixels(tempTexture, 0, 0, width, height,
                                    tempDrawInfo.fTempSurfaceDesc.fConfig, buffer,
                                    rowBytes)) {
                 return false;
             }
+            if (buffer) {
+                tempTexture->setFromRawPixels(true);
+                tempTexture->setException(true);
+            }
             SkMatrix matrix;
             matrix.setTranslate(SkIntToScalar(left), SkIntToScalar(top));
+
             SkAutoTUnref<GrDrawContext> drawContext(this->drawContext(renderTarget));
             if (!drawContext) {
                 return false;
             }
             paint.addColorFragmentProcessor(fp);
             SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
             drawContext->drawRect(GrClip::WideOpen(), paint, matrix, rect, nullptr);
 
             if (kFlushWrites_PixelOp & pixelOpsFlags) {
                 this->flushSurfaceWrites(surface);
             }
         }
     }
     if (!tempTexture) {
         if (applyPremulToSrc) {
             size_t tmpRowBytes = 4 * width;
             tmpPixels.reset(width * height);
             if (!sw_convert_to_premul(srcConfig, width, height, rowBytes, buffer, tmpRowBytes,
                                       tmpPixels.get())) {
                 return false;
             }
             rowBytes = tmpRowBytes;
             buffer = tmpPixels.get();
             applyPremulToSrc = false;
         }
         return fGpu->writePixels(surface, left, top, width, height, srcConfig, buffer, rowBytes);
     }
+
     return true;
 }
 
 bool GrContext::readSurfacePixels(GrSurface* src,
                                   int left, int top, int width, int height,
                                   GrPixelConfig dstConfig, void* buffer, size_t rowBytes,
                                   uint32_t flags) {
     RETURN_FALSE_IF_ABANDONED
     ASSERT_OWNED_RESOURCE(src);
     SkASSERT(src);
@@ skipping 48 matching lines @@
         } else {
             temp.reset(this->textureProvider()->createApproxTexture(tempDrawInfo.fTempSurfaceDesc));
         }
         if (temp) {
             SkMatrix textureMatrix;
             textureMatrix.setTranslate(SkIntToScalar(left), SkIntToScalar(top));
             textureMatrix.postIDiv(src->width(), src->height());
             GrPaint paint;
             SkAutoTUnref<const GrFragmentProcessor> fp;
             if (unpremul) {
-                fp.reset(this->createPMToUPMEffect(src->asTexture(), tempDrawInfo.fSwapRAndB,
-                    textureMatrix));
+                fp.reset(this->createPMToUPMEffect(
+                    src->asTexture(), tempDrawInfo.fSwapRAndB,
+                    textureMatrix, temp->asRenderTarget()));
                 if (fp) {
                     unpremul = false; // we no longer need to do this on CPU after the read back.
                 } else if (GrGpu::kCallerPrefersDraw_DrawPreference == drawPreference) {
                     // We only wanted to do the draw in order to perform the unpremul so don't
                     // bother.
                     temp.reset(nullptr);
                 }
             }
             if (!fp && temp) {
-                fp.reset(GrConfigConversionEffect::Create(src->asTexture(), tempDrawInfo.fSwapRAndB,
-                    GrConfigConversionEffect::kNone_PMConversion, textureMatrix));
+                fp.reset(GrConfigConversionEffect::Create(
+                    src->asTexture(), tempDrawInfo.fSwapRAndB,
+                    GrConfigConversionEffect::kNone_PMConversion, textureMatrix, temp->asRenderTarget()));
             }
             if (fp) {
                 paint.addColorFragmentProcessor(fp);
                 SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
                 SkAutoTUnref<GrDrawContext> drawContext(this->drawContext(temp->asRenderTarget()));
                 drawContext->drawRect(GrClip::WideOpen(), paint, SkMatrix::I(), rect, nullptr);
                 surfaceToRead.reset(SkRef(temp.get()));
                 left = 0;
                 top = 0;
                 didTempDraw = true;
@@ skipping 127 matching lines @@
         SkAutoMutexAcquire ama(fTestPMConversionsMutex);
         if (!fDidTestPMConversions) {
             test_pm_conversions(this, &fPMToUPMConversion, &fUPMToPMConversion);
             fDidTestPMConversions = true;
         }
     }
 }
 
 const GrFragmentProcessor* GrContext::createPMToUPMEffect(GrTexture* texture,
                                                           bool swapRAndB,
-                                                          const SkMatrix& matrix) const {
+                                                          const SkMatrix& matrix,
+                                                          GrRenderTarget* dst) const {
     // We should have already called this->testPMConversionsIfNecessary().
     SkASSERT(fDidTestPMConversions);
     GrConfigConversionEffect::PMConversion pmToUPM =
         static_cast<GrConfigConversionEffect::PMConversion>(fPMToUPMConversion);
     if (GrConfigConversionEffect::kNone_PMConversion != pmToUPM) {
-        return GrConfigConversionEffect::Create(texture, swapRAndB, pmToUPM, matrix);
+        return GrConfigConversionEffect::Create(texture, swapRAndB, pmToUPM,
+                                                matrix, dst);
     } else {
         return nullptr;
     }
 }
 
 const GrFragmentProcessor* GrContext::createUPMToPMEffect(GrTexture* texture,
                                                           bool swapRAndB,
-                                                          const SkMatrix& matrix) const {
+                                                          const SkMatrix& matrix, GrRenderTarget* dst) const {
     // We should have already called this->testPMConversionsIfNecessary().
     SkASSERT(fDidTestPMConversions);
     GrConfigConversionEffect::PMConversion upmToPM =
         static_cast<GrConfigConversionEffect::PMConversion>(fUPMToPMConversion);
     if (GrConfigConversionEffect::kNone_PMConversion != upmToPM) {
-        return GrConfigConversionEffect::Create(texture, swapRAndB, upmToPM, matrix);
+        return GrConfigConversionEffect::Create(texture, swapRAndB, upmToPM,
+                                                matrix, dst);
     } else {
         return nullptr;
     }
 }
 
 bool GrContext::didFailPMUPMConversionTest() const {
     // We should have already called this->testPMConversionsIfNecessary().
     SkASSERT(fDidTestPMConversions);
     // The PM<->UPM tests fail or succeed together so we only need to check one.
     return GrConfigConversionEffect::kNone_PMConversion == fPMToUPMConversion;
@@ skipping 12 matching lines @@
 
 void GrContext::setResourceCacheLimits(int maxTextures, size_t maxTextureBytes) {
     fResourceCache->setLimits(maxTextures, maxTextureBytes);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 void GrContext::dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const {
     fResourceCache->dumpMemoryStatistics(traceMemoryDump);
 }