diff --git a/gpu/include/GrAllocPool.h b/gpu/include/GrAllocPool.h
index 46359e5..251c0b4 100644
--- a/gpu/include/GrAllocPool.h
+++ b/gpu/include/GrAllocPool.h
@@ -33,7 +33,7 @@
     /**
      *  Returns a block of memory bytes size big. This address must not be
      *  passed to realloc/free/delete or any other function that assumes the
-     *  address was allocated by malloc or new (becuase it hasn't).
+     *  address was allocated by malloc or new (because it hasn't).
      */
     void* alloc(size_t bytes);
     
diff --git a/gpu/include/GrContext.h b/gpu/include/GrContext.h
index 6b9c3f3..973198b 100644
--- a/gpu/include/GrContext.h
+++ b/gpu/include/GrContext.h
@@ -445,25 +445,33 @@
     GrFontCache* getFontCache() { return fFontCache; }
     GrDrawTarget* getTextTarget(const GrPaint& paint);
     void flushText();
-
-    const GrIndexBuffer* quadIndexBuffer() const;
-    int maxQuadsInIndexBuffer() const;
+    const GrIndexBuffer* getQuadIndexBuffer() const;
 
 private:
+    // used to keep track of when we need to flush the draw buffer
+    enum DrawCategory {
+        kBuffered_DrawCategory,      // last draw was inserted in draw buffer
+        kUnbuffered_DrawCategory,    // last draw was not inserted in the draw buffer
+        kText_DrawCategory           // text context was last to draw
+    };
+    DrawCategory fLastDrawCategory;
+
     GrGpu*          fGpu;
     GrTextureCache* fTextureCache;
     GrFontCache*    fFontCache;
 
-    GrVertexBufferAllocPool*    fTextVBAllocPool;
-    GrIndexBufferAllocPool*     fTextIBAllocPool;
-    GrInOrderDrawBuffer*        fTextDrawBuffer;
+    GrVertexBufferAllocPool*    fDrawBufferVBAllocPool;
+    GrIndexBufferAllocPool*     fDrawBufferIBAllocPool;
+    GrInOrderDrawBuffer*        fDrawBuffer;
 
     GrContext(GrGpu* gpu);
+    void flushDrawBuffer();
 
     static void SetPaint(const GrPaint& paint, GrDrawTarget* target);
 
     bool finalizeTextureKey(GrTextureKey*, const GrSamplerState&) const;
-    void prepareToDraw(const GrPaint& paint);
+    
+    GrDrawTarget* prepareToDraw(const GrPaint& paint, DrawCategory drawType);
 
     void drawClipIntoStencil();
 };
diff --git a/gpu/include/GrContext_impl.h b/gpu/include/GrContext_impl.h
index b54e927..8af38e6 100644
--- a/gpu/include/GrContext_impl.h
+++ b/gpu/include/GrContext_impl.h
@@ -30,7 +30,7 @@
 
     GrDrawTarget::AutoReleaseGeometry geo;
 
-    this->prepareToDraw(paint);
+    GrDrawTarget* target = this->prepareToDraw(paint, kUnbuffered_DrawCategory);
 
     if (NULL != paint.getTexture()) {
         if (NULL != texCoordSrc) {
@@ -47,7 +47,7 @@
     int vertexCount = posSrc.count();
     int indexCount = (NULL != idxSrc) ? idxSrc->count() : 0;
 
-    if (!geo.set(fGpu, layout, vertexCount, indexCount)) {
+    if (!geo.set(target, layout, vertexCount, indexCount)) {
         GrPrintf("Failed to get space for vertices!");
         return;
     }
@@ -77,9 +77,9 @@
     }
 
     if (NULL == idxSrc) {
-        fGpu->drawNonIndexed(primitiveType, 0, vertexCount);
+        target->drawNonIndexed(primitiveType, 0, vertexCount);
     } else {
-        fGpu->drawIndexed(primitiveType, 0, 0, vertexCount, indexCount);
+        target->drawIndexed(primitiveType, 0, 0, vertexCount, indexCount);
     }
 }
 
diff --git a/gpu/include/GrDrawTarget.h b/gpu/include/GrDrawTarget.h
index 88782f1..91af9ce 100644
--- a/gpu/include/GrDrawTarget.h
+++ b/gpu/include/GrDrawTarget.h
@@ -18,7 +18,6 @@
 #ifndef GrDrawTarget_DEFINED
 #define GrDrawTarget_DEFINED
 
-#include "GrScalar.h"
 #include "GrMatrix.h"
 #include "GrColor.h"
 #include "GrRefCnt.h"
@@ -347,7 +346,11 @@
     void disableState(uint32_t stateBits);
 
     bool isDitherState() const {
-        return fCurrDrawState.fFlagBits & kDither_StateBit;
+        return 0 != (fCurrDrawState.fFlagBits & kDither_StateBit);
+    }
+
+    bool isClipState() const {
+        return 0 != (fCurrDrawState.fFlagBits & kClip_StateBit);
     }
 
     /**
@@ -435,6 +438,16 @@
         GrAssert(texCoordIdx < kMaxTexCoords);
         return 1 << (stage + (texCoordIdx * kNumStages));
     }
+
+    /**
+     * Determines if blend is effectively disabled.
+     *
+     * @return true if blend can be disabled without changing the rendering
+     *  result given the current state including the vertex layout specified
+     *  with the vertex source.
+     */
+    bool canDisableBlend() const;
+
 private:
     static const int TEX_COORD_BIT_CNT = kNumStages*kMaxTexCoords;
 public:
@@ -655,6 +668,45 @@
                                 int startVertex,
                                 int vertexCount)  = 0;
 
