Add direct getter for GrCaps to GrContext.

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 "GrCaps.h"
 #include "GrDrawContext.h"
 #include "GrXferProcessor.h"
 #include "SkColorFilter.h"
 #include "SkConfig8888.h"
 #include "SkData.h"
 #include "SkErrorInternals.h"
 #include "SkGrPixelRef.h"
 #include "SkMessageBus.h"
 #include "SkPixelRef.h"
 #include "SkResourceCache.h"
@@ skipping 69 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()) {
-        if (!ctx->npotTextureTileSupport() && (!SkIsPow2(width) || !SkIsPow2(height))) {
+        if (!ctx->caps()->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 81 matching lines @@
 // creates a new texture that is the input texture scaled up to the next power of two in
 // width or height. If optionalKey is valid it will be set on the new texture. stretch
 // controls whether the scaling is done using nearest or bilerp filtering.
 GrTexture* stretch_texture_to_next_pot(GrTexture* inputTexture, Stretch stretch,
                                        SkPixelRef* pixelRef,
                                        const GrUniqueKey& optionalKey) {
     SkASSERT(kNo_Stretch != stretch);
 
     GrContext* context = inputTexture->getContext();
     SkASSERT(context);
+    const GrCaps* caps = context->caps();
 
     // Either it's a cache miss or the original wasn't cached to begin with.
     GrSurfaceDesc rtDesc = inputTexture->desc();
     rtDesc.fFlags =  rtDesc.fFlags | kRenderTarget_GrSurfaceFlag;
     rtDesc.fWidth  = GrNextPow2(rtDesc.fWidth);
     rtDesc.fHeight = GrNextPow2(rtDesc.fHeight);
     rtDesc.fConfig = GrMakePixelConfigUncompressed(rtDesc.fConfig);
 
     // If the config isn't renderable try converting to either A8 or an 32 bit config. Otherwise,
     // fail.
-    if (!context->isConfigRenderable(rtDesc.fConfig, false)) {
+    if (!caps->isConfigRenderable(rtDesc.fConfig, false)) {
         if (GrPixelConfigIsAlphaOnly(rtDesc.fConfig)) {
-            if (context->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
+            if (caps->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
                 rtDesc.fConfig = kAlpha_8_GrPixelConfig;
-            } else if (context->isConfigRenderable(kSkia8888_GrPixelConfig, false)) {
+            } else if (caps->isConfigRenderable(kSkia8888_GrPixelConfig, false)) {
                 rtDesc.fConfig = kSkia8888_GrPixelConfig;
             } else {
                 return NULL;
             }
         } else if (kRGB_GrColorComponentFlags ==
                    (kRGB_GrColorComponentFlags & GrPixelConfigComponentMask(rtDesc.fConfig))) {
-            if (context->isConfigRenderable(kSkia8888_GrPixelConfig, false)) {
+            if (caps->isConfigRenderable(kSkia8888_GrPixelConfig, false)) {
                 rtDesc.fConfig = kSkia8888_GrPixelConfig;
             } else {
                 return NULL;
             }
         } else {
             return NULL;
         }
     }
 
     GrTexture* stretched = create_texture_for_bmp(context, optionalKey, rtDesc, pixelRef, NULL, 0);
@@ skipping 183 matching lines @@
 
 static GrTexture* create_unstretched_bitmap_texture(GrContext* ctx,
                                                     const SkBitmap& origBitmap,
                                                     const GrUniqueKey& optionalKey) {
     SkBitmap tmpBitmap;
 
     const SkBitmap* bitmap = &origBitmap;
 
     GrSurfaceDesc desc;
     generate_bitmap_texture_desc(*bitmap, &desc);
+    const GrCaps* caps = ctx->caps();
 
     if (kIndex_8_SkColorType == bitmap->colorType()) {
-        if (ctx->isConfigTexturable(kIndex_8_GrPixelConfig)) {
+        if (caps->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 create_texture_for_bmp(ctx, optionalKey, desc, origBitmap.pixelRef(),
                                           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
     // Make sure that the underlying device supports ETC1 textures before we go ahead
     // and check the data.
-    else if (ctx->isConfigTexturable(kETC1_GrPixelConfig)
+    else if (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())) {
         GrTexture *texture = load_etc1_texture(ctx, optionalKey, *bitmap, desc);
         if (texture) {
             return texture;
         }
     }
@@ skipping 303 matching lines @@
     }
     return SkImageInfo::Make(w, h, ct, at);
 }
 
 
 void GrWrapTextureInBitmap(GrTexture* src, int w, int h, bool isOpaque, SkBitmap* dst) {
     const SkImageInfo info = GrMakeInfoFromTexture(src, w, h, isOpaque);
     dst->setInfo(info);
     dst->setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, src)))->unref();
 }