More cleanup around GrContext, textures, and SkGr.cpp

src/gpu/SkGr.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGr.h"
 
-#include "GrDrawTargetCaps.h"
-#include "GrGpu.h"
-#include "GrGpuResourceCacheAccess.h"
 #include "GrXferProcessor.h"
 #include "SkColorFilter.h"
 #include "SkConfig8888.h"
 #include "SkData.h"
 #include "SkMessageBus.h"
 #include "SkPixelRef.h"
 #include "SkResourceCache.h"
 #include "SkTextureCompressor.h"
 #include "SkYUVPlanesCache.h"
 #include "effects/GrDitherEffect.h"
@@ skipping 66 matching lines @@
 
 enum Stretch {
     kNo_Stretch,
     kBilerp_Stretch,
     kNearest_Stretch
 };
 
 static Stretch get_stretch_type(const GrContext* ctx, int width, int height,
                                 const GrTextureParams* params) {
     if (params && params->isTiled()) {
-        const GrDrawTargetCaps* caps = ctx->getGpu()->caps();
-        if (!caps->npotTextureTileSupport() && (!SkIsPow2(width) || !SkIsPow2(height))) {
+        if (!ctx->npotTextureTileSupport() && (!SkIsPow2(width) || !SkIsPow2(height))) {
             switch(params->filterMode()) {
                 case GrTextureParams::kNone_FilterMode:
                     return kNearest_Stretch;
                 case GrTextureParams::kBilerp_FilterMode:
                 case GrTextureParams::kMipMap_FilterMode:
                     return kBilerp_Stretch;
             }
         }
     }
     return kNo_Stretch;
@@ skipping 102 matching lines @@
             if (context->isConfigRenderable(kSkia8888_GrPixelConfig, false)) {
                 rtDesc.fConfig = kSkia8888_GrPixelConfig;
             } else {
                 return NULL;
             }
         } else {
             return NULL;
         }
     }
 