+    /**
+     * Helper function for drawing rects. This does not use the current index
+     * and vertex sources. After returning, the vertex and index sources may
+     * have changed. They should be reestablished before the next drawIndexed
+     * or drawNonIndexed. This cannot be called between reserving and releasing
+     * geometry. The GrDrawTarget subclass may be able to perform additional
+     * optimizations if drawRect is used rather than drawIndexed or 
+     * drawNonIndexed.
+     * @param rect      the rect to draw
+     * @param matrix    optional matrix applied to rect (before viewMatrix)
+     * @param stageEnableMask   bitmask indicating which stages are enabled.
+     *                          Bit i indicates whether stage i is enabled.
+     * @param srcRects  specifies rects for stages enabled by stageEnableMask.
+     *                  if stageEnableMask bit i is 1, srcRects is not NULL,
+     *                  and srcRects[i] is not NULL, then srcRects[i] will be
+     *                  used as coordinates for stage i. Otherwise, if stage i
+     *                  is enabled then rect is used as the coordinates.
+     * @param srcMatrices   optional matrices applied to srcRects. If
+     *                      srcRect[i] is non-NULL and srcMatrices[i] is
+     *                      non-NULL then srcRect[i] will be transformed by
+     *                      srcMatrix[i]. srcMatrices can be NULL when no
+     *                      srcMatrices are desired.
+     */
+    virtual void drawRect(const GrRect& rect, 
+                          const GrMatrix* matrix,
+                          int stageEnableMask,
+                          const GrRect* srcRects[],
+                          const GrMatrix* srcMatrices[]);
+
+    /**
+     * Helper for drawRect when the caller doesn't need separate src rects or 
+     * matrices.
+     */
+    void drawSimpleRect(const GrRect& rect, 
+                        const GrMatrix* matrix, 
+                        int stageEnableMask) {
+         drawRect(rect, matrix, stageEnableMask, NULL, NULL);
+    }
+
     ///////////////////////////////////////////////////////////////////////////
 
     class AutoStateRestore : ::GrNoncopyable {
@@ -869,6 +921,65 @@
     static int VertexSizeAndOffsetsByStage(GrVertexLayout vertexLayout,
                                            int texCoordOffsetsByStage[kNumStages],
                                            int *colorOffset);
+
+    /**
+     * Accessing positions, texture coords, or colors, of a vertex within an
+     * array is a hassle involving casts and simple math. These helpers exist
+     * to keep GrDrawTarget clients' code a bit nicer looking.
+     */
+
+    /**
+     * Gets a pointer to a GrPoint of a vertex's position or texture
+     * coordinate.
+     * @param vertices      the vetex array
+     * @param vertexIndex   the index of the vertex in the array
+     * @param vertexSize    the size of each vertex in the array
+     * @param offset        the offset in bytes of the vertex component.
+     *                      Defaults to zero (corresponding to vertex position)
+     * @return pointer to the vertex component as a GrPoint
+     */
+    static GrPoint* GetVertexPoint(void* vertices, 
+                                   int vertexIndex,
+                                   int vertexSize,
+                                   int offset = 0) {
+        intptr_t start = GrTCast<intptr_t>(vertices);
+        return GrTCast<GrPoint*>(start + offset + 
+                                 vertexIndex * vertexSize);
+    }
+    static const GrPoint* GetVertexPoint(const void* vertices,
+                                         int vertexIndex,
+                                         int vertexSize, 
+                                         int offset = 0) {
+        intptr_t start = GrTCast<intptr_t>(vertices);
+        return GrTCast<const GrPoint*>(start + offset + 
+                                       vertexIndex * vertexSize);
+    }
+
+    /**
+     * Gets a pointer to a GrColor inside a vertex within a vertex array.
+     * @param vertices      the vetex array
+     * @param vertexIndex   the index of the vertex in the array
+     * @param vertexSize    the size of each vertex in the array
+     * @param offset        the offset in bytes of the vertex color
+     * @return pointer to the vertex component as a GrColor
+     */
+    static GrColor* GetVertexColor(void* vertices, 
+                                   int vertexIndex,
+                                   int vertexSize,
+                                   int offset) {
+        intptr_t start = GrTCast<intptr_t>(vertices);
+        return GrTCast<GrColor*>(start + offset + 
+                                 vertexIndex * vertexSize);
+    }
+    static const GrColor* GetVertexColor(const void* vertices,
+                                         int vertexIndex,
+                                         int vertexSize, 
+                                         int offset) {
+        const intptr_t start = GrTCast<intptr_t>(vertices);
+        return GrTCast<const GrColor*>(start + offset + 
+                                       vertexIndex * vertexSize);
+    }
+
 protected:
 
     // Helpers for GrDrawTarget subclasses that won't have private access to
@@ -885,7 +996,8 @@
 
     virtual void releaseGeometryHelper() = 0;
 
-    virtual void clipWillChange(const GrClip& clip) = 0;
+    // subclass overrides to be notified when clip is set.
+    virtual void clipWillBeSet(const GrClip& clip) = 0;
 
     virtual void setVertexSourceToArrayHelper(const void* vertexArray,
                                               int vertexCount) = 0;
@@ -893,6 +1005,18 @@
     virtual void setIndexSourceToArrayHelper(const void* indexArray,
                                              int indexCount) = 0;
 
+    // Helpers for drawRect, protected so subclasses that override drawRect
+    // can use them.
+    static GrVertexLayout GetRectVertexLayout(int stageEnableMask, 
+                                              const GrRect* srcRects[]);
+
+    static void SetRectVertices(const GrRect& rect,
+                                const GrMatrix* matrix, 
+                                const GrRect* srcRects[], 
+                                const GrMatrix* srcMatrices[],
+                                GrVertexLayout layout, 
+                                void* vertices);
+
     enum GeometrySrcType {
         kReserved_GeometrySrcType,  // src was set using reserveAndLockGeometry
         kArray_GeometrySrcType,     // src was set using set*SourceToArray
diff --git a/gpu/include/GrGeometryBuffer.h b/gpu/include/GrGeometryBuffer.h
index fc3e358..af6eed5 100644
--- a/gpu/include/GrGeometryBuffer.h
+++ b/gpu/include/GrGeometryBuffer.h
@@ -31,7 +31,7 @@
      *
      * @return the size of the buffer in bytes
      */
-    size_t size() { return fSizeInBytes; }
+    size_t size() const { return fSizeInBytes; }
     
     /**
      *Retrieves whether the buffer was created with the dynamic flag
@@ -107,9 +107,9 @@
         fDynamic(dynamic) {}
 
 private:
-    size_t fSizeInBytes;
+    size_t   fSizeInBytes;
     bool     fDynamic;
-    
+
     typedef GrRefCnt INHERITED;
 };
 
diff --git a/gpu/include/GrGpu.h b/gpu/include/GrGpu.h
index 9fb7b9c..a132e9f 100644
--- a/gpu/include/GrGpu.h
+++ b/gpu/include/GrGpu.h
@@ -21,9 +21,7 @@
 #include "GrRect.h"
 #include "GrRefCnt.h"
 #include "GrDrawTarget.h"
-#include "GrGpuVertex.h"
 #include "GrTexture.h"
-#include "GrMemory.h"
 
 class GrVertexBufferAllocPool;
 class GrIndexBufferAllocPool;
@@ -295,29 +293,20 @@
                                 int vertexCount);
 
     /**
-     * Determines if blend is effectively disabled.
-     *
-     * @return true if blend can be disabled without changing the rendering
-     *  result given the current state including the vertex layout specified
-     *  with the vertex source.
-     */
-    bool canDisableBlend() const;
-
-    /**
      * Returns an index buffer that can be used to render quads.
-     * Indices are 0, 1, 2, 0, 2, 3, etc.
+     * Six indices per quad: 0, 1, 2, 0, 2, 3, etc.
+     * The max number of quads can be queried using GrIndexBuffer::maxQuads().
      * Draw with kTriangles_PrimitiveType
+     * @ return the quad index buffer
      */
-    const GrIndexBuffer* quadIndexBuffer() const;
-    /**
-     * Gets the number of quads that can be rendered using quadIndexBuffer.
-     */
-    int maxQuadsInIndexBuffer() const;
+    const GrIndexBuffer* getQuadIndexBuffer() const;
 
     /**
-     * Returns a vertex buffer with four position-only vertices [(0,0), (1,0), (1,1), (0,1)]
+     * Returns a vertex buffer with four position-only vertices [(0,0), (1,0), 
+     * (1,1), (0,1)].
+     * @ return unit square vertex buffer
      */
-    const GrVertexBuffer* unitSquareVertexBuffer() const;
+    const GrVertexBuffer* getUnitSquareVertexBuffer() const;
 
     /**
      * Ensures that the current render target is actually set in the
@@ -356,7 +345,10 @@
         GrRenderTarget* fStencilClipTarget;
     } fClipState;
 
-    virtual void clipWillChange(const GrClip& clip);
+    // GrDrawTarget override
+    virtual void clipWillBeSet(const GrClip& newClip);
+
+    // prepares clip flushes gpu state before a draw
     bool setupClipAndFlushState(PrimitiveType type);
 
     struct BoundsState {
diff --git a/gpu/include/GrInOrderDrawBuffer.h b/gpu/include/GrInOrderDrawBuffer.h
index 463ea2d..0dba8e3 100644
--- a/gpu/include/GrInOrderDrawBuffer.h
+++ b/gpu/include/GrInOrderDrawBuffer.h
@@ -41,31 +41,65 @@
 class GrInOrderDrawBuffer : public GrDrawTarget {
 public:
 
+    /**
+     * Creates a GrInOrderDrawBuffer
+     *
+     * @param vertexPool pool where vertices for queued draws will be saved when
+     *                   the vertex source is either reserved or array.
+     * @param indexPool  pool where indices for queued draws will be saved when
+     *                   the index source is either reserved or array.
+     */
     GrInOrderDrawBuffer(GrVertexBufferAllocPool* vertexPool,
                         GrIndexBufferAllocPool* indexPool);
 
     virtual ~GrInOrderDrawBuffer();
 
+    /**
+     * Copies the draw state and clip from target to this draw buffer.
+     *
+     * @param target    the target whose clip and state should be copied.
+     */
     void initializeDrawStateAndClip(const GrDrawTarget& target);
 
+    /**
+     * Provides the buffer with an index buffer that can be used for quad rendering.
+     * The buffer may be able to batch consecutive drawRects if this is provided.
+     * @param indexBuffer   index buffer with quad indices.
+     */
+    void setQuadIndexBuffer(const GrIndexBuffer* indexBuffer);
+
+    /**
+     * Empties the draw buffer of any queued up draws.
+     */
+    void reset();
+
+    /**
+     * plays the queued up draws to another target. Does not empty this buffer so
+     * that it can be played back multiple times.
+     * @param target    the target to receive the playback
+     */
+    void playback(GrDrawTarget* target);
+    
+    // overrides from GrDrawTarget
     virtual void drawIndexed(PrimitiveType primitiveType,
                              int startVertex,
                              int startIndex,
                              int vertexCount,
                              int indexCount);
-
     virtual void drawNonIndexed(PrimitiveType primitiveType,
                                 int startVertex,
                                 int vertexCount);
 
+    virtual void drawRect(const GrRect& rect, 
+                          const GrMatrix* matrix = NULL,
+                          int stageEnableMask = 0,
+                          const GrRect* srcRects[] = NULL,
+                          const GrMatrix* srcMatrices[] = NULL);
+
     virtual bool geometryHints(GrVertexLayout vertexLayout,
                                int* vertexCount,
                                int* indexCount) const;
 
-    void reset();
-
-    void playback(GrDrawTarget* target);
-
 private:
 
     struct Draw {
@@ -85,7 +119,7 @@
                                        void**         vertices,
                                        void**         indices);
     virtual void releaseGeometryHelper();
-    virtual void clipWillChange(const GrClip& clip);
+    virtual void clipWillBeSet(const GrClip& newClip);
 
     virtual void setVertexSourceToArrayHelper(const void* vertexArray,
                                               int vertexCount);
@@ -93,9 +127,11 @@
     virtual void setIndexSourceToArrayHelper(const void* indexArray,
                                              int indexCount);
 
+    bool needsNewState() const;
+    bool needsNewClip() const;
 
-    bool grabState();
-    bool grabClip();
+    void pushState();
+    void pushClip();
 
     GrTAllocator<Draw>              fDraws;
     // HACK: We currently do not hold refs on RTs in the saved draw states.
@@ -106,7 +142,12 @@
     GrTAllocator<SavedDrawState>    fStates;
 
     GrTAllocator<GrClip>            fClips;
-    bool                            fClipChanged;
+    bool                            fClipSet;
+
+    GrVertexLayout                  fLastRectVertexLayout;
+    const GrIndexBuffer*            fQuadIndexBuffer;
+    int                             fMaxQuads;
+    int                             fCurrQuad;
 
     GrVertexBufferAllocPool&        fVertexPool;
     const GrVertexBuffer*           fCurrPoolVertexBuffer;
@@ -134,6 +175,7 @@
                                                    STATES_BLOCK_SIZE];
     int8_t                          fClipsStorage[sizeof(GrClip) *
                                                   CLIPS_BLOCK_SIZE];
+    typedef GrDrawTarget INHERITED;
 };
 
 #endif
