diff --git a/gpu/src/GrAAHairLinePathRenderer.cpp b/gpu/src/GrAAHairLinePathRenderer.cpp
index 8349fa7..4d05a6b 100644
--- a/gpu/src/GrAAHairLinePathRenderer.cpp
+++ b/gpu/src/GrAAHairLinePathRenderer.cpp
@@ -87,7 +87,7 @@
 }
 
 bool GrAAHairLinePathRenderer::CanBeUsed(const GrContext* context) {
-    return context->getGpu()->supportsShaderDerivatives();
+    return context->getGpu()->getCaps().fShaderDerivativeSupport;
 
 }
 
diff --git a/gpu/src/GrBufferAllocPool.cpp b/gpu/src/GrBufferAllocPool.cpp
index 667e437..715d4a9 100644
--- a/gpu/src/GrBufferAllocPool.cpp
+++ b/gpu/src/GrBufferAllocPool.cpp
@@ -91,7 +91,7 @@
         fFirstPreallocBuffer = (fFirstPreallocBuffer + fPreallocBuffersInUse) %
                                fPreallocBuffers.count();
     }
-    fCpuData.reset(fGpu->supportsBufferLocking() ? 0 : fMinBlockSize);
+    fCpuData.reset(fGpu->getCaps().fBufferLockSupport ? 0 : fMinBlockSize);
     GrAssert(0 == fPreallocBuffersInUse);
     VALIDATE();
 }
@@ -276,7 +276,7 @@
 
     GrAssert(NULL == fBufferPtr);
 
