rename GrTextureDesc->GrSurfaceDesc, GrTextureFlags->GrSurfaceFlags

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 "SkColorFilter.h"
 #include "SkConfig8888.h"
@@ skipping 87 matching lines @@
     memcpy(key.fData8 +  8, &origin.fY, 4);
     memcpy(key.fData8 + 12, &width,     2);
     memcpy(key.fData8 + 14, &height,    2);
     static const size_t kKeyDataSize = 16;
     memset(key.fData8 + kKeyDataSize, 0, sizeof(key) - kKeyDataSize);
     GR_STATIC_ASSERT(sizeof(key) >= kKeyDataSize);
     static const GrCacheID::Domain gBitmapTextureDomain = GrCacheID::GenerateDomain();
     id->reset(gBitmapTextureDomain, key);
 }
 
-static void generate_bitmap_texture_desc(const SkBitmap& bitmap, GrTextureDesc* desc) {
-    desc->fFlags = kNone_GrTextureFlags;
+static void generate_bitmap_texture_desc(const SkBitmap& bitmap, GrSurfaceDesc* desc) {
+    desc->fFlags = kNone_GrSurfaceFlags;
     desc->fWidth = bitmap.width();
     desc->fHeight = bitmap.height();
     desc->fConfig = SkImageInfo2GrPixelConfig(bitmap.info());
     desc->fSampleCnt = 0;
 }
 
 namespace {
 
 // When the SkPixelRef genID changes, invalidate a corresponding GrResource described by key.
 class GrResourceInvalidator : public SkPixelRef::GenIDChangeListener {
@@ skipping 12 matching lines @@
 
 static void add_genID_listener(GrResourceKey key, SkPixelRef* pixelRef) {
     SkASSERT(pixelRef);
     pixelRef->addGenIDChangeListener(SkNEW_ARGS(GrResourceInvalidator, (key)));
 }
 
 static GrTexture* sk_gr_allocate_texture(GrContext* ctx,
                                          bool cache,
                                          const GrTextureParams* params,
                                          const SkBitmap& bm,
-                                         GrTextureDesc desc,
+                                         GrSurfaceDesc desc,
                                          const void* pixels,
                                          size_t rowBytes) {
     GrTexture* result;
     if (cache) {
         // This texture is likely to be used again so leave it in the cache
         GrCacheID cacheID;
         generate_bitmap_cache_id(bm, &cacheID);
 
         GrResourceKey key;
         result = ctx->createTexture(params, desc, cacheID, pixels, rowBytes, &key);
@@ skipping 10 matching lines @@
         if (pixels) {
             result->writePixels(0, 0, bm.width(), bm.height(), desc.fConfig, pixels, rowBytes);
         }
     }
     return result;
 }
 
 #ifndef SK_IGNORE_ETC1_SUPPORT
 static GrTexture *load_etc1_texture(GrContext* ctx, bool cache,
                                     const GrTextureParams* params,
-                                    const SkBitmap &bm, GrTextureDesc desc) {
+                                    const SkBitmap &bm, GrSurfaceDesc desc) {
     SkAutoTUnref<SkData> data(bm.pixelRef()->refEncodedData());
 
     // Is this even encoded data?
     if (NULL == data) {
         return NULL;
     }
 
     // Is this a valid PKM encoded data?
     const uint8_t *bytes = data->bytes();
     if (etc1_pkm_is_valid(bytes)) {
@@ skipping 28 matching lines @@
         desc.fConfig = kETC1_GrPixelConfig;
     } else {
         return NULL;
     }
 
     return sk_gr_allocate_texture(ctx, cache, params, bm, desc, bytes, 0);
 }
 #endif   // SK_IGNORE_ETC1_SUPPORT
 
 static GrTexture *load_yuv_texture(GrContext* ctx, bool cache, const GrTextureParams* params,
-                                   const SkBitmap& bm, const GrTextureDesc& desc) {
+                                   const SkBitmap& bm, const GrSurfaceDesc& desc) {
     // Subsets are not supported, the whole pixelRef is loaded when using YUV decoding
     if ((bm.pixelRef()->info().width()  != bm.info().width()) ||
         (bm.pixelRef()->info().height() != bm.info().height())) {
         return NULL;
     }
 
     SkPixelRef* pixelRef = bm.pixelRef();
     SkISize yuvSizes[3];
     if ((NULL == pixelRef) || !pixelRef->getYUV8Planes(yuvSizes, NULL, NULL, NULL)) {
         return NULL;
@@ skipping 12 matching lines @@
     planes[1] = (uint8_t*)planes[0] + sizes[0];
     planes[2] = (uint8_t*)planes[1] + sizes[1];
 
     SkYUVColorSpace colorSpace;
 
     // Get the YUV planes
     if (!pixelRef->getYUV8Planes(yuvSizes, planes, rowBytes, &colorSpace)) {
         return NULL;
     }
 
-    GrTextureDesc yuvDesc;
+    GrSurfaceDesc yuvDesc;
     yuvDesc.fConfig = kAlpha_8_GrPixelConfig;
     SkAutoTUnref<GrTexture> yuvTextures[3];
     for (int i = 0; i < 3; ++i) {
         yuvDesc.fWidth  = yuvSizes[i].fWidth;
         yuvDesc.fHeight = yuvSizes[i].fHeight;
         yuvTextures[i].reset(
             ctx->refScratchTexture(yuvDesc, GrContext::kApprox_ScratchTexMatch));
         if (!yuvTextures[i] ||
             !yuvTextures[i]->writePixels(0, 0, yuvDesc.fWidth, yuvDesc.fHeight,
                                          yuvDesc.fConfig, planes[i], rowBytes[i])) {
             return NULL;
         }
     }
 
-    GrTextureDesc rtDesc = desc;
+    GrSurfaceDesc rtDesc = desc;
     rtDesc.fFlags = rtDesc.fFlags |
-                    kRenderTarget_GrTextureFlagBit |
-                    kNoStencil_GrTextureFlagBit;
+                    kRenderTarget_GrSurfaceFlag |
+                    kNoStencil_GrSurfaceFlag;
 
     GrTexture* result = sk_gr_allocate_texture(ctx, cache, params, bm, rtDesc, NULL, 0);
 
     GrRenderTarget* renderTarget = result ? result->asRenderTarget() : NULL;
     if (renderTarget) {
         SkAutoTUnref<GrFragmentProcessor> yuvToRgbProcessor(
             GrYUVtoRGBEffect::Create(yuvTextures[0], yuvTextures[1], yuvTextures[2], colorSpace));
         GrPaint paint;
         paint.addColorProcessor(yuvToRgbProcessor);
         SkRect r = SkRect::MakeWH(SkIntToScalar(yuvSizes[0].fWidth),
@@ skipping 11 matching lines @@
 }
 
 static GrTexture* sk_gr_create_bitmap_texture(GrContext* ctx,
                                               bool cache,
                                               const GrTextureParams* params,
                                               const SkBitmap& origBitmap) {
     SkBitmap tmpBitmap;
 
     const SkBitmap* bitmap = &origBitmap;
 
-    GrTextureDesc desc;
+    GrSurfaceDesc desc;
     generate_bitmap_texture_desc(*bitmap, &desc);
 
     if (kIndex_8_SkColorType == bitmap->colorType()) {
         // build_compressed_data doesn't do npot->pot expansion
         // and paletted textures can't be sub-updated
         if (cache && ctx->supportsIndex8PixelConfig(params, bitmap->width(), bitmap->height())) {
             size_t imageSize = GrCompressedFormatDataSize(kIndex_8_GrPixelConfig,
                                                           bitmap->width(), bitmap->height());
             SkAutoMalloc storage(imageSize);
             build_index8_data(storage.get(), origBitmap);
@@ skipping 45 matching lines @@
     return sk_gr_allocate_texture(ctx, cache, params, origBitmap, desc,
                                   bitmap->getPixels(), bitmap->rowBytes());
 }
 
 bool GrIsBitmapInCache(const GrContext* ctx,
                        const SkBitmap& bitmap,
                        const GrTextureParams* params) {
     GrCacheID cacheID;
     generate_bitmap_cache_id(bitmap, &cacheID);
 
-    GrTextureDesc desc;
+    GrSurfaceDesc desc;
     generate_bitmap_texture_desc(bitmap, &desc);
     return ctx->isTextureInCache(desc, cacheID, params);
 }
 
 GrTexture* GrRefCachedBitmapTexture(GrContext* ctx,
                                     const SkBitmap& bitmap,
                                     const GrTextureParams* params) {
     GrTexture* result = NULL;
 
     bool cache = !bitmap.isVolatile();
 
     if (cache) {
         // If the bitmap isn't changing try to find a cached copy first.
 
         GrCacheID cacheID;
         generate_bitmap_cache_id(bitmap, &cacheID);
 
-        GrTextureDesc desc;
+        GrSurfaceDesc desc;
         generate_bitmap_texture_desc(bitmap, &desc);
 
         result = ctx->findAndRefTexture(desc, cacheID, params);
     }
     if (NULL == result) {
         result = sk_gr_create_bitmap_texture(ctx, cache, params, bitmap);
     }
     if (NULL == result) {
         GrPrintf("---- failed to create texture for cache [%d %d]\n",
                     bitmap.width(), bitmap.height());
@@ skipping 174 matching lines @@
         if (shader->asFragmentProcessor(context, skPaint, 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);
 }