Revert of Add direct getter for GrCaps to GrContext. (patchset #4 id:60001 of https://codereview.chromium.org/1149773005/)

Reason for revert:
Breaking

Original issue's description:
> Add direct getter for GrCaps to GrContext.
>
> TBR=joshualitt@google.com
>
> Committed: https://skia.googlesource.com/skia/+/9138c46e572085870638b6f7ad7fcdfcdf3cac99

TBR=joshualitt@google.com
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true

Review URL: https://codereview.chromium.org/1164443002

bench/nanobench.cpp

@@ -43,7 +43,6 @@
 
 #if SK_SUPPORT_GPU
     #include "gl/GrGLDefines.h"
-    #include "GrCaps.h"
     #include "GrContextFactory.h"
     SkAutoTDelete<GrContextFactory> gGrFactory;
 #endif
@@ -373,7 +372,7 @@ static bool is_gpu_config_allowed(const char* name, GrContextFactory::GLContextT
         return false;
     }
     if (const GrContext* ctx = gGrFactory->get(ctxType)) {
-        return sampleCnt <= ctx->caps()->maxSampleCount();
+        return sampleCnt <= ctx->getMaxSampleCount();
     }
     return false;
 }

include/gpu/GrContext.h

@@ -20,7 +20,6 @@
 
 class GrAARectRenderer;
 class GrBatchFontCache;
-class GrCaps;
 struct GrContextOptions;
 class GrDrawContext;
 class GrDrawTarget;
@@ -156,8 +155,45 @@ public:
      */
     void purgeAllUnlockedResources();
 