-    if (fGpu->supportsBufferLocking() &&
+    if (fGpu->getCaps().fBufferLockSupport &&
         size > GR_GEOM_BUFFER_LOCK_THRESHOLD &&
         (!fFrequentResetHint || requestSize > GR_GEOM_BUFFER_LOCK_THRESHOLD)) {
         fBufferPtr = block.fBuffer->lock();
@@ -318,7 +318,7 @@
     GrAssert(flushSize <= buffer->sizeInBytes());
 
     bool updated = false;
-    if (fGpu->supportsBufferLocking() &&
+    if (fGpu->getCaps().fBufferLockSupport &&
         flushSize > GR_GEOM_BUFFER_LOCK_THRESHOLD) {
         void* data = buffer->lock();
         if (NULL != data) {
diff --git a/gpu/src/GrContext.cpp b/gpu/src/GrContext.cpp
index 6de3169..ee38d72 100644
--- a/gpu/src/GrContext.cpp
+++ b/gpu/src/GrContext.cpp
@@ -166,13 +166,13 @@
     // we assume we only need 16 bits of width and height
     // assert that texture creation will fail anyway if this assumption
     // would cause key collisions.
-    GrAssert(gpu->maxTextureSize() <= SK_MaxU16);
+    GrAssert(gpu->getCaps().fMaxTextureSize <= SK_MaxU16);
     v[0] = clientKey & 0xffffffffUL;
     v[1] = (clientKey >> 32) & 0xffffffffUL;
     v[2] = width | (height << 16);
 
     v[3] = 0;
-    if (!gpu->npotTextureTileSupport()) {
+    if (!gpu->getCaps().fNPOTTextureTileSupport) {
         bool isPow2 = GrIsPow2(width) && GrIsPow2(height);
 
         bool tiled = (sampler.getWrapX() != GrSamplerState::kClamp_WrapMode) ||
@@ -310,10 +310,12 @@
         rtDesc.fFlags =  rtDesc.fFlags |
                          kRenderTarget_GrTextureFlagBit |
                          kNoStencil_GrTextureFlagBit;
-        rtDesc.fWidth  = GrNextPow2(GrMax<int>(desc.fWidth,
-                                               fGpu->minRenderTargetWidth()));
-        rtDesc.fHeight = GrNextPow2(GrMax<int>(desc.fHeight,
-                                               fGpu->minRenderTargetHeight()));
+        rtDesc.fWidth  =
+            GrNextPow2(GrMax<int>(desc.fWidth,
+                                  fGpu->getCaps().fMinRenderTargetWidth));
+        rtDesc.fHeight =
+            GrNextPow2(GrMax<int>(desc.fHeight,
+                                  fGpu->getCaps().fMinRenderTargetHeight));
 
         GrTexture* texture = fGpu->createTexture(rtDesc, NULL, 0);
 
@@ -510,11 +512,11 @@
 }
 
 int GrContext::getMaxTextureSize() const {
-    return fGpu->maxTextureSize();
+    return fGpu->getCaps().fMaxTextureSize;
 }
 
 int GrContext::getMaxRenderTargetSize() const {
-    return fGpu->maxRenderTargetSize();
+    return fGpu->getCaps().fMaxRenderTargetSize;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -541,21 +543,21 @@
 
 bool GrContext::supportsIndex8PixelConfig(const GrSamplerState& sampler,
                                           int width, int height) const {
-    if (!fGpu->supports8BitPalette()) {
+    const GrDrawTarget::Caps& caps = fGpu->getCaps();
+    if (!caps.f8BitPaletteSupport) {
         return false;
     }
 
-
     bool isPow2 = GrIsPow2(width) && GrIsPow2(height);
 
     if (!isPow2) {
-        if (!fGpu->npotTextureSupport()) {
+        if (!caps.fNPOTTextureSupport) {
             return false;
         }
 
         bool tiled = sampler.getWrapX() != GrSamplerState::kClamp_WrapMode ||
                      sampler.getWrapY() != GrSamplerState::kClamp_WrapMode;
-        if (tiled && !fGpu->npotTextureTileSupport()) {
+        if (tiled && !caps.fNPOTTextureTileSupport) {
             return false;
         }
     }
@@ -659,7 +661,7 @@
     // Line primitves are always rasterized as 1 pixel wide.
     // Super-sampling would make them too thin but MSAA would be OK.
     if (isHairLines &&
-        (!PREFER_MSAA_OFFSCREEN_AA || !fGpu->supportsFullsceneAA())) {
+        (!PREFER_MSAA_OFFSCREEN_AA || !fGpu->getCaps().fFSAASupport)) {
         return false;
     }
     if (target->getRenderTarget()->isMultisampled()) {
@@ -708,12 +710,12 @@
 
     desc.fFormat = kRGBA_8888_GrPixelConfig;
 
-    if (PREFER_MSAA_OFFSCREEN_AA && fGpu->supportsFullsceneAA()) {
+    if (PREFER_MSAA_OFFSCREEN_AA && fGpu->getCaps().fFSAASupport) {
         record->fDownsample = OffscreenRecord::kFSAA_Downsample;
         record->fScale = 1;
         desc.fAALevel = kMed_GrAALevel;
     } else {
-        record->fDownsample = (fGpu->supportsShaders()) ?
+        record->fDownsample = fGpu->getCaps().fShaderSupport ?
                                 OffscreenRecord::k4x4SinglePass_Downsample :
                                 OffscreenRecord::k4x4TwoPass_Downsample;
         record->fScale = OFFSCREEN_SSAA_SCALE;
@@ -1519,7 +1521,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrContext::supportsShaders() const {
-    return fGpu->supportsShaders();
+    return fGpu->getCaps().fShaderSupport;
 }
 
 void GrContext::flush(int flagsBitfield) {
@@ -1773,8 +1775,8 @@
     fAAFillRectIndexBuffer = NULL;
     fAAStrokeRectIndexBuffer = NULL;
     
-    int gpuMaxOffscreen = fGpu->maxRenderTargetSize();
-    if (!PREFER_MSAA_OFFSCREEN_AA || !fGpu->supportsFullsceneAA()) {
+    int gpuMaxOffscreen = gpu->getCaps().fMaxRenderTargetSize;
+    if (!PREFER_MSAA_OFFSCREEN_AA || !gpu->getCaps().fFSAASupport) {
         gpuMaxOffscreen /= OFFSCREEN_SSAA_SCALE;
     }
     fMaxOffscreenAASize = GrMin(GR_MAX_OFFSCREEN_AA_SIZE, gpuMaxOffscreen);
diff --git a/gpu/src/GrDrawTarget.cpp b/gpu/src/GrDrawTarget.cpp
index 51cff6d..bfcc07d 100644
--- a/gpu/src/GrDrawTarget.cpp
+++ b/gpu/src/GrDrawTarget.cpp
@@ -1041,3 +1041,23 @@
     fIndices = NULL;
 }
 
+void GrDrawTarget::Caps::print() const {
+    static const char* gNY[] = {"NO", "YES"};
+    GrPrintf("8 Bit Palette Support       : %s\n", gNY[f8BitPaletteSupport]);
+    GrPrintf("NPOT Texture Support        : %s\n", gNY[fNPOTTextureSupport]);
+    GrPrintf("NPOT Texture Tile Support   : %s\n", gNY[fNPOTTextureTileSupport]);
+    GrPrintf("NPOT Render Target Support  : %s\n", gNY[fNPOTRenderTargetSupport]);
+    GrPrintf("Two Sided Stencil Support   : %s\n", gNY[fTwoSidedStencilSupport]);
+    GrPrintf("Stencil Wrap Ops  Support   : %s\n", gNY[fStencilWrapOpsSupport]);
+    GrPrintf("HW AA Lines Support         : %s\n", gNY[fHWAALineSupport]);
+    GrPrintf("Shader Support              : %s\n", gNY[fShaderSupport]);
+    GrPrintf("Shader Derivative Support   : %s\n", gNY[fShaderDerivativeSupport]);
+    GrPrintf("FSAA Support                : %s\n", gNY[fFSAASupport]);
+    GrPrintf("Dual Source Blending Support: %s\n", gNY[fDualSourceBlendingSupport]);
+    GrPrintf("Buffer Lock Support         : %s\n", gNY[fBufferLockSupport]);
+    GrPrintf("Min Render Target Width     : %d\n", fMinRenderTargetWidth);
+    GrPrintf("Min Render Target Height    : %d\n", fMinRenderTargetHeight);
+    GrPrintf("Max Texture Size            : %d\n", fMaxTextureSize);
+    GrPrintf("Max Render Target Size      : %d\n", fMaxRenderTargetSize);
+}
+
diff --git a/gpu/src/GrDrawTarget.h b/gpu/src/GrDrawTarget.h
index 1d61a18..a57ff81 100644
--- a/gpu/src/GrDrawTarget.h
+++ b/gpu/src/GrDrawTarget.h
@@ -30,6 +30,35 @@
 class GrDrawTarget : public GrRefCnt {
 public:
     /**
+     * Represents the draw target capabilities.
+     */
+    struct Caps {
+        Caps() { memset(this, 0, sizeof(Caps)); }
+        Caps(const Caps& c) { *this = c; }
+        Caps& operator= (const Caps& c) {
+            memcpy(this, &c, sizeof(Caps));
+            return *this;
+        }
+        void print() const;
+        bool f8BitPaletteSupport        : 1;
+        bool fNPOTTextureSupport        : 1;
+        bool fNPOTTextureTileSupport    : 1;
+        bool fNPOTRenderTargetSupport   : 1;
+        bool fTwoSidedStencilSupport    : 1;
+        bool fStencilWrapOpsSupport     : 1;
+        bool fHWAALineSupport           : 1;
+        bool fShaderSupport             : 1;
+        bool fShaderDerivativeSupport   : 1;
+        bool fFSAASupport               : 1;
+        bool fDualSourceBlendingSupport : 1;
+        bool fBufferLockSupport         : 1;
+        int fMinRenderTargetWidth;
+        int fMinRenderTargetHeight;
+        int fMaxRenderTargetSize;
+        int fMaxTextureSize;
+    };
+
+    /**
      * Number of texture stages. Each stage takes as input a color and
      * 2D texture coordinates. The color input to the first enabled stage is the
      * per-vertex color or the constant color (setColor/setAlpha) if there are
@@ -48,7 +77,6 @@
         kMaxTexCoords = kNumStages
     };
 
-
     /**
      * The absolute maximum number of edges that may be specified for
      * a single draw call when performing edge antialiasing.  This is used for
@@ -197,6 +225,11 @@
     virtual ~GrDrawTarget();
 
     /**
+     * Gets the capabilities of the draw target.
+     */
+    const Caps& getCaps() const { return fCaps; }
+
+    /**
      * Sets the current clip to the region specified by clip. All draws will be
      * clipped against this clip if kClip_StateBit is enabled.
      *
@@ -1307,6 +1340,8 @@
 
     DrState fCurrDrawState;
 
+    Caps fCaps;
+
 private:
     // called when setting a new vert/idx source to unref prev vb/ib
     void releasePreviousVertexSource();
diff --git a/gpu/src/GrGLIndexBuffer.cpp b/gpu/src/GrGLIndexBuffer.cpp
index 2791527..084a4c6 100644
--- a/gpu/src/GrGLIndexBuffer.cpp
+++ b/gpu/src/GrGLIndexBuffer.cpp
@@ -51,7 +51,7 @@
 void* GrGLIndexBuffer::lock() {
     GrAssert(fBufferID);
     GrAssert(!isLocked());
-    if (GPUGL->supportsBufferLocking()) {
+    if (this->getGpu()->getCaps().fBufferLockSupport) {
         this->bind();
         // Let driver know it can discard the old data
         GL_CALL(BufferData(GR_GL_ELEMENT_ARRAY_BUFFER,
@@ -76,7 +76,7 @@
 void GrGLIndexBuffer::unlock() {
     GrAssert(fBufferID);
     GrAssert(isLocked());
-    GrAssert(GPUGL->supportsBufferLocking());
+    GrAssert(this->getGpu()->getCaps().fBufferLockSupport);
 
     this->bind();
     GL_CALL(UnmapBuffer(GR_GL_ELEMENT_ARRAY_BUFFER));
@@ -85,7 +85,7 @@
 
 bool GrGLIndexBuffer::isLocked() const {
 #if GR_DEBUG
-    if (this->isValid() && GPUGL->supportsBufferLocking()) {
+    if (this->isValid() && this->getGpu()->getCaps().fBufferLockSupport) {
         this->bind();
         GrGLint mapped;
         GL_CALL(GetBufferParameteriv(GR_GL_ELEMENT_ARRAY_BUFFER,
diff --git a/gpu/src/GrGLVertexBuffer.cpp b/gpu/src/GrGLVertexBuffer.cpp
index 2d5aee0..c542602 100644
--- a/gpu/src/GrGLVertexBuffer.cpp
+++ b/gpu/src/GrGLVertexBuffer.cpp
@@ -50,7 +50,7 @@
 void* GrGLVertexBuffer::lock() {
     GrAssert(fBufferID);
     GrAssert(!isLocked());
-    if (GPUGL->supportsBufferLocking()) {
+    if (this->getGpu()->getCaps().fBufferLockSupport) {
         this->bind();
         // Let driver know it can discard the old data
         GL_CALL(BufferData(GR_GL_ARRAY_BUFFER, this->sizeInBytes(), NULL,
@@ -72,7 +72,7 @@
 
     GrAssert(fBufferID);
     GrAssert(isLocked());
-    GrAssert(GPUGL->supportsBufferLocking());
+    GrAssert(this->getGpu()->getCaps().fBufferLockSupport);
 
     this->bind();
     GL_CALL(UnmapBuffer(GR_GL_ARRAY_BUFFER));
@@ -82,7 +82,7 @@
 bool GrGLVertexBuffer::isLocked() const {
     GrAssert(!this->isValid() || fBufferID);
 #if GR_DEBUG
-    if (this->isValid() && GPUGL->supportsBufferLocking()) {
+    if (this->isValid() && this->getGpu()->getCaps().fBufferLockSupport) {
         GrGLint mapped;
         this->bind();
         GL_CALL(GetBufferParameteriv(GR_GL_ARRAY_BUFFER, 
diff --git a/gpu/src/GrGpu.cpp b/gpu/src/GrGpu.cpp
index b338d05..91e659d 100644
--- a/gpu/src/GrGpu.cpp
+++ b/gpu/src/GrGpu.cpp
@@ -31,8 +31,7 @@
 #define DEBUG_INVAL_START_IDX -1
 
 GrGpu::GrGpu()
-    : f8bitPaletteSupport(false)
-    , fContext(NULL)
+    : fContext(NULL)
     , fVertexPool(NULL)
     , fIndexPool(NULL)
     , fVertexPoolUseCnt(0)
diff --git a/gpu/src/GrGpu.h b/gpu/src/GrGpu.h
index e970554..9ecb4b0 100644
--- a/gpu/src/GrGpu.h
+++ b/gpu/src/GrGpu.h
@@ -54,6 +54,7 @@
 class GrGpu : public GrDrawTarget {
 
 public:
+
     /**
      * Additional blend coeffecients for dual source blending, not exposed
      * through GrPaint/GrContext.
@@ -147,118 +148,6 @@
     GrIndexBuffer* createIndexBuffer(uint32_t size, bool dynamic);
 
     /**
-     * Are 8 bit paletted textures supported.
-     *
-     * @return    true if 8bit palette textures are supported, false otherwise
-     */
-    bool supports8BitPalette() const { return f8bitPaletteSupport; }
-
-    /**
-     * returns true if two sided stenciling is supported. If false then only
-     * the front face values of the GrStencilSettings
-     * @return    true if only a single stencil pass is needed.
-     */
-    bool supportsTwoSidedStencil() const
-                                        { return fTwoSidedStencilSupport; }
-
-    /**
-     * returns true if stencil wrap is supported. If false then
-     * kIncWrap_StencilOp and kDecWrap_StencilOp are treated as
-     * kIncClamp_StencilOp and kDecClamp_StencilOp, respectively.
-     * @return    true if stencil wrap ops are supported.
-     */
-    bool supportsStencilWrapOps() const
-                                        { return fStencilWrapOpsSupport; }
-
-    /**
-     * Checks whether locking vertex and index buffers is supported.
-     *
-     * @return true if locking is supported.
-     */
-    bool supportsBufferLocking() const { return fBufferLockSupport; }
-
-    /**
-     * Does the 3D API support anti-aliased lines. If so then line primitive
-     * types will use this functionality when the AA state flag is set.
-     */
-    bool supportsHWAALines() const { return fAALineSupport; }
-
-    /**
-     * Are shaders supported.
-     */
-    bool supportsShaders() const { return fShaderSupport; }
-
-    /**
-     * Are derivative instructions supported in fragment shaders
-     */
-    bool supportsShaderDerivatives() const { return fShaderDerivativeSupport; }
-
-    /**
-     * Does the subclass support GrSamplerState::k4x4Downsample_Filter
-     */
-    bool supports4x4DownsampleFilter() const { return f4X4DownsampleFilterSupport; }
-
-    /**
-     * Does this instance support dual-source blending? Required for proper
-     * blending with partial coverage with certain blend modes (dst coeff is
-     * not 1, ISA, or ISC)
-     */
-    bool supportsDualSourceBlending() const {
-        return fDualSourceBlendingSupport;
-    }
-
-    /**
-     * Gets the minimum width of a render target. If a texture/rt is created
-     * with a width less than this size the GrGpu object will clamp it to this
-     * value.
-     */
-    int minRenderTargetWidth() const { return fMinRenderTargetWidth; }
-
-    /**
-     * Gets the minimum width of a render target. If a texture/rt is created
-     * with a height less than this size the GrGpu object will clamp it to this
-     * value.
-     */
-    int minRenderTargetHeight() const  { return fMinRenderTargetHeight; }
-    
-    /**
-     * Reports whether full scene anti-aliasing is supported.
-     */
-    bool supportsFullsceneAA() const { return fFSAASupport; }
-
-    /**
-     * Returns true if NPOT textures can be created
-     *
-     * @return    true if NPOT textures can be created
-     */
-    bool npotTextureSupport() const { return fNPOTTextureSupport; }
-
-    /**
-     * Returns true if NPOT textures can be repeat/mirror tiled.
-     *
-     * @return    true if NPOT textures can be tiled
-     */
-    bool npotTextureTileSupport() const { return fNPOTTextureTileSupport; }
-
-    /**
-     * Returns true if a NPOT texture can be a rendertarget
-     *
-     * @return    the true if NPOT texture/rendertarget can be created.
-     */
-    bool npotRenderTargetSupport() const { return fNPOTRenderTargetSupport; }
-
-    /**
-     * Gets the largest allowed width and height of a texture.
-     */
-    int maxTextureSize() const { return fMaxTextureSize; }
-    /**
-     * Gets the largest allowed width and height of a render target.
-     */
-    int maxRenderTargetSize() const { return fMaxRenderTargetSize; }
-
-    virtual void clear(const GrIRect* rect, GrColor color);
-
-    /**
      * Returns an index buffer that can be used to render quads.
      * Six indices per quad: 0, 1, 2, 0, 2, 3, etc.
      * The max number of quads can be queried using GrIndexBuffer::maxQuads().
@@ -331,6 +220,7 @@
 
     // GrDrawTarget overrides
     virtual bool willUseHWAALines() const;
+    virtual void clear(const GrIRect* rect, GrColor color);
 
 protected:
     enum PrivateStateBits {
@@ -363,31 +253,6 @@
     // and the client isn't using the stencil test.
     static const GrStencilSettings gClipStencilSettings;
 
-    // defaults to false, subclass can set true to support palleted textures
-    bool f8bitPaletteSupport;
-
-    // set by subclass
-    bool fNPOTTextureSupport;
-    bool fNPOTTextureTileSupport;
-    bool fNPOTRenderTargetSupport;
-    bool fTwoSidedStencilSupport;
-    bool fStencilWrapOpsSupport;
-    bool fAALineSupport;
-    bool fShaderSupport;
-    bool fShaderDerivativeSupport;
-    bool fFSAASupport;
-    bool f4X4DownsampleFilterSupport; // supports GrSamplerState::k4x4Downsample_Filter
-    bool fDualSourceBlendingSupport;
-
-    // set by subclass to true if index and vertex buffers can be locked, false
-    // otherwise.
-    bool fBufferLockSupport;
-
-    // set by subclass
-    int fMinRenderTargetWidth;
-    int fMinRenderTargetHeight;
-    int fMaxRenderTargetSize;
-    int fMaxTextureSize;
 
     GrGpuStats fStats;
 
diff --git a/gpu/src/GrGpuGL.cpp b/gpu/src/GrGpuGL.cpp
index 9906037..f1d6f8a 100644
--- a/gpu/src/GrGpuGL.cpp
+++ b/gpu/src/GrGpuGL.cpp
@@ -257,9 +257,9 @@
     return minRenderTargetWidth;
 }
 
+GrGpuGL::GrGpuGL(const GrGLInterface* gl, GrGLBinding glBinding) {
 
-GrGpuGL::GrGpuGL(const GrGLInterface* gl, GrGLBinding glBinding) 
-    : fStencilFormats(8) {
+    fPrintedCaps = false;
 
     gl->ref();
     fGL = gl;
@@ -303,241 +303,7 @@
 
     this->resetDirtyFlags();
 
-    GrGLint maxTextureUnits;
-    // check FS and fixed-function texture unit limits
-    // we only use textures in the fragment stage currently.
-    // checks are > to make sure we have a spare unit.
-    if (kES1_GrGLBinding != this->glBinding()) {
-        GR_GL_GetIntegerv(gl, GR_GL_MAX_TEXTURE_IMAGE_UNITS, &maxTextureUnits);
-        GrAssert(maxTextureUnits > kNumStages);
-    }
-    if (kES2_GrGLBinding != this->glBinding()) {
-        GR_GL_GetIntegerv(gl, GR_GL_MAX_TEXTURE_UNITS, &maxTextureUnits);
-        GrAssert(maxTextureUnits > kNumStages);
-    }
-    if (kES2_GrGLBinding == this->glBinding()) {
-        GR_GL_GetIntegerv(gl, GR_GL_MAX_FRAGMENT_UNIFORM_VECTORS,
-                          &fMaxFragmentUniformVectors);
-    } else if (kDesktop_GrGLBinding != this->glBinding()) {
-        GrGLint max;
-        GR_GL_GetIntegerv(gl, GR_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &max);
-        fMaxFragmentUniformVectors = max / 4;
-    } else {
-        fMaxFragmentUniformVectors = 16;
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-    // Check for supported features.
-
-    this->setupStencilFormats();
-
-    GrGLint numFormats;
-    GR_GL_GetIntegerv(gl, GR_GL_NUM_COMPRESSED_TEXTURE_FORMATS, &numFormats);
-    SkAutoSTMalloc<10, GrGLint> formats(numFormats);
-    GR_GL_GetIntegerv(gl, GR_GL_COMPRESSED_TEXTURE_FORMATS, formats);
-    for (int i = 0; i < numFormats; ++i) {
-        if (formats[i] == GR_GL_PALETTE8_RGBA8) {
-            f8bitPaletteSupport = true;
-            break;
-        }
-    }
-
-    if (gPrintStartupSpew) {
-        GrPrintf("Palette8 support: %s\n", (f8bitPaletteSupport ? "YES" : "NO"));
-    }
-
-    GR_STATIC_ASSERT(0 == kNone_GrAALevel);
-    GR_STATIC_ASSERT(1 == kLow_GrAALevel);
-    GR_STATIC_ASSERT(2 == kMed_GrAALevel);
-    GR_STATIC_ASSERT(3 == kHigh_GrAALevel);
-
-    memset(fAASamples, 0, sizeof(fAASamples));
-    fMSFBOType = kNone_MSFBO;
-    if (kDesktop_GrGLBinding != this->glBinding()) {
-       if (this->hasExtension("GL_CHROMIUM_framebuffer_multisample")) {
-           // chrome's extension is equivalent to the EXT msaa
-           // and fbo_blit extensions.
-            fMSFBOType = kDesktopEXT_MSFBO;
-       } else if (this->hasExtension("GL_APPLE_framebuffer_multisample")) {
-            fMSFBOType = kAppleES_MSFBO;
-        }
-    } else {
-        if ((fGLVersion >= GR_GL_VER(3,0)) || this->hasExtension("GL_ARB_framebuffer_object")) {
-            fMSFBOType = kDesktopARB_MSFBO;
-        } else if (this->hasExtension("GL_EXT_framebuffer_multisample") &&
-                   this->hasExtension("GL_EXT_framebuffer_blit")) {
-            fMSFBOType = kDesktopEXT_MSFBO;
-        }
-    }
-    if (gPrintStartupSpew) {
-        switch (fMSFBOType) {
-            case kNone_MSFBO:
-                GrPrintf("MSAA Support: NONE\n");
-                break;
-            case kDesktopARB_MSFBO:
-                GrPrintf("MSAA Support: DESKTOP ARB.\n");
-                break;
-            case kDesktopEXT_MSFBO:
-                GrPrintf("MSAA Support: DESKTOP EXT.\n");
-                break;
-            case kAppleES_MSFBO:
-                GrPrintf("MSAA Support: APPLE ES.\n");
-                break;
-        }
-    }
-
-    if (kNone_MSFBO != fMSFBOType) {
-        GrGLint maxSamples;
-        GR_GL_GetIntegerv(gl, GR_GL_MAX_SAMPLES, &maxSamples);
-        if (maxSamples > 1 ) {
-            fAASamples[kNone_GrAALevel] = 0;
-            fAASamples[kLow_GrAALevel] = GrMax(2,
-                                               GrFixedFloorToInt((GR_FixedHalf) *
-                                               maxSamples));
-            fAASamples[kMed_GrAALevel] = GrMax(2,
-                                               GrFixedFloorToInt(((GR_Fixed1*3)/4) *
-                                               maxSamples));
-            fAASamples[kHigh_GrAALevel] = maxSamples;
-        }
-        if (gPrintStartupSpew) {
-            GrPrintf("\tMax Samples: %d\n", maxSamples);
-        }
-    }
-    fFSAASupport = fAASamples[kHigh_GrAALevel] > 0;
-
-    if (kDesktop_GrGLBinding == this->glBinding()) {
-        fHasStencilWrap = (fGLVersion >= GR_GL_VER(1,4)) ||
-                          this->hasExtension("GL_EXT_stencil_wrap");
-    } else {
-        fHasStencilWrap = (fGLVersion >= GR_GL_VER(2,0)) || 
-                          this->hasExtension("GL_OES_stencil_wrap");
-    }
-    if (gPrintStartupSpew) {
-        GrPrintf("Stencil Wrap: %s\n", (fHasStencilWrap ? "YES" : "NO"));
-    }
-
-    if (kDesktop_GrGLBinding == this->glBinding()) {
-        // we could also look for GL_ATI_separate_stencil extension or
-        // GL_EXT_stencil_two_side but they use different function signatures
-        // than GL2.0+ (and than each other).
-        fTwoSidedStencilSupport = (fGLVersion >= GR_GL_VER(2,0));
-        // supported on GL 1.4 and higher or by extension
-        fStencilWrapOpsSupport = (fGLVersion >= GR_GL_VER(1,4)) ||
-                                  this->hasExtension("GL_EXT_stencil_wrap");
-    } else {
-        // ES 2 has two sided stencil but 1.1 doesn't. There doesn't seem to be
-        // an ES1 extension.
-        fTwoSidedStencilSupport = (fGLVersion >= GR_GL_VER(2,0));
-        // stencil wrap support is in ES2, ES1 requires extension.
-        fStencilWrapOpsSupport = (fGLVersion >= GR_GL_VER(2,0)) ||
-                                 this->hasExtension("GL_OES_stencil_wrap");
-    }
-    if (gPrintStartupSpew) {
-        GrPrintf("Stencil Caps: TwoSide: %s, Wrap: %s\n",
-                (fTwoSidedStencilSupport ? "YES" : "NO"),
-                (fStencilWrapOpsSupport ? "YES" : "NO"));
-    }
-
-    if (kDesktop_GrGLBinding == this->glBinding()) {
-        fRGBA8Renderbuffer = true;
-    } else {
-        fRGBA8Renderbuffer = this->hasExtension("GL_OES_rgb8_rgba8");
-    }
-    if (gPrintStartupSpew) {
-        GrPrintf("RGBA Renderbuffer: %s\n", (fRGBA8Renderbuffer ? "YES" : "NO"));
-    }
-
-
-    if (kDesktop_GrGLBinding != this->glBinding()) {
-        if (GR_GL_32BPP_COLOR_FORMAT == GR_GL_BGRA) {
-            GrAssert(this->hasExtension("GL_EXT_texture_format_BGRA8888"));
-        }
-    }
-
-    if (kDesktop_GrGLBinding == this->glBinding()) {
-        fBufferLockSupport = true; // we require VBO support and the desktop VBO
-                                   // extension includes glMapBuffer.
-    } else {
-        fBufferLockSupport = this->hasExtension("GL_OES_mapbuffer");
-    }
-
-    if (gPrintStartupSpew) {
-        GrPrintf("Map Buffer: %s\n", (fBufferLockSupport ? "YES" : "NO"));
-    }
-
-    if (kDesktop_GrGLBinding == this->glBinding()) {
-        if (fGLVersion >= GR_GL_VER(2,0) || 
-            this->hasExtension("GL_ARB_texture_non_power_of_two")) {
-            fNPOTTextureTileSupport = true;
-            fNPOTTextureSupport = true;
-        } else {
-            fNPOTTextureTileSupport = false;
-            fNPOTTextureSupport = false;
-        }
-    } else {
-        if (fGLVersion >= GR_GL_VER(2,0)) {
-            fNPOTTextureSupport = true;
-            fNPOTTextureTileSupport = this->hasExtension("GL_OES_texture_npot");
-        } else {
-            fNPOTTextureSupport =
-                        this->hasExtension("GL_APPLE_texture_2D_limited_npot");
-            fNPOTTextureTileSupport = false;
-        }
-    }
-
-    fAALineSupport = (kDesktop_GrGLBinding == this->glBinding());
-
-    ////////////////////////////////////////////////////////////////////////////
-    // Experiments to determine limitations that can't be queried.
-    // TODO: Make these a preprocess that generate some compile time constants.
-    // TODO: probe once at startup, rather than once per context creation.
-
-    int expectNPOTTargets = gl->fNPOTRenderTargetSupport;
-    if (expectNPOTTargets == kProbe_GrGLCapability) {
-        fNPOTRenderTargetSupport =
-            probe_for_npot_render_target_support(gl, fNPOTTextureSupport);
-    } else {
-        GrAssert(expectNPOTTargets == 0 || expectNPOTTargets == 1);
-        fNPOTRenderTargetSupport = static_cast<bool>(expectNPOTTargets);
-    }
-
-    if (gPrintStartupSpew) {
-        if (fNPOTTextureSupport) {
-            GrPrintf("NPOT textures supported\n");
-            if (fNPOTTextureTileSupport) {
-                GrPrintf("NPOT texture tiling supported\n");
-            } else {
-                GrPrintf("NPOT texture tiling NOT supported\n");
-            }
-            if (fNPOTRenderTargetSupport) {
-                GrPrintf("NPOT render targets supported\n");
-            } else {
-                GrPrintf("NPOT render targets NOT supported\n");
-            }
-        } else {
-            GrPrintf("NPOT textures NOT supported\n");
-        }
-    }
-
-    GR_GL_GetIntegerv(gl, GR_GL_MAX_TEXTURE_SIZE, &fMaxTextureSize);
-    GR_GL_GetIntegerv(gl, GR_GL_MAX_RENDERBUFFER_SIZE, &fMaxRenderTargetSize);
-    // Our render targets are always created with textures as the color
-    // attachment, hence this min:
-    fMaxRenderTargetSize = GrMin(fMaxTextureSize, fMaxRenderTargetSize);
-
-    fMinRenderTargetHeight = gl->fMinRenderTargetHeight;
-    if (fMinRenderTargetHeight == kProbe_GrGLCapability) {
-        fMinRenderTargetHeight =
-            probe_for_min_render_target_height(gl,fNPOTRenderTargetSupport,
-                                               fMaxRenderTargetSize);
-    }
-
-    fMinRenderTargetWidth = gl->fMinRenderTargetWidth;
-    if (fMinRenderTargetWidth == kProbe_GrGLCapability) {
-        fMinRenderTargetWidth =
-            probe_for_min_render_target_width(gl, fNPOTRenderTargetSupport,
-                                              fMaxRenderTargetSize);
-    }
+    this->initCaps();
 
     fLastSuccessfulStencilFmtIdx = 0;
 }
@@ -549,7 +315,255 @@
     fGL->unref();
 }
 
+///////////////////////////////////////////////////////////////////////////////
+
+static const GrGLuint kUnknownBitCount = ~0;
+
+void GrGpuGL::initCaps() {
+    GrGLint maxTextureUnits;
+    // check FS and fixed-function texture unit limits
+    // we only use textures in the fragment stage currently.
+    // checks are > to make sure we have a spare unit.
+    if (kES1_GrGLBinding != this->glBinding()) {
+        GR_GL_GetIntegerv(fGL, GR_GL_MAX_TEXTURE_IMAGE_UNITS, &maxTextureUnits);
+        GrAssert(maxTextureUnits > kNumStages);
+    }
+    if (kES2_GrGLBinding != this->glBinding()) {
+        GR_GL_GetIntegerv(fGL, GR_GL_MAX_TEXTURE_UNITS, &maxTextureUnits);
+        GrAssert(maxTextureUnits > kNumStages);
+    }
+    if (kES2_GrGLBinding == this->glBinding()) {
+        GR_GL_GetIntegerv(fGL, GR_GL_MAX_FRAGMENT_UNIFORM_VECTORS,
+                          &fGLCaps.fMaxFragmentUniformVectors);
+    } else if (kDesktop_GrGLBinding != this->glBinding()) {
+        GrGLint max;
+        GR_GL_GetIntegerv(fGL, GR_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &max);
+        fGLCaps.fMaxFragmentUniformVectors = max / 4;
+    } else {
+        fGLCaps.fMaxFragmentUniformVectors = 16;
+    }
+
+    GrGLint numFormats;
+    GR_GL_GetIntegerv(fGL, GR_GL_NUM_COMPRESSED_TEXTURE_FORMATS, &numFormats);
+    SkAutoSTMalloc<10, GrGLint> formats(numFormats);
+    GR_GL_GetIntegerv(fGL, GR_GL_COMPRESSED_TEXTURE_FORMATS, formats);
+    for (int i = 0; i < numFormats; ++i) {
+        if (formats[i] == GR_GL_PALETTE8_RGBA8) {
+            fCaps.f8BitPaletteSupport = true;
+            break;
+        }
+    }
+
+    if (kDesktop_GrGLBinding == this->glBinding()) {
+        fCaps.fStencilWrapOpsSupport = (fGLVersion >= GR_GL_VER(1,4)) ||
+                                    this->hasExtension("GL_EXT_stencil_wrap");
+    } else {
+        fCaps.fStencilWrapOpsSupport = (fGLVersion >= GR_GL_VER(2,0)) ||
+                                this->hasExtension("GL_OES_stencil_wrap");
+    }
+
+    if (kDesktop_GrGLBinding == this->glBinding()) {
+        // we could also look for GL_ATI_separate_stencil extension or
+        // GL_EXT_stencil_two_side but they use different function signatures
+        // than GL2.0+ (and than each other).
+        fCaps.fTwoSidedStencilSupport = (fGLVersion >= GR_GL_VER(2,0));
+        // supported on GL 1.4 and higher or by extension
+        fCaps.fStencilWrapOpsSupport = (fGLVersion >= GR_GL_VER(1,4)) ||
+                                       this->hasExtension("GL_EXT_stencil_wrap");
+    } else {
+        // ES 2 has two sided stencil but 1.1 doesn't. There doesn't seem to be
+        // an ES1 extension.
+        fCaps.fTwoSidedStencilSupport = (fGLVersion >= GR_GL_VER(2,0));
+        // stencil wrap support is in ES2, ES1 requires extension.
+        fCaps.fStencilWrapOpsSupport = (fGLVersion >= GR_GL_VER(2,0)) ||
+                                       this->hasExtension("GL_OES_stencil_wrap");
+    }
+
+    if (kDesktop_GrGLBinding == this->glBinding()) {
+        fGLCaps.fRGBA8Renderbuffer = true;
+    } else {
+        fGLCaps.fRGBA8Renderbuffer = this->hasExtension("GL_OES_rgb8_rgba8");
+    }
+
+
+    if (kDesktop_GrGLBinding != this->glBinding()) {
+        if (GR_GL_32BPP_COLOR_FORMAT == GR_GL_BGRA) {
+            GrAssert(this->hasExtension("GL_EXT_texture_format_BGRA8888"));
+        }
+    }
+
+    if (kDesktop_GrGLBinding == this->glBinding()) {
+        fCaps.fBufferLockSupport = true; // we require VBO support and the desktop VBO
+                                         // extension includes glMapBuffer.
+    } else {
+        fCaps.fBufferLockSupport = this->hasExtension("GL_OES_mapbuffer");
+    }
+
+    if (kDesktop_GrGLBinding == this->glBinding()) {
+        if (fGLVersion >= GR_GL_VER(2,0) || 
+            this->hasExtension("GL_ARB_texture_non_power_of_two")) {
+            fCaps.fNPOTTextureTileSupport = true;
+            fCaps.fNPOTTextureSupport = true;
+        } else {
+            fCaps.fNPOTTextureTileSupport = false;
+            fCaps.fNPOTTextureSupport = false;
+        }
+    } else {
+        if (fGLVersion >= GR_GL_VER(2,0)) {
+            fCaps.fNPOTTextureSupport = true;
+            fCaps.fNPOTTextureTileSupport = this->hasExtension("GL_OES_texture_npot");
+        } else {
+            fCaps.fNPOTTextureSupport =
+                        this->hasExtension("GL_APPLE_texture_2D_limited_npot");
+            fCaps.fNPOTTextureTileSupport = false;
+        }
+    }
+
+    fCaps.fHWAALineSupport = (kDesktop_GrGLBinding == this->glBinding());
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Experiments to determine limitations that can't be queried.
+    // TODO: Make these a preprocess that generate some compile time constants.
+    // TODO: probe once at startup, rather than once per context creation.
+
+    int expectNPOTTargets = fGL->fNPOTRenderTargetSupport;
+    if (expectNPOTTargets == kProbe_GrGLCapability) {
+        fCaps.fNPOTRenderTargetSupport =
+            probe_for_npot_render_target_support(fGL, fCaps.fNPOTTextureSupport);
+    } else {
+        GrAssert(expectNPOTTargets == 0 || expectNPOTTargets == 1);
+        fCaps.fNPOTRenderTargetSupport = static_cast<bool>(expectNPOTTargets);
+    }
+
+    GR_GL_GetIntegerv(fGL, GR_GL_MAX_TEXTURE_SIZE, &fCaps.fMaxTextureSize);
+    GR_GL_GetIntegerv(fGL, GR_GL_MAX_RENDERBUFFER_SIZE, &fCaps.fMaxRenderTargetSize);
+    // Our render targets are always created with textures as the color
+    // attachment, hence this min:
+    fCaps.fMaxRenderTargetSize = GrMin(fCaps.fMaxTextureSize, fCaps.fMaxRenderTargetSize);
+
+    fCaps.fMinRenderTargetHeight = fGL->fMinRenderTargetHeight;
+    if (fCaps.fMinRenderTargetHeight == kProbe_GrGLCapability) {
+        fCaps.fMinRenderTargetHeight =
+            probe_for_min_render_target_height(fGL, fCaps.fNPOTRenderTargetSupport,
+                                               fCaps.fMaxRenderTargetSize);
+    }
+
+    fCaps.fMinRenderTargetWidth = fGL->fMinRenderTargetWidth;
+    if (fCaps.fMinRenderTargetWidth == kProbe_GrGLCapability) {
+        fCaps.fMinRenderTargetWidth =
+            probe_for_min_render_target_width(fGL, fCaps.fNPOTRenderTargetSupport,
+                                              fCaps.fMaxRenderTargetSize);
+    }
+
+    this->initFSAASupport();
+    this->initStencilFormats();
+}
+
+void GrGpuGL::initFSAASupport() {
+    // TODO: Get rid of GrAALevel and use # samples directly.
+    GR_STATIC_ASSERT(0 == kNone_GrAALevel);
+    GR_STATIC_ASSERT(1 == kLow_GrAALevel);
+    GR_STATIC_ASSERT(2 == kMed_GrAALevel);
+    GR_STATIC_ASSERT(3 == kHigh_GrAALevel);
+    memset(fGLCaps.fAASamples, 0, sizeof(fGLCaps.fAASamples));
+
+    fGLCaps.fMSFBOType = GLCaps::kNone_MSFBO;
+    if (kDesktop_GrGLBinding != this->glBinding()) {
+       if (this->hasExtension("GL_CHROMIUM_framebuffer_multisample")) {
+           // chrome's extension is equivalent to the EXT msaa
+           // and fbo_blit extensions.
+            fGLCaps.fMSFBOType = GLCaps::kDesktopEXT_MSFBO;
+       } else if (this->hasExtension("GL_APPLE_framebuffer_multisample")) {
+            fGLCaps.fMSFBOType = GLCaps::kAppleES_MSFBO;
+        }
+    } else {
+        if ((fGLVersion >= GR_GL_VER(3,0)) || this->hasExtension("GL_ARB_framebuffer_object")) {
+            fGLCaps.fMSFBOType = GLCaps::kDesktopARB_MSFBO;
+        } else if (this->hasExtension("GL_EXT_framebuffer_multisample") &&
+                   this->hasExtension("GL_EXT_framebuffer_blit")) {
+            fGLCaps.fMSFBOType = GLCaps::kDesktopEXT_MSFBO;
+        }
+    }
+
+    if (GLCaps::kNone_MSFBO != fGLCaps.fMSFBOType) {
+        GrGLint maxSamples;
+        GR_GL_GetIntegerv(fGL, GR_GL_MAX_SAMPLES, &maxSamples);
+        if (maxSamples > 1 ) {
+            fGLCaps.fAASamples[kNone_GrAALevel] = 0;
+            fGLCaps.fAASamples[kLow_GrAALevel] =
+                GrMax(2, GrFixedFloorToInt((GR_FixedHalf) * maxSamples));
+            fGLCaps.fAASamples[kMed_GrAALevel] =
+                GrMax(2, GrFixedFloorToInt(((GR_Fixed1*3)/4) * maxSamples));
+            fGLCaps.fAASamples[kHigh_GrAALevel] = maxSamples;
+        }
+    }
+    fCaps.fFSAASupport = fGLCaps.fAASamples[kHigh_GrAALevel] > 0;
+}
+
+void GrGpuGL::initStencilFormats() {
+
+    // Build up list of legal stencil formats (though perhaps not supported on
+    // the particular gpu/driver) from most preferred to least.
+
+    // these consts are in order of most preferred to least preferred
+    // we don't bother with GL_STENCIL_INDEX1 or GL_DEPTH32F_STENCIL8
+    static const GrGLStencilBuffer::Format
+                  // internal Format      stencil bits      total bits        packed?
+        gS8    = {GR_GL_STENCIL_INDEX8,   8,                8,                false},
+        gS16   = {GR_GL_STENCIL_INDEX16,  16,               16,               false},
+        gD24S8 = {GR_GL_DEPTH24_STENCIL8, 8,                32,               true },
+        gS4    = {GR_GL_STENCIL_INDEX4,   4,                4,                false},
+        gS     = {GR_GL_STENCIL_INDEX,    kUnknownBitCount, kUnknownBitCount, false},
+        gDS    = {GR_GL_DEPTH_STENCIL,    kUnknownBitCount, kUnknownBitCount, true };
+
+    if (kDesktop_GrGLBinding == this->glBinding()) {
+        bool supportsPackedDS = fGLVersion >= GR_GL_VER(3,0) || 
+                                this->hasExtension("GL_EXT_packed_depth_stencil") ||
+                                this->hasExtension("GL_ARB_framebuffer_object");
+
+        // S1 thru S16 formats are in GL 3.0+, EXT_FBO, and ARB_FBO since we
+        // require FBO support we can expect these are legal formats and don't
+        // check. These also all support the unsized GL_STENCIL_INDEX.
+        fGLCaps.fStencilFormats.push_back() = gS8;
+        fGLCaps.fStencilFormats.push_back() = gS16;
+        if (supportsPackedDS) {
+            fGLCaps.fStencilFormats.push_back() = gD24S8;
+        }
+        fGLCaps.fStencilFormats.push_back() = gS4;
+        if (supportsPackedDS) {
+            fGLCaps.fStencilFormats.push_back() = gDS;
+        }
+    } else {
+        // ES2 has STENCIL_INDEX8 without extensions.
+        // ES1 with GL_OES_framebuffer_object (which we require for ES1)
+        // introduces tokens for S1 thu S8 but there are separate extensions
+        // that make them legal (GL_OES_stencil1, ...).
+        // GL_OES_packed_depth_stencil adds DEPTH24_STENCIL8
+        // ES doesn't support using the unsized formats.
+
+        if (fGLVersion >= GR_GL_VER(2,0) ||
+            this->hasExtension("GL_OES_stencil8")) {
+            fGLCaps.fStencilFormats.push_back() = gS8;
+        }
+        //fStencilFormats.push_back() = gS16;
+        if (this->hasExtension("GL_OES_packed_depth_stencil")) {
+            fGLCaps.fStencilFormats.push_back() = gD24S8;
+        }
+        if (this->hasExtension("GL_OES_stencil4")) {
+            fGLCaps.fStencilFormats.push_back() = gS4;
+        }
+        // we require some stencil format.
+        GrAssert(fGLCaps.fStencilFormats.count() > 0);
+    }
+}
+
 void GrGpuGL::resetContext() {
+    if (gPrintStartupSpew && !fPrintedCaps) {
+        fPrintedCaps = true;
+        this->getCaps().print();
+        fGLCaps.print();
+    }
+
     // We detect cases when blending is effectively off
     fHWBlendDisabled = false;
     GL_CALL(Enable(GR_GL_BLEND));
@@ -698,66 +712,6 @@
     }
 }
 
-///////////////////////////////////////////////////////////////////////////////
-
-static const GrGLuint kUnknownBitCount = ~0;
-
-void GrGpuGL::setupStencilFormats() {
-
-    // Build up list of legal stencil formats (though perhaps not supported on
-    // the particular gpu/driver) from most preferred to least.
-
-    // these consts are in order of most preferred to least preferred
-    // we don't bother with GL_STENCIL_INDEX1 or GL_DEPTH32F_STENCIL8
-    static const GrGLStencilBuffer::Format
-                  // internal Format      stencil bits      total bits        packed?
-        gS8    = {GR_GL_STENCIL_INDEX8,   8,                8,                false},
-        gS16   = {GR_GL_STENCIL_INDEX16,  16,               16,               false},
-        gD24S8 = {GR_GL_DEPTH24_STENCIL8, 8,                32,               true },
-        gS4    = {GR_GL_STENCIL_INDEX4,   4,                4,                false},
-        gS     = {GR_GL_STENCIL_INDEX,    kUnknownBitCount, kUnknownBitCount, false},
-        gDS    = {GR_GL_DEPTH_STENCIL,    kUnknownBitCount, kUnknownBitCount, true };
-
-    if (kDesktop_GrGLBinding == this->glBinding()) {
-        bool supportsPackedDS = fGLVersion >= GR_GL_VER(3,0) || 
-                                this->hasExtension("GL_EXT_packed_depth_stencil") ||
-                                this->hasExtension("GL_ARB_framebuffer_object");
-
-        // S1 thru S16 formats are in GL 3.0+, EXT_FBO, and ARB_FBO since we
-        // require FBO support we can expect these are legal formats and don't
-        // check. These also all support the unsized GL_STENCIL_INDEX.
-        fStencilFormats.push_back() = gS8;
-        fStencilFormats.push_back() = gS16;
-        if (supportsPackedDS) {
-            fStencilFormats.push_back() = gD24S8;
-        }
-        fStencilFormats.push_back() = gS4;
-        if (supportsPackedDS) {
-            fStencilFormats.push_back() = gDS;
-        }
-    } else {
-        // ES2 has STENCIL_INDEX8 without extensions.
-        // ES1 with GL_OES_framebuffer_object (which we require for ES1)
-        // introduces tokens for S1 thu S8 but there are separate extensions
-        // that make them legal (GL_OES_stencil1, ...).
-        // GL_OES_packed_depth_stencil adds DEPTH24_STENCIL8
-        // ES doesn't support using the unsized formats.
-
-        if (fGLVersion >= GR_GL_VER(2,0) ||
-            this->hasExtension("GL_OES_stencil8")) {
-            fStencilFormats.push_back() = gS8;
-        }
-        //fStencilFormats.push_back() = gS16;
-        if (this->hasExtension("GL_OES_packed_depth_stencil")) {
-            fStencilFormats.push_back() = gD24S8;
-        }
-        if (this->hasExtension("GL_OES_stencil4")) {
-            fStencilFormats.push_back() = gS4;
-        }
-        // we require some stencil format.
-        GrAssert(fStencilFormats.count() > 0);
-    }
-}
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -812,7 +766,7 @@
 
     GL_CALL(PixelStorei(GR_GL_UNPACK_ALIGNMENT, desc.fUploadByteCount));
     if (kIndex_8_GrPixelConfig == desc.fFormat &&
-        supports8BitPalette()) {
+        this->getCaps().f8BitPaletteSupport) {
         // ES only supports CompressedTexImage2D, not CompressedTexSubimage2D
         GrAssert(desc.fContentWidth == desc.fAllocWidth);
         GrAssert(desc.fContentHeight == desc.fAllocHeight);
@@ -920,7 +874,7 @@
 
     // If we are using multisampling we will create two FBOS. We render
     // to one and then resolve to the texture bound to the other.
-    if (desc->fSampleCnt > 1 && kNone_MSFBO != fMSFBOType) {
+    if (desc->fSampleCnt > 1 && GLCaps::kNone_MSFBO != fGLCaps.fMSFBOType) {
         GL_CALL(GenFramebuffers(1, &desc->fRTFBOID));
         GL_CALL(GenRenderbuffers(1, &desc->fMSColorRenderbufferID));
         if (!desc->fRTFBOID ||
@@ -1032,39 +986,42 @@
         return return_null_texture();
     }
 
+    const Caps& caps = this->getCaps();
+
     // We keep GrRenderTargets in GL's normal orientation so that they
     // can be drawn to by the outside world without the client having
     // to render upside down.
     glTexDesc.fOrientation = renderTarget ? GrGLTexture::kBottomUp_Orientation :
                                             GrGLTexture::kTopDown_Orientation;
 
-    GrAssert(as_size_t(desc.fAALevel) < GR_ARRAY_COUNT(fAASamples));
-    glRTDesc.fSampleCnt = fAASamples[desc.fAALevel];
-    if (kNone_MSFBO == fMSFBOType && desc.fAALevel != kNone_GrAALevel) {
+    GrAssert(as_size_t(desc.fAALevel) < GR_ARRAY_COUNT(fGLCaps.fAASamples));
+    glRTDesc.fSampleCnt = fGLCaps.fAASamples[desc.fAALevel];
+    if (GLCaps::kNone_MSFBO == fGLCaps.fMSFBOType &&
+        desc.fAALevel != kNone_GrAALevel) {
         GrPrintf("AA RT requested but not supported on this platform.");
     }
 
     glTexDesc.fUploadByteCount = GrBytesPerPixel(desc.fFormat);
 
     if (renderTarget) {
-        if (!this->npotRenderTargetSupport()) {
+        if (!caps.fNPOTRenderTargetSupport) {
             glTexDesc.fAllocWidth  = GrNextPow2(desc.fWidth);
             glTexDesc.fAllocHeight = GrNextPow2(desc.fHeight);
         }
 
-        glTexDesc.fAllocWidth = GrMax(fMinRenderTargetWidth,
+        glTexDesc.fAllocWidth = GrMax(caps.fMinRenderTargetWidth,
                                       glTexDesc.fAllocWidth);
-        glTexDesc.fAllocHeight = GrMax(fMinRenderTargetHeight,
+        glTexDesc.fAllocHeight = GrMax(caps.fMinRenderTargetHeight,
                                        glTexDesc.fAllocHeight);
-        if (glTexDesc.fAllocWidth > fMaxRenderTargetSize ||
-            glTexDesc.fAllocHeight > fMaxRenderTargetSize) {
+        if (glTexDesc.fAllocWidth > caps.fMaxRenderTargetSize ||
+            glTexDesc.fAllocHeight > caps.fMaxRenderTargetSize) {
             return return_null_texture();
         }
-    } else if (!this->npotTextureSupport()) {
+    } else if (!caps.fNPOTTextureSupport) {
         glTexDesc.fAllocWidth  = GrNextPow2(desc.fWidth);
         glTexDesc.fAllocHeight = GrNextPow2(desc.fHeight);
-        if (glTexDesc.fAllocWidth > fMaxTextureSize ||
-            glTexDesc.fAllocHeight > fMaxTextureSize) {
+        if (glTexDesc.fAllocWidth > caps.fMaxTextureSize ||
+            glTexDesc.fAllocHeight > caps.fMaxTextureSize) {
             return return_null_texture();
         }
     }
@@ -1156,13 +1113,14 @@
 
     GrGLStencilBuffer* sb = NULL;
 
-    int stencilFmtCnt = fStencilFormats.count();
+    int stencilFmtCnt = fGLCaps.fStencilFormats.count();
     for (int i = 0; i < stencilFmtCnt; ++i) {
         GL_CALL(BindRenderbuffer(GR_GL_RENDERBUFFER, sbID));
         // we start with the last stencil format that succeeded in hopes
         // that we won't go through this loop more than once after the
         // first (painful) stencil creation.
         int sIdx = (i + fLastSuccessfulStencilFmtIdx) % stencilFmtCnt;
+        const GrGLStencilBuffer::Format& sFmt = fGLCaps.fStencilFormats[sIdx];
         // we do this "if" so that we don't call the multisample
         // version on a GL that doesn't have an MSAA extension.
         if (samples > 1) {
@@ -1170,21 +1128,21 @@
                                   RenderbufferStorageMultisample(
                                         GR_GL_RENDERBUFFER,
                                         samples,
-                                        fStencilFormats[sIdx].fInternalFormat,
+                                        sFmt.fInternalFormat,
                                         width,
                                         height));
         } else {
             GR_GL_CALL_NOERRCHECK(this->glInterface(),
                                   RenderbufferStorage(GR_GL_RENDERBUFFER,
-                                        fStencilFormats[sIdx].fInternalFormat,
-                                        width, height));
+                                                      sFmt.fInternalFormat,
+                                                      width, height));
         }
 
         GrGLenum err = GR_GL_GET_ERROR(this->glInterface());
         if (err == GR_GL_NO_ERROR) {
             // After sized formats we attempt an unsized format and take whatever
             // sizes GL gives us. In that case we query for the size.
-            GrGLStencilBuffer::Format format = fStencilFormats[sIdx];
+            GrGLStencilBuffer::Format format = sFmt;
             get_stencil_rb_sizes(this->glInterface(), sbID, &format);
             sb = new GrGLStencilBuffer(this, sbID, width, height, 
                                        samples, format);
@@ -1606,7 +1564,7 @@
 void GrGpuGL::resolveRenderTarget(GrGLRenderTarget* rt) {
 
     if (rt->needsResolve()) {
-        GrAssert(kNone_MSFBO != fMSFBOType);
+        GrAssert(GLCaps::kNone_MSFBO != fGLCaps.fMSFBOType);
         GrAssert(rt->textureFBOID() != rt->renderFBOID());
         GL_CALL(BindFramebuffer(GR_GL_READ_FRAMEBUFFER,
                                 rt->renderFBOID()));
@@ -1624,7 +1582,7 @@
         r.setRelativeTo(vp, dirtyRect.fLeft, dirtyRect.fTop, 
                         dirtyRect.width(), dirtyRect.height());
 
-        if (kAppleES_MSFBO == fMSFBOType) {
+        if (GLCaps::kAppleES_MSFBO == fGLCaps.fMSFBOType) {
             // Apple's extension uses the scissor as the blit bounds.
             GL_CALL(Enable(GR_GL_SCISSOR_TEST));
             GL_CALL(Scissor(r.fLeft, r.fBottom,
@@ -1633,10 +1591,10 @@
             fHWBounds.fScissorRect.invalidate();
             fHWBounds.fScissorEnabled = true;
         } else {
-            if (kDesktopARB_MSFBO != fMSFBOType) {
+            if (GLCaps::kDesktopARB_MSFBO != fGLCaps.fMSFBOType) {
                 // this respects the scissor during the blit, so disable it.
-                GrAssert(kDesktopEXT_MSFBO == fMSFBOType);
-                flushScissor(NULL);
+                GrAssert(GLCaps::kDesktopEXT_MSFBO == fGLCaps.fMSFBOType);
+                this->flushScissor(NULL);
             }
             int right = r.fLeft + r.fWidth;
             int top = r.fBottom + r.fHeight;
@@ -1716,7 +1674,7 @@
         } else {
             GL_CALL(Enable(GR_GL_STENCIL_TEST));
     #if GR_DEBUG
-            if (!fStencilWrapOpsSupport) {
+            if (!this->getCaps().fStencilWrapOpsSupport) {
                 GrAssert(settings->fFrontPassOp != kIncWrap_StencilOp);
                 GrAssert(settings->fFrontPassOp != kDecWrap_StencilOp);
                 GrAssert(settings->fFrontFailOp != kIncWrap_StencilOp);
@@ -1768,7 +1726,7 @@
                      (unsigned) settings->fBackFailOp < GR_ARRAY_COUNT(grToGLStencilOp));
             GrAssert(settings->fBackPassOp >= 0 &&
                      (unsigned) settings->fBackPassOp < GR_ARRAY_COUNT(grToGLStencilOp));
-            if (fTwoSidedStencilSupport) {
+            if (this->getCaps().fTwoSidedStencilSupport) {
                 GrGLenum backFunc;
 
                 unsigned int backRef  = settings->fBackFuncRef;
@@ -2133,7 +2091,7 @@
             *type = GR_GL_UNSIGNED_SHORT_4_4_4_4;
             break;
         case kIndex_8_GrPixelConfig:
-            if (this->supports8BitPalette()) {
+            if (this->getCaps().f8BitPaletteSupport) {
                 *format = GR_GL_PALETTE8_RGBA8;
                 *internalFormat = GR_GL_PALETTE8_RGBA8;
                 *type = GR_GL_UNSIGNED_BYTE;   // unused I think
@@ -2177,7 +2135,7 @@
     switch (config) {
         case kRGBA_8888_GrPixelConfig:
         case kRGBX_8888_GrPixelConfig:
-            if (fRGBA8Renderbuffer) {
+            if (fGLCaps.fRGBA8Renderbuffer) {
                 *format = GR_GL_RGBA8;
                 return true;
             } else {
@@ -2267,6 +2225,32 @@
 int GrGpuGL::getMaxEdges() const {
     // FIXME:  This is a pessimistic estimate based on how many other things
     // want to add uniforms.  This should be centralized somewhere.
-    return GR_CT_MIN(fMaxFragmentUniformVectors - 8, kMaxEdges);
+    return GR_CT_MIN(fGLCaps.fMaxFragmentUniformVectors - 8, kMaxEdges);
 }
 
+void GrGpuGL::GLCaps::print() const {
+    for (int i = 0; i < fStencilFormats.count(); ++i) {
+        GrPrintf("Stencil Format %d, stencil bits: %02d, total bits: %02d\n",
+                 i,
+                 fStencilFormats[i].fStencilBits,
+                 fStencilFormats[i].fTotalBits);
+    }
+
+    GR_STATIC_ASSERT(0 == kNone_MSFBO);
+    GR_STATIC_ASSERT(1 == kDesktopARB_MSFBO);
+    GR_STATIC_ASSERT(2 == kDesktopEXT_MSFBO);
+    GR_STATIC_ASSERT(3 == kAppleES_MSFBO);
+    static const char* gMSFBOExtStr[] = {
+        "None",
+        "ARB",
+        "EXT",
+        "Apple",
+    };
+    GrPrintf("MSAA Type: %s\n", gMSFBOExtStr[fMSFBOType]);
+    for (int i = 0; i < GR_ARRAY_COUNT(fAASamples); ++i) {
+        GrPrintf("AA Level %d has %d samples\n", i, fAASamples[i]);
+    }
+    GrPrintf("Max FS Uniform Vectors: %d\n", fMaxFragmentUniformVectors);
+    GrPrintf("Support RGBA8 Render Buffer: %s\n",
+             (fRGBA8Renderbuffer ? "YES": "NO"));
+}
diff --git a/gpu/src/GrGpuGL.h b/gpu/src/GrGpuGL.h
index a38d6b6..353394f 100644
--- a/gpu/src/GrGpuGL.h
+++ b/gpu/src/GrGpuGL.h
@@ -146,9 +146,14 @@
     static bool BlendCoeffReferencesConstant(GrBlendCoeff coeff);
 
 private:
+    // Inits GrDrawTarget::Caps and GLCaps, sublcass may enable
+    // additional caps.
+    void initCaps();
+
+    void initFSAASupport();
 
     // determines valid stencil formats
-    void setupStencilFormats();
+    void initStencilFormats();
 
     // notify callbacks to update state tracking when related
     // objects are bound to GL or deleted outside of the class
@@ -194,7 +199,43 @@
     SkString fExtensionString;
     GrGLVersion fGLVersion;
 
-    SkTArray<GrGLStencilBuffer::Format, true> fStencilFormats;
+    struct GLCaps {
+        // prealloc space for 8 stencil formats
+        GLCaps() : fStencilFormats(8) {}
+        SkTArray<GrGLStencilBuffer::Format, true> fStencilFormats;
+
+        enum {
+            /**
+             * no support for MSAA FBOs
+             */
+            kNone_MSFBO = 0,  
+            /**
+             * GL3.0-style MSAA FBO (GL_ARB_framebuffer_object)
+             */
+            kDesktopARB_MSFBO,
+            /**
+             * earlier GL_EXT_framebuffer* extensions
+             */
+            kDesktopEXT_MSFBO,
+            /**
+             * GL_APPLE_framebuffer_multisample ES extension
+             */
+            kAppleES_MSFBO,
+        } fMSFBOType;
+
+        // TODO: get rid of GrAALevel and use sample cnt directly
+        GrGLuint fAASamples[4];
+
+        // The maximum number of fragment uniform vectors (GLES has min. 16).
+        int fMaxFragmentUniformVectors;
+
+        // ES requires an extension to support RGBA8 in RenderBufferStorage
+        bool fRGBA8Renderbuffer;
+
+        void print() const;
+    } fGLCaps;
+
+
     // we want to clear stencil buffers when they are created. We want to clear
     // the entire buffer even if it is larger than the color attachment. We
     // attach it to this fbo with no color attachment to do the initial clear.
@@ -202,23 +243,6 @@
 
     bool fHWBlendDisabled;
 
-    GrGLuint fAASamples[4];
-    enum {
-        kNone_MSFBO = 0,  //<! no support for MSAA FBOs
-        kDesktopARB_MSFBO,//<! GL3.0-style MSAA FBO (GL_ARB_framebuffer_object)
-        kDesktopEXT_MSFBO,//<! earlier GL_EXT_framebuffer* extensions
-        kAppleES_MSFBO,   //<! GL_APPLE_framebuffer_multisample ES extension
-    } fMSFBOType;
-
-    // Do we have stencil wrap ops.
-    bool fHasStencilWrap;
-
-    // The maximum number of fragment uniform vectors (GLES has min. 16).
-    int fMaxFragmentUniformVectors;
-
-    // ES requires an extension to support RGBA8 in RenderBufferStorage
-    bool fRGBA8Renderbuffer;
-
     int fActiveTextureUnitIdx;
 
     // we record what stencil format worked last time to hopefully exit early
@@ -228,6 +252,8 @@
     const GrGLInterface* fGL;
     GrGLBinding fGLBinding;
 
+    bool fPrintedCaps;
+
     typedef GrGpu INHERITED;
 };
 
diff --git a/gpu/src/GrGpuGLFixed.cpp b/gpu/src/GrGpuGLFixed.cpp
index 2c97e69..195ca32 100644
--- a/gpu/src/GrGpuGLFixed.cpp
+++ b/gpu/src/GrGpuGLFixed.cpp
@@ -62,9 +62,6 @@
 
 GrGpuGLFixed::GrGpuGLFixed(const GrGLInterface* gl)
     : GrGpuGL(gl, get_binding_in_use(gl)) {
-    fShaderSupport = false;
-    fShaderDerivativeSupport = false;
-    fDualSourceBlendingSupport = false;
 }
 
 GrGpuGLFixed::~GrGpuGLFixed() {
diff --git a/gpu/src/GrGpuGLShaders.cpp b/gpu/src/GrGpuGLShaders.cpp
index 7d15c4f..05f6652 100644
--- a/gpu/src/GrGpuGLShaders.cpp
+++ b/gpu/src/GrGpuGLShaders.cpp
@@ -213,7 +213,7 @@
             bool vertexEdgeAA = random.nextF() > .5f;
             if (vertexEdgeAA) {
                 pdesc.fVertexLayout |= GrDrawTarget::kEdge_VertexLayoutBit;
-                if (this->supportsShaderDerivatives()) {
+                if (this->getCaps().fShaderDerivativeSupport) {
                     pdesc.fVertexEdgeType = random.nextF() > 0.5f ?
                                                         kHairQuad_EdgeType :
                                                         kHairLine_EdgeType;
@@ -229,7 +229,7 @@
             pdesc.fEdgeAANumEdges = 0;
         }
 
-        if (fDualSourceBlendingSupport) {
+        if (this->getCaps().fDualSourceBlendingSupport) {
             pdesc.fDualSrcOutput =
                (ProgramDesc::DualSrcOutput)
                (int)(random.nextF() * ProgramDesc::kDualSrcOutputCnt);
@@ -290,15 +290,15 @@
 GrGpuGLShaders::GrGpuGLShaders(const GrGLInterface* gl)
     : GrGpuGL(gl, get_binding_in_use(gl)) {
 
-    fShaderSupport = true;
+    fCaps.fShaderSupport = true;
     if (kDesktop_GrGLBinding == this->glBinding()) {
-        fDualSourceBlendingSupport =
+        fCaps.fDualSourceBlendingSupport =
                             this->glVersion() >= GR_GL_VER(3,3) ||
                             this->hasExtension("GL_ARB_blend_func_extended");
-        fShaderDerivativeSupport = true;
+        fCaps.fShaderDerivativeSupport = true;
     } else {
-        fDualSourceBlendingSupport = false;
-        fShaderDerivativeSupport =
+        fCaps.fDualSourceBlendingSupport = false;
+        fCaps.fShaderDerivativeSupport =
                             this->hasExtension("GL_OES_standard_derivatives");
     }
 
@@ -937,7 +937,7 @@
         // (e.g. solid draw, and dst coeff is kZero. It's correct to make
         // the dst coeff be kISA. Or solid draw with kSA can be tweaked to be
         // kOne).
-        if (fDualSourceBlendingSupport) {
+        if (this->getCaps().fDualSourceBlendingSupport) {
             if (kZero_BlendCoeff == fCurrDrawState.fDstBlend) {
                 // write the coverage value to second color
                 desc.fDualSrcOutput =  ProgramDesc::kCoverage_DualSrcOutput;
diff --git a/gpu/src/GrInOrderDrawBuffer.cpp b/gpu/src/GrInOrderDrawBuffer.cpp
index 85af430..9519655 100644
--- a/gpu/src/GrInOrderDrawBuffer.cpp
+++ b/gpu/src/GrInOrderDrawBuffer.cpp
@@ -18,8 +18,7 @@
 GrInOrderDrawBuffer::GrInOrderDrawBuffer(const GrGpu* gpu,
                                          GrVertexBufferAllocPool* vertexPool,
                                          GrIndexBufferAllocPool* indexPool)
-    : fGpu(gpu)
-    , fDraws(&fDrawStorage)
+    : fDraws(&fDrawStorage)
     , fStates(&fStateStorage)
     , fClears(&fClearStorage)
     , fClips(&fClipStorage)
@@ -33,12 +32,12 @@
     , fVertexPool(*vertexPool)
     , fIndexPool(*indexPool)
     , fGeoPoolStateStack(&fGeoStackStorage) {
-    
+
+    fCaps = gpu->getCaps();
+
     GrAssert(NULL != vertexPool);
     GrAssert(NULL != indexPool);
 
-    gpu->ref();
-
     GeometryPoolState& poolState = fGeoPoolStateStack.push_back();
     poolState.fUsedPoolVertexBytes = 0;
     poolState.fUsedPoolIndexBytes = 0;
@@ -53,7 +52,6 @@
 GrInOrderDrawBuffer::~GrInOrderDrawBuffer() {
     this->reset();
     GrSafeUnref(fQuadIndexBuffer);
-    fGpu->unref();
 }
 
 void GrInOrderDrawBuffer::initializeDrawStateAndClip(const GrDrawTarget& target) {
@@ -627,7 +625,7 @@
 }
 
 bool GrInOrderDrawBuffer::willUseHWAALines() const {
-    return fGpu->supportsHWAALines() &&
+    return this->getCaps().fHWAALineSupport &&
            CanUseHWAALines(this->getGeomSrc().fVertexLayout, fCurrDrawState);
 }
 
diff --git a/gpu/src/GrPathRendererChain.cpp b/gpu/src/GrPathRendererChain.cpp
index dc09d43..a6da6d3 100644
--- a/gpu/src/GrPathRendererChain.cpp
+++ b/gpu/src/GrPathRendererChain.cpp
@@ -57,9 +57,9 @@
 void GrPathRendererChain::init() {
     GrAssert(!fInit);
     GrGpu* gpu = fOwner->getGpu();
-    this->addPathRenderer(
-                    new GrDefaultPathRenderer(gpu->supportsTwoSidedStencil(),
-                    gpu->supportsStencilWrapOps()))->unref();
+    bool twoSided = gpu->getCaps().fTwoSidedStencilSupport;
+    bool wrapOp = gpu->getCaps().fStencilWrapOpsSupport;
+    this->addPathRenderer(new GrDefaultPathRenderer(twoSided, wrapOp))->unref();
     GrPathRenderer::AddPathRenderers(fOwner, fFlags, this);
     fInit = true;
 }