diff --git a/gpu/include/GrGpu.h b/gpu/include/GrGpu.h
index fff40fb..ef03bdb 100644
--- a/gpu/include/GrGpu.h
+++ b/gpu/include/GrGpu.h
@@ -19,7 +19,6 @@
 class GrContext;
 class GrIndexBufferAllocPool;
 class GrResource;
-class GrStencilBuffer;
 class GrVertexBufferAllocPool;
 
 /**
@@ -314,13 +313,12 @@
 
     /**
      * Called to tell Gpu object that all GrResources have been lost and should
-     * be abandoned. Overrides must call INHERITED::abandonResources().
+     * be abandoned.
      */
     virtual void abandonResources();
 
     /**
-     * Called to tell Gpu object to release all GrResources. Overrides must call
-     * INHERITED::releaseResources().
+     * Called to tell Gpu object to release all GrResources.
      */
     void releaseResources();
 
@@ -471,16 +469,6 @@
                                int vertexCount,
                                int indexCount) = 0;
 
-    // width and height may be larger than rt (if underlying API allows it).
-    // Should attach the SB to the RT. Returns false if compatible sb could
-    // not be created.
-    virtual bool createStencilBufferForRenderTarget(GrRenderTarget* rt,
-                                                    int width, 
-                                                    int height) = 0;
-
-    // attaches an existing SB to an existing RT.
-    virtual bool attachStencilBufferToRenderTarget(GrStencilBuffer* sb,
-                                                   GrRenderTarget* rt) = 0;
 
     // The GrGpu typically records the clients requested state and then flushes
     // deltas from previous state at draw time. This function does the
@@ -525,9 +513,6 @@
 
     GrResource*                 fResourceHead;
 
-    // Given a rt, find or create a stencil buffer and attach it
-    bool attachStencilBufferToRenderTarget(GrRenderTarget* target);
-
     // GrDrawTarget overrides
     virtual void onDrawIndexed(GrPrimitiveType type,
                                int startVertex,
diff --git a/gpu/include/GrRenderTarget.h b/gpu/include/GrRenderTarget.h
index 06d62a4..a5616b9 100644
--- a/gpu/include/GrRenderTarget.h
+++ b/gpu/include/GrRenderTarget.h
@@ -18,10 +18,10 @@
 #ifndef GrRenderTarget_DEFINED
 #define GrRenderTarget_DEFINED
 
+#include "GrClip.h"
 #include "GrRect.h"
 #include "GrResource.h"
 
-class GrStencilBuffer;
 class GrTexture;
 
 /**
@@ -51,6 +51,11 @@
     int config() const { return fConfig; }
 
     /**
+     * @return the number of stencil bits in the rendertarget
+     */
+    int stencilBits() const { return fStencilBits; }
+
+    /**
      * @return the texture associated with the rendertarget, may be NULL.
      */
     GrTexture* asTexture() {return fTexture;}
@@ -140,25 +145,20 @@
     };
     virtual ResolveType getResolveType() const = 0;
 
-    /**
-     * GrStencilBuffer is not part of the public API.
-     */
-    GrStencilBuffer* getStencilBuffer() const { return fStencilBuffer; }
-    void setStencilBuffer(GrStencilBuffer* stencilBuffer);
-
 protected:
     GrRenderTarget(GrGpu* gpu,
                    GrTexture* texture,
                    int width,
                    int height,
                    GrPixelConfig config,
+                   int stencilBits,
                    int sampleCnt)
         : INHERITED(gpu)
-        , fStencilBuffer(NULL)
         , fTexture(texture)
         , fWidth(width)
         , fHeight(height)
         , fConfig(config)
+        , fStencilBits(stencilBits)
         , fSampleCnt(sampleCnt)
     {
         fResolveRect.setLargestInverted();
@@ -175,16 +175,20 @@
         fTexture = NULL;
     }
 
-    GrStencilBuffer*  fStencilBuffer;
-
 private:
-    GrTexture*      fTexture; // not ref'ed
+    GrTexture* fTexture; // not ref'ed
     int             fWidth;
     int             fHeight;
     GrPixelConfig   fConfig;
+    int             fStencilBits;
     int             fSampleCnt;
     GrIRect         fResolveRect;
 
+    // GrGpu keeps a cached clip in the render target to avoid redundantly
+    // rendering the clip into the same stencil buffer.
+    friend class GrGpu;
+    GrClip     fLastStencilClip;
+
     typedef GrResource INHERITED;
 };
 
diff --git a/gpu/src/GrGLRenderTarget.cpp b/gpu/src/GrGLRenderTarget.cpp
index 38b9eb7..7be8b32 100644
--- a/gpu/src/GrGLRenderTarget.cpp
+++ b/gpu/src/GrGLRenderTarget.cpp
@@ -19,6 +19,7 @@
     fRTFBOID                = desc.fRTFBOID;
     fTexFBOID               = desc.fTexFBOID;
     fMSColorRenderbufferID  = desc.fMSColorRenderbufferID;
+    fStencilRenderbufferID  = desc.fStencilRenderbufferID;
     fViewport               = viewport;
     fOwnIDs                 = desc.fOwnIDs;
     fTexIDObj               = texID;
@@ -31,7 +32,8 @@
                                    GrGLTexID* texID,
                                    GrGLTexture* texture)
     : INHERITED(gpu, texture, viewport.fWidth,
-                viewport.fHeight, desc.fConfig, desc.fSampleCnt) {
+                viewport.fHeight, desc.fConfig,
+                desc.fStencilBits, desc.fSampleCnt) {
     GrAssert(NULL != texID);
     GrAssert(NULL != texture);
     // FBO 0 can't also be a texture, right?
@@ -44,7 +46,8 @@
                                    const Desc& desc,
                                    const GrGLIRect& viewport)
     : INHERITED(gpu, NULL, viewport.fWidth,
-                viewport.fHeight, desc.fConfig, desc.fSampleCnt) {
+                viewport.fHeight, desc.fConfig,
+                desc.fStencilBits, desc.fSampleCnt) {
     this->init(desc, viewport, NULL);
 }
 
@@ -57,26 +60,29 @@
         if (fRTFBOID && fRTFBOID != fTexFBOID) {
             GR_GL(DeleteFramebuffers(1, &fRTFBOID));
         }
+        if (fStencilRenderbufferID) {
+            GR_GL(DeleteRenderbuffers(1, &fStencilRenderbufferID));
+        }
         if (fMSColorRenderbufferID) {
             GR_GL(DeleteRenderbuffers(1, &fMSColorRenderbufferID));
         }
     }
     fRTFBOID                = 0;
     fTexFBOID               = 0;