-    GrTexture* resized = context->getGpu()->createTexture(rtDesc, true, NULL, 0);
+    GrTexture* resized = context->createTexture(rtDesc);
 
     if (!resized) {
         return NULL;
     }
     GrPaint paint;
 
     // If filtering is not desired then we want to ensure all texels in the resampled image are
     // copies of texels from the original.
     GrTextureParams params(SkShader::kClamp_TileMode,
                            kBilerp_Stretch == stretch ? GrTextureParams::kBilerp_FilterMode :
@@ skipping 13 matching lines @@
 
     return resized;
 }
 
 static GrTexture* sk_gr_allocate_texture(GrContext* ctx,
                                          const GrContentKey& optionalKey,
                                          GrSurfaceDesc desc,
                                          const void* pixels,
                                          size_t rowBytes) {
     GrTexture* result;
-    if (optionalKey.isValid()) {
+    // Compressed textures cannot be scratch.
+    if (optionalKey.isValid() || GrPixelConfigIsCompressed(desc.fConfig)) {
         result = ctx->createTexture(desc, pixels, rowBytes);
         if (result) {
             SkASSERT(ctx->addResourceToCache(optionalKey, result));
         }
 
     } else {
         result = ctx->refScratchTexture(desc, GrContext::kExact_ScratchTexMatch);
         if (pixels && result) {
             result->writePixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig, pixels, rowBytes);
         }
@@ skipping 145 matching lines @@
                                                     const SkBitmap& origBitmap,
                                                     const GrContentKey& optionalKey) {
     SkBitmap tmpBitmap;
 
     const SkBitmap* bitmap = &origBitmap;
 
     GrSurfaceDesc desc;
     generate_bitmap_texture_desc(*bitmap, &desc);
 
     if (kIndex_8_SkColorType == bitmap->colorType()) {
-        if (ctx->supportsIndex8PixelConfig()) {
+        if (ctx->isConfigTexturable(kIndex_8_GrPixelConfig)) {
             size_t imageSize = GrCompressedFormatDataSize(kIndex_8_GrPixelConfig,
                                                           bitmap->width(), bitmap->height());
             SkAutoMalloc storage(imageSize);
             build_index8_data(storage.get(), origBitmap);
 
             // our compressed data will be trimmed, so pass width() for its
             // "rowBytes", since they are the same now.
             return sk_gr_allocate_texture(ctx, optionalKey, desc, storage.get(), bitmap->width());
         } else {
             origBitmap.copyTo(&tmpBitmap, kN32_SkColorType);
             // now bitmap points to our temp, which has been promoted to 32bits
             bitmap = &tmpBitmap;
             desc.fConfig = SkImageInfo2GrPixelConfig(bitmap->info());
         }
     }
 
     // Is this an ETC1 encoded texture?
 #ifndef SK_IGNORE_ETC1_SUPPORT
-    else if (
-        // We do not support scratch ETC1 textures, hence they should all be at least
-        // trying to go to the cache.
-        optionalKey.isValid()
-        // Make sure that the underlying device supports ETC1 textures before we go ahead
-        // and check the data.
-        && ctx->getGpu()->caps()->isConfigTexturable(kETC1_GrPixelConfig)
-        // If the bitmap had compressed data and was then uncompressed, it'll still return
-        // compressed data on 'refEncodedData' and upload it. Probably not good, since if
-        // the bitmap has available pixels, then they might not be what the decompressed
-        // data is.
-        && !(bitmap->readyToDraw())) {
+    // Make sure that the underlying device supports ETC1 textures before we go ahead
+    // and check the data.
+    else if (ctx->isConfigTexturable(kETC1_GrPixelConfig)
+            // If the bitmap had compressed data and was then uncompressed, it'll still return
+            // compressed data on 'refEncodedData' and upload it. Probably not good, since if
+            // the bitmap has available pixels, then they might not be what the decompressed
+            // data is.
+            && !(bitmap->readyToDraw())) {
         GrTexture *texture = load_etc1_texture(ctx, optionalKey, *bitmap, desc);
         if (texture) {
             return texture;
         }
     }
 #endif   // SK_IGNORE_ETC1_SUPPORT
 
-    else {

[bsalomon, 2015/02/01 03:37:50]

This else meant that when etc1 was compiled in and supported, we usually
wouldn't use the yuv path!

-        GrTexture *texture = load_yuv_texture(ctx, optionalKey, *bitmap, desc);
-        if (texture) {
-            return texture;
-        }
+    GrTexture *texture = load_yuv_texture(ctx, optionalKey, *bitmap, desc);
+    if (texture) {
+        return texture;
     }
+
     SkAutoLockPixels alp(*bitmap);
     if (!bitmap->readyToDraw()) {
         return NULL;
     }
 
     return sk_gr_allocate_texture(ctx, optionalKey, desc, bitmap->getPixels(), bitmap->rowBytes());
 }
 
 static GrTexture* create_bitmap_texture(GrContext* ctx,
                                         const SkBitmap& bmp,
@@ skipping 20 matching lines @@
 
 }
 
 static GrTexture* get_texture_backing_bmp(const SkBitmap& bitmap, const GrContext* context,
                                           const GrTextureParams* params) {
     if (GrTexture* texture = bitmap.getTexture()) {
         // Our texture-resizing-for-tiling used to upscale NPOT textures for tiling only works with
         // content-key cached resources. Rather than invest in that legacy code path, we'll just
         // take the horribly slow route of causing a cache miss which will cause the pixels to be
         // read and reuploaded to a texture with a content key.
-        if (params && !context->getGpu()->caps()->npotTextureTileSupport() &&
+        if (params && !context->npotTextureTileSupport() &&
             (params->isTiled() || GrTextureParams::kMipMap_FilterMode == params->filterMode())) {
             return NULL;
         }
         return texture;
     }
     return NULL;
 }
 
 bool GrIsBitmapInCache(const GrContext* ctx,
                        const SkBitmap& bitmap,
@@ skipping 204 matching lines @@
         if (shader->asFragmentProcessor(context, skPaint, viewM, NULL, &paintColor, &fp) && fp) {
             grPaint->addColorProcessor(fp)->unref();
             constantColor = false;
         }
     }
 
     // The grcolor is automatically set when calling asFragmentProcessor.
     // If the shader can be seen as an effect it returns true and adds its effect to the grpaint.
     SkPaint2GrPaintNoShader(context, skPaint, paintColor, constantColor, grPaint);
 }