-    /** Access the context capabilities */
+    //////////////////////////////////////////////////////////////////////////
-    const GrCaps* caps() const { return fCaps; }
+    /// Texture and Render Target Queries
+
+    /**
+     * Are shader derivatives supported?
+     */
+    bool shaderDerivativeSupport() const;
+
+    /**
+     * Can the provided configuration act as a texture?
+     */
+    bool isConfigTexturable(GrPixelConfig) const;
+
+    /**
+     * Can non-power-of-two textures be used with tile modes other than clamp?
+     */
+    bool npotTextureTileSupport() const;
+
+    /**
+     *  Return the max width or height of a texture supported by the current GPU.
+     */
+    int getMaxTextureSize() const;
+
+    /**
+     * Can the provided configuration act as a color render target?
+     */
+    bool isConfigRenderable(GrPixelConfig config, bool withMSAA) const;
+
+    /**
+     * Return the max width or height of a render target supported by the
+     * current GPU.
+     */
+    int getMaxRenderTargetSize() const;
+
+    /**
+     * Returns the max sample count for a render target. It will be 0 if MSAA
+     * is not supported.
+     */
+    int getMaxSampleCount() const;
 
     /**
      * Returns the recommended sample count for a render target when using this
@@ -356,7 +392,6 @@ public:
 
 private:
     GrGpu*                          fGpu;
-    const GrCaps*                   fCaps;
     GrResourceCache*                fResourceCache;
     // this union exists because the inheritance of GrTextureProvider->GrResourceProvider
     // is in a private header.

src/core/SkPictureShader.cpp

@@ -17,7 +17,6 @@
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
-#include "GrCaps.h"
 #endif
 
 namespace {
@@ -346,7 +345,7 @@ bool SkPictureShader::asFragmentProcessor(GrContext* context, const SkPaint& pai
                                           GrFragmentProcessor** fp) const {
     int maxTextureSize = 0;
     if (context) {
-        maxTextureSize = context->caps()->maxTextureSize();
+        maxTextureSize = context->getMaxTextureSize();
     }
     SkAutoTUnref<SkShader> bitmapShader(this->refBitmapShader(viewM, localMatrix, maxTextureSize));
     if (!bitmapShader) {

src/effects/SkAlphaThresholdFilter.cpp

@@ -271,7 +271,7 @@ bool SkAlphaThresholdFilterImpl::asFragmentProcessor(GrFragmentProcessor** fp,
     if (fp) {
         GrContext* context = texture->getContext();
         GrSurfaceDesc maskDesc;
-        if (context->caps()->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
+        if (context->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
             maskDesc.fConfig = kAlpha_8_GrPixelConfig;
         } else {
             maskDesc.fConfig = kRGBA_8888_GrPixelConfig;

src/effects/SkGpuBlurUtils.cpp

@@ -13,7 +13,6 @@
 #include "effects/GrConvolutionEffect.h"
 #include "effects/GrMatrixConvolutionEffect.h"
 #include "GrContext.h"
-#include "GrCaps.h"
 #include "GrDrawContext.h"
 #endif
 
@@ -155,7 +154,7 @@ GrTexture* GaussianBlur(GrContext* context,
     SkIRect clearRect;
     int scaleFactorX, radiusX;
     int scaleFactorY, radiusY;
-    int maxTextureSize = context->caps()->maxTextureSize();
+    int maxTextureSize = context->getMaxTextureSize();
     sigmaX = adjust_sigma(sigmaX, maxTextureSize, &scaleFactorX, &radiusX);
     sigmaY = adjust_sigma(sigmaY, maxTextureSize, &scaleFactorY, &radiusY);
 

src/gpu/GrAddPathRenderers_default.cpp

@@ -27,7 +27,7 @@
 #endif
 
 void GrPathRenderer::AddPathRenderers(GrContext* ctx, GrPathRendererChain* chain) {
-    chain->addPathRenderer(SkNEW(GrDashLinePathRenderer))->unref();
+    chain->addPathRenderer(SkNEW_ARGS(GrDashLinePathRenderer, (ctx)))->unref();
 
 #if GR_STROKE_PATH_RENDERING
     chain->addPathRenderer(SkNEW(GrStrokePathRenderer))->unref();
@@ -36,7 +36,7 @@ void GrPathRenderer::AddPathRenderers(GrContext* ctx, GrPathRendererChain* chain
     chain->addPathRenderer(SkNEW(GrAndroidPathRenderer))->unref();
 #endif
     if (GrPathRenderer* pr = GrStencilAndCoverPathRenderer::Create(ctx->resourceProvider(),
-                                                                   *ctx->caps())) {
+                                                                   *ctx->getGpu()->caps())) {
         chain->addPathRenderer(pr)->unref();
     }
 #if GR_TESSELLATING_PATH_RENDERING

src/gpu/GrAtlasTextContext.cpp

@@ -460,7 +460,7 @@ inline bool GrAtlasTextContext::canDrawAsDistanceFields(const SkPaint& skPaint,
     // rasterizers and mask filters modify alpha, which doesn't
     // translate well to distance
     if (skPaint.getRasterizer() || skPaint.getMaskFilter() ||
-        !fContext->caps()->shaderCaps()->shaderDerivativeSupport()) {
+        !fContext->shaderDerivativeSupport()) {
         return false;
     }
 

src/gpu/GrBlurUtils.cpp

@@ -7,7 +7,6 @@
 
 #include "GrBlurUtils.h"
 #include "GrDrawContext.h"
-#include "GrCaps.h"
 #include "GrContext.h"
 #include "effects/GrSimpleTextureEffect.h"
 #include "GrStrokeInfo.h"
@@ -111,7 +110,7 @@ static GrTexture* create_mask_GPU(GrContext* context,
     // render target so default to RGBA_8888
     desc.fConfig = kRGBA_8888_GrPixelConfig;
 
-    if (context->caps()->isConfigRenderable(kAlpha_8_GrPixelConfig, desc.fSampleCnt > 0)) {
+    if (context->isConfigRenderable(kAlpha_8_GrPixelConfig, desc.fSampleCnt > 0)) {
         desc.fConfig = kAlpha_8_GrPixelConfig;
     }
 

src/gpu/GrClipMaskManager.cpp

@@ -489,7 +489,7 @@ GrTexture* GrClipMaskManager::createTempMask(int width, int height) {
     desc.fFlags = kRenderTarget_GrSurfaceFlag;
     desc.fWidth = width;
     desc.fHeight = height;
-    if (this->getContext()->caps()->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
+    if (this->getContext()->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
         desc.fConfig = kAlpha_8_GrPixelConfig;
     } else {
         desc.fConfig = kRGBA_8888_GrPixelConfig;
@@ -526,8 +526,7 @@ GrTexture* GrClipMaskManager::allocMaskTexture(int32_t elementsGenID,
     desc.fWidth = clipSpaceIBounds.width();
     desc.fHeight = clipSpaceIBounds.height();
     desc.fConfig = kRGBA_8888_GrPixelConfig;
-    if (willUpload ||
+    if (willUpload || this->getContext()->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
-        this->getContext()->caps()->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
         // We would always like A8 but it isn't supported on all platforms
         desc.fConfig = kAlpha_8_GrPixelConfig;
     }

src/gpu/GrContext.cpp

@@ -138,7 +138,6 @@ static int32_t next_id() {
 
 GrContext::GrContext() : fUniqueID(next_id()) {
     fGpu = NULL;
-    fCaps = NULL;
     fResourceCache = NULL;
     fResourceProvider = NULL;
     fPathRendererChain = NULL;
@@ -174,13 +173,10 @@ void GrContext::initCommon() {
     fBatchFontCache = SkNEW_ARGS(GrBatchFontCache, (this));
 
     fTextBlobCache.reset(SkNEW_ARGS(GrTextBlobCache, (TextBlobCacheOverBudgetCB, this)));
-
-    fCaps = SkRef(fGpu->caps());
 }
 
 GrContext::~GrContext() {
     if (!fGpu) {
-        SkASSERT(!fCaps);
         return;
     }
 
@@ -195,7 +191,6 @@ GrContext::~GrContext() {
     SkDELETE(fBatchFontCache);
 
     fGpu->unref();
-    fCaps->unref();
     SkSafeUnref(fPathRendererChain);
     SkSafeUnref(fSoftwarePathRenderer);
 }
@@ -263,6 +258,18 @@ GrTextContext* GrContext::createTextContext(GrRenderTarget* renderTarget,
 
 ////////////////////////////////////////////////////////////////////////////////
 
+bool GrContext::shaderDerivativeSupport() const {
+    return fGpu->caps()->shaderCaps()->shaderDerivativeSupport();
+}
+
+bool GrContext::isConfigTexturable(GrPixelConfig config) const {
+    return fGpu->caps()->isConfigTexturable(config);
+}
+
+bool GrContext::npotTextureTileSupport() const {
+    return fGpu->caps()->npotTextureTileSupport();
+}
+
 void GrContext::OverBudgetCB(void* data) {
     SkASSERT(data);
 
@@ -283,6 +290,18 @@ void GrContext::TextBlobCacheOverBudgetCB(void* data) {
     context->flush();
 }
 
+int GrContext::getMaxTextureSize() const {
+    return fGpu->caps()->maxTextureSize();
+}
+
+int GrContext::getMaxRenderTargetSize() const {
+    return fGpu->caps()->maxRenderTargetSize();
+}
+
+int GrContext::getMaxSampleCount() const {
+    return fGpu->caps()->maxSampleCount();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrContext::flush(int flagsBitfield) {
@@ -668,9 +687,13 @@ GrPathRenderer* GrContext::getPathRenderer(const GrDrawTarget* target,
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+bool GrContext::isConfigRenderable(GrPixelConfig config, bool withMSAA) const {
+    return fGpu->caps()->isConfigRenderable(config, withMSAA);
+}
+
 int GrContext::getRecommendedSampleCount(GrPixelConfig config,
                                          SkScalar dpi) const {
-    if (!this->caps()->isConfigRenderable(config, true)) {
+    if (!this->isConfigRenderable(config, true)) {
         return 0;
     }
     int chosenSampleCount = 0;

src/gpu/GrCoordTransform.cpp

@@ -27,7 +27,7 @@ void GrCoordTransform::reset(GrCoordSet sourceCoords, const SkMatrix& m, const G
     int subPixelThresh = filter > GrTextureParams::kNone_FilterMode ? 4 : 1;
     fPrecision = kDefault_GrSLPrecision;
     if (texture->getContext()) {
-        const GrShaderCaps* caps = texture->getContext()->caps()->shaderCaps();
+        const GrShaderCaps* caps = texture->getContext()->getGpu()->caps()->shaderCaps();
         if (caps->floatPrecisionVaries()) {
             int maxD = SkTMax(texture->width(), texture->height());
             const GrShaderCaps::PrecisionInfo* info;

src/gpu/GrDashLinePathRenderer.cpp

@@ -10,6 +10,13 @@
 #include "GrGpu.h"
 #include "effects/GrDashingEffect.h"
 
+GrDashLinePathRenderer::GrDashLinePathRenderer(GrContext* context)
+        : fGpu(SkRef(context->getGpu())) {
+}
+
+GrDashLinePathRenderer::~GrDashLinePathRenderer() {
+}
+
 bool GrDashLinePathRenderer::canDrawPath(const GrDrawTarget* target,
                                          const GrPipelineBuilder* pipelineBuilder,
                                          const SkMatrix& viewMatrix,

src/gpu/GrDashLinePathRenderer.h

@@ -13,6 +13,9 @@
 
 class GrDashLinePathRenderer : public GrPathRenderer {
 public:
+    GrDashLinePathRenderer(GrContext*);
+    ~GrDashLinePathRenderer();
+
     bool canDrawPath(const GrDrawTarget*,
                      const GrPipelineBuilder*,
                      const SkMatrix& viewMatrix,

src/gpu/GrDrawTarget.cpp

@@ -32,7 +32,7 @@
 
 GrDrawTarget::GrDrawTarget(GrContext* context)
     : fContext(context)
-    , fCaps(SkRef(context->caps()))
+    , fCaps(SkRef(context->getGpu()->caps()))
     , fGpuTraceMarkerCount(0)
     , fFlushing(false) {
     SkASSERT(context);

src/gpu/GrInOrderDrawBuffer.cpp

@@ -9,14 +9,15 @@
 
 // We will use the reordering buffer, unless we have NVPR.
 // TODO move NVPR to batch so we can reorder
-static inline bool allow_reordering(const GrCaps* caps) {
+static inline bool allow_reordering(const GrGpu* gpu) {
-    //return !caps->shaderCaps()->pathRenderingSupport();
+    //const GrCaps* caps = gpu->caps();
+    //return caps && caps->shaderCaps() && !caps->shaderCaps()->pathRenderingSupport();
     return false;
 }
 
 GrInOrderDrawBuffer::GrInOrderDrawBuffer(GrContext* context)
     : INHERITED(context)
-    , fCommands(GrCommandBuilder::Create(context->getGpu(), allow_reordering(context->caps())))
+    , fCommands(GrCommandBuilder::Create(context->getGpu(), allow_reordering(context->getGpu())))
     , fPathIndexBuffer(kPathIdxBufferMinReserve * sizeof(char)/4)
     , fPathTransformBuffer(kPathXformBufferMinReserve * sizeof(float)/4)
     , fPipelineBuffer(kPipelineBufferMinReserve)

src/gpu/GrPathRendererChain.cpp

@@ -78,9 +78,9 @@ GrPathRenderer* GrPathRendererChain::getPathRenderer(const GrDrawTarget* target,
 
 void GrPathRendererChain::init() {
     SkASSERT(!fInit);
-    const GrCaps* caps = fOwner->caps();
+    GrGpu* gpu = fOwner->getGpu();
-    bool twoSided = caps->twoSidedStencilSupport();
+    bool twoSided = gpu->caps()->twoSidedStencilSupport();
-    bool wrapOp = caps->stencilWrapOpsSupport();
+    bool wrapOp = gpu->caps()->stencilWrapOpsSupport();
     GrPathRenderer::AddPathRenderers(fOwner, this);
     this->addPathRenderer(SkNEW_ARGS(GrDefaultPathRenderer,
                                      (twoSided, wrapOp)))->unref();

src/gpu/GrSWMaskHelper.cpp

@@ -174,8 +174,8 @@ bool GrSWMaskHelper::init(const SkIRect& resultBounds,
                                      resultBounds.height());
 
     if (allowCompression &&
-        fContext->caps()->drawPathMasksToCompressedTexturesSupport() &&
+        fContext->getGpu()->caps()->drawPathMasksToCompressedTexturesSupport() &&
-        choose_compressed_fmt(fContext->caps(), &fCompressedFormat)) {
+        choose_compressed_fmt(fContext->getGpu()->caps(), &fCompressedFormat)) {
         fCompressionMode = kCompress_CompressionMode;
     }
 
@@ -245,7 +245,7 @@ GrTexture* GrSWMaskHelper::createTexture() {
 #endif
 
         desc.fConfig = fmt_to_config(fCompressedFormat);
-        SkASSERT(fContext->caps()->isConfigTexturable(desc.fConfig));
+        SkASSERT(fContext->getGpu()->caps()->isConfigTexturable(desc.fConfig));
     }
 
     return fContext->textureProvider()->refScratchTexture(
@@ -256,7 +256,7 @@ void GrSWMaskHelper::sendTextureData(GrTexture *texture, const GrSurfaceDesc& de
                                      const void *data, size_t rowbytes) {
     // If we aren't reusing scratch textures we don't need to flush before
     // writing since no one else will be using 'texture'
-    bool reuseScratch = fContext->caps()->reuseScratchTextures();
+    bool reuseScratch = fContext->getGpu()->caps()->reuseScratchTextures();
 
     // Since we're uploading to it, and it's compressed, 'texture' shouldn't
     // have a render target.

src/gpu/SkGpuDevice.cpp

@@ -910,7 +910,7 @@ void SkGpuDevice::drawBitmapCommon(const SkDraw& draw,
     // FIXME: the tiled bitmap code path doesn't currently support
     // anti-aliased edges, we work around that for now by drawing directly
     // if the image size exceeds maximum texture size.
-    int maxTextureSize = fContext->caps()->maxTextureSize();
+    int maxTextureSize = fContext->getMaxTextureSize();
     bool directDraw = fRenderTarget->isMultisampled() ||
                       !paint.isAntiAlias() ||
                       bitmap.width() > maxTextureSize ||
@@ -1034,7 +1034,7 @@ void SkGpuDevice::drawBitmapCommon(const SkDraw& draw,
     }
     params.setFilterMode(textureFilterMode);
 
-    int maxTileSize = fContext->caps()->maxTextureSize() - 2 * tileFilterPad;
+    int maxTileSize = fContext->getMaxTextureSize() - 2 * tileFilterPad;
     int tileSize;
 
     SkIRect clippedSrcRect;
@@ -1163,8 +1163,8 @@ void SkGpuDevice::internalDrawBitmap(const SkBitmap& bitmap,
                                      SkCanvas::DrawBitmapRectFlags flags,
                                      bool bicubic,
                                      bool needsTextureDomain) {
-    SkASSERT(bitmap.width() <= fContext->caps()->maxTextureSize() &&
+    SkASSERT(bitmap.width() <= fContext->getMaxTextureSize() &&
-             bitmap.height() <= fContext->caps()->maxTextureSize());
+             bitmap.height() <= fContext->getMaxTextureSize());
 
     GrTexture* texture;
     AutoBitmapTexture abt(fContext, bitmap, &params, &texture);

src/gpu/SkGr.cpp

@@ -7,7 +7,6 @@
 
 #include "SkGr.h"
 
-#include "GrCaps.h"
 #include "GrDrawContext.h"
 #include "GrXferProcessor.h"
 #include "SkColorFilter.h"
@@ -97,7 +96,7 @@ enum Stretch {
 static Stretch get_stretch_type(const GrContext* ctx, int width, int height,
                                 const GrTextureParams* params) {
     if (params && params->isTiled()) {
-        if (!ctx->caps()->npotTextureTileSupport() && (!SkIsPow2(width) || !SkIsPow2(height))) {
+        if (!ctx->npotTextureTileSupport() && (!SkIsPow2(width) || !SkIsPow2(height))) {
             switch(params->filterMode()) {
                 case GrTextureParams::kNone_FilterMode:
                     return kNearest_Stretch;
@@ -199,7 +198,6 @@ GrTexture* stretch_texture_to_next_pot(GrTexture* inputTexture, 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();
@@ -210,18 +208,18 @@ GrTexture* stretch_texture_to_next_pot(GrTexture* inputTexture, Stretch stretch,
 
     // If the config isn't renderable try converting to either A8 or an 32 bit config. Otherwise,
     // fail.
-    if (!caps->isConfigRenderable(rtDesc.fConfig, false)) {
+    if (!context->isConfigRenderable(rtDesc.fConfig, false)) {
         if (GrPixelConfigIsAlphaOnly(rtDesc.fConfig)) {
-            if (caps->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
+            if (context->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
                 rtDesc.fConfig = kAlpha_8_GrPixelConfig;
-            } else if (caps->isConfigRenderable(kSkia8888_GrPixelConfig, false)) {
+            } else if (context->isConfigRenderable(kSkia8888_GrPixelConfig, false)) {
                 rtDesc.fConfig = kSkia8888_GrPixelConfig;
             } else {
                 return NULL;
             }
         } else if (kRGB_GrColorComponentFlags ==
                    (kRGB_GrColorComponentFlags & GrPixelConfigComponentMask(rtDesc.fConfig))) {
-            if (caps->isConfigRenderable(kSkia8888_GrPixelConfig, false)) {
+            if (context->isConfigRenderable(kSkia8888_GrPixelConfig, false)) {
                 rtDesc.fConfig = kSkia8888_GrPixelConfig;
             } else {
                 return NULL;
@@ -425,10 +423,9 @@ static GrTexture* create_unstretched_bitmap_texture(GrContext* ctx,
 
     GrSurfaceDesc desc;
     generate_bitmap_texture_desc(*bitmap, &desc);
-    const GrCaps* caps = ctx->caps();
 
     if (kIndex_8_SkColorType == bitmap->colorType()) {
-        if (caps->isConfigTexturable(kIndex_8_GrPixelConfig)) {
+        if (ctx->isConfigTexturable(kIndex_8_GrPixelConfig)) {
             size_t imageSize = GrCompressedFormatDataSize(kIndex_8_GrPixelConfig,
                                                           bitmap->width(), bitmap->height());
             SkAutoMalloc storage(imageSize);
@@ -450,7 +447,7 @@ static GrTexture* create_unstretched_bitmap_texture(GrContext* ctx,
 #ifndef SK_IGNORE_ETC1_SUPPORT
     // Make sure that the underlying device supports ETC1 textures before we go ahead
     // and check the data.
-    else if (caps->isConfigTexturable(kETC1_GrPixelConfig)
+    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

tests/GrDrawTargetTest.cpp

@@ -29,7 +29,7 @@ DEF_GPUTEST(GrDrawTarget, reporter, factory) {
             continue;
         }
 
-        test_print(reporter, grContext->caps());
+        test_print(reporter, grContext->getGpu()->caps());
     }
 }
 

tests/GrPorterDuffTest.cpp

@@ -949,7 +949,7 @@ static void test_no_dual_source_blending(skiatest::Reporter* reporter) {
         return;
     }
 
-    const GrCaps& caps = *ctx->caps();
+    const GrCaps& caps = *ctx->getGpu()->caps();
     if (caps.shaderCaps()->dualSourceBlendingSupport()) {
         SkFAIL("Null context failed to honor request for no ARB_blend_func_extended.");
         return;

tests/ResourceCacheTest.cpp

@@ -122,7 +122,7 @@ static void test_stencil_buffers(skiatest::Reporter* reporter, GrContext* contex
                     smallRT0->asRenderTarget()->renderTargetPriv().getStencilAttachment() !=
                     bigRT->asRenderTarget()->renderTargetPriv().getStencilAttachment());
 
-    if (context->caps()->maxSampleCount() >= 4) {
+    if (context->getMaxSampleCount() >= 4) {
         // An RT with a different sample count should not share. 
         GrSurfaceDesc smallMSAADesc = smallDesc;
         smallMSAADesc.fSampleCnt = 4;
@@ -154,8 +154,7 @@ static void test_stencil_buffers(skiatest::Reporter* reporter, GrContext* contex
                         smallMSAART1->asRenderTarget()->renderTargetPriv().getStencilAttachment());
         // But not one with a larger sample count should not. (Also check that the request for 4
         // samples didn't get rounded up to >= 8 or else they could share.).
-        if (context->caps()->maxSampleCount() >= 8 &&
+        if (context->getMaxSampleCount() >= 8 && smallMSAART0 && smallMSAART0->asRenderTarget() &&
-            smallMSAART0 && smallMSAART0->asRenderTarget() &&
             smallMSAART0->asRenderTarget()->numSamples() < 8) {
             smallMSAADesc.fSampleCnt = 8;
             smallMSAART1.reset(cache->createTexture(smallMSAADesc, false));