diff --git a/gpu/include/GrIndexBuffer.h b/gpu/include/GrIndexBuffer.h
index 85ff749..09d1977 100644
--- a/gpu/include/GrIndexBuffer.h
+++ b/gpu/include/GrIndexBuffer.h
@@ -21,6 +21,13 @@
 #include "GrGeometryBuffer.h"
 
 class GrIndexBuffer : public GrGeometryBuffer {
+public:
+        /**
+         * Retrieves the maximum number of quads that could be rendered
+         * from the index buffer (using kTriangles_PrimitiveType).
+         * @return the maximum number of quads using full size of index buffer.
+         */
+        int maxQuads() const { return size() / (sizeof(uint16_t) * 6); }
 protected:
     GrIndexBuffer(size_t sizeInBytes, bool dynamic) :
         INHERITED(sizeInBytes, dynamic) {}
diff --git a/gpu/include/GrRect.h b/gpu/include/GrRect.h
index 5192ebd..e98913a 100644
--- a/gpu/include/GrRect.h
+++ b/gpu/include/GrRect.h
@@ -131,7 +131,7 @@
      *  Initialize a rectangle to a point.
      *  @param pt the point used to initialize the rectanglee.
      */
-    GrRect(GrPoint pt) {
+    explicit GrRect(const GrPoint& pt) {
         setToPoint(pt);
     }
 
@@ -187,6 +187,11 @@
     bool isInverted() const {
         return (fLeft > fRight) || (fTop > fBottom);
     }
+
+    bool contains(const GrPoint& point) const {
+        return point.fX >= fLeft && point.fX < fRight &&
+               point.fY >= fTop && point.fY < fBottom;
+    }
     
     /**
      *  Initialize a rectangle to a point.
diff --git a/gpu/include/GrTextContext.h b/gpu/include/GrTextContext.h
index 727358e..3dc9c7a 100644
--- a/gpu/include/GrTextContext.h
+++ b/gpu/include/GrTextContext.h
@@ -19,8 +19,10 @@
 #define GrTextContext_DEFINED
 
 #include "GrGlyph.h"
-#include "GrGpuVertex.h"
+#include "GrPaint.h"
 
+struct GrGpuTextVertex;
+class GrMatrix;
 class GrContext;
 class GrTextStrike;
 class GrFontScaler;
diff --git a/gpu/include/GrTypes.h b/gpu/include/GrTypes.h
index 9553678..8311239 100644
--- a/gpu/include/GrTypes.h
+++ b/gpu/include/GrTypes.h
@@ -141,14 +141,14 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
- *  Use to cast a pointer to a different type, and maintaining strict-aliasing
+ *  Use to cast a ptr to a different type, and maintain strict-aliasing
  */
-template <typename Dst> Dst GrTCast(const void* ptr) {
+template <typename Dst, typename Src> Dst GrTCast(Src src) {
     union {
-        const void* src;
+        Src src;
         Dst dst;
     } data;
-    data.src = ptr;
+    data.src = src;
     return data.dst;
 }
 
diff --git a/gpu/src/GrContext.cpp b/gpu/src/GrContext.cpp
index c11d02f..ad7f776 100644
--- a/gpu/src/GrContext.cpp
+++ b/gpu/src/GrContext.cpp
@@ -27,11 +27,18 @@
 
 #define DEFER_TEXT_RENDERING 1
 
+#define BATCH_RECT_TO_RECT (1 && !GR_STATIC_RECT_VB)
+
 static const size_t MAX_TEXTURE_CACHE_COUNT = 128;
 static const size_t MAX_TEXTURE_CACHE_BYTES = 8 * 1024 * 1024;
 
-static const uint32_t TEXT_POOL_VB_SIZE = 1 << 18; // enough to draw 4K untextured glyphs
-static const uint32_t NUM_TEXT_POOL_VBS = 4;
+static const size_t DRAW_BUFFER_VBPOOL_BUFFER_SIZE = 1 << 18;
+static const int DRAW_BUFFER_VBPOOL_PREALLOC_BUFFERS = 4;
+
+// We are currently only batching Text and drawRectToRect, both
+// of which use the quad index buffer.
+static const size_t DRAW_BUFFER_IBPOOL_BUFFER_SIZE = 0;
+static const int DRAW_BUFFER_IBPOOL_PREALLOC_BUFFERS = 0;
 
 GrContext* GrContext::Create(GrGpu::Engine engine,
                              GrGpu::Platform3DContext context3D) {
@@ -52,9 +59,9 @@
     fGpu->unref();
     delete fTextureCache;
     delete fFontCache;
-    delete fTextDrawBuffer;
-    delete fTextVBAllocPool;
-    delete fTextIBAllocPool;
+    delete fDrawBuffer;
+    delete fDrawBufferVBAllocPool;
+    delete fDrawBufferVBAllocPool;
 }
 
 void GrContext::abandonAllTextures() {
@@ -331,18 +338,18 @@
                          const GrMatrix* matrix) {
 
     bool textured = NULL != paint.getTexture();
-    GrVertexLayout layout = (textured) ?
-                            GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0) :
-                            0;
 
-    this->prepareToDraw(paint);
+    GrDrawTarget* target = this->prepareToDraw(paint, kUnbuffered_DrawCategory);
 
     if (width >= 0) {
         // TODO: consider making static vertex buffers for these cases.
         // Hairline could be done by just adding closing vertex to
         // unitSquareVertexBuffer()
+        GrVertexLayout layout = (textured) ?
+                                 GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0) :
+                                 0;
         static const int worstCaseVertCount = 10;
-        GrDrawTarget::AutoReleaseGeometry geo(fGpu, layout, worstCaseVertCount, 0);
+        GrDrawTarget::AutoReleaseGeometry geo(target, layout, worstCaseVertCount, 0);
 
         if (!geo.succeeded()) {
             return;
@@ -369,16 +376,20 @@
 
         GrDrawTarget::AutoViewMatrixRestore avmr;
         if (NULL != matrix) {
-            avmr.set(fGpu);
-            fGpu->concatViewMatrix(*matrix);
-            fGpu->concatTextureMatrix(0, *matrix);
+            avmr.set(target);
+            target->concatViewMatrix(*matrix);
+            target->concatTextureMatrix(0, *matrix);
         }
 
-        fGpu->drawNonIndexed(primType, 0, vertCount);
+        target->drawNonIndexed(primType, 0, vertCount);
     } else {
         #if GR_STATIC_RECT_VB
-            fGpu->setVertexSourceToBuffer(layout, fGpu->unitSquareVertexBuffer());
-            GrDrawTarget::AutoViewMatrixRestore avmr(fGpu);
+            GrVertexLayout layout = (textured) ?
+                            GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0) :
+                            0;
+            target->setVertexSourceToBuffer(layout, 
+                                            fGpu->getUnitSquareVertexBuffer());
+            GrDrawTarget::AutoViewMatrixRestore avmr(target);
             GrMatrix m;
             m.setAll(rect.width(), 0,             rect.fLeft,
                      0,            rect.height(), rect.fTop,
@@ -388,25 +399,15 @@
                 m.postConcat(*matrix);
             }
 
-            fGpu->concatViewMatrix(m);
+            target->concatViewMatrix(m);
 
             if (textured) {
-                fGpu->concatTextureMatrix(0, m);
+                target->concatTextureMatrix(0, m);
             }
+            target->drawNonIndexed(GrDrawTarget::kTriangleFan_PrimitiveType, 0, 4);
         #else
-            GrDrawTarget::AutoReleaseGeometry geo(fGpu, layout, 4, 0);
-            GrPoint* vertex = geo.positions();
-            vertex->setRectFan(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
-
-            GrDrawTarget::AutoViewMatrixRestore avmr;
-            if (NULL != matrix) {
-                avmr.set(fGpu);
-                fGpu->concatViewMatrix(*matrix);
-                fGpu->concatTextureMatrix(0, *matrix);
-            }
+            target->drawSimpleRect(rect, matrix, textured ? 1 : 0);
         #endif
-
-        fGpu->drawNonIndexed(GrDrawTarget::kTriangleFan_PrimitiveType, 0, 4);
     }
 }
 
@@ -420,12 +421,14 @@
         drawRect(paint, dstRect, -1, dstMatrix);
         return;
     }
-
-    this->prepareToDraw(paint);
+    
+    GR_STATIC_ASSERT(!BATCH_RECT_TO_RECT || !GR_STATIC_RECT_VB);
 
 #if GR_STATIC_RECT_VB
+    GrDrawTarget* target = this->prepareToDraw(paint, kUnbuffered_DrawCategory);
+
     GrVertexLayout layout = GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0);
-    GrDrawTarget::AutoViewMatrixRestore avmr(fGpu);
+    GrDrawTarget::AutoViewMatrixRestore avmr(target);
 
     GrMatrix m;
 
@@ -435,7 +438,7 @@
     if (NULL != dstMatrix) {
         m.postConcat(*dstMatrix);
     }
-    fGpu->concatViewMatrix(m);
+    target->concatViewMatrix(m);
 
     m.setAll(srcRect.width(), 0,                srcRect.fLeft,
              0,               srcRect.height(), srcRect.fTop,
@@ -443,34 +446,26 @@
     if (NULL != srcMatrix) {
         m.postConcat(*srcMatrix);
     }
-    fGpu->concatTextureMatrix(0, m);
+    target->concatTextureMatrix(0, m);
 
-    fGpu->setVertexSourceToBuffer(layout, fGpu->unitSquareVertexBuffer());
+    target->setVertexSourceToBuffer(layout, fGpu->getUnitSquareVertexBuffer());
+    target->drawNonIndexed(GrDrawTarget::kTriangleFan_PrimitiveType, 0, 4);
 #else
-    GrVertexLayout layout = GrDrawTarget::StageTexCoordVertexLayoutBit(0,0);
 
-    GrDrawTarget::AutoReleaseGeometry geo(fGpu, layout, 4, 0);
-    GrPoint* pos = geo.positions();
-    GrPoint* tex = pos + 1;
-    static const size_t stride = 2 * sizeof(GrPoint);
-    pos[0].setRectFan(dstRect.fLeft, dstRect.fTop,
-                      dstRect.fRight, dstRect.fBottom,
-                      stride);
-    tex[0].setRectFan(srcRect.fLeft, srcRect.fTop,
-                      srcRect.fRight, srcRect.fBottom,
-                      stride);
-
-    GrDrawTarget::AutoViewMatrixRestore avmr;
-    if (NULL != dstMatrix) {
-        avmr.set(fGpu);
-        fGpu->concatViewMatrix(*dstMatrix);
-    }
-    if (NULL != srcMatrix) {
-        fGpu->concatTextureMatrix(0, *srcMatrix);
-    }
-
+    GrDrawTarget* target;
+#if BATCH_RECT_TO_RECT 
+    target = this->prepareToDraw(paint, kBuffered_DrawCategory);
+#else 
+    target = this->prepareToDraw(paint, kUnbuffered_DrawCategory);
 #endif
-    fGpu->drawNonIndexed(GrDrawTarget::kTriangleFan_PrimitiveType, 0, 4);
+
+    const GrRect* srcRects[GrDrawTarget::kNumStages] = {NULL};
+    const GrMatrix* srcMatrices[GrDrawTarget::kNumStages] = {NULL};
+    srcRects[0] = &srcRect;
+    srcMatrices[0] = srcMatrix;
+
+    target->drawRect(dstRect, dstMatrix, 1, srcRects, srcMatrices);
+#endif
 }
 
 void GrContext::drawVertices(const GrPaint& paint,
@@ -486,7 +481,7 @@
 
     GrDrawTarget::AutoReleaseGeometry geo;
 
-    this->prepareToDraw(paint);
+    GrDrawTarget* target = this->prepareToDraw(paint, kUnbuffered_DrawCategory);
 
     if (NULL != paint.getTexture()) {
         if (NULL == texCoords) {
@@ -503,7 +498,7 @@
     }
 
     if (sizeof(GrPoint) != vertexSize) {
-        if (!geo.set(fGpu, layout, vertexCount, 0)) {
+        if (!geo.set(target, layout, vertexCount, 0)) {
             GrPrintf("Failed to get space for vertices!");
             return;
         }
@@ -526,14 +521,14 @@
             curVertex = (void*)((intptr_t)curVertex + vsize);
         }
     } else {
-        fGpu->setVertexSourceToArray(layout, positions, vertexCount);
+        target->setVertexSourceToArray(layout, positions, vertexCount);
     }
 
     if (NULL != indices) {
-        fGpu->setIndexSourceToArray(indices, indexCount);
-        fGpu->drawIndexed(primitiveType, 0, 0, vertexCount, indexCount);
+        target->setIndexSourceToArray(indices, indexCount);
+        target->drawIndexed(primitiveType, 0, 0, vertexCount, indexCount);
     } else {
-        fGpu->drawNonIndexed(primitiveType, 0, vertexCount);
+        target->drawNonIndexed(primitiveType, 0, vertexCount);
     }
 }
 
@@ -666,7 +661,7 @@
 
 static inline bool single_pass_path(const GrPathIter& path,
                                     GrContext::PathFills fill,
-                                    const GrGpu& gpu) {
+                                    const GrDrawTarget& target) {
 #if STENCIL_OFF
     return true;
 #else
@@ -679,7 +674,7 @@
         return hint == GrPathIter::kConvex_ConvexHint ||
                hint == GrPathIter::kNonOverlappingConvexPieces_ConvexHint ||
                (hint == GrPathIter::kSameWindingConvexPieces_ConvexHint &&
-                gpu.canDisableBlend() && !gpu.isDitherState());
+                target.canDisableBlend() && !target.isDitherState());
 
     }
     return false;
@@ -692,11 +687,11 @@
                          const GrPoint* translate) {
 
 
-    this->prepareToDraw(paint);
+    GrDrawTarget* target = this->prepareToDraw(paint, kUnbuffered_DrawCategory);
 
-    GrDrawTarget::AutoStateRestore asr(fGpu);
+    GrDrawTarget::AutoStateRestore asr(target);
 
-    GrMatrix viewM = fGpu->getViewMatrix();
+    GrMatrix viewM = target->getViewMatrix();
     // In order to tesselate the path we get a bound on how much the matrix can
     // stretch when mapping to screen coordinates.
     GrScalar stretch = viewM.getMaxStretch();
@@ -722,7 +717,7 @@
         layout = GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0);
     }
     // add 4 to hold the bounding rect
-    GrDrawTarget::AutoReleaseGeometry arg(fGpu, layout, maxPts + 4, 0);
+    GrDrawTarget::AutoReleaseGeometry arg(target, layout, maxPts + 4, 0);
 
     GrPoint* base = (GrPoint*) arg.vertices();
     GrPoint* vert = base;
@@ -744,7 +739,7 @@
         passes[0] = GrDrawTarget::kNone_StencilPass;
     } else {
         type = GrDrawTarget::kTriangleFan_PrimitiveType;
-        if (single_pass_path(*path, fill, *fGpu)) {
+        if (single_pass_path(*path, fill, *target)) {
             passCount = 1;
             passes[0] = GrDrawTarget::kNone_StencilPass;
         } else {
@@ -778,7 +773,7 @@
             }
         }
     }
-    fGpu->setReverseFill(reverse);
+    target->setReverseFill(reverse);
 
     GrPoint pts[4];
 
@@ -840,13 +835,13 @@
     if (useBounds) {
         GrRect bounds;
         if (reverse) {
-            GrAssert(NULL != fGpu->getRenderTarget());
+            GrAssert(NULL != target->getRenderTarget());
             // draw over the whole world.
             bounds.setLTRB(0, 0,
-                           GrIntToScalar(fGpu->getRenderTarget()->width()),
-                           GrIntToScalar(fGpu->getRenderTarget()->height()));
+                           GrIntToScalar(target->getRenderTarget()->width()),
+                           GrIntToScalar(target->getRenderTarget()->height()));
             GrMatrix vmi;
-            if (fGpu->getViewInverse(&vmi)) {
+            if (target->getViewInverse(&vmi)) {
                 vmi.mapRect(&bounds);
             }
         } else {
@@ -857,16 +852,16 @@
     }
 
     for (int p = 0; p < passCount; ++p) {
-        fGpu->setStencilPass(passes[p]);
+        target->setStencilPass(passes[p]);
         if (useBounds && (GrDrawTarget::kEvenOddColor_StencilPass == passes[p] ||
                           GrDrawTarget::kWindingColor_StencilPass == passes[p])) {
-            fGpu->drawNonIndexed(GrDrawTarget::kTriangleFan_PrimitiveType,
+            target->drawNonIndexed(GrDrawTarget::kTriangleFan_PrimitiveType,
                                  maxPts, 4);
 
         } else {
             int baseVertex = 0;
             for (int sp = 0; sp < subpathCnt; ++sp) {
-                fGpu->drawNonIndexed(type,
+                target->drawNonIndexed(type,
                                      baseVertex,
                                      subpathVertCount[sp]);
                 baseVertex += subpathVertCount[sp];
@@ -878,19 +873,25 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrContext::flush(bool flushRenderTarget) {
-    flushText();
+    flushDrawBuffer();
     if (flushRenderTarget) {
         fGpu->forceRenderTargetFlush();
     }
 }
 
 void GrContext::flushText() {
-    if (NULL != fTextDrawBuffer) {
-        fTextDrawBuffer->playback(fGpu);
-        fTextDrawBuffer->reset();
+    if (kText_DrawCategory == fLastDrawCategory) {
+        flushDrawBuffer();
     }
 }
 
+void GrContext::flushDrawBuffer() {
+#if BATCH_RECT_TO_RECT || DEFER_TEXT_RENDERING
+    fDrawBuffer->playback(fGpu);
+    fDrawBuffer->reset();
+#endif
+}
+
 bool GrContext::readPixels(int left, int top, int width, int height,
                            GrTexture::PixelConfig config, void* buffer) {
     this->flush(true);
@@ -962,10 +963,32 @@
     target->setBlendFunc(paint.fSrcBlendCoeff, paint.fDstBlendCoeff);
 }
 
-void GrContext::prepareToDraw(const GrPaint& paint) {
-
-    flushText();
+GrDrawTarget* GrContext::prepareToDraw(const GrPaint& paint, 
+                                       DrawCategory category) {
+    if (category != fLastDrawCategory) {
+        flushDrawBuffer();
+        fLastDrawCategory = category;
+    }
     SetPaint(paint, fGpu);
+    GrDrawTarget* target = fGpu;
+    switch (category) {
+    case kText_DrawCategory:
+#if DEFER_TEXT_RENDERING
+        target = fDrawBuffer;
+        fDrawBuffer->initializeDrawStateAndClip(*fGpu);
+#else
+        target = fGpu;
+#endif
+        break;
+    case kUnbuffered_DrawCategory:
+        target = fGpu;
+        break;
+    case kBuffered_DrawCategory:
+        target = fDrawBuffer;
+        fDrawBuffer->initializeDrawStateAndClip(*fGpu);
+        break;
+    }
+    return target;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -975,7 +998,7 @@
 }
 
 void GrContext::setRenderTarget(GrRenderTarget* target) {
-    flushText();
+    flush(false);
     fGpu->setRenderTarget(target);
 }
 
@@ -1028,19 +1051,28 @@
                                        MAX_TEXTURE_CACHE_BYTES);
     fFontCache = new GrFontCache(fGpu);
 
-#if DEFER_TEXT_RENDERING
-    fTextVBAllocPool = new GrVertexBufferAllocPool(gpu,
-                                                   false,
-                                                   TEXT_POOL_VB_SIZE,
-                                                   NUM_TEXT_POOL_VBS);
-    fTextIBAllocPool = new GrIndexBufferAllocPool(gpu, false, 0, 0);
+    fLastDrawCategory = kUnbuffered_DrawCategory;
 
-    fTextDrawBuffer = new GrInOrderDrawBuffer(fTextVBAllocPool,
-                                              fTextIBAllocPool);
+#if DEFER_TEXT_RENDERING || BATCH_RECT_TO_RECT
+    fDrawBufferVBAllocPool = 
+        new GrVertexBufferAllocPool(gpu, false,
+                                    DRAW_BUFFER_VBPOOL_BUFFER_SIZE,
+                                    DRAW_BUFFER_VBPOOL_PREALLOC_BUFFERS);
+    fDrawBufferIBAllocPool = 
+        new GrIndexBufferAllocPool(gpu, false,
+                                   DRAW_BUFFER_IBPOOL_BUFFER_SIZE, 
+                                   DRAW_BUFFER_IBPOOL_PREALLOC_BUFFERS);
+
+    fDrawBuffer = new GrInOrderDrawBuffer(fDrawBufferVBAllocPool,
+                                          fDrawBufferIBAllocPool);
 #else
-    fTextDrawBuffer = NULL;
-    fTextVBAllocPool = NULL;
-    fTextIBAllocPool = NULL;
+    fDrawBuffer = NULL;
+    fDrawBufferVBAllocPool = NULL;
+    fDrawBufferIBAllocPool = NULL;
+#endif
+
+#if BATCH_RECT_TO_RECT
+    fDrawBuffer->setQuadIndexBuffer(this->getQuadIndexBuffer());
 #endif
 
 }
@@ -1070,22 +1102,14 @@
 GrDrawTarget* GrContext::getTextTarget(const GrPaint& paint) {
     GrDrawTarget* target;
 #if DEFER_TEXT_RENDERING
-    fTextDrawBuffer->initializeDrawStateAndClip(*fGpu);
-    target = fTextDrawBuffer;
+    target = prepareToDraw(paint, kText_DrawCategory);
 #else
-    target = fGpu;
+    target = prepareToDraw(paint, kUnbuffered_DrawCategory);
 #endif
     SetPaint(paint, target);
     return target;
 }
 
-const GrIndexBuffer* GrContext::quadIndexBuffer() const {
-    return fGpu->quadIndexBuffer();
+const GrIndexBuffer* GrContext::getQuadIndexBuffer() const {
+    return fGpu->getQuadIndexBuffer();
 }
-
-int GrContext::maxQuadsInIndexBuffer() const {
-    return fGpu->maxQuadsInIndexBuffer();
-}
-
-
-
diff --git a/gpu/src/GrDrawTarget.cpp b/gpu/src/GrDrawTarget.cpp
index 5cfc6f4..06e5ab8b 100644
--- a/gpu/src/GrDrawTarget.cpp
+++ b/gpu/src/GrDrawTarget.cpp
@@ -17,6 +17,7 @@
 
 #include "GrDrawTarget.h"
 #include "GrGpuVertex.h"
+#include "GrTexture.h"
 
 // recursive helper for creating mask with all the tex coord bits set for
 // one stage
@@ -291,7 +292,7 @@
 }
 
 void GrDrawTarget::setClip(const GrClip& clip) {
-    clipWillChange(clip);
+    clipWillBeSet(clip);
     fClip = clip;
 }
 
@@ -484,7 +485,127 @@
     fGeometrySrc.fIndexBuffer  = buffer;
 }
 
-////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+bool GrDrawTarget::canDisableBlend() const {
+    if ((kOne_BlendCoeff == fCurrDrawState.fSrcBlend) &&
+        (kZero_BlendCoeff == fCurrDrawState.fDstBlend)) {
+            return true;
+    }
+
+    // If we have vertex color without alpha then we can't force blend off
+    if ((fGeometrySrc.fVertexLayout & kColor_VertexLayoutBit) ||
+         0xff != GrColorUnpackA(fCurrDrawState.fColor)) {
+        return false;
+    }
+
+    // If the src coef will always be 1...
+    if (kSA_BlendCoeff != fCurrDrawState.fSrcBlend &&
+        kOne_BlendCoeff != fCurrDrawState.fSrcBlend) {
+        return false;
+    }
+
+    // ...and the dst coef is always 0...
+    if (kISA_BlendCoeff != fCurrDrawState.fDstBlend &&
+        kZero_BlendCoeff != fCurrDrawState.fDstBlend) {
+        return false;
+    }
+
+    // ...and there isn't a texture with an alpha channel...
+    for (int s = 0; s < kNumStages; ++s) {
+        if (VertexUsesStage(s, fGeometrySrc.fVertexLayout)) {
+            GrAssert(NULL != fCurrDrawState.fTextures[s]);
+            GrTexture::PixelConfig config = fCurrDrawState.fTextures[s]->config();
+
+            if (GrTexture::kRGB_565_PixelConfig != config &&
+                GrTexture::kRGBX_8888_PixelConfig != config) {
+                return false;
+            }
+        }
+    }
+
+    // ...then we disable blend.
+    return true;
+}
+///////////////////////////////////////////////////////////////////////////////
+void GrDrawTarget::drawRect(const GrRect& rect, 
+                            const GrMatrix* matrix,
+                            int stageEnableMask,
+                            const GrRect* srcRects[],
+                            const GrMatrix* srcMatrices[]) {
+    GR_STATIC_ASSERT(8*sizeof(int) >= kNumStages);
+
+    GrVertexLayout layout = GetRectVertexLayout(stageEnableMask, srcRects);
+
+    AutoReleaseGeometry geo(this, layout, 4, 0);
+
+    SetRectVertices(rect, matrix, srcRects, 
+                    srcMatrices, layout, geo.vertices());
+
+    drawNonIndexed(kTriangleFan_PrimitiveType, 0, 4);
+}
+
+GrVertexLayout GrDrawTarget::GetRectVertexLayout(int stageEnableMask, 
+                                                 const GrRect* srcRects[]) {
+    GrVertexLayout layout = 0;
+
+    for (int i = 0; i < kNumStages; ++i) {
+        int numTC = 0;
+        if (stageEnableMask & (1 << i)) {
+            if (NULL != srcRects && NULL != srcRects[i]) {
+                layout |= StageTexCoordVertexLayoutBit(i, numTC);
+                ++numTC;
+            } else {
+                layout |= StagePosAsTexCoordVertexLayoutBit(i);
+            }
+        }
+    }
+    return layout;
+}
+void GrDrawTarget::SetRectVertices(const GrRect& rect,
+                                   const GrMatrix* matrix, 
+                                   const GrRect* srcRects[], 
+                                   const GrMatrix* srcMatrices[],
+                                   GrVertexLayout layout, 
+                                   void* vertices) {
+#if GR_DEBUG
+    // check that the layout and srcRects agree
+    for (int i = 0; i < kNumStages; ++i) {
+        if (VertexTexCoordsForStage(i, layout) >= 0) {
+            GR_DEBUGASSERT(NULL != srcRects && NULL != srcRects[i]);
+        } else {
+            GR_DEBUGASSERT(NULL == srcRects || NULL == srcRects[i]);
+        }
+    }
+#endif
+
+    int stageOffsets[kNumStages];
+    int colorOffset;
+    int vsize = VertexSizeAndOffsetsByStage(layout, stageOffsets, &colorOffset);
+    GrAssert(-1 == colorOffset);
+
+    GrTCast<GrPoint*>(vertices)->setRectFan(rect.fLeft, rect.fTop, 
+                                            rect.fRight, rect.fBottom,
+                                            vsize);
+    if (NULL != matrix) {
+        matrix->mapPointsWithStride(GrTCast<GrPoint*>(vertices), vsize, 4);
+    }
+
+    for (int i = 0; i < kNumStages; ++i) {
+        if (stageOffsets[i] > 0) {
+            GrPoint* coords = GrTCast<GrPoint*>(GrTCast<intptr_t>(vertices) + 
+                                                stageOffsets[i]);
+            coords->setRectFan(srcRects[i]->fLeft, srcRects[i]->fTop,
+                               srcRects[i]->fRight, srcRects[i]->fBottom, 
+                               vsize);
+            if (NULL != srcMatrices && NULL != srcMatrices[i]) {
+                srcMatrices[i]->mapPointsWithStride(coords, vsize, 4);
+            }
+        }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
 
 GrDrawTarget::AutoStateRestore::AutoStateRestore(GrDrawTarget* target) {
     fDrawTarget = target;
diff --git a/gpu/src/GrGpu.cpp b/gpu/src/GrGpu.cpp
index e406f6f..5425b58 100644
--- a/gpu/src/GrGpu.cpp
+++ b/gpu/src/GrGpu.cpp
@@ -92,49 +92,6 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-bool GrGpu::canDisableBlend() const {
-    if ((kOne_BlendCoeff == fCurrDrawState.fSrcBlend) &&
-        (kZero_BlendCoeff == fCurrDrawState.fDstBlend)) {
-            return true;
-    }
-
-    // If we have vertex color without alpha then we can't force blend off
-    if ((fGeometrySrc.fVertexLayout & kColor_VertexLayoutBit) ||
-         0xff != GrColorUnpackA(fCurrDrawState.fColor)) {
-        return false;
-    }
-
-    // If the src coef will always be 1...
-    if (kSA_BlendCoeff != fCurrDrawState.fSrcBlend &&
-        kOne_BlendCoeff != fCurrDrawState.fSrcBlend) {
-        return false;
-    }
-
-    // ...and the dst coef is always 0...
-    if (kISA_BlendCoeff != fCurrDrawState.fDstBlend &&
-        kZero_BlendCoeff != fCurrDrawState.fDstBlend) {
-        return false;
-    }
-
-    // ...and there isn't a texture with an alpha channel...
-    for (int s = 0; s < kNumStages; ++s) {
-        if (VertexUsesStage(s, fGeometrySrc.fVertexLayout)) {
-            GrAssert(NULL != fCurrDrawState.fTextures[s]);
-            GrTexture::PixelConfig config = fCurrDrawState.fTextures[s]->config();
-
-            if (GrTexture::kRGB_565_PixelConfig != config &&
-                GrTexture::kRGBX_8888_PixelConfig != config) {
-                return false;
-            }
-        }
-    }
-
-    // ...then we disable blend.
-    return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
 static const int MAX_QUADS = 1 << 12; // max possible: (1 << 14) - 1;
 
 GR_STATIC_ASSERT(4 * MAX_QUADS <= 65535);
@@ -150,7 +107,7 @@
     }
 }
 
-const GrIndexBuffer* GrGpu::quadIndexBuffer() const {
+const GrIndexBuffer* GrGpu::getQuadIndexBuffer() const {
     if (NULL == fQuadIndexBuffer) {
         static const int SIZE = sizeof(uint16_t) * 6 * MAX_QUADS;
         GrGpu* me = const_cast<GrGpu*>(this);
@@ -176,7 +133,7 @@
     return fQuadIndexBuffer;
 }
 
-const GrVertexBuffer* GrGpu::unitSquareVertexBuffer() const {
+const GrVertexBuffer* GrGpu::getUnitSquareVertexBuffer() const {
     if (NULL == fUnitSquareVertexBuffer) {
 
         static const GrPoint DATA[] = {
@@ -201,14 +158,10 @@
     return fUnitSquareVertexBuffer;
 }
 
-int GrGpu::maxQuadsInIndexBuffer() const {
-    return (NULL == this->quadIndexBuffer()) ? 0 : MAX_QUADS;
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
-void GrGpu::clipWillChange(const GrClip& clip) {
-    if (clip != fClip) {
+void GrGpu::clipWillBeSet(const GrClip& newClip) {
+    if (newClip != fClip) {
         fClipState.fClipIsDirty = true;
     }
 }
@@ -260,7 +213,7 @@
             }
             fVertexPool->unlock();
             this->setVertexSourceToBuffer(0, vertexBuffer);
-            this->setIndexSourceToBuffer(quadIndexBuffer());
+            this->setIndexSourceToBuffer(getQuadIndexBuffer());
             this->setViewMatrix(GrMatrix::I());
             // don't clip the clip or recurse!
             this->disableState(kClip_StateBit);
@@ -268,7 +221,7 @@
             this->setStencilPass((GrDrawTarget::StencilPass)kSetClip_StencilPass);
             int currRect = 0;
             while (currRect < rectTotal) {
-                int rectCount = GrMin(this->maxQuadsInIndexBuffer(),
+                int rectCount = GrMin(MAX_QUADS,
                                       rectTotal - currRect);
                 this->drawIndexed(kTriangles_PrimitiveType,
                                   vStart + currRect * 4,
diff --git a/gpu/src/GrInOrderDrawBuffer.cpp b/gpu/src/GrInOrderDrawBuffer.cpp
index 49b8901..25e74e3 100644
--- a/gpu/src/GrInOrderDrawBuffer.cpp
+++ b/gpu/src/GrInOrderDrawBuffer.cpp
@@ -18,6 +18,8 @@
 #include "GrInOrderDrawBuffer.h"
 #include "GrTexture.h"
 #include "GrBufferAllocPool.h"
+#include "GrIndexBuffer.h"
+#include "GrVertexBuffer.h"
 #include "GrGpu.h"
 
 GrInOrderDrawBuffer::GrInOrderDrawBuffer(GrVertexBufferAllocPool* vertexPool,
@@ -25,7 +27,13 @@
         fDraws(DRAWS_BLOCK_SIZE, fDrawsStorage),
         fStates(STATES_BLOCK_SIZE, fStatesStorage),
         fClips(CLIPS_BLOCK_SIZE, fClipsStorage),
-        fClipChanged(true),
+        fClipSet(true),
+
+        fLastRectVertexLayout(0),
+        fQuadIndexBuffer(NULL),
+        fMaxQuads(0),
+        fCurrQuad(0),
+
         fVertexPool(*vertexPool),
         fCurrPoolVertexBuffer(NULL),
         fCurrPoolStartVertex(0),
@@ -41,7 +49,8 @@
 }
 
 GrInOrderDrawBuffer::~GrInOrderDrawBuffer() {
-    reset();
+    this->reset();
+    GrSafeUnref(fQuadIndexBuffer);
 }
 
 void GrInOrderDrawBuffer::initializeDrawStateAndClip(const GrDrawTarget& target) {
@@ -49,6 +58,121 @@
     this->setClip(target.getClip());
 }
 
+void GrInOrderDrawBuffer::setQuadIndexBuffer(const GrIndexBuffer* indexBuffer) {
+    bool newIdxBuffer = fQuadIndexBuffer != indexBuffer;
+    if (newIdxBuffer) {
+        GrSafeUnref(fQuadIndexBuffer);
+        fQuadIndexBuffer = indexBuffer;
+        GrSafeRef(fQuadIndexBuffer);
+        fCurrQuad = 0;
+        fMaxQuads = (NULL == indexBuffer) ? 0 : indexBuffer->maxQuads();
+    } else {
+        GrAssert((NULL == indexBuffer && 0 == fMaxQuads) || 
+                 (indexBuffer->maxQuads() == fMaxQuads));
+    }
+}
+
+void GrInOrderDrawBuffer::drawRect(const GrRect& rect, 
+                                   const GrMatrix* matrix,
+                                   int stageEnableMask,
+                                   const GrRect* srcRects[],
+                                   const GrMatrix* srcMatrices[]) {
+    
+    GrAssert(!(NULL == fQuadIndexBuffer && fCurrQuad));
+    GrAssert(!(fDraws.empty() && fCurrQuad));
+    GrAssert(!(0 != fMaxQuads && NULL == fQuadIndexBuffer));
+
+    // if we have a quad IB then either append to the previous run of
+    // rects or start a new run
+    if (fMaxQuads) {
+        
+        bool appendToPreviousDraw = false;
+        GrVertexLayout layout = GetRectVertexLayout(stageEnableMask, srcRects);
+        AutoReleaseGeometry geo(this, layout, 4, 0);
+        AutoViewMatrixRestore avmr(this);
+        GrMatrix combinedMatrix = this->getViewMatrix();
+        this->setViewMatrix(GrMatrix::I());
+        if (NULL != matrix) {
+            combinedMatrix.preConcat(*matrix);
+        }
+
+        SetRectVertices(rect, &combinedMatrix, srcRects, srcMatrices, layout, geo.vertices());
+
+        // we don't want to miss an opportunity to batch rects together
+        // simply because the clip has changed if the clip doesn't affect
+        // the rect.
+        bool disabledClip = false;
+        if (this->isClipState() && fClip.isRect()) {
+            GrRect clipRect = GrRect(*fClip.getRects());
+            // If the clip rect touches the edge of the viewport, extended it
+            // out (close) to infinity to avoid bogus intersections.
+            // We might consider a more exact clip to viewport if this 
+            // conservative test fails.
+            const GrRenderTarget* target = this->getRenderTarget();
+            if (0 >= clipRect.fLeft) {
+                clipRect.fLeft = GR_ScalarMin;
+            }
+            if (target->width() <= clipRect.fRight) {
+                clipRect.fRight = GR_ScalarMax;
+            }
+            if (0 >= clipRect.top()) {
+                clipRect.fTop = GR_ScalarMin;
+            }
+            if (target->height() <= clipRect.fBottom) {
+                clipRect.fBottom = GR_ScalarMax;
+            }
+            int stride = VertexSize(layout);
+            bool insideClip = true;
+            for (int v = 0; v < 4; ++v) {
+                const GrPoint& p = *GetVertexPoint(geo.vertices(), v, stride);
+                if (!clipRect.contains(p)) {
+                    insideClip = false;
+                    break;
+                }
+            }
+            if (insideClip) {
+                this->disableState(kClip_StateBit);
+                disabledClip = true;
+            }
+        }
+        if (!needsNewClip() && !needsNewState() && fCurrQuad > 0 && 
+            fCurrQuad < fMaxQuads && layout == fLastRectVertexLayout) {
+
+            int vsize = VertexSize(layout);
+        
+            Draw& lastDraw = fDraws.back();
+
+            GrAssert(lastDraw.fIndexBuffer == fQuadIndexBuffer);
+            GrAssert(kTriangles_PrimitiveType == lastDraw.fPrimitiveType);
+            GrAssert(0 == lastDraw.fVertexCount % 4);
+            GrAssert(0 == lastDraw.fIndexCount % 6);
+            GrAssert(0 == lastDraw.fStartIndex);
+
+            appendToPreviousDraw = lastDraw.fVertexBuffer == fCurrPoolVertexBuffer &&
+                                   (fCurrQuad * 4 + lastDraw.fStartVertex) == fCurrPoolStartVertex;
+            if (appendToPreviousDraw) {
+                lastDraw.fVertexCount += 4;
+                lastDraw.fIndexCount += 6;
+                fCurrQuad += 1;
+                GrAssert(0 == fUsedReservedVertexBytes);
+                fUsedReservedVertexBytes = 4 * vsize;
+            }
+        }
+        if (!appendToPreviousDraw) {
+            this->setIndexSourceToBuffer(fQuadIndexBuffer);
+            drawIndexed(kTriangles_PrimitiveType, 0, 0, 4, 6);
+            fCurrQuad = 1;
+            fLastRectVertexLayout = layout;
+        }
+        if (disabledClip) {
+            this->enableState(kClip_StateBit);
+        }
+this->enableState(kClip_StateBit);
+    } else {
+        INHERITED::drawRect(rect, matrix, stageEnableMask, srcRects, srcMatrices);
+    }
+}
+
 void GrInOrderDrawBuffer::drawIndexed(PrimitiveType primitiveType,
                                       int startVertex,
                                       int startIndex,
@@ -59,14 +183,24 @@
         return;
     }
 
+    fCurrQuad = 0;
+
     Draw& draw = fDraws.push_back();
     draw.fPrimitiveType = primitiveType;
     draw.fStartVertex   = startVertex;
     draw.fStartIndex    = startIndex;
     draw.fVertexCount   = vertexCount;
     draw.fIndexCount    = indexCount;
-    draw.fClipChanged   = grabClip();
-    draw.fStateChanged  = grabState();
+
+    draw.fClipChanged = this->needsNewClip();
+    if (draw.fClipChanged) {
+       this->pushClip();
+    }
+
+    draw.fStateChanged = this->needsNewState();
+    if (draw.fStateChanged) {
+        this->pushState();
+    }
 
     draw.fVertexLayout = fGeometrySrc.fVertexLayout;
     switch (fGeometrySrc.fVertexSrc) {
@@ -76,8 +210,7 @@
     case kReserved_GeometrySrcType: {
         size_t vertexBytes = (vertexCount + startVertex) *
         VertexSize(fGeometrySrc.fVertexLayout);
-        fUsedReservedVertexBytes = GrMax(fUsedReservedVertexBytes,
-                                         vertexBytes);
+        fUsedReservedVertexBytes = GrMax(fUsedReservedVertexBytes, vertexBytes);
     } // fallthrough
     case kArray_GeometrySrcType:
         draw.fVertexBuffer = fCurrPoolVertexBuffer;
@@ -86,6 +219,7 @@
     default:
         GrCrash("unknown geom src type");
     }
+    draw.fVertexBuffer->ref();
 
     switch (fGeometrySrc.fIndexSrc) {
     case kBuffer_GeometrySrcType:
@@ -102,6 +236,7 @@
     default:
         GrCrash("unknown geom src type");
     }
+    draw.fIndexBuffer->ref();
 }
 
 void GrInOrderDrawBuffer::drawNonIndexed(PrimitiveType primitiveType,
@@ -111,6 +246,8 @@
         return;
     }
 
+    fCurrQuad = 0;
+
     Draw& draw = fDraws.push_back();
     draw.fPrimitiveType = primitiveType;
     draw.fStartVertex   = startVertex;
@@ -118,8 +255,15 @@
     draw.fVertexCount   = vertexCount;
     draw.fIndexCount    = 0;
 
-    draw.fClipChanged   = grabClip();
-    draw.fStateChanged  = grabState();
+    draw.fClipChanged = this->needsNewClip();
+    if (draw.fClipChanged) {
+        this->pushClip();
+    }
+
+    draw.fStateChanged = this->needsNewState();
+    if (draw.fStateChanged) {
+        this->pushState();
+    }
 
     draw.fVertexLayout = fGeometrySrc.fVertexLayout;
     switch (fGeometrySrc.fVertexSrc) {
@@ -139,6 +283,8 @@
     default:
         GrCrash("unknown geom src type");
     }
+    draw.fVertexBuffer->ref();
+    draw.fIndexBuffer = NULL;
 }
 
 void GrInOrderDrawBuffer::reset() {
@@ -146,12 +292,19 @@
     uint32_t numStates = fStates.count();
     for (uint32_t i = 0; i < numStates; ++i) {
         for (int s = 0; s < kNumStages; ++s) {
-            GrTexture* tex = accessSavedDrawState(fStates[i]).fTextures[s];
+            GrTexture* tex = this->accessSavedDrawState(fStates[i]).fTextures[s];
             if (NULL != tex) {
                 tex->unref();
             }
         }
     }
+    int numDraws = fDraws.count();
+    for (int d = 0; d < numDraws; ++d) {
+        // we always have a VB, but not always an IB
+        GrAssert(NULL != fDraws[d].fVertexBuffer);
+        fDraws[d].fVertexBuffer->unref();
+        GrSafeUnref(fDraws[d].fIndexBuffer);
+    }
     fDraws.reset();
     fStates.reset();
 
@@ -159,6 +312,8 @@
     fIndexPool.reset();
 
     fClips.reset();
+
+    fCurrQuad = 0;
 }
 
 void GrInOrderDrawBuffer::playback(GrDrawTarget* target) {
@@ -331,37 +486,36 @@
     GR_DEBUGASSERT(success);
 }
 
-bool GrInOrderDrawBuffer::grabState() {
-    bool newState;
-    if (fStates.empty()) {
-        newState = true;
-    } else {
-        const DrState& old = accessSavedDrawState(fStates.back());
-        newState = old != fCurrDrawState;
-    }
-    if (newState) {
-        for (int s = 0; s < kNumStages; ++s) {
-            if (NULL != fCurrDrawState.fTextures[s]) {
-                fCurrDrawState.fTextures[s]->ref();
-            }
-        }
-        saveCurrentDrawState(&fStates.push_back());
-    }
-    return newState;
+bool GrInOrderDrawBuffer::needsNewState() const {
+     if (fStates.empty()) {
+        return true;
+     } else {
+         const DrState& old = this->accessSavedDrawState(fStates.back());
+        return old != fCurrDrawState;
+     }
 }
 
-bool GrInOrderDrawBuffer::grabClip() {
-    if ((fCurrDrawState.fFlagBits & kClip_StateBit) &&
-        (fClipChanged || fClips.empty())) {
-
-        fClips.push_back() = fClip;
-        fClipChanged = false;
-        return true;
+void GrInOrderDrawBuffer::pushState() {
+    for (int s = 0; s < kNumStages; ++s) {
+        GrSafeRef(fCurrDrawState.fTextures[s]);
+    }
+    this->saveCurrentDrawState(&fStates.push_back());
+ }
+ 
+bool GrInOrderDrawBuffer::needsNewClip() const {
+   if (fCurrDrawState.fFlagBits & kClip_StateBit) {
+       if (fClips.empty() || (fClipSet && fClips.back() != fClip)) {
+           return true;
+       }
     }
     return false;
 }
-
-void GrInOrderDrawBuffer::clipWillChange(const GrClip& clip)  {
-    fClipChanged = true;
+ 
+void GrInOrderDrawBuffer::pushClip() {
+    fClips.push_back() = fClip;
+    fClipSet = false;
 }
-
+ 
+void GrInOrderDrawBuffer::clipWillBeSet(const GrClip& newClip)  {
+    fClipSet = true;
+}
diff --git a/gpu/src/GrTextContext.cpp b/gpu/src/GrTextContext.cpp
index d59f4ce..7341005 100644
--- a/gpu/src/GrTextContext.cpp
+++ b/gpu/src/GrTextContext.cpp
@@ -15,13 +15,14 @@
  */
 
 
-#include "GrAtlas.h"
-#include "GrClipIterator.h"
-#include "GrContext.h"
 #include "GrTextContext.h"
+#include "GrAtlas.h"
+#include "GrContext.h"
 #include "GrTextStrike.h"
 #include "GrTextStrike_impl.h"
 #include "GrFontScaler.h"
+#include "GrIndexBuffer.h"
+#include "GrGpuVertex.h"
 
 static const int TEXT_STAGE = 1;
 
@@ -45,7 +46,7 @@
         GrAssert(fCurrTexture);
         fDrawTarget->setTexture(TEXT_STAGE, fCurrTexture);
         fDrawTarget->setTextureMatrix(TEXT_STAGE, GrMatrix::I());
-        fDrawTarget->setIndexSourceToBuffer(fContext->quadIndexBuffer());
+        fDrawTarget->setIndexSourceToBuffer(fContext->getQuadIndexBuffer());
 
         fDrawTarget->drawIndexed(GrDrawTarget::kTriangles_PrimitiveType,
                                  0, 0, fCurrVertex, nIndices);
@@ -217,11 +218,12 @@
                                        NULL);
         }
 
+        int maxQuadVertices = 4 * fContext->getQuadIndexBuffer()->size() / (6 * sizeof(uint16_t));
         if (fMaxVertices < kMinRequestedVerts) {
             fMaxVertices = kDefaultRequestedVerts;
-        } else if (fMaxVertices > (fContext->maxQuadsInIndexBuffer() * 4)) {
+        } else if (fMaxVertices > maxQuadVertices) {
             // don't exceed the limit of the index buffer
-            fMaxVertices = (fContext->maxQuadsInIndexBuffer() * 4);
+            fMaxVertices = maxQuadVertices;
         }
         bool success = fDrawTarget->reserveAndLockGeometry(fVertexLayout,
                                                            fMaxVertices, 0,