Refugee from Dead Machine 4: MDB Monster

src/gpu/GrTextureProvider.cpp

 
 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrTextureProvider.h"
 #include "GrTexturePriv.h"
@@ skipping 12 matching lines @@
         return nullptr;
     }
     if ((desc.fFlags & kRenderTarget_GrSurfaceFlag) &&
         !fGpu->caps()->isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) {
         return nullptr;
     }
     if (!GrPixelConfigIsCompressed(desc.fConfig)) {
         static const uint32_t kFlags = kExact_ScratchTextureFlag |
                                        kNoCreate_ScratchTextureFlag;
         if (GrTexture* texture = this->refScratchTexture(desc, kFlags)) {
-            if (!srcData || texture->writePixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
+            if (!srcData || texture->writePixels(NULL, 0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
                                                  srcData, rowBytes)) {
                 if (!budgeted) {
                     texture->resourcePriv().makeUnbudgeted();
                 }
+                if (srcData) {
+                    texture->setFromRawPixels(true);
+                }
                 return texture;
             }
             texture->unref();
         }
     }
-    return fGpu->createTexture(desc, budgeted, srcData, rowBytes);
+    GrTexture* tmp = fGpu->createTexture(desc, budgeted, srcData, rowBytes);
+    if (tmp && srcData) {
+        tmp->setFromRawPixels(true);
+    }
+    return tmp;
 }
 
 GrTexture* GrTextureProvider::createApproxTexture(const GrSurfaceDesc& desc) {
-    return this->internalCreateApproxTexture(desc, 0);
+    GrTexture* texture = this->internalCreateApproxTexture(desc, 0);
+    if (texture) {
+        SkASSERT(!texture->fromRawPixels2());
+    }
+    return texture;
 }
 
 GrTexture* GrTextureProvider::internalCreateApproxTexture(const GrSurfaceDesc& desc,
                                                           uint32_t scratchFlags) {
     if (this->isAbandoned()) {
         return nullptr;
     }
     // Currently we don't recycle compressed textures as scratch.
     if (GrPixelConfigIsCompressed(desc.fConfig)) {
         return nullptr;
@@ skipping 28 matching lines @@
             // writePixels() which will trigger a flush if the texture has pending IO.
             scratchFlags = GrResourceCache::kPreferNoPendingIO_ScratchFlag;
         }
         GrGpuResource* resource = fCache->findAndRefScratchResource(key,
                                                                    GrSurface::WorseCaseSize(*desc),
                                                                    scratchFlags);
         if (resource) {
             GrSurface* surface = static_cast<GrSurface*>(resource);
             GrRenderTarget* rt = surface->asRenderTarget();
             if (rt && fGpu->caps()->discardRenderTargetSupport()) {
+                // trash the existing DC in this case
                 rt->discard();
             }
             return surface->asTexture();
         }
     }
 
     if (!(kNoCreate_ScratchTextureFlag & flags)) {
         return fGpu->createTexture(*desc, true, nullptr, 0);
     }
 
@@ skipping 20 matching lines @@
     resource->resourcePriv().setUniqueKey(key);
 }
 
 bool GrTextureProvider::existsResourceWithUniqueKey(const GrUniqueKey& key) const {
     return this->isAbandoned() ? false : fCache->hasUniqueKey(key);
 }
 
 GrGpuResource* GrTextureProvider::findAndRefResourceByUniqueKey(const GrUniqueKey& key) {
     return this->isAbandoned() ? nullptr : fCache->findAndRefUniqueResource(key);
 }