+    fStencilRenderbufferID  = 0;
     fMSColorRenderbufferID  = 0;
     GrSafeUnref(fTexIDObj);
     fTexIDObj = NULL;
-    GrSafeSetNull(fStencilBuffer);
 }
 
 void GrGLRenderTarget::onAbandon() {
     fRTFBOID                = 0;
     fTexFBOID               = 0;
+    fStencilRenderbufferID  = 0;
     fMSColorRenderbufferID  = 0;
     if (NULL != fTexIDObj) {
         fTexIDObj->abandon();
         fTexIDObj = NULL;
     }
-    GrSafeSetNull(fStencilBuffer);
 }
 
diff --git a/gpu/src/GrGLRenderTarget.h b/gpu/src/GrGLRenderTarget.h
index 5aeb36d..3d64fab 100644
--- a/gpu/src/GrGLRenderTarget.h
+++ b/gpu/src/GrGLRenderTarget.h
@@ -28,9 +28,11 @@
     struct Desc {
         GrGLuint      fRTFBOID;
         GrGLuint      fTexFBOID;
+        GrGLuint      fStencilRenderbufferID;
         GrGLuint      fMSColorRenderbufferID;
         bool          fOwnIDs;
         GrPixelConfig fConfig;
+        int           fStencilBits;
         int           fSampleCnt;
     };
 
@@ -85,7 +87,7 @@
 private:
     GrGLuint      fRTFBOID;
     GrGLuint      fTexFBOID;
-
+    GrGLuint      fStencilRenderbufferID;
     GrGLuint      fMSColorRenderbufferID;
 
     // Should this object delete IDs when it is destroyed or does someone
diff --git a/gpu/src/GrGLStencilBuffer.h b/gpu/src/GrGLStencilBuffer.h
deleted file mode 100644
index 97394e3..0000000
--- a/gpu/src/GrGLStencilBuffer.h
+++ /dev/null
@@ -1,72 +0,0 @@
-
-/*
- * Copyright 2011 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-
-#ifndef GrGLStencilBuffer_DEFINED
-#define GrGLStencilBuffer_DEFINED
-
-#include "GrGLInterface.h"
-#include "GrStencilBuffer.h"
-
-class GrGLStencilBuffer : public GrStencilBuffer {
-public:
-    static const GrGLenum kUnknownInternalFormat = ~0;
-    struct Format {
-        GrGLenum  fInternalFormat;
-        GrGLuint  fStencilBits;
-        GrGLuint  fTotalBits;
-        bool      fPacked;
-    };
-
-    GrGLStencilBuffer(GrGpu* gpu, GrGLint rbid, 
-                      int width, int height,
-                      const Format& format) 
-        : GrStencilBuffer(gpu, width, height, format.fStencilBits)
-        , fFormat(format)
-        , fRenderbufferID(rbid) {
-    }
-
-    virtual ~GrGLStencilBuffer() {
-        this->release();
-    }
-
-    virtual size_t sizeInBytes() const {
-        return this->width() * this->height() * fFormat.fTotalBits;
-    }
-
-    GrGLuint renderbufferID() const {
-        return fRenderbufferID;
-    }
-
-    const Format& format() const {
-        return fFormat;
-    }
-
-protected:
-    virtual void onRelease() {
-        if (0 != fRenderbufferID) {
-            GR_GL(DeleteRenderbuffers(1, &fRenderbufferID));
-            fRenderbufferID = 0;
-        }
-    }
-
-    virtual void onAbandon() {
-        fRenderbufferID = 0;
-    }
-
-private:
-    Format fFormat;
-    // may be zero for external SBs associated with external RTs
-    // (we don't require the client to give us the id, just tell
-    // us how many bits of stencil there are).
-    GrGLuint fRenderbufferID;
-
-    typedef GrStencilBuffer INHERITED;
-};
-
-#endif
diff --git a/gpu/src/GrGpu.cpp b/gpu/src/GrGpu.cpp
index be84e27..c89dd4e 100644
--- a/gpu/src/GrGpu.cpp
+++ b/gpu/src/GrGpu.cpp
@@ -8,12 +8,12 @@
 
 
 #include "GrGpu.h"
-#include "GrBufferAllocPool.h"
+#include "GrTextStrike.h"
 #include "GrClipIterator.h"
 #include "GrIndexBuffer.h"
-#include "GrPathRenderer.h"
-#include "GrGLStencilBuffer.h"
 #include "GrVertexBuffer.h"
+#include "GrBufferAllocPool.h"
+#include "GrPathRenderer.h"
 
 // probably makes no sense for this to be less than a page
 static const size_t VERTEX_POOL_VB_SIZE = 1 << 18;
@@ -140,24 +140,7 @@
 GrTexture* GrGpu::createTexture(const GrTextureDesc& desc,
                                 const void* srcData, size_t rowBytes) {
     this->handleDirtyContext();
-    GrTexture* tex = this->onCreateTexture(desc, srcData, rowBytes);
-    if (NULL != tex && 
-        (kRenderTarget_GrTextureFlagBit & desc.fFlags) &&
-        !(kNoStencil_GrTextureFlagBit & desc.fFlags)) {
-        GrAssert(NULL != tex->asRenderTarget());
-        // TODO: defer this and attach dynamically
-        if (!this->attachStencilBufferToRenderTarget(tex->asRenderTarget())) {
-            tex->unref();
-            return NULL;
-        }
-    }
-    return tex;
-}
-
-bool GrGpu::attachStencilBufferToRenderTarget(GrRenderTarget* rt) {
-    // TODO: use a cache of stencil buffers rather than create per-rt.
-    return this->createStencilBufferForRenderTarget(rt, rt->width(),
-                                                    rt->height());
+    return this->onCreateTexture(desc, srcData, rowBytes);
 }
 
 GrRenderTarget* GrGpu::createRenderTargetFrom3DApiState() {
@@ -415,22 +398,14 @@
         fClipInStencil = !fClip.isRect() && !fClip.isEmpty() && 
                          !bounds.isEmpty();
 
-        // TODO: dynamically attach a SB when needed.
-        GrStencilBuffer* stencilBuffer = rt.getStencilBuffer();
-        if (fClipInStencil && NULL == stencilBuffer) {
-            return false;
-        }
-
         if (fClipInStencil &&
-            stencilBuffer->mustRenderClip(fClip, rt.width(), rt.height())) {
+            fClip != rt.fLastStencilClip) {
 
-            stencilBuffer->setLastClip(fClip, rt.width(), rt.height());
-
+            rt.fLastStencilClip = fClip;
             // we set the current clip to the bounds so that our recursive
             // draws are scissored to them. We use the copy of the complex clip
-            // we just stashed on the SB to render from. We set it back after
-            // we finish drawing it into the stencil.
-            const GrClip& clip = stencilBuffer->getLastClip();
+            // in the rt to render
+            const GrClip& clip = rt.fLastStencilClip;
             fClip.setFromRect(bounds);
 
             AutoStateRestore asr(this);
@@ -445,7 +420,7 @@
             this->disableState(kNoColorWrites_StateBit);
 #endif
             int count = clip.getElementCount();
-            int clipBit = stencilBuffer->bits();
+            int clipBit = rt.stencilBits();
             clipBit = (1 << (clipBit-1));
 
             // often we'll see the first two elements of the clip are
diff --git a/gpu/src/GrGpuGL.cpp b/gpu/src/GrGpuGL.cpp
index 3ced743..2498972 100644
--- a/gpu/src/GrGpuGL.cpp
+++ b/gpu/src/GrGpuGL.cpp
@@ -8,7 +8,6 @@
 
 
 #include "GrGpuGL.h"
-#include "GrGLStencilBuffer.h"
 #include "GrTypes.h"
 #include "SkTemplates.h"
 
@@ -516,14 +515,9 @@
     }
 
     fLastSuccessfulStencilFmtIdx = 0;
-
-    fStencilClearFBO = 0;
 }
 
 GrGpuGL::~GrGpuGL() {
-    if (fStencilClearFBO) {
-        GR_GL(DeleteFramebuffers(1, &fStencilClearFBO));
-    }
 }
 
 void GrGpuGL::resetContext() {
@@ -595,21 +589,6 @@
     fHWDrawState.fRenderTarget = NULL;
 }
 
-void GrGpuGL::abandonResources() {
-    INHERITED::abandonResources();
-
-    fStencilClearFBO = 0;
-}
-
-void GrGpuGL::releaseResources() {
-    INHERITED::releaseResources();
-
-    if (fStencilClearFBO) {
-        GR_GL(DeleteFramebuffers(1, &fStencilClearFBO));
-        fStencilClearFBO = 0;
-    }
-}
-
 GrResource* GrGpuGL::onCreatePlatformSurface(const GrPlatformSurfaceDesc& desc) {
 
     bool isTexture = kTexture_GrPlatformSurfaceType == desc.fSurfaceType ||
@@ -618,8 +597,6 @@
                           kTextureRenderTarget_GrPlatformSurfaceType == desc.fSurfaceType;
 
     GrGLRenderTarget::Desc rtDesc;
-    GrGLStencilBuffer* sb = NULL;
-
     if (isRenderTarget) {
         rtDesc.fRTFBOID = desc.fPlatformRenderTarget;
 #if GR_USE_PLATFORM_CREATE_SAMPLE_COUNT
@@ -638,6 +615,7 @@
         }
         // we don't know what the RB ids are without glGets and we don't care
         // since we aren't responsible for deleting them.
+        rtDesc.fStencilRenderbufferID = 0;
         rtDesc.fMSColorRenderbufferID = 0;
 #if GR_USE_PLATFORM_CREATE_SAMPLE_COUNT
         rtDesc.fSampleCnt = desc.fSampleCnt;
@@ -651,15 +629,7 @@
             rtDesc.fSampleCnt = 0;
         }
 #endif
-        if (desc.fStencilBits) {
-            GrGLStencilBuffer::Format format;
-            format.fInternalFormat = GrGLStencilBuffer::kUnknownInternalFormat;
-            format.fPacked = false;
-            format.fStencilBits = desc.fStencilBits;
-            format.fTotalBits = desc.fStencilBits;
-            sb = new GrGLStencilBuffer(this, 0, desc.fWidth,
-                                       desc.fHeight, format);
-        }
+        rtDesc.fStencilBits = desc.fStencilBits;
         rtDesc.fOwnIDs = false;
     }
 
@@ -685,9 +655,7 @@
 
         params.invalidate(); // rather than do glGets.
         if (isRenderTarget) {
-            GrTexture* tex = new GrGLTexture(this, texDesc, rtDesc, params);
-            tex->asRenderTarget()->setStencilBuffer(sb);
-            return tex;
+            return new GrGLTexture(this, texDesc, rtDesc, params);
         } else {
             return new GrGLTexture(this, texDesc, params);
         }
@@ -698,9 +666,7 @@
         viewport.fWidth  = desc.fWidth;
         viewport.fHeight = desc.fHeight;
 
-        GrGLRenderTarget* rt =  new GrGLRenderTarget(this, rtDesc, viewport);
-        rt->setStencilBuffer(sb);
-        return rt;
+        return new GrGLRenderTarget(this, rtDesc, viewport);
     }
 }
 
@@ -849,25 +815,14 @@
     GR_GL_GetIntegerv(GR_GL_FRAMEBUFFER_BINDING, (GrGLint*)&rtDesc.fRTFBOID);
     rtDesc.fTexFBOID = rtDesc.fRTFBOID;
     rtDesc.fMSColorRenderbufferID = 0;
+    rtDesc.fStencilRenderbufferID = 0;
 
     bool arbFBO = (GR_GL_SUPPORT_DESKTOP && (fGLVersion > 3.0 ||
                    this->hasExtension("GL_ARB_framebuffer_object")));
 
     GrGLIRect viewport;
     viewport.setFromGLViewport();
-    int stencilBits = get_fbo_stencil_bits(arbFBO);
-
-    GrGLStencilBuffer* sb = NULL;
-    if (stencilBits) {
-        GrGLStencilBuffer::Format format;
-        // we could query this but we don't really need it
-        format.fInternalFormat = GrGLStencilBuffer::kUnknownInternalFormat;
-        format.fPacked = false;
-        format.fStencilBits = stencilBits;
-        format.fTotalBits = stencilBits;
-        sb = new GrGLStencilBuffer(this, 0, viewport.fWidth,
-                                   viewport.fHeight, format);
-    }
+    rtDesc.fStencilBits = get_fbo_stencil_bits(arbFBO);
 
     GR_GL_GetIntegerv(GR_GL_SAMPLES, &rtDesc.fSampleCnt);
     GrGLenum fmat = get_fbo_color_format();
@@ -882,13 +837,10 @@
 
     rtDesc.fOwnIDs = false;
 
-    GrGLRenderTarget* target = new GrGLRenderTarget(this, rtDesc, viewport);
-    target->setStencilBuffer(sb);
-    return target;
+    return new GrGLRenderTarget(this, rtDesc, viewport);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-static const GrGLuint kUnknownBitCount = ~0;
 
 void GrGpuGL::setupStencilFormats() {
 
@@ -897,14 +849,12 @@
 
     // 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 };
+    static const StencilFormat gS8    = {GR_GL_STENCIL_INDEX8,     8,                 false};
+    static const StencilFormat gS16   = {GR_GL_STENCIL_INDEX16,    16,                false};
+    static const StencilFormat gD24S8 = {GR_GL_DEPTH24_STENCIL8,   8,                 true };
+    static const StencilFormat gS4    = {GR_GL_STENCIL_INDEX4,     4,                 false};
+    static const StencilFormat gS     = {GR_GL_STENCIL_INDEX,      gUNKNOWN_BITCOUNT, false};
+    static const StencilFormat gDS    = {GR_GL_DEPTH_STENCIL,      gUNKNOWN_BITCOUNT, true };
 
     if (GR_GL_SUPPORT_DESKTOP) {
         bool supportsPackedDS = fGLVersion >= 3.0f || 
@@ -1086,86 +1036,6 @@
     }
 }
 
-bool GrGpuGL::createRenderTargetObjects(int width, int height,
-                                        GrGLuint texID,
-                                        GrGLRenderTarget::Desc* desc) {
-    desc->fMSColorRenderbufferID = 0;
-    desc->fRTFBOID = 0;
-    desc->fTexFBOID = 0;
-    desc->fOwnIDs = true;
-
-    GrGLenum status;
-    GrGLint err;
-
-    GR_GL(GenFramebuffers(1, &desc->fTexFBOID));
-    if (!desc->fTexFBOID) {
-        goto FAILED;
-    }
-    
-    GrGLenum msColorFormat;
-
-    // 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) {
-        GR_GL(GenFramebuffers(1, &desc->fRTFBOID));
-        GR_GL(GenRenderbuffers(1, &desc->fMSColorRenderbufferID));
-        if (!desc->fRTFBOID ||
-            !desc->fMSColorRenderbufferID || 
-            !this->fboInternalFormat(desc->fConfig, &msColorFormat)) {
-            goto FAILED;
-        }
-    } else {
-        desc->fRTFBOID = desc->fTexFBOID;
-    }
-
-    if (desc->fRTFBOID != desc->fTexFBOID) {
-        GrAssert(desc->fSampleCnt > 1);
-        GR_GL(BindRenderbuffer(GR_GL_RENDERBUFFER,
-                               desc->fMSColorRenderbufferID));
-        GR_GL_NO_ERR(RenderbufferStorageMultisample(GR_GL_RENDERBUFFER, 
-                                                    desc->fSampleCnt,
-                                                    msColorFormat,
-                                                    width, height));
-        err = GrGLGetGLInterface()->fGetError();
-        if (err != GR_GL_NO_ERROR) {
-            goto FAILED;
-        }
-        GR_GL(BindFramebuffer(GR_GL_FRAMEBUFFER, desc->fRTFBOID));
-        GR_GL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER, 
-                                      GR_GL_COLOR_ATTACHMENT0,
-                                      GR_GL_RENDERBUFFER,
-                                      desc->fMSColorRenderbufferID));
-        GrGLenum status = GR_GL(CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
-        if (status != GR_GL_FRAMEBUFFER_COMPLETE) {
-            goto FAILED;
-        }
-    }
-    GR_GL(BindFramebuffer(GR_GL_FRAMEBUFFER, desc->fTexFBOID));
-
-    GR_GL(FramebufferTexture2D(GR_GL_FRAMEBUFFER,
-                               GR_GL_COLOR_ATTACHMENT0,
-                               GR_GL_TEXTURE_2D,
-                               texID, 0));
-    status = GR_GL(CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
-    if (status != GR_GL_FRAMEBUFFER_COMPLETE) {
-        goto FAILED;
-    }
-
-    return true;
-
-FAILED:
-    if (desc->fMSColorRenderbufferID) {
-        GR_GL(DeleteRenderbuffers(1, &desc->fMSColorRenderbufferID));
-    }
-    if (desc->fRTFBOID != desc->fTexFBOID) {
-        GR_GL(DeleteFramebuffers(1, &desc->fRTFBOID));
-    }
-    if (desc->fTexFBOID) {
-        GR_GL(DeleteFramebuffers(1, &desc->fTexFBOID));
-    }
-    return false;
-}
-
 // good to set a break-point here to know when createTexture fails
 static GrTexture* return_null_texture() {
 //    GrAssert(!"null texture");
@@ -1203,6 +1073,7 @@
     glTexDesc.fFormat        = desc.fFormat;
     glTexDesc.fOwnsID        = true;
 
+    glRTDesc.fStencilRenderbufferID = 0;
     glRTDesc.fMSColorRenderbufferID = 0;
     glRTDesc.fRTFBOID = 0;
     glRTDesc.fTexFBOID = 0;
@@ -1221,7 +1092,7 @@
     // 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;
+                                         GrGLTexture::kTopDown_Orientation;
 
     GrAssert(as_size_t(desc.fAALevel) < GR_ARRAY_COUNT(fAASamples));
     glRTDesc.fSampleCnt = fAASamples[desc.fAALevel];
@@ -1238,9 +1109,9 @@
         }
 
         glTexDesc.fAllocWidth = GrMax(fMinRenderTargetWidth,
-                                      glTexDesc.fAllocWidth);
+                                   glTexDesc.fAllocWidth);
         glTexDesc.fAllocHeight = GrMax(fMinRenderTargetHeight,
-                                       glTexDesc.fAllocHeight);
+                                    glTexDesc.fAllocHeight);
         if (glTexDesc.fAllocWidth > fMaxRenderTargetSize ||
             glTexDesc.fAllocHeight > fMaxRenderTargetSize) {
             return return_null_texture();
@@ -1276,203 +1147,198 @@
 
     this->allocateAndUploadTexData(glTexDesc, internalFormat,srcData, rowBytes);
 
-    GrGLTexture* tex;
     if (renderTarget) {
         GrGLenum msColorRenderbufferFormat = -1;
 #if GR_COLLECT_STATS
         ++fStats.fRenderTargetCreateCnt;
 #endif
-        if (!this->createRenderTargetObjects(glTexDesc.fAllocWidth,
-                                             glTexDesc.fAllocHeight,
-                                             glTexDesc.fTextureID,
-                                             &glRTDesc)) {
+        bool failed = true;
+        GrGLenum status;
+        GrGLint err;
+
+        GR_GL(GenFramebuffers(1, &glRTDesc.fTexFBOID));
+        GrAssert(glRTDesc.fTexFBOID);
+
+        // If we are using multisampling and we will create two FBOS We render
+        // to one and then resolve to the texture bound to the other.
+        if (glRTDesc.fSampleCnt > 0 && kNone_MSFBO != fMSFBOType) {
+            GR_GL(GenFramebuffers(1, &glRTDesc.fRTFBOID));
+            GrAssert(0 != glRTDesc.fRTFBOID);
+            GR_GL(GenRenderbuffers(1, &glRTDesc.fMSColorRenderbufferID));
+            GrAssert(0 != glRTDesc.fMSColorRenderbufferID);
+            if (!fboInternalFormat(desc.fFormat, &msColorRenderbufferFormat)) {
+                GR_GL(DeleteRenderbuffers(1, &glRTDesc.fMSColorRenderbufferID));
+                GR_GL(DeleteTextures(1, &glTexDesc.fTextureID));
+                GR_GL(DeleteFramebuffers(1, &glRTDesc.fTexFBOID));
+                GR_GL(DeleteFramebuffers(1, &glRTDesc.fRTFBOID));
+                return return_null_texture();
+            }
+        } else {
+            glRTDesc.fRTFBOID = glRTDesc.fTexFBOID;
+        }
+        if (!(kNoStencil_GrTextureFlagBit & desc.fFlags)) {
+            GR_GL(GenRenderbuffers(1, &glRTDesc.fStencilRenderbufferID));
+            GrAssert(0 != glRTDesc.fStencilRenderbufferID);
+        }
+
+        // someone suggested that some systems might require
+        // unbinding the texture before we call FramebufferTexture2D
+        // (seems unlikely)
+        GR_GL(BindTexture(GR_GL_TEXTURE_2D, 0));
+
+        err = ~GR_GL_NO_ERROR;
+
+        int stencilFmtCnt;
+        if (glRTDesc.fStencilRenderbufferID) {
+            stencilFmtCnt = fStencilFormats.count();
+        } else {
+            stencilFmtCnt = 1; // only 1 attempt when we don't need a stencil
+        }
+
+        for (int i = 0; i < stencilFmtCnt; ++i) {
+            // 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;
+            
+            if (glRTDesc.fStencilRenderbufferID) {
+                GR_GL(BindRenderbuffer(GR_GL_RENDERBUFFER,
+                                       glRTDesc.fStencilRenderbufferID));
+                if (glRTDesc.fSampleCnt > 0) {
+                    GR_GL_NO_ERR(RenderbufferStorageMultisample(
+                                                GR_GL_RENDERBUFFER,
+                                                glRTDesc.fSampleCnt,
+                                                fStencilFormats[sIdx].fEnum,
+                                                glTexDesc.fAllocWidth,
+                                                glTexDesc.fAllocHeight));
+                } else {
+                    GR_GL_NO_ERR(RenderbufferStorage(GR_GL_RENDERBUFFER,
+                                                     fStencilFormats[sIdx].fEnum,
+                                                     glTexDesc.fAllocWidth,
+                                                     glTexDesc.fAllocHeight));
+                }
+                err = GrGLGetGLInterface()->fGetError();
+                if (err != GR_GL_NO_ERROR) {
+                    continue;
+                }
+            }
+            if (glRTDesc.fRTFBOID != glRTDesc.fTexFBOID) {
+                GrAssert(glRTDesc.fSampleCnt > 0);
+                GR_GL(BindRenderbuffer(GR_GL_RENDERBUFFER,
+                                       glRTDesc.fMSColorRenderbufferID));
+                GR_GL_NO_ERR(RenderbufferStorageMultisample(
+                                                   GR_GL_RENDERBUFFER,
+                                                   glRTDesc.fSampleCnt,
+                                                   msColorRenderbufferFormat,
+                                                   glTexDesc.fAllocWidth,
+                                                   glTexDesc.fAllocHeight));
+                err = GrGLGetGLInterface()->fGetError();
+                if (err != GR_GL_NO_ERROR) {
+                    continue;
+                }
+            }
+            GR_GL(BindFramebuffer(GR_GL_FRAMEBUFFER, glRTDesc.fTexFBOID));
+
+#if GR_COLLECT_STATS
+            ++fStats.fRenderTargetChngCnt;
+#endif
+            GR_GL(FramebufferTexture2D(GR_GL_FRAMEBUFFER,
+                                        GR_GL_COLOR_ATTACHMENT0,
+                                        GR_GL_TEXTURE_2D,
+                                        glTexDesc.fTextureID, 0));
+            if (glRTDesc.fRTFBOID != glRTDesc.fTexFBOID) {
+                GrGLenum status = GR_GL(CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
+                if (status != GR_GL_FRAMEBUFFER_COMPLETE) {
+                    continue;
+                }
+                GR_GL(BindFramebuffer(GR_GL_FRAMEBUFFER, glRTDesc.fRTFBOID));
+            #if GR_COLLECT_STATS
+                ++fStats.fRenderTargetChngCnt;
+            #endif
+                GR_GL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
+                                              GR_GL_COLOR_ATTACHMENT0,
+                                              GR_GL_RENDERBUFFER,
+                                              glRTDesc.fMSColorRenderbufferID));
+
+            }
+            if (glRTDesc.fStencilRenderbufferID) {
+                // bind the stencil to rt fbo if present, othewise the tex fbo
+                GR_GL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
+                                              GR_GL_STENCIL_ATTACHMENT,
+                                              GR_GL_RENDERBUFFER,
+                                              glRTDesc.fStencilRenderbufferID));
+                // if it is a packed format bind to depth also, otherwise 
+                // we may get an unsupported fbo completeness result
+                if (fStencilFormats[sIdx].fPacked) {
+                    GR_GL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
+                                                  GR_GL_DEPTH_ATTACHMENT,
+                                                  GR_GL_RENDERBUFFER,
+                                                  glRTDesc.fStencilRenderbufferID));
+                }
+            }
+            status = GR_GL(CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
+
+            if (status != GR_GL_FRAMEBUFFER_COMPLETE) {
+                // undo the depth bind
+                if (glRTDesc.fStencilRenderbufferID && 
+                    fStencilFormats[sIdx].fPacked) {
+                    GR_GL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
+                                                  GR_GL_DEPTH_ATTACHMENT,
+                                                  GR_GL_RENDERBUFFER, 0));
+                }
+                continue;
+            }
+            // we're successful!
+            failed = false;
+            if (glRTDesc.fStencilRenderbufferID) {
+                fLastSuccessfulStencilFmtIdx = sIdx;
+                if (gUNKNOWN_BITCOUNT == fStencilFormats[sIdx].fBits) {
+                    GR_GL_GetIntegerv(GR_GL_STENCIL_BITS, (GrGLint*)&glRTDesc.fStencilBits);
+                } else {
+                    glRTDesc.fStencilBits = fStencilFormats[sIdx].fBits;
+                }
+            }
+            break;
+        }
+        if (failed) {
+            if (glRTDesc.fStencilRenderbufferID) {
+                GR_GL(DeleteRenderbuffers(1, &glRTDesc.fStencilRenderbufferID));
+            }
+            if (glRTDesc.fMSColorRenderbufferID) {
+                GR_GL(DeleteRenderbuffers(1, &glRTDesc.fMSColorRenderbufferID));
+            }
+            if (glRTDesc.fRTFBOID != glRTDesc.fTexFBOID) {
+                GR_GL(DeleteFramebuffers(1, &glRTDesc.fRTFBOID));
+            }
+            if (glRTDesc.fTexFBOID) {
+                GR_GL(DeleteFramebuffers(1, &glRTDesc.fTexFBOID));
+            }
             GR_GL(DeleteTextures(1, &glTexDesc.fTextureID));
             return return_null_texture();
         }
-        tex = new GrGLTexture(this, glTexDesc, glRTDesc, DEFAULT_PARAMS);
-    } else {
-        tex = new GrGLTexture(this, glTexDesc, DEFAULT_PARAMS);
     }
 #ifdef TRACE_TEXTURE_CREATION
     GrPrintf("--- new texture [%d] size=(%d %d) bpp=%d\n",
              tex->fTextureID, width, height, tex->fUploadByteCount);
 #endif
-    return tex;
-}
-
-namespace {
-void inline get_stencil_rb_sizes(GrGLuint rb, GrGLStencilBuffer::Format* format) {
-    // we shouldn't ever know one size and not the other
-    GrAssert((kUnknownBitCount == format->fStencilBits) ==
-             (kUnknownBitCount == format->fTotalBits));
-    if (kUnknownBitCount == format->fStencilBits) {
-        GR_GL_GetRenderbufferParameteriv(GR_GL_RENDERBUFFER,
-                                         GR_GL_RENDERBUFFER_STENCIL_SIZE,
-                                         (GrGLint*)&format->fStencilBits);
-        if (format->fPacked) {
-            GR_GL_GetRenderbufferParameteriv(GR_GL_RENDERBUFFER,
-                                             GR_GL_RENDERBUFFER_DEPTH_SIZE,
-                                             (GrGLint*)&format->fTotalBits);
-            format->fTotalBits += format->fStencilBits;
-        } else {
-            format->fTotalBits = format->fStencilBits;
-        }
-    }
-}
-}
-
-bool GrGpuGL::createStencilBufferForRenderTarget(GrRenderTarget* rt,
-                                                 int width, int height) {
-
-    // All internally created RTs are also textures. We don't create
-    // SBs for a client's standalone RT (that is RT that isnt also a texture).
-    GrAssert(rt->asTexture());
-    // if this thing is bloated for NPOT reasons we'll have to bloat the SB 
-    // as well.
-    GrGLTexture* tex = (GrGLTexture*) rt->asTexture();
-    width = GrMax(width, tex->allocWidth());
-    height = GrMax(height, tex->allocWidth());
-
-    int samples = rt->numSamples();
-    GrGLuint sbID;
-    GR_GL(GenRenderbuffers(1, &sbID));
-    if (!sbID) {
-        return false;
-    }
-
-    GrGLStencilBuffer* sb = NULL;
-
-    int stencilFmtCnt = fStencilFormats.count();
-    for (int i = 0; i < stencilFmtCnt; ++i) {
-        GR_GL(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;
-        // 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) {
-            GR_GL_NO_ERR(RenderbufferStorageMultisample(
-                                        GR_GL_RENDERBUFFER,
-                                        samples,
-                                        fStencilFormats[sIdx].fInternalFormat,
-                                        width,
-                                        height));
-        } else {
-            GR_GL_NO_ERR(RenderbufferStorage(GR_GL_RENDERBUFFER,
-                                        fStencilFormats[sIdx].fInternalFormat,
-                                        width, height));
-        }
-
-        GrGLenum err = GrGLGetGLInterface()->fGetError();
-        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];
-            get_stencil_rb_sizes(sbID, &format);
-            sb = new GrGLStencilBuffer(this, sbID, width, height, format);
-            if (this->attachStencilBufferToRenderTarget(sb, rt)) {
-                fLastSuccessfulStencilFmtIdx = sIdx;
-                sb->unref();
-                // initial clear zeros the entire sb by attaching it alone
-                // to an fbo (that we create here on demand).
-                if (!fStencilClearFBO) {
-                    GR_GL(GenFramebuffers(1, &fStencilClearFBO));
-                    if (0 == fStencilClearFBO) {
-                        rt->setStencilBuffer(NULL);
-                        return false;
-                    }
-                }
-                fHWDrawState.fRenderTarget = NULL;
-
-                GR_GL(BindFramebuffer(GR_GL_FRAMEBUFFER, fStencilClearFBO));
-                GR_GL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
-                                                GR_GL_STENCIL_ATTACHMENT,
-                                                GR_GL_RENDERBUFFER, sbID));
-                if (fStencilFormats[sIdx].fPacked) {
-                    GR_GL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
-                                                GR_GL_DEPTH_ATTACHMENT,
-                                                GR_GL_RENDERBUFFER, sbID));
-                } else {
-                    GR_GL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
-                                                    GR_GL_DEPTH_ATTACHMENT,
-                                                    GR_GL_RENDERBUFFER, 0));
-                }
-#if GR_DEBUG
-                GrGLenum status = 
-                    GR_GL(CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
-                GrAssert(GR_GL_FRAMEBUFFER_COMPLETE == status);
-#endif
-
-                this->flushScissor(NULL);
-                GR_GL(ClearStencil(0));
-                GR_GL(Clear(GR_GL_STENCIL_BUFFER_BIT));
-                return true;
-           }
-           sb->abandon(); // otherwise we lose sbID
-           sb->unref();
-        }
-    }
-    GR_GL(DeleteRenderbuffers(1, &sbID));
-    return NULL;
-}
-
-bool GrGpuGL::attachStencilBufferToRenderTarget(GrStencilBuffer* sb,
-                                                GrRenderTarget* rt) {
-    GrGLRenderTarget* glrt = (GrGLRenderTarget*) rt;
-
-    GrGLuint fbo = glrt->renderFBOID();
-
-    if (NULL == sb) {
-        if (NULL != rt->getStencilBuffer()) {
-            GR_GL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
-                                          GR_GL_STENCIL_ATTACHMENT,
-                                          GR_GL_RENDERBUFFER, 0));
-            GR_GL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
-                                          GR_GL_DEPTH_ATTACHMENT,
-                                          GR_GL_RENDERBUFFER, 0));
-#if GR_DEBUG
-            GrGLenum status = 
-                GR_GL(CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
-            GrAssert(GR_GL_FRAMEBUFFER_COMPLETE == status);
-#endif
-        }
-        return true;
-    } else {
-        GrGLStencilBuffer* glsb = (GrGLStencilBuffer*) sb;
-        GrGLuint rb = glsb->renderbufferID();
-
+    if (renderTarget) {
+        GrGLTexture* tex = new GrGLTexture(this, glTexDesc, 
+                                           glRTDesc, DEFAULT_PARAMS);
+        GrRenderTarget* rt = tex->asRenderTarget();
+        // We've messed with FBO state but may not have set the correct viewport
+        // so just dirty the rendertarget state to force a resend.
         fHWDrawState.fRenderTarget = NULL;
 
-        GR_GL(BindFramebuffer(GR_GL_FRAMEBUFFER, fbo));
-        GR_GL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
-                                      GR_GL_STENCIL_ATTACHMENT,
-                                      GR_GL_RENDERBUFFER, rb));
-        if (glsb->format().fPacked) {
-            GR_GL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
-                                          GR_GL_DEPTH_ATTACHMENT,
-                                          GR_GL_RENDERBUFFER, rb));
-        } else {
-            GR_GL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
-                                          GR_GL_DEPTH_ATTACHMENT,
-                                          GR_GL_RENDERBUFFER, 0));
+        // clear the new stencil buffer if we have one
+        if (!(desc.fFlags & kNoStencil_GrTextureFlagBit)) {
+            GrRenderTarget* rtSave = fCurrDrawState.fRenderTarget;
+            fCurrDrawState.fRenderTarget = rt;
+            this->clearStencil(0, ~0);
+            fCurrDrawState.fRenderTarget = rtSave;
         }
-
-        GrGLenum status = GR_GL(CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
-        if (status != GR_GL_FRAMEBUFFER_COMPLETE) {
-            GR_GL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
-                                          GR_GL_STENCIL_ATTACHMENT,
-                                          GR_GL_RENDERBUFFER, 0));
-            if (glsb->format().fPacked) {
-                GR_GL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
-                                              GR_GL_DEPTH_ATTACHMENT,
-                                              GR_GL_RENDERBUFFER, 0));
-            }
-            return false;
-        } else {
-            rt->setStencilBuffer(sb);
-            return true;
-        }
+        return tex;
+    } else {
+        return new GrGLTexture(this, glTexDesc, DEFAULT_PARAMS);
     }
 }
 
@@ -1602,25 +1468,20 @@
 
 void GrGpuGL::clearStencilClip(const GrIRect& rect) {
     GrAssert(NULL != fCurrDrawState.fRenderTarget);
-
-    // this should only be called internally when we know we have a
-    // stencil buffer.
-    GrAssert(NULL != fCurrDrawState.fRenderTarget->getStencilBuffer());
 #if 0
-    GrGLint stencilBitCount = 
-        fCurrDrawState.fRenderTarget->getStencilBuffer()->bits();
+    GrGLint stencilBitCount = fCurrDrawState.fRenderTarget->stencilBits();
     GrAssert(stencilBitCount > 0);
     GrGLint clipStencilMask  = (1 << (stencilBitCount - 1));
 #else
     // we could just clear the clip bit but when we go through
-    // ANGLE a partial stencil mask will cause clears to be
+    // angle a partial stencil mask will cause clears to be
     // turned into draws. Our contract on GrDrawTarget says that
     // changing the clip between stencil passes may or may not
     // zero the client's clip bits. So we just clear the whole thing.
     static const GrGLint clipStencilMask  = ~0;
 #endif
     this->flushRenderTarget(&GrIRect::EmptyIRect());
-    this->flushScissor(&rect);
+    flushScissor(&rect);
     GR_GL(StencilMask(clipStencilMask));
     GR_GL(ClearStencil(0));
     GR_GL(Clear(GR_GL_STENCIL_BUFFER_BIT));
@@ -1933,13 +1794,7 @@
                 GrAssert(settings->fFrontFailOp != kDecWrap_StencilOp);
             }
     #endif
-            int stencilBits = 0;
-            GrStencilBuffer* stencilBuffer = 
-                            fCurrDrawState.fRenderTarget->getStencilBuffer();
-            if (NULL != stencilBuffer) {
-                stencilBits = stencilBuffer->bits();
-            }
-            // TODO: dynamically attach a stencil buffer
+            int stencilBits = fCurrDrawState.fRenderTarget->stencilBits();
             GrAssert(stencilBits ||
                      (GrStencilSettings::gDisabled ==
                       fCurrDrawState.fStencilSettings));
diff --git a/gpu/src/GrGpuGL.h b/gpu/src/GrGpuGL.h
index 6dbc9d7..59e32cf 100644
--- a/gpu/src/GrGpuGL.h
+++ b/gpu/src/GrGpuGL.h
@@ -12,11 +12,11 @@
 #define GrGpuGL_DEFINED
 
 #include "GrGpu.h"
-#include "GrGLIndexBuffer.h"
 #include "GrGLIRect.h"
-#include "GrGLStencilBuffer.h"
 #include "GrGLTexture.h"
+
 #include "GrGLVertexBuffer.h"
+#include "GrGLIndexBuffer.h"
 
 #include "SkString.h"
 
@@ -69,9 +69,8 @@
     } fHWBounds;
 
     // GrGpu overrides
+    // overrides from GrGpu
     virtual void resetContext();
-    virtual void abandonResources();
-    virtual void releaseResources();
 
     virtual GrTexture* onCreateTexture(const GrTextureDesc& desc,
                                        const void* srcData,
@@ -82,10 +81,6 @@
                                                bool dynamic);
     virtual GrResource* onCreatePlatformSurface(const GrPlatformSurfaceDesc& desc);
     virtual GrRenderTarget* onCreateRenderTargetFrom3DApiState();
-    virtual bool createStencilBufferForRenderTarget(GrRenderTarget* rt,
-                                                    int width, int height);
-    virtual bool attachStencilBufferToRenderTarget(GrStencilBuffer* sb,
-                                                   GrRenderTarget* rt);
 
     virtual void onClear(const GrIRect* rect, GrColor color);
 
@@ -178,16 +173,12 @@
                       GrGLenum* internalFormat,
                       GrGLenum* format,
                       GrGLenum* type);
-    // helpers for onCreateTexture
+    // helper for onCreateTexture
     void allocateAndUploadTexData(const GrGLTexture::Desc& desc,
                                   GrGLenum internalFormat,
                                   const void* data,
                                   size_t rowBytes);
 
-    bool createRenderTargetObjects(int width, int height,
-                                   GrGLuint texID,
-                                   GrGLRenderTarget::Desc* desc);
-
     bool fboInternalFormat(GrPixelConfig config, GrGLenum* format);
 
     friend class GrGLVertexBuffer;
@@ -195,13 +186,16 @@
     friend class GrGLTexture;
     friend class GrGLRenderTarget;
 
+    static const GrGLuint gUNKNOWN_BITCOUNT = ~0;
 
-    GrTArray<GrGLStencilBuffer::Format, true> fStencilFormats;
-    // 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.
-    GrGLuint fStencilClearFBO;
-    
+    struct StencilFormat {
+        GrGLenum  fEnum;
+        GrGLuint  fBits;
+        bool      fPacked;
+    };
+
+    GrTArray<StencilFormat, true> fStencilFormats;
+
     bool fHWBlendDisabled;
 
     GrGLuint fAASamples[4];
diff --git a/gpu/src/GrRenderTarget.cpp b/gpu/src/GrRenderTarget.cpp
index 8eb9ae0..186fe8e 100644
--- a/gpu/src/GrRenderTarget.cpp
+++ b/gpu/src/GrRenderTarget.cpp
@@ -11,7 +11,6 @@
 
 #include "GrContext.h"
 #include "GrGpu.h"
-#include "GrStencilBuffer.h"
 
 bool GrRenderTarget::readPixels(int left, int top, int width, int height,
                                 GrPixelConfig config, void* buffer) {
@@ -31,7 +30,7 @@
     } else {
         colorBits = GrBytesPerPixel(fConfig);
     }
-    return fWidth * fHeight * colorBits;
+    return fWidth * fHeight * (fStencilBits + colorBits);
 }
 
 void GrRenderTarget::flagAsNeedingResolve(const GrIRect* rect) {
@@ -56,8 +55,4 @@
             fResolveRect.setLargestInverted();
         }
     }
-}
-
-void GrRenderTarget::setStencilBuffer(GrStencilBuffer* stencilBuffer) {
-    GrSafeAssign(fStencilBuffer, stencilBuffer);
-}
+}
\ No newline at end of file
diff --git a/gpu/src/GrStencilBuffer.h b/gpu/src/GrStencilBuffer.h
deleted file mode 100644
index 34fbe11..0000000
--- a/gpu/src/GrStencilBuffer.h
+++ /dev/null
@@ -1,69 +0,0 @@
-
-/*
- * Copyright 2011 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-
-#ifndef GrStencilBuffer_DEFINED
-#define GrStencilBuffer_DEFINED
-
-#include "GrClip.h"
-#include "GrResource.h"
-
-class GrStencilBuffer : public GrResource {
-public:
-    int width() const { return fWidth; }
-    int height() const { return fHeight; }
-    int bits() const { return fBits; }
-
-    // called to note the last clip drawn to this buffer.
-    void setLastClip(const GrClip& clip, int width, int height) {
-        fLastClip = clip;
-        fLastClipWidth = width;
-        fLastClipHeight = height;
-        GrAssert(width <= fWidth);
-        GrAssert(height <= fHeight);
-    }
-
-    // called to determine if we have to render the clip into SB.
-    bool mustRenderClip(const GrClip& clip, int width, int height) const {
-        // The clip is in device space. That is it doesn't scale to fit a
-        // smaller RT. It is just truncated on the right / bottom edges.
-        // Note that this assumes that the viewport origin never moves within
-        // the stencil buffer. This is valid today.
-        return width > fLastClipWidth ||
-               height > fLastClipHeight ||
-               clip != fLastClip;
-    }
-
-    const GrClip& getLastClip() const {
-        return fLastClip;
-    }
-
-protected:
-    GrStencilBuffer(GrGpu* gpu, int width, int height, int bits)
-        : GrResource(gpu)
-        , fWidth(width)
-        , fHeight(height)
-        , fBits(bits)
-        , fLastClip()
-        , fLastClipWidth(-1)
-        , fLastClipHeight(-1) {
-    }
-
-private:
-    int fWidth;
-    int fHeight;
-    int fBits;
-
-    GrClip     fLastClip;
-    int        fLastClipWidth;
-    int        fLastClipHeight;
-
-    typedef GrResource INHERITED;
-};
-
-#endif
diff --git a/gyp/gpu.gyp b/gyp/gpu.gyp
index f96e39c..f25e158 100644
--- a/gyp/gpu.gyp
+++ b/gyp/gpu.gyp
@@ -153,7 +153,6 @@
         '../gpu/src/GrGLProgram.h',
         '../gpu/src/GrGLRenderTarget.cpp',
         '../gpu/src/GrGLRenderTarget.h',
-        '../gpu/src/GrGLStencilBuffer.h',
         '../gpu/src/GrGLTexture.cpp',
         '../gpu/src/GrGLTexture.h',
         '../gpu/src/GrGLUtil.cpp',
@@ -180,7 +179,6 @@
         '../gpu/src/GrResourceCache.cpp',
         '../gpu/src/GrResourceCache.h',
         '../gpu/src/GrStencil.cpp',
-        '../gpu/src/GrStencilBuffer.h',
         '../gpu/src/GrTesselatedPathRenderer.cpp',
         '../gpu/src/GrTextContext.cpp',
         '../gpu/src/GrTextStrike.cpp',