diff --git a/gpu/include/GrContext.h b/gpu/include/GrContext.h
index fdf0e9f..c2838b8 100644
--- a/gpu/include/GrContext.h
+++ b/gpu/include/GrContext.h
@@ -19,16 +19,14 @@
 
 #include "GrClip.h"
 #include "GrGpu.h"
-#include "GrSamplerState.h"
 #include "GrTextureCache.h"
 #include "GrInOrderDrawBuffer.h"
 #include "GrVertexBufferAllocPool.h"
+#include "GrPaint.h"
 
 class GrFontCache;
 class GrPathIter;
 
-//TODO: move GrGpu enums/nested types here
-
 class GrContext : public GrRefCnt {
 public:
     /**
@@ -52,6 +50,9 @@
      */
     void resetContext();
 
+    ///////////////////////////////////////////////////////////////////////////
+    // Textures
+
     /**
      *  Abandons all textures. Call this if you have lost the associated GPU
      *  context, and thus internal texture references/IDs are now invalid.
@@ -108,6 +109,35 @@
                                      size_t rowBytes);
 
     /**
+     *  Returns true if the specified use of an indexed texture is supported.
+     */
+    bool supportsIndex8PixelConfig(const GrSamplerState&, int width, int height);
+
+    /**
+     *  Return the current texture cache limits.
+     *
+     *  @param maxTextures If non-null, returns maximum number of textures that
+     *                     can be held in the cache.
+     *  @param maxTextureBytes If non-null, returns maximum number of bytes of
+     *                         texture memory that can be held in the cache.
+     */
+    void getTextureCacheLimits(int* maxTextures, size_t* maxTextureBytes) const;
+
+    /**
+     *  Specify the texture cache limits. If the current cache exceeds either
+     *  of these, it will be purged (LRU) to keep the cache within these limits.
+     *
+     *  @param maxTextures The maximum number of textures that can be held in
+     *                     the cache.
+     *  @param maxTextureBytes The maximum number of bytes of texture memory
+     *                         that can be held in the cache.
+     */
+    void setTextureCacheLimits(int maxTextures, size_t maxTextureBytes);
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Render targets
+
+    /**
      * Wraps an externally-created rendertarget in a GrRenderTarget.
      * e.g. in GL platforamRenderTarget is an FBO id.
      */
@@ -128,52 +158,91 @@
     }
 
     /**
-     *  Returns true if the specified use of an indexed texture is supported.
+     * Sets the render target.
+     * @param target    the render target to set. (should not be NULL.)
      */
-    bool supportsIndex8PixelConfig(const GrSamplerState&, int width, int height);
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    GrRenderTarget* currentRenderTarget() const;
-    void getViewMatrix(GrMatrix* m) const;
-    const GrClip& getClip() const { return fGpu->getClip(); }
-
     void setRenderTarget(GrRenderTarget* target);
 
-    void setTexture(int stage, GrTexture* texture);
-    void setSamplerState(int stage, const GrSamplerState&);
-    void setTextureMatrix(int stage, const GrMatrix& m);
+    /**
+     * Gets the current render target.
+     * @return the currently bound render target. Should never be NULL.
+     */
+    const GrRenderTarget* getRenderTarget() const;
+    GrRenderTarget* getRenderTarget();
 
-    void setAntiAlias(bool);
-    void setDither(bool);
-    void setAlpha(uint8_t alpha);
-    void setColor(GrColor color);
-    void setPointSize(float size);
-    void setBlendFunc(GrGpu::BlendCoeff srcCoef, GrGpu::BlendCoeff dstCoef);
-    void setViewMatrix(const GrMatrix& m);
-    void setClip(const GrClip&);
+    ///////////////////////////////////////////////////////////////////////////
+    // Matrix state
 
     /**
-     *  Erase the entire render target, ignoring any clips/scissors.
+     * Gets the current transformation matrix.
+     * @return the current matrix.
+     */
+    const GrMatrix& getMatrix() const;
+
+    /**
+     * Sets the transformation matrix.
+     * @param m the matrix to set.
+     */
+    void setMatrix(const GrMatrix& m);
+
+    /**
+     * Concats the current matrix. The passed matrix is applied before the
+     * current matrix.
+     * @param m the matrix to concat.
+     */
+    void concatMatrix(const GrMatrix& m) const;
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Clip state
+    /**
+     * Gets the current clip.
+     * @return the current clip.
+     */
+    const GrClip& getClip() const { return fGpu->getClip(); }
+
+    /**
+     * Sets the clip.
+     * @param clip  the clip to set.
+     */
+    void setClip(const GrClip& clip);
+
+    /**
+     * Convenience method for setting the clip to a rect.
+     * @param rect  the rect to set as the new clip.
+     */
+    void setClip(const GrIRect& rect);
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Draws
+
+    /**
+     *  Erase the entire render target, ignoring any clips
      */
     void eraseColor(GrColor color);
 
     /**
-     *  Draw everywhere (respecting the clip) with the current color.
+     *  Draw everywhere (respecting the clip) with the paint.
      */
-    void drawFull(bool useTexture);
+    void drawPaint(const GrPaint& paint);
 
     /**
-     *  Draw the rect, respecting the current texture if useTexture is true.
-     *  If strokeWidth < 0, then the rect is filled, else the rect is stroked
-     *  based on strokeWidth. If strokeWidth == 0, then the stroke is always
-     *  a single pixel thick.
+     *  Draw the rect using a paint.
+     *  If strokeWidth < 0, then the rect is filled, else the rect is mitered
+     *  stroked based on strokeWidth. If strokeWidth == 0, then the stroke is
+     *  always a single pixel thick.
+     *  The rects coords are used to access the paint (through texture matrix)
      */
-    void drawRect(const GrRect&, bool useTexture, GrScalar strokeWidth);
+    void drawRect(const GrPaint& paint, const GrRect&, GrScalar strokeWidth = -1);
 
-    void fillRect(const GrRect& rect, bool useTexture) {
-        this->drawRect(rect, useTexture, -1);
-    }
+    /**
+     * Maps a rect of paint coordinates onto the a rect of destination
+     * coordinates. The srcRect is transformed by the paint's matrix and the
+     * dstRect is transformed by the context's matrix.
+     */
+    void drawRectToRect(const GrPaint& paint,
+                        const GrRect& dstRect,
+                        const GrRect& srcRect);
 
     /**
      * Path filling rules
@@ -191,16 +260,100 @@
     /**
      * Tessellates and draws a path.
      *
+     * @param paint         describes how to color pixels.
      * @param path          the path to draw
-     * @param paint         the paint to set before drawing
-     * @param useTexture    if true the path vertices will also be used as
-     *                      texture coorindates referencing last texture passed
-     *                      to setTexture.
+     * @param fill          the path filling rule to use.
+     * @param translate     optional additional translation applied to the
+     *                      path.
      */
-    void drawPath(GrPathIter* path,
+    void drawPath(const GrPaint& paint,
+                  GrPathIter* path,
                   PathFills fill,
-                  bool useTexture,
                   const GrPoint* translate = NULL);
+    /**
+     * Draws vertices with a paint.
+     *
+     * @param   paint           describes how to color pixels.
+     * @param   primitiveType   primitives type to draw.
+     * @param   vertexCount     number of vertices.
+     * @param   positions       array of vertex positions, required.
+     * @param   texCoords       optional array of texture coordinates used
+     *                          to access the paint.
+     * @param   colors          optional array of per-vertex colors, supercedes
+     *                          the paint's color field.
+     * @param   indices         optional array of indices. If NULL vertices
+     *                          are drawn non-indexed.
+     * @param   indexCount      if indices is non-null then this is the
+     *                          number of indices.
+     */
+    void drawVertices(const GrPaint& paint,
+                      GrDrawTarget::PrimitiveType primitiveType,
+                      int vertexCount,
+                      const GrPoint positions[],
+                      const GrPoint texs[],
+                      const GrColor colors[],
+                      const uint16_t indices[],
+                      int indexCount);
+
+    /**
+     * Similar to drawVertices but caller provides objects that convert to Gr
+     * types. The count of vertices is given by posSrc.
+     *
+     * @param   paint           describes how to color pixels.
+     * @param   primitiveType   primitives type to draw.
+     * @param   posSrc          Source of vertex positions. Must implement
+     *                              int count() const;
+     *                              void writeValue(int i, GrPoint* point) const;
+     *                          count returns the total number of vertices and
+     *                          writeValue writes a vertex position to point.
+     * @param   texSrc          optional, pass NULL to not use explicit tex
+     *                          coords. If present provides tex coords with
+     *                          method:
+     *                              void writeValue(int i, GrPoint* point) const;
+     * @param   texSrc          optional, pass NULL to not use per-vertex colors
+     *                          If present provides colors with method:
+     *                              void writeValue(int i, GrColor* point) const;
+     * @param   indices         optional, pass NULL for non-indexed drawing. If
+     *                          present supplies indices for indexed drawing
+     *                          with following methods:
+     *                              int count() const;
+     *                              void writeValue(int i, uint16_t* point) const;
+     *                          count returns the number of indices and
+     *                          writeValue supplies each index.
+     */
+    template <typename POS_SRC,
+              typename TEX_SRC,
+              typename COL_SRC,
+              typename IDX_SRC>
+    void drawCustomVertices(const GrPaint& paint,
+                            GrDrawTarget::PrimitiveType primitiveType,
+                            const POS_SRC& posSrc,
+                            const TEX_SRC* texCoordSrc,
+                            const COL_SRC* colorSrc,
+                            const IDX_SRC* idxSrc);
+    /**
+     * To avoid the problem of having to create a typename for NULL parameters,
+     * these reduced versions of drawCustomVertices are provided.
+     */
+    template <typename POS_SRC>
+    void drawCustomVertices(const GrPaint& paint,
+                            GrDrawTarget::PrimitiveType primitiveType,
+                            const POS_SRC& posSrc);
+    template <typename POS_SRC, typename TEX_SRC>
+    void drawCustomVertices(const GrPaint& paint,
+                            GrDrawTarget::PrimitiveType primitiveType,
+                            const POS_SRC& posSrc,
+                            const TEX_SRC* texCoordSrc);
+    template <typename POS_SRC, typename TEX_SRC, typename COL_SRC>
+    void drawCustomVertices(const GrPaint& paint,
+                            GrDrawTarget::PrimitiveType primitiveType,
+                            const POS_SRC& posSrc,
+                            const TEX_SRC* texCoordSrc,
+                            const COL_SRC* colorSrc);
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Misc.
 
     /**
      * Call to ensure all drawing to the context has been issued to the
@@ -227,39 +380,9 @@
     void writePixels(int left, int top, int width, int height,
                      GrTexture::PixelConfig, const void* buffer, size_t stride);
 
-    /* -------------------------------------------------------
-     * Mimicking the GrGpu interface for now
-     * TODO: define appropriate higher-level API for context
-     */
 
-    GrVertexBuffer* createVertexBuffer(uint32_t size, bool dynamic);
-
-    GrIndexBuffer* createIndexBuffer(uint32_t size, bool dynamic);
-
-    bool reserveAndLockGeometry(GrVertexLayout    vertexLayout,
-                                uint32_t          vertexCount,
-                                uint32_t          indexCount,
-                                void**            vertices,
-                                void**            indices);
-
-    void drawIndexed(GrGpu::PrimitiveType type,
-                     uint32_t startVertex,
-                     uint32_t startIndex,
-                     uint32_t vertexCount,
-                     uint32_t indexCount);
-
-    void drawNonIndexed(GrGpu::PrimitiveType type,
-                        uint32_t startVertex,
-                        uint32_t vertexCount);
-
-    void setVertexSourceToArray(const void* array,
-                                GrVertexLayout vertexLayout);
-    void setIndexSourceToArray(const void* array);
-    void setVertexSourceToBuffer(GrVertexBuffer* buffer,
-                                GrVertexLayout vertexLayout);
-    void setIndexSourceToBuffer(GrIndexBuffer* buffer);
-
-    void releaseReservedGeometry();
+    ///////////////////////////////////////////////////////////////////////////
+    // Statistics
 
     void resetStats();
 
@@ -267,11 +390,14 @@
 
     void printStats() const;
 
+    ///////////////////////////////////////////////////////////////////////////
+    // Helpers
+
     class AutoRenderTarget : ::GrNoncopyable {
     public:
         AutoRenderTarget(GrContext* context, GrRenderTarget* target) {
             fContext = NULL;
-            fPrevTarget = context->currentRenderTarget();
+            fPrevTarget = context->getRenderTarget();
             if (fPrevTarget != target) {
                 context->setRenderTarget(target);
                 fContext = context;
@@ -287,36 +413,12 @@
         GrRenderTarget* fPrevTarget;
     };
 
+
     ///////////////////////////////////////////////////////////////////////////
-
-    /**
-     *  Return the current texture cache limits.
-     *
-     *  @param maxTextures If non-null, returns maximum number of textures that
-     *                     can be held in the cache.
-     *  @param maxTextureBytes If non-null, returns maximum number of bytes of
-     *                         texture memory that can be held in the cache.
-     */
-    void getTextureCacheLimits(int* maxTextures, size_t* maxTextureBytes) const;
-
-    /**
-     *  Specify the texture cache limits. If the current cache exceeds either
-     *  of these, it will be purged (LRU) to keep the cache within these limits.
-     *
-     *  @param maxTextures The maximum number of textures that can be held in
-     *                     the cache.
-     *  @param maxTextureBytes The maximum number of bytes of texture memory
-     *                         that can be held in the cache.
-     */
-    void setTextureCacheLimits(int maxTextures, size_t maxTextureBytes);
-
-    /* -------------------------------------------------------
-     */
-
-    // Intended only to be used within Ganesh:
+    // Functions intended for internal use only.
     GrGpu* getGpu() { return fGpu; }
     GrFontCache* getFontCache() { return fFontCache; }
-    GrDrawTarget* getTextTarget();
+    GrDrawTarget* getTextTarget(const GrPaint& paint);
     void flushText();
 
     const GrIndexBuffer* quadIndexBuffer() const;
@@ -331,7 +433,11 @@
     GrInOrderDrawBuffer     fTextDrawBuffer;
 
     GrContext(GrGpu* gpu);
+
+    static void SetPaint(const GrPaint& paint, GrDrawTarget* target);
+
     bool finalizeTextureKey(GrTextureKey*, const GrSamplerState&) const;
+    void prepareToDraw(const GrPaint& paint);
 
     void drawClipIntoStencil();
 };
@@ -339,17 +445,17 @@
 /**
  *  Save/restore the view-matrix in the context.
  */
-class GrAutoViewMatrix : GrNoncopyable {
+class GrAutoMatrix : GrNoncopyable {
 public:
-    GrAutoViewMatrix(GrContext* ctx) : fContext(ctx) {
-        ctx->getViewMatrix(&fMatrix);
+    GrAutoMatrix(GrContext* ctx) : fContext(ctx) {
+        fMatrix = ctx->getMatrix();
     }
-    GrAutoViewMatrix(GrContext* ctx, const GrMatrix& matrix) : fContext(ctx) {
-        ctx->getViewMatrix(&fMatrix);
-        ctx->setViewMatrix(matrix);
+    GrAutoMatrix(GrContext* ctx, const GrMatrix& matrix) : fContext(ctx) {
+        fMatrix = ctx->getMatrix();
+        ctx->setMatrix(matrix);
     }
-    ~GrAutoViewMatrix() {
-        fContext->setViewMatrix(fMatrix);
+    ~GrAutoMatrix() {
+        fContext->setMatrix(fMatrix);
     }
 
 private:
@@ -359,3 +465,4 @@
 
 #endif
 
+#include "GrContext_impl.h"
diff --git a/gpu/include/GrContext_impl.h b/gpu/include/GrContext_impl.h
new file mode 100644
index 0000000..b54e927
--- /dev/null
+++ b/gpu/include/GrContext_impl.h
@@ -0,0 +1,135 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+#ifndef GrContext_impl_DEFINED
+#define GrContext_impl_DEFINED
+
+template <typename POS_SRC, typename TEX_SRC,
+          typename COL_SRC, typename IDX_SRC>
+inline void GrContext::drawCustomVertices(const GrPaint& paint,
+                                          GrDrawTarget::PrimitiveType primitiveType,
+                                          const POS_SRC& posSrc,
+                                          const TEX_SRC* texCoordSrc,
+                                          const COL_SRC* colorSrc,
+                                          const IDX_SRC* idxSrc) {
+
+    GrVertexLayout layout = 0;
+
+    GrDrawTarget::AutoReleaseGeometry geo;
+
+    this->prepareToDraw(paint);
+
+    if (NULL != paint.getTexture()) {
+        if (NULL != texCoordSrc) {
+            layout |= GrDrawTarget::StageTexCoordVertexLayoutBit(0,0);
+        } else {
+            layout |= GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0);
+        }
+    }
+
+    if (NULL != colorSrc) {
+        layout |= GrDrawTarget::kColor_VertexLayoutBit;
+    }
+
+    int vertexCount = posSrc.count();
+    int indexCount = (NULL != idxSrc) ? idxSrc->count() : 0;
+
+    if (!geo.set(fGpu, layout, vertexCount, indexCount)) {
+        GrPrintf("Failed to get space for vertices!");
+        return;
+    }
+
+    int texOffsets[GrDrawTarget::kMaxTexCoords];
+    int colorOffset;
+    int vsize = GrDrawTarget::VertexSizeAndOffsetsByIdx(layout,
+                                                        texOffsets,
+                                                        &colorOffset);
+    void* curVertex = geo.vertices();
+
+    for (int i = 0; i < vertexCount; ++i) {
+        posSrc.writeValue(i, (GrPoint*)curVertex);
+
+        if (texOffsets[0] > 0) {
+            texCoordSrc->writeValue(i, (GrPoint*)((intptr_t)curVertex + texOffsets[0]));
+        }
+        if (colorOffset > 0) {
+            colorSrc->writeValue(i, (GrColor*)((intptr_t)curVertex + colorOffset));
+        }
+        curVertex = (void*)((intptr_t)curVertex + vsize);
+    }
+
+    uint16_t* indices = (uint16_t*) geo.indices();
+    for (int i = 0; i < indexCount; ++i) {
+        idxSrc->writeValue(i, indices + i);
+    }
+
+    if (NULL == idxSrc) {
+        fGpu->drawNonIndexed(primitiveType, 0, vertexCount);
+    } else {
+        fGpu->drawIndexed(primitiveType, 0, 0, vertexCount, indexCount);
+    }
+}
+
+class GrNullTexCoordSource {
+public:
+    void writeValue(int i, GrPoint* dstCoord) const { GrAssert(false); }
+};
+
+class GrNullColorSource {
+public:
+    void writeValue(int i, GrColor* dstColor) const { GrAssert(false); }
+};
+
+class GrNullIndexSource {
+public:
+    void writeValue(int i, uint16_t* dstIndex) const { GrAssert(false); }
+    int count() const { GrAssert(false); return 0; }
+};
+
+template <typename POS_SRC>
+inline void GrContext::drawCustomVertices(const GrPaint& paint,
+                                          GrDrawTarget::PrimitiveType primitiveType,
+                                          const POS_SRC& posSrc) {
+    this->drawCustomVertices<POS_SRC,
+                             GrNullTexCoordSource,
+                             GrNullColorSource,
+                             GrNullIndexSource>(paint, primitiveType, posSrc,
+                                                NULL, NULL, NULL);
+}
+
+template <typename POS_SRC, typename TEX_SRC>
+inline void GrContext::drawCustomVertices(const GrPaint& paint,
+                                          GrDrawTarget::PrimitiveType primitiveType,
+                                          const POS_SRC& posSrc,
+                                          const TEX_SRC* texCoordSrc) {
+    this->drawCustomVertices<POS_SRC, TEX_SRC,
+                             GrNullColorSource,
+                             GrNullIndexSource>(paint, primitiveType, posSrc,
+                                                texCoordSrc, NULL, NULL);
+}
+
+template <typename POS_SRC, typename TEX_SRC, typename COL_SRC>
+inline void GrContext::drawCustomVertices(const GrPaint& paint,
+                                          GrDrawTarget::PrimitiveType primitiveType,
+                                          const POS_SRC& posSrc,
+                                          const TEX_SRC* texCoordSrc,
+                                          const COL_SRC* colorSrc) {
+    drawCustomVertices<POS_SRC, TEX_SRC, COL_SRC,
+                       GrNullIndexSource>(paint, primitiveType, posSrc, 
+                                          texCoordSrc, colorSrc, NULL);
+}
+
+#endif
diff --git a/gpu/include/GrDrawTarget.h b/gpu/include/GrDrawTarget.h
index 3405bb5..ec84cda 100644
--- a/gpu/include/GrDrawTarget.h
+++ b/gpu/include/GrDrawTarget.h
@@ -34,26 +34,26 @@
 class GrDrawTarget : public GrRefCnt {
 public:
     /**
-     * Number of texture stages. Each stage takes as input a color and 
-     * 2D texture coordinates. The color input to the first enabled stage is the 
-     * per-vertex color or the constant color (setColor/setAlpha) if there are no
-     * per-vertex colors. For subsequent stages the input color is the output  
+     * Number of texture stages. Each stage takes as input a color and
+     * 2D texture coordinates. The color input to the first enabled stage is the
+     * per-vertex color or the constant color (setColor/setAlpha) if there are
+     * no per-vertex colors. For subsequent stages the input color is the output
      * color from the previous enabled stage. The output color of each stage is
-     * the input color modulated with the result of a texture lookup. Texture 
+     * the input color modulated with the result of a texture lookup. Texture
      * lookups are specified by a texture (setTexture), a texture matrix
-     * (setTextureMatrix), and a sampler (setSamplerState). Texture coordinates 
+     * (setTextureMatrix), and a sampler (setSamplerState). Texture coordinates
      * for each stage come from the vertices based on a GrVertexLayout bitfield.
      * The output fragment color is the output color of the last enabled stage.
-     * The presence or absence of texture coordinates for each stage in the 
+     * The presence or absence of texture coordinates for each stage in the
      * vertex layout indicates whether a stage is enabled or not.
      */
-    
+
     // Currently there is just one stage but this will be changed soon.
     enum {
         kNumStages = 1,
         kMaxTexCoords = kNumStages
     };
-    
+
     /**
      * Geometric primitives used for drawing.
      */
@@ -154,7 +154,6 @@
         GrSamplerState        	fSamplerStates[kNumStages];
         GrRenderTarget*     	fRenderTarget;
         GrColor             	fColor;
-        float               	fPointSize;
         StencilPass             fStencilPass;
         bool                    fReverseFill;
         GrMatrix                fViewMatrix;
@@ -202,14 +201,13 @@
      *            texture has been set, NULL was most recently passed to
      *            setTexture, or the last setTexture was destroyed.
      */
-    GrTexture* currentTexture(int stage) const;
+    const GrTexture* getTexture(int stage) const;
+    GrTexture* getTexture(int stage);
 
     /**
      * Sets the rendertarget used at the next drawing call
      *
-     * @param target  The render target to set. Must be a valid rendertarget.
-     *                That is it is a value that was returned by
-     *                currentRenderTarget() or GrTexture::asRenderTarget().
+     * @param target  The render target to set.
      */
     void setRenderTarget(GrRenderTarget* target);
 
@@ -218,7 +216,8 @@
      *
      * @return    The currently set render target.
      */
-    GrRenderTarget* currentRenderTarget() const;
+    const GrRenderTarget* getRenderTarget() const;
+    GrRenderTarget* getRenderTarget();
 
     /**
      * Sets the sampler state for the next draw.
@@ -318,13 +317,6 @@
     }
 
     /**
-     * Sets the size of points used the next time points are drawn.
-     *
-     * @param the point size
-     */
-    void setPointSize(float size);
-
-    /**
      * Sets the blending function coeffecients.
      *
      * The blend function will be:
@@ -341,9 +333,9 @@
 
     /**
      * Retrieves the current view matrix
-     * @param matrix will be the current view matrix after return.
+     * return the current view matrix.
      */
-    void getViewMatrix(GrMatrix* matrix) const;
+    const GrMatrix& getViewMatrix() const;
 
     /**
      *  Retrieves the inverse of the current view matrix.
@@ -396,7 +388,7 @@
     /**
      * The format of vertices is represented as a bitfield of flags.
      * Flags that indicate the layout of vertex data. Vertices always contain
-     * positions and may also contain up to kMaxTexCoords sets of 2D texture 
+     * positions and may also contain up to kMaxTexCoords sets of 2D texture
      * coordinates and per-vertex colors. Each stage can use any of the texture
      * coordinates as its input texture coordinates or it may use the positions.
      *
@@ -404,18 +396,18 @@
      * disabled.
      *
      * Only one type of texture coord can be specified per stage. For
-     * example StageTexCoordVertexLayoutBit(0, 2) and 
+     * example StageTexCoordVertexLayoutBit(0, 2) and
      * StagePosAsTexCoordVertexLayoutBit(0) cannot both be specified.
      *
-     * The order in memory is always (position, texture coord 0, ..., color) 
+     * The order in memory is always (position, texture coord 0, ..., color)
      * with any unused fields omitted. Note that this means that if only texture
-     * coordinates 1 is referenced then there is no texture coordinates 0 and 
+     * coordinates 1 is referenced then there is no texture coordinates 0 and
      * the order would be (position, texture coordinate 1[, color]).
      */
-    
+
     /**
      * Generates a bit indicating that a texture stage uses texture coordinates
-     * 
+     *
      * @param stage       the stage that will use texture coordinates.
      * @param texCoordIdx the index of the texture coordinates to use
      *
@@ -433,31 +425,31 @@
      * Generates a bit indicating that a texture stage uses the position
      * as its texture coordinate.
      *
-     * @param stage       the stage that will use position as texture 
+     * @param stage       the stage that will use position as texture
      *                    coordinates.
      *
      * @return the bit to add to a GrVertexLayout bitfield.
      */
     static int StagePosAsTexCoordVertexLayoutBit(int stage) {
         GrAssert(stage < kNumStages);
-        return (1 << (TEX_COORD_BIT_CNT + stage)); 
+        return (1 << (TEX_COORD_BIT_CNT + stage));
     }
 private:
     static const int STAGE_BIT_CNT = TEX_COORD_BIT_CNT + kNumStages;
-    
+
 public:
-    
+
     /**
      * Additional Bits that can be specified in GrVertexLayout.
      */
     enum VertexLayoutBits {
-        
+
         kColor_VertexLayoutBit              = 1 << (STAGE_BIT_CNT + 0),
                                                 //<! vertices have colors
         kTextFormat_VertexLayoutBit         = 1 << (STAGE_BIT_CNT + 1),
                                                 //<! use text vertices. (Pos
                                                 //   and tex coords may be
-                                                //   a different type for 
+                                                //   a different type for
                                                 //   text [GrGpuTextVertex vs
                                                 //   GrPoint].)
         // for below assert
@@ -634,12 +626,33 @@
                                                        &fVertices,
                                                        &fIndices);
         }
+
+        AutoReleaseGeometry() {
+            fSuccess = false;
+        }
+
         ~AutoReleaseGeometry() {
             if (fSuccess) {
                 fTarget->releaseReservedGeometry();
             }
         }
 
+        bool set(GrDrawTarget*  target,
+                 GrVertexLayout vertexLayout,
+                 uint32_t       vertexCount,
+                 uint32_t       indexCount) {
+            if (fSuccess) {
+                fTarget->releaseReservedGeometry();
+            }
+            fTarget = target;
+            fSuccess = fTarget->reserveAndLockGeometry(vertexLayout,
+                                                       vertexCount,
+                                                       indexCount,
+                                                       &fVertices,
+                                                       &fIndices);
+            return fSuccess;
+        }
+
         bool succeeded() const { return fSuccess; }
         void* vertices() const { return fVertices; }
         void* indices() const { return fIndices; }
@@ -674,13 +687,13 @@
 
     ////////////////////////////////////////////////////////////////////////////
     // Helpers for picking apart vertex layouts
-    
+
     /**
      * Helper function to compute the size of a vertex from a vertex layout
      * @return size of a single vertex.
      */
     static size_t VertexSize(GrVertexLayout vertexLayout);
-    
+
     /**
      * Helper function for determining the index of texture coordinates that
      * is input for a texture stage. Note that a stage may instead use positions
@@ -698,7 +711,7 @@
     /**
      * Helper function to compute the offset of texture coordinates in a vertex
      * @return offset of texture coordinates in vertex layout or -1 if the
-     *         layout has no texture coordinates. Will be 0 if positions are 
+     *         layout has no texture coordinates. Will be 0 if positions are
      *         used as texture coordinates for the stage.
      */
     static int VertexStageCoordOffset(int stage, GrVertexLayout vertexLayout);
@@ -711,18 +724,18 @@
     static int VertexColorOffset(GrVertexLayout vertexLayout);
 
     /**
-     * Helper function to determine if vertex layout contains explicit texture 
+     * Helper function to determine if vertex layout contains explicit texture
      * coordinates of some index.
      *
      * @param coordIndex    the tex coord index to query
      * @param vertexLayout  layout to query
      *
-     * @return true if vertex specifies texture coordinates for the index, 
+     * @return true if vertex specifies texture coordinates for the index,
      *              false otherwise.
      */
-    static bool VertexUsesTexCoordIdx(int coordIndex, 
+    static bool VertexUsesTexCoordIdx(int coordIndex,
                                       GrVertexLayout vertexLayout);
-    
+
     /**
      * Helper function to determine if vertex layout contains either explicit or
      * implicit texture coordinates for a stage.
@@ -730,15 +743,15 @@
      * @param stage         the stage to query
      * @param vertexLayout  layout to query
      *
-     * @return true if vertex specifies texture coordinates for the stage, 
+     * @return true if vertex specifies texture coordinates for the stage,
      *              false otherwise.
      */
     static bool VertexUsesStage(int stage, GrVertexLayout vertexLayout);
 
     /**
-     * Helper function to compute the size of each vertex and the offsets of 
-     * texture coordinates and color. Determines tex coord offsets by tex coord 
-     * index rather than by stage. (Each stage can be mapped to any t.c. index 
+     * Helper function to compute the size of each vertex and the offsets of
+     * texture coordinates and color. Determines tex coord offsets by tex coord
+     * index rather than by stage. (Each stage can be mapped to any t.c. index
      * by StageTexCoordVertexLayoutBit.)
      *
      * @param vertexLayout          the layout to query
@@ -750,12 +763,12 @@
     static int VertexSizeAndOffsetsByIdx(GrVertexLayout vertexLayout,
                                          int texCoordOffsetsByIdx[kMaxTexCoords],
                                          int *colorOffset);
-    
+
     /**
-     * Helper function to compute the size of each vertex and the offsets of 
-     * texture coordinates and color. Determines tex coord offsets by stage 
-     * rather than by index. (Each stage can be mapped to any t.c. index 
-     * by StageTexCoordVertexLayoutBit.) If a stage uses positions for 
+     * Helper function to compute the size of each vertex and the offsets of
+     * texture coordinates and color. Determines tex coord offsets by stage
+     * rather than by index. (Each stage can be mapped to any t.c. index
+     * by StageTexCoordVertexLayoutBit.) If a stage uses positions for
      * tex coords then that stage's offset will be 0 (positions are always at 0).
      *
      * @param vertexLayout              the layout to query
@@ -768,7 +781,7 @@
                                            int texCoordOffsetsByStage[kNumStages],
                                            int *colorOffset);
 protected:
-    
+
     // Helpers for GrDrawTarget subclasses that won't have private access to
     // SavedDrawState but need to peek at the state values.
     static DrState& accessSavedDrawState(SavedDrawState& sds)
diff --git a/gpu/include/GrPaint.h b/gpu/include/GrPaint.h
new file mode 100644
index 0000000..23902a8
--- /dev/null
+++ b/gpu/include/GrPaint.h
@@ -0,0 +1,106 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+#ifndef GrPaint_DEFINED
+#define GrPaint_DEFINED
+
+#include "GrTexture.h"
+#include "GrSamplerState.h"
+#include "GrDrawTarget.h"
+
+/**
+ * The paint describes how pixels are colored when the context draws to
+ * them.
+ */
+class GrPaint {
+public:
+
+    // All the paint fields are public except texture (it's ref-counted)
+    GrDrawTarget::BlendCoeff    fSrcBlendCoeff;
+    GrDrawTarget::BlendCoeff    fDstBlendCoeff;
+    bool                        fAntiAlias;
+    bool                        fDither;
+
+    GrColor                     fColor;
+
+    GrMatrix                    fTextureMatrix;
+    GrSamplerState              fSampler;
+
+    void setTexture(GrTexture* texture) {
+        GrSafeRef(texture);
+        GrSafeUnref(fTexture);
+        fTexture = texture;
+    }
+
+    GrTexture* getTexture() const { return fTexture; }
+
+    // uninitialized
+    GrPaint() {
+        fTexture = NULL;
+    }
+
+    GrPaint(const GrPaint& paint) {
+        fSrcBlendCoeff = paint.fSrcBlendCoeff;
+        fDstBlendCoeff = paint.fDstBlendCoeff;
+        fAntiAlias = paint.fAntiAlias;
+        fDither = paint.fDither;
+
+        fColor = paint.fColor;
+
+        fTextureMatrix = paint.fTextureMatrix;
+        fSampler = paint.fSampler;
+        fTexture = paint.fTexture;
+        GrSafeRef(fTexture);
+    }
+
+    ~GrPaint() {
+        GrSafeUnref(fTexture);
+    }
+
+    // sets paint to src-over, solid white, no texture
+    void reset() {
+        resetBlend();
+        resetOptions();
+        resetColor();
+        resetTexture();
+    }
+
+private:
+    GrTexture*      fTexture;
+
+    void resetBlend() {
+        fSrcBlendCoeff = GrDrawTarget::kOne_BlendCoeff;
+        fDstBlendCoeff = GrDrawTarget::kZero_BlendCoeff;
+    }
+
+    void resetOptions() {
+        fAntiAlias = false;
+        fDither = false;
+    }
+
+    void resetColor() {
+        fColor = GrColorPackRGBA(0xff, 0xff, 0xff, 0xff);
+    }
+
+    void resetTexture() {
+        setTexture(NULL);
+        fTextureMatrix = GrMatrix::I();
+        fSampler.setClampNoFilter();
+    }
+
+};
+
+#endif
diff --git a/gpu/include/GrSamplerState.h b/gpu/include/GrSamplerState.h
index 5fb10b9..9715c45 100644
--- a/gpu/include/GrSamplerState.h
+++ b/gpu/include/GrSamplerState.h
@@ -46,27 +46,27 @@
         this->setClampNoFilter();
     }
 
-    GrSamplerState(bool filter) {
+    explicit GrSamplerState(bool filter) {
         fWrapX = kClamp_WrapMode;
         fWrapY = kClamp_WrapMode;
         fSampleMode = kNormal_SampleMode;
         fFilter = filter;
     }
-    
+
     GrSamplerState(WrapMode wx, WrapMode wy, bool filter) {
         fWrapX = wx;
         fWrapY = wy;
         fSampleMode = kNormal_SampleMode;
         fFilter = filter;
     }
-    
+
     GrSamplerState(WrapMode wx, WrapMode wy, SampleMode sample, bool filter) {
         fWrapX = wx;
         fWrapY = wy;
         fSampleMode = sample;
         fFilter = filter;
     }
-    
+
     WrapMode getWrapX() const { return fWrapX; }
     WrapMode getWrapY() const { return fWrapY; }
     SampleMode getSampleMode() const { return fSampleMode; }
@@ -95,8 +95,8 @@
     bool     isRadial2PosRoot() const { return fRadial2PosRoot; }
 
     /**
-     * Sets the parameters for kRadial2_SampleMode. The texture 
-     * matrix must be set so that the first point is at (0,0) and the second 
+     * Sets the parameters for kRadial2_SampleMode. The texture
+     * matrix must be set so that the first point is at (0,0) and the second
      * point lies on the x-axis. The second radius minus the first is 1 unit.
      * The additional parameters to define the gradient are specified by this
      * function.
diff --git a/gpu/include/GrTextContext.h b/gpu/include/GrTextContext.h
index 6b7446b..d813c09 100644
--- a/gpu/include/GrTextContext.h
+++ b/gpu/include/GrTextContext.h
@@ -27,7 +27,9 @@
 
 class GrTextContext {
 public:
-    GrTextContext(GrContext*, const GrMatrix* extMatrix = NULL);
+    GrTextContext(GrContext*,
+                  const GrPaint& paint,
+                  const GrMatrix* extMatrix = NULL);
     ~GrTextContext();
 
     void drawPackedGlyph(GrGlyph::PackedID, GrFixed left, GrFixed top,
@@ -36,6 +38,7 @@
     void flush();   // optional; automatically called by destructor
 
 private:
+    const GrPaint&  fPaint;
     GrContext*      fContext;
     GrDrawTarget*   fDrawTarget;
 
@@ -53,7 +56,7 @@
     };
 
     GrGpuTextVertex* fVertices;
-    
+
     int32_t     fMaxVertices;
     GrTexture*  fCurrTexture;
     int         fCurrVertex;
diff --git a/gpu/src/GrContext.cpp b/gpu/src/GrContext.cpp
index ee78848..5e6b824 100644
--- a/gpu/src/GrContext.cpp
+++ b/gpu/src/GrContext.cpp
@@ -138,17 +138,17 @@
         GrTexture* texture = fGpu->createTexture(rtDesc, NULL, 0);
 
         if (NULL != texture) {
-            GrGpu::AutoStateRestore asr(fGpu);
+            GrDrawTarget::AutoStateRestore asr(fGpu);
             fGpu->setRenderTarget(texture->asRenderTarget());
             fGpu->setTexture(0, clampEntry->texture());
-            fGpu->setStencilPass(GrGpu::kNone_StencilPass);
+            fGpu->setStencilPass(GrDrawTarget::kNone_StencilPass);
             fGpu->setTextureMatrix(0, GrMatrix::I());
             fGpu->setViewMatrix(GrMatrix::I());
             fGpu->setAlpha(0xff);
-            fGpu->setBlendFunc(GrGpu::kOne_BlendCoeff, GrGpu::kZero_BlendCoeff);
-            fGpu->disableState(GrGpu::kDither_StateBit |
-                               GrGpu::kClip_StateBit   |
-                               GrGpu::kAntialias_StateBit);
+            fGpu->setBlendFunc(GrDrawTarget::kOne_BlendCoeff, GrDrawTarget::kZero_BlendCoeff);
+            fGpu->disableState(GrDrawTarget::kDither_StateBit |
+                               GrDrawTarget::kClip_StateBit   |
+                               GrDrawTarget::kAntialias_StateBit);
             GrSamplerState stretchSampler(GrSamplerState::kClamp_WrapMode,
                                           GrSamplerState::kClamp_WrapMode,
                                           sampler.isFilter());
@@ -171,7 +171,7 @@
                                               clampTexture->contentHeight() /
                                               clampTexture->allocHeight());
                 verts[1].setRectFan(0, 0, tw, th, 2*sizeof(GrPoint));
-                fGpu->drawNonIndexed(GrGpu::kTriangleFan_PrimitiveType,
+                fGpu->drawNonIndexed(GrDrawTarget::kTriangleFan_PrimitiveType,
                                      0, 4);
                 entry = fTextureCache->createAndLock(*key, texture);
             }
@@ -275,11 +275,24 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
+void GrContext::setClip(const GrClip& clip) {
+    fGpu->setClip(clip);
+    fGpu->enableState(GrDrawTarget::kClip_StateBit);
+}
+
+void GrContext::setClip(const GrIRect& rect) {
+    GrClip clip;
+    clip.setRect(rect);
+    fGpu->setClip(clip);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 void GrContext::eraseColor(GrColor color) {
     fGpu->eraseColor(color);
 }
 
-void GrContext::drawFull(bool useTexture) {
+void GrContext::drawPaint(const GrPaint& paint) {
     // set rect to be big enough to fill the space, but not super-huge, so we
     // don't overflow fixed-point implementations
     GrRect r(fGpu->getClip().getBounds());
@@ -289,8 +302,7 @@
     } else {
         GrPrintf("---- fGpu->getViewInverse failed\n");
     }
-
-    this->fillRect(r, useTexture);
+    this->drawRect(paint, r);
 }
 
 /*  create a triangle strip that strokes the specified triangle. There are 8
@@ -314,8 +326,11 @@
     verts[9] = verts[1];
 }
 
-void GrContext::drawRect(const GrRect& rect, bool useTexture, GrScalar width) {
-    GrVertexLayout layout = useTexture ?
+void GrContext::drawRect(const GrPaint& paint,
+                         const GrRect& rect,
+                         GrScalar width) {
+
+    GrVertexLayout layout = (NULL != paint.getTexture()) ?
                             GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0) :
                             0;
 
@@ -325,21 +340,21 @@
         return;
     }
 
-    this->flushText();
+    this->prepareToDraw(paint);
 
     int vertCount;
-    GrGpu::PrimitiveType primType;
+    GrDrawTarget::PrimitiveType primType;
     GrPoint* vertex = geo.positions();
 
     if (width >= 0) {
         if (width > 0) {
             vertCount = 10;
-            primType = GrGpu::kTriangleStrip_PrimitiveType;
+            primType = GrDrawTarget::kTriangleStrip_PrimitiveType;
             setStrokeRectStrip(vertex, rect, width);
         } else {
             // hairline
             vertCount = 5;
-            primType = GrGpu::kLineStrip_PrimitiveType;
+            primType = GrDrawTarget::kLineStrip_PrimitiveType;
             vertex[0].set(rect.fLeft, rect.fTop);
             vertex[1].set(rect.fRight, rect.fTop);
             vertex[2].set(rect.fRight, rect.fBottom);
@@ -348,13 +363,111 @@
         }
     } else {
         vertCount = 4;
-        primType = GrGpu::kTriangleFan_PrimitiveType;
+        primType = GrDrawTarget::kTriangleFan_PrimitiveType;
         vertex->setRectFan(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
     }
 
     fGpu->drawNonIndexed(primType, 0, vertCount);
 }
 
+void GrContext::drawRectToRect(const GrPaint& paint,
+                               const GrRect& dstRect,
+                               const GrRect& srcRect) {
+
+    if (NULL == paint.getTexture()) {
+        drawRect(paint, dstRect);
+        return;
+    }
+
+    GrVertexLayout layout = GrDrawTarget::StageTexCoordVertexLayoutBit(0,0);
+    static const int VCOUNT = 4;
+
+    GrDrawTarget::AutoReleaseGeometry geo(fGpu, layout, VCOUNT, 0);
+    if (!geo.succeeded()) {
+        return;
+    }
+
+    this->prepareToDraw(paint);
+
+    GrPoint* vertex = (GrPoint*) geo.vertices();
+
+    vertex[0].setRectFan(dstRect.fLeft, dstRect.fTop,
+                         dstRect.fRight, dstRect.fBottom,
+                         2 * sizeof(GrPoint));
+    vertex[1].setRectFan(srcRect.fLeft, srcRect.fTop,
+                         srcRect.fRight, srcRect.fBottom,
+                         2 * sizeof(GrPoint));
+
+    fGpu->drawNonIndexed(GrDrawTarget::kTriangleFan_PrimitiveType, 0, VCOUNT);
+}
+
+void GrContext::drawVertices(const GrPaint& paint,
+                             GrDrawTarget::PrimitiveType primitiveType,
+                             int vertexCount,
+                             const GrPoint positions[],
+                             const GrPoint texCoords[],
+                             const GrColor colors[],
+                             const uint16_t indices[],
+                             int indexCount) {
+    GrVertexLayout layout = 0;
+    bool interLeave = false;
+
+    GrDrawTarget::AutoReleaseGeometry geo;
+
+    this->prepareToDraw(paint);
+
+    if (NULL != paint.getTexture()) {
+        if (NULL == texCoords) {
+            layout |= GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0);
+        } else {
+            layout |= GrDrawTarget::StageTexCoordVertexLayoutBit(0,0);
+            interLeave = true;
+        }
+    }
+
+    if (NULL != colors) {
+        layout |= GrDrawTarget::kColor_VertexLayoutBit;
+    }
+
+    static const GrVertexLayout interleaveMask =
+        (GrDrawTarget::StageTexCoordVertexLayoutBit(0,0) |
+         GrDrawTarget::kColor_VertexLayoutBit);
+    if (interleaveMask & layout) {
+        if (!geo.set(fGpu, layout, vertexCount, 0)) {
+            GrPrintf("Failed to get space for vertices!");
+            return;
+        }
+        int texOffsets[GrDrawTarget::kMaxTexCoords];
+        int colorOffset;
+        int vsize = GrDrawTarget::VertexSizeAndOffsetsByIdx(layout,
+                                                            texOffsets,
+                                                            &colorOffset);
+        void* curVertex = geo.vertices();
+
+        for (int i = 0; i < vertexCount; ++i) {
+            *((GrPoint*)curVertex) = positions[i];
+
+            if (texOffsets[0] > 0) {
+                *(GrPoint*)((intptr_t)curVertex + texOffsets[0]) = texCoords[i];
+            }
+            if (colorOffset > 0) {
+                *(GrColor*)((intptr_t)curVertex + colorOffset) = colors[i];
+            }
+            curVertex = (void*)((intptr_t)curVertex + vsize);
+        }
+    } else {
+        fGpu->setVertexSourceToArray(positions, layout);
+    }
+
+    if (NULL != indices) {
+        fGpu->setIndexSourceToArray(indices);
+        fGpu->drawIndexed(primitiveType, 0, 0, vertexCount, indexCount);
+    } else {
+        fGpu->drawNonIndexed(primitiveType, 0, vertexCount);
+    }
+}
+
+
 ////////////////////////////////////////////////////////////////////////////////
 
 #define NEW_EVAL        1   // Use adaptive path tesselation
@@ -533,7 +646,6 @@
 
 static inline bool single_pass_path(const GrPathIter& path,
                                     GrContext::PathFills fill,
-                                    bool useTex,
                                     const GrGpu& gpu) {
 #if STENCIL_OFF
     return true;
@@ -554,16 +666,18 @@
 #endif
 }
 
-void GrContext::drawPath(GrPathIter* path, PathFills fill,
-                         bool useTexture, const GrPoint* translate) {
+void GrContext::drawPath(const GrPaint& paint,
+                         GrPathIter* path,
+                         PathFills fill,
+                         const GrPoint* translate) {
 
-    flushText();
 
-    GrGpu::AutoStateRestore asr(fGpu);
+    this->prepareToDraw(paint);
+
+    GrDrawTarget::AutoStateRestore asr(fGpu);
 
 #if NEW_EVAL
-    GrMatrix viewM;
-    fGpu->getViewMatrix(&viewM);
+    GrMatrix viewM = fGpu->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();
@@ -594,7 +708,8 @@
 #endif
                                         tol);
     GrVertexLayout layout = 0;
-    if (useTexture) {
+
+    if (NULL != paint.getTexture()) {
         layout = GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0);
     }
     // add 4 to hold the bounding rect
@@ -609,20 +724,20 @@
     path->rewind();
 
     // TODO: use primitve restart if available rather than multiple draws
-    GrGpu::PrimitiveType  type;
+    GrDrawTarget::PrimitiveType  type;
     int                   passCount = 0;
-    GrGpu::StencilPass    passes[3];
+    GrDrawTarget::StencilPass    passes[3];
     bool                  reverse = false;
 
     if (kHairLine_PathFill == fill) {
-        type = GrGpu::kLineStrip_PrimitiveType;
+        type = GrDrawTarget::kLineStrip_PrimitiveType;
         passCount = 1;
-        passes[0] = GrGpu::kNone_StencilPass;
+        passes[0] = GrDrawTarget::kNone_StencilPass;
     } else {
-        type = GrGpu::kTriangleFan_PrimitiveType;
-        if (single_pass_path(*path, fill, useTexture, *fGpu)) {
+        type = GrDrawTarget::kTriangleFan_PrimitiveType;
+        if (single_pass_path(*path, fill, *fGpu)) {
             passCount = 1;
-            passes[0] = GrGpu::kNone_StencilPass;
+            passes[0] = GrDrawTarget::kNone_StencilPass;
         } else {
             switch (fill) {
                 case kInverseEvenOdd_PathFill:
@@ -630,21 +745,21 @@
                     // fallthrough
                 case kEvenOdd_PathFill:
                     passCount = 2;
-                    passes[0] = GrGpu::kEvenOddStencil_StencilPass;
-                    passes[1] = GrGpu::kEvenOddColor_StencilPass;
+                    passes[0] = GrDrawTarget::kEvenOddStencil_StencilPass;
+                    passes[1] = GrDrawTarget::kEvenOddColor_StencilPass;
                     break;
 
                 case kInverseWinding_PathFill:
                     reverse = true;
                     // fallthrough
                 case kWinding_PathFill:
-                    passes[0] = GrGpu::kWindingStencil1_StencilPass;
+                    passes[0] = GrDrawTarget::kWindingStencil1_StencilPass;
                     if (fGpu->supportsSingleStencilPassWinding()) {
-                        passes[1] = GrGpu::kWindingColor_StencilPass;
+                        passes[1] = GrDrawTarget::kWindingColor_StencilPass;
                         passCount = 2;
                     } else {
-                        passes[1] = GrGpu::kWindingStencil2_StencilPass;
-                        passes[2] = GrGpu::kWindingColor_StencilPass;
+                        passes[1] = GrDrawTarget::kWindingStencil2_StencilPass;
+                        passes[2] = GrDrawTarget::kWindingColor_StencilPass;
                         passCount = 3;
                     }
                     break;
@@ -752,11 +867,15 @@
     if (useBounds) {
         GrRect bounds;
         if (reverse) {
-            GrAssert(NULL != fGpu->currentRenderTarget());
+            GrAssert(NULL != fGpu->getRenderTarget());
             // draw over the whole world.
             bounds.setLTRB(0, 0,
-                           GrIntToScalar(fGpu->currentRenderTarget()->width()),
-                           GrIntToScalar(fGpu->currentRenderTarget()->height()));
+                           GrIntToScalar(fGpu->getRenderTarget()->width()),
+                           GrIntToScalar(fGpu->getRenderTarget()->height()));
+            GrMatrix vmi;
+            if (fGpu->getViewInverse(&vmi)) {
+                vmi.mapRect(&bounds);
+            }
         } else {
             bounds.setBounds((GrPoint*)base, vert - base);
         }
@@ -766,10 +885,11 @@
 
     for (int p = 0; p < passCount; ++p) {
         fGpu->setStencilPass(passes[p]);
-        if (useBounds && (GrGpu::kEvenOddColor_StencilPass == passes[p] ||
-                          GrGpu::kWindingColor_StencilPass == passes[p])) {
-            fGpu->drawNonIndexed(GrGpu::kTriangleFan_PrimitiveType,
+        if (useBounds && (GrDrawTarget::kEvenOddColor_StencilPass == passes[p] ||
+                          GrDrawTarget::kWindingColor_StencilPass == passes[p])) {
+            fGpu->drawNonIndexed(GrDrawTarget::kTriangleFan_PrimitiveType,
                                  maxPts, 4);
+
         } else {
             int baseVertex = 0;
             for (int sp = 0; sp < subpathCnt; ++sp) {
@@ -782,6 +902,8 @@
     }
 }
 
+////////////////////////////////////////////////////////////////////////////////
+
 void GrContext::flush(bool flushRenderTarget) {
     flushText();
     if (flushRenderTarget) {
@@ -803,6 +925,10 @@
 void GrContext::writePixels(int left, int top, int width, int height,
                             GrTexture::PixelConfig config, const void* buffer,
                             size_t stride) {
+
+    // TODO: when underlying api has a direct way to do this we should use it
+    // (e.g. glDrawPixels on desktop GL).
+
     const GrGpu::TextureDesc desc = {
         0, GrGpu::kNone_AALevel, width, height, config
     };
@@ -830,126 +956,72 @@
     fGpu->setTexture(0, texture);
     fGpu->setSamplerState(0, GrSamplerState::ClampNoFilter());
 
-    this->fillRect(GrRect(0, 0, GrIntToScalar(width), GrIntToScalar(height)),
-                   true);
+    GrVertexLayout layout = GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0);
+    static const int VCOUNT = 4;
+
+    GrDrawTarget::AutoReleaseGeometry geo(fGpu, layout, VCOUNT, 0);
+    if (!geo.succeeded()) {
+        return;
+    }
+    ((GrPoint*)geo.vertices())->setIRectFan(0, 0, width, height);
+    fGpu->drawNonIndexed(GrDrawTarget::kTriangleFan_PrimitiveType, 0, VCOUNT);
+}
+////////////////////////////////////////////////////////////////////////////////
+
+void GrContext::SetPaint(const GrPaint& paint, GrDrawTarget* target) {
+    target->setTexture(0, paint.getTexture());
+    target->setTextureMatrix(0, paint.fTextureMatrix);
+    target->setSamplerState(0, paint.fSampler);
+    target->setColor(paint.fColor);
+
+    if (paint.fDither) {
+        target->enableState(GrDrawTarget::kDither_StateBit);
+    } else {
+        target->disableState(GrDrawTarget::kDither_StateBit);
+    }
+    if (paint.fAntiAlias) {
+        target->enableState(GrDrawTarget::kAntialias_StateBit);
+    } else {
+        target->disableState(GrDrawTarget::kAntialias_StateBit);
+    }
+    target->setBlendFunc(paint.fSrcBlendCoeff, paint.fDstBlendCoeff);
+}
+
+void GrContext::prepareToDraw(const GrPaint& paint) {
+
+    flushText();
+    SetPaint(paint, fGpu);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-
-/* -------------------------------------------------------
- * Mimicking the GrGpu interface for now
- * TODO: define appropriate higher-level API for context
- */
-
 void GrContext::resetContext() {
     fGpu->resetContext();
 }
 
-GrVertexBuffer* GrContext::createVertexBuffer(uint32_t size, bool dynamic) {
-    return fGpu->createVertexBuffer(size, dynamic);
-}
-
-GrIndexBuffer* GrContext::createIndexBuffer(uint32_t size, bool dynamic) {
-    return fGpu->createIndexBuffer(size, dynamic);
-}
-
-void GrContext::setTexture(int stage, GrTexture* texture) {
-    fGpu->setTexture(stage, texture);
-}
-
 void GrContext::setRenderTarget(GrRenderTarget* target) {
     flushText();
     fGpu->setRenderTarget(target);
 }
 
-GrRenderTarget* GrContext::currentRenderTarget() const {
-    return fGpu->currentRenderTarget();
+GrRenderTarget* GrContext::getRenderTarget() {
+    return fGpu->getRenderTarget();
 }
 
-void GrContext::setSamplerState(int stage, const GrSamplerState& samplerState) {
-    fGpu->setSamplerState(stage, samplerState);
+const GrRenderTarget* GrContext::getRenderTarget() const {
+    return fGpu->getRenderTarget();
 }
 
-void GrContext::setTextureMatrix(int stage, const GrMatrix& m) {
-    fGpu->setTextureMatrix(stage, m);
+const GrMatrix& GrContext::getMatrix() const {
+    return fGpu->getViewMatrix();
 }
 
-void GrContext::getViewMatrix(GrMatrix* m) const {
-    fGpu->getViewMatrix(m);
-}
-
-void GrContext::setViewMatrix(const GrMatrix& m) {
+void GrContext::setMatrix(const GrMatrix& m) {
     fGpu->setViewMatrix(m);
 }
 
-bool GrContext::reserveAndLockGeometry(GrVertexLayout    vertexLayout,
-                                       uint32_t          vertexCount,
-                                       uint32_t          indexCount,
-                                       void**            vertices,
-                                       void**            indices) {
-    return fGpu->reserveAndLockGeometry(vertexLayout,
-                                        vertexCount,
-                                        indexCount,
-                                        vertices,
-                                        indices);
-}
-
-void GrContext::drawIndexed(GrGpu::PrimitiveType type,
-                            uint32_t startVertex,
-                            uint32_t startIndex,
-                            uint32_t vertexCount,
-                            uint32_t indexCount) {
-    flushText();
-    fGpu->drawIndexed(type,
-                      startVertex,
-                      startIndex,
-                      vertexCount,
-                      indexCount);
-}
-
-void GrContext::drawNonIndexed(GrGpu::PrimitiveType type,
-                               uint32_t startVertex,
-                               uint32_t vertexCount) {
-    flushText();
-    fGpu->drawNonIndexed(type,
-                         startVertex,
-                         vertexCount);
-}
-
-void GrContext::setVertexSourceToArray(const void* array,
-                                       GrVertexLayout vertexLayout) {
-    fGpu->setVertexSourceToArray(array, vertexLayout);
-}
-
-void GrContext::setIndexSourceToArray(const void* array) {
-    fGpu->setIndexSourceToArray(array);
-}
-
-void GrContext::setVertexSourceToBuffer(GrVertexBuffer* buffer,
-                                       GrVertexLayout vertexLayout) {
-    fGpu->setVertexSourceToBuffer(buffer, vertexLayout);
-}
-
-void GrContext::setIndexSourceToBuffer(GrIndexBuffer* buffer) {
-    fGpu->setIndexSourceToBuffer(buffer);
-}
-
-void GrContext::releaseReservedGeometry() {
-    fGpu->releaseReservedGeometry();
-}
-
-void GrContext::setClip(const GrClip& clip) {
-    fGpu->setClip(clip);
-    fGpu->enableState(GrDrawTarget::kClip_StateBit);
-}
-
-void GrContext::setAlpha(uint8_t alpha) {
-    fGpu->setAlpha(alpha);
-}
-
-void GrContext::setColor(GrColor color) {
-    fGpu->setColor(color);
+void GrContext::concatMatrix(const GrMatrix& m) const {
+    fGpu->concatViewMatrix(m);
 }
 
 static inline intptr_t setOrClear(intptr_t bits, int shift, intptr_t pred) {
@@ -962,34 +1034,6 @@
     return bits;
 }
 
-void GrContext::setAntiAlias(bool aa) {
-    if (aa) {
-        fGpu->enableState(GrGpu::kAntialias_StateBit);
-    } else {
-        fGpu->disableState(GrGpu::kAntialias_StateBit);
-    }
-}
-
-void GrContext::setDither(bool dither) {
-    // hack for now, since iPad dither is hella-slow
-    dither = false;
-
-    if (dither) {
-        fGpu->enableState(GrGpu::kDither_StateBit);
-    } else {
-        fGpu->disableState(GrGpu::kDither_StateBit);
-    }
-}
-
-void GrContext::setPointSize(float size) {
-    fGpu->setPointSize(size);
-}
-
-void GrContext::setBlendFunc(GrGpu::BlendCoeff srcCoef,
-                             GrGpu::BlendCoeff dstCoef) {
-    fGpu->setBlendFunc(srcCoef, dstCoef);
-}
-
 void GrContext::resetStats() {
     fGpu->resetStats();
 }
@@ -1031,13 +1075,16 @@
     return 0 != bits;
 }
 
-GrDrawTarget* GrContext::getTextTarget() {
+GrDrawTarget* GrContext::getTextTarget(const GrPaint& paint) {
+    GrDrawTarget* target;
 #if DEFER_TEXT_RENDERING
     fTextDrawBuffer.initializeDrawStateAndClip(*fGpu);
-    return &fTextDrawBuffer;
+    target = &fTextDrawBuffer;
 #else
-    return fGpu;
+    target = fGpu;
 #endif
+    SetPaint(paint, target);
+    return target;
 }
 
 const GrIndexBuffer* GrContext::quadIndexBuffer() const {
@@ -1050,4 +1097,3 @@
 
 
 
-
diff --git a/gpu/src/GrDrawTarget.cpp b/gpu/src/GrDrawTarget.cpp
index df0f0be..abc9fb4 100644
--- a/gpu/src/GrDrawTarget.cpp
+++ b/gpu/src/GrDrawTarget.cpp
@@ -22,7 +22,7 @@
 // one stage
 template <int N>
 static int stage_mask_recur(int stage) {
-    return GrDrawTarget::StageTexCoordVertexLayoutBit(stage, N) | 
+    return GrDrawTarget::StageTexCoordVertexLayoutBit(stage, N) |
            stage_mask_recur<N+1>(stage);
 }
 template<> // linux build doesn't like static on specializations
@@ -35,7 +35,7 @@
 
 // mask of all bits relevant to one stage
 static int stage_mask(int stage) {
-    return stage_tex_coord_mask(stage) | 
+    return stage_tex_coord_mask(stage) |
            GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(stage);
 }
 
@@ -43,7 +43,7 @@
 // texture coordinate index
 template <int N>
 static int tex_coord_mask_recur(int texCoordIdx) {
-    return GrDrawTarget::StageTexCoordVertexLayoutBit(N, texCoordIdx) | 
+    return GrDrawTarget::StageTexCoordVertexLayoutBit(N, texCoordIdx) |
            tex_coord_mask_recur<N+1>(texCoordIdx);
 }
 template<> // linux build doesn't like static on specializations
@@ -67,8 +67,8 @@
 
 size_t GrDrawTarget::VertexSize(GrVertexLayout vertexLayout) {
     GrAssert(check_layout(vertexLayout));
-    
-    size_t vecSize = (vertexLayout & kTextFormat_VertexLayoutBit) ? 
+
+    size_t vecSize = (vertexLayout & kTextFormat_VertexLayoutBit) ?
                         sizeof(GrGpuTextVertex) :
                         sizeof(GrPoint);
 
@@ -91,8 +91,8 @@
     }
     int tcIdx = VertexTexCoordsForStage(stage, vertexLayout);
     if (tcIdx >= 0) {
-        
-        int vecSize = (vertexLayout & kTextFormat_VertexLayoutBit) ? 
+
+        int vecSize = (vertexLayout & kTextFormat_VertexLayoutBit) ?
                                     sizeof(GrGpuTextVertex) :
                                     sizeof(GrPoint);
         int offset = vecSize; // position
@@ -110,9 +110,9 @@
 
 int  GrDrawTarget::VertexColorOffset(GrVertexLayout vertexLayout) {
     GrAssert(check_layout(vertexLayout));
-    
+
     if (vertexLayout & kColor_VertexLayoutBit) {
-        int vecSize = (vertexLayout & kTextFormat_VertexLayoutBit) ? 
+        int vecSize = (vertexLayout & kTextFormat_VertexLayoutBit) ?
                                     sizeof(GrGpuTextVertex) :
                                     sizeof(GrPoint);
         int offset = vecSize; // position
@@ -131,15 +131,15 @@
                                              int texCoordOffsetsByIdx[kMaxTexCoords],
                                              int* colorOffset) {
     GrAssert(check_layout(vertexLayout));
-    
+
     GrAssert(NULL != texCoordOffsetsByIdx);
     GrAssert(NULL != colorOffset);
 
-    int vecSize = (vertexLayout & kTextFormat_VertexLayoutBit) ? 
+    int vecSize = (vertexLayout & kTextFormat_VertexLayoutBit) ?
                                                     sizeof(GrGpuTextVertex) :
                                                     sizeof(GrPoint);
     int size = vecSize; // position
-    
+
     for (int t = 0; t < kMaxTexCoords; ++t) {
         if (tex_coord_idx_mask(t) & vertexLayout) {
             texCoordOffsetsByIdx[t] = size;
@@ -164,10 +164,10 @@
 
     GrAssert(NULL != texCoordOffsetsByStage);
     GrAssert(NULL != colorOffset);
-    
+
     int texCoordOffsetsByIdx[kMaxTexCoords];
-    int size = VertexSizeAndOffsetsByIdx(vertexLayout, 
-                                         texCoordOffsetsByIdx, 
+    int size = VertexSizeAndOffsetsByIdx(vertexLayout,
+                                         texCoordOffsetsByIdx,
                                          colorOffset);
     for (int s = 0; s < kNumStages; ++s) {
         int tcIdx;
@@ -179,7 +179,7 @@
             texCoordOffsetsByStage[s] = -1;
         }
     }
-    return size;    
+    return size;
 }
 
 bool GrDrawTarget::VertexUsesStage(int stage, GrVertexLayout vertexLayout) {
@@ -188,9 +188,9 @@
     return !!(stage_mask(stage) & vertexLayout);
 }
 
-bool GrDrawTarget::VertexUsesTexCoordIdx(int coordIndex, 
+bool GrDrawTarget::VertexUsesTexCoordIdx(int coordIndex,
                                          GrVertexLayout vertexLayout) {
-    GrAssert(coordIndex < kMaxTexCoords);     
+    GrAssert(coordIndex < kMaxTexCoords);
     GrAssert(check_layout(vertexLayout));
     return !!(tex_coord_idx_mask(coordIndex) & vertexLayout);
 }
@@ -222,7 +222,7 @@
             for (int t = 0; t < kMaxTexCoords; ++t) {
                 stageMask |= StageTexCoordVertexLayoutBit(s,t);
             }
-            GrAssert(1 == kMaxTexCoords || !check_layout(stageMask));            
+            GrAssert(1 == kMaxTexCoords || !check_layout(stageMask));
             GrAssert(stage_tex_coord_mask(s) == stageMask);
             stageMask |= StagePosAsTexCoordVertexLayoutBit(s);
             GrAssert(stage_mask(s) == stageMask);
@@ -242,7 +242,7 @@
                     GrAssert(-1 == VertexStageCoordOffset(s2, tcMask));
                     GrAssert(!VertexUsesStage(s2, tcMask));
                     GrAssert(-1 == VertexTexCoordsForStage(s2, tcMask));
-                    
+
                     GrVertexLayout posAsTex = tcMask | StagePosAsTexCoordVertexLayoutBit(s2);
                     GrAssert(0 == VertexStageCoordOffset(s2, posAsTex));
                     GrAssert(VertexUsesStage(s2, posAsTex));
@@ -255,7 +255,7 @@
             }
             GrAssert(tex_coord_idx_mask(t) == tcMask);
             GrAssert(check_layout(tcMask));
-            
+
             int stageOffsets[kNumStages];
             int colorOffset;
             int size;
@@ -300,7 +300,12 @@
     fCurrDrawState.fTextures[stage] = tex;
 }
 
-GrTexture* GrDrawTarget::currentTexture(int stage) const {
+const GrTexture* GrDrawTarget::getTexture(int stage) const {
+    GrAssert(stage >= 0 && stage < kNumStages);
+    return fCurrDrawState.fTextures[stage];
+}
+
+GrTexture* GrDrawTarget::getTexture(int stage) {
     GrAssert(stage >= 0 && stage < kNumStages);
     return fCurrDrawState.fTextures[stage];
 }
@@ -309,7 +314,11 @@
     fCurrDrawState.fRenderTarget = target;
 }
 
-GrRenderTarget* GrDrawTarget::currentRenderTarget() const {
+const GrRenderTarget* GrDrawTarget::getRenderTarget() const {
+    return fCurrDrawState.fRenderTarget;
+}
+
+GrRenderTarget* GrDrawTarget::getRenderTarget() {
     return fCurrDrawState.fRenderTarget;
 }
 
@@ -321,13 +330,12 @@
     fCurrDrawState.fViewMatrix.preConcat(matrix);
 }
 
-// Can't this just return a const&
-void GrDrawTarget::getViewMatrix(GrMatrix* matrix) const {
-    *matrix = fCurrDrawState.fViewMatrix;
+const GrMatrix& GrDrawTarget::getViewMatrix() const {
+    return fCurrDrawState.fViewMatrix;
 }
 
 bool GrDrawTarget::getViewInverse(GrMatrix* matrix) const {
-    // Mike:  Can we cache this somewhere? 
+    // Mike:  Can we cache this somewhere?
     // Brian: Sure, do we use it often?
 
     GrMatrix inverse;
@@ -366,10 +374,6 @@
     fCurrDrawState.fFlagBits &= ~(bits);
 }
 
-void GrDrawTarget::setPointSize(float size) {
-    fCurrDrawState.fPointSize = size;
-}
-
 void GrDrawTarget::setBlendFunc(BlendCoeff srcCoef,
                                 BlendCoeff dstCoef) {
     fCurrDrawState.fSrcBlend = srcCoef;
diff --git a/gpu/src/GrGpuGL.cpp b/gpu/src/GrGpuGL.cpp
index 63cf237..1dbc5fb 100644
--- a/gpu/src/GrGpuGL.cpp
+++ b/gpu/src/GrGpuGL.cpp
@@ -415,7 +415,6 @@
     fHWDrawState.fSrcBlend = (BlendCoeff)-1;
     fHWDrawState.fDstBlend = (BlendCoeff)-1;
     fHWDrawState.fColor = GrColor_ILLEGAL;
-    fHWDrawState.fPointSize = -1;
 
     fHWDrawState.fViewMatrix.setScale(GR_ScalarMax, GR_ScalarMax); // illegal
 
@@ -501,6 +500,8 @@
                                 this);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+
 // defines stencil formats from more to less preferred
 GLenum GR_GL_STENCIL_FORMAT_ARRAY[] = {
     GR_STENCIL_INDEX8,
@@ -852,7 +853,7 @@
                 // bind the stencil to rt fbo if present, othewise the tex fbo
                 GR_GLEXT(fExts, FramebufferRenderbuffer(GR_FRAMEBUFFER,
                                                  GR_STENCIL_ATTACHMENT,
-                                                GR_RENDERBUFFER,
+                                                 GR_RENDERBUFFER,
                                                  rtIDs.fStencilRenderbufferID));
             }
             status = GR_GLEXT(fExts, CheckFramebufferStatus(GR_FRAMEBUFFER));
diff --git a/gpu/src/GrGpuGL.h b/gpu/src/GrGpuGL.h
index 611485d..dbc5de3 100644
--- a/gpu/src/GrGpuGL.h
+++ b/gpu/src/GrGpuGL.h
@@ -85,7 +85,7 @@
 
     void eraseStencil(uint32_t value, uint32_t mask);
     virtual void eraseStencilClip();
-    
+
     void setTextureUnit(int unitIdx);
 
     // flushes state that is common to fixed and programmable GL
@@ -123,7 +123,7 @@
     void notifyTextureDelete(GrGLTexture* texture);
     void notifyRenderTargetDelete(GrRenderTarget* renderTarget);
     void notifyTextureRemoveRenderTarget(GrGLTexture* texture);
-    
+
     void setSpareTextureUnit();
 
     void flushRenderTarget();
@@ -156,9 +156,9 @@
 
     // ES requires an extension to support RGBA8 in RenderBufferStorage
     bool fRGBA8Renderbuffer;
-    
+
     int fActiveTextureUnitIdx;
-    
+
     typedef GrGpu INHERITED;
 };
 
diff --git a/gpu/src/GrGpuGLFixed.cpp b/gpu/src/GrGpuGLFixed.cpp
index 99a593d..3fd8d5c 100644
--- a/gpu/src/GrGpuGLFixed.cpp
+++ b/gpu/src/GrGpuGLFixed.cpp
@@ -26,26 +26,26 @@
 
 struct GrGpuMatrix {
     GrScalar    fMat[16];
-    
+
     void reset() {
         Gr_bzero(fMat, sizeof(fMat));
         fMat[0] = fMat[5] = fMat[10] = fMat[15] = GR_Scalar1;
     }
-    
+
     void set(const GrMatrix& m) {
         Gr_bzero(fMat, sizeof(fMat));
         fMat[0]  = m[GrMatrix::kScaleX];
         fMat[4]  = m[GrMatrix::kSkewX];
         fMat[12] = m[GrMatrix::kTransX];
-        
+
         fMat[1]  = m[GrMatrix::kSkewY];
         fMat[5]  = m[GrMatrix::kScaleY];
         fMat[13] = m[GrMatrix::kTransY];
-        
+
         fMat[3]  = m[GrMatrix::kPersp0];
         fMat[7]  = m[GrMatrix::kPersp1];
         fMat[15] = m[GrMatrix::kPersp2];
-        
+
         fMat[10] = GR_Scalar1;    // z-scale
     }
 };
@@ -74,7 +74,7 @@
 
     for (int s = 0; s < kNumStages; ++s) {
         setTextureUnit(s);
-        GR_GL(EnableClientState(GL_VERTEX_ARRAY));    
+        GR_GL(EnableClientState(GL_VERTEX_ARRAY));
         GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE));
         GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,   GL_MODULATE));
         GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB,      GL_TEXTURE0+s));
@@ -86,12 +86,12 @@
         GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA));
         GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_SRC1_ALPHA, GL_PREVIOUS));
         GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA));
-        
-        // color oprand0 changes between GL_SRC_COLR and GL_SRC_ALPHA depending 
-        // upon whether we have a (premultiplied) RGBA texture or just an ALPHA 
+
+        // color oprand0 changes between GL_SRC_COLR and GL_SRC_ALPHA depending
+        // upon whether we have a (premultiplied) RGBA texture or just an ALPHA
         // texture, e.g.:
         //glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB,  GL_SRC_COLOR);
-        fHWRGBOperand0[s] = (TextureEnvRGBOperands) -1;    
+        fHWRGBOperand0[s] = (TextureEnvRGBOperands) -1;
     }
 
     fHWGeometryState.fVertexLayout = 0;
@@ -100,11 +100,13 @@
     GR_GL(DisableClientState(GL_TEXTURE_COORD_ARRAY));
     GR_GL(ShadeModel(GL_FLAT));
     GR_GL(DisableClientState(GL_COLOR_ARRAY));
-    
+
+    GR_GL(PointSize(1.f));
+
     GrGLClearErr();
     fTextVerts = false;
 
-    fHWTextureOrientation = (GrGLTexture::Orientation)-1; // illegal    
+    fHWTextureOrientation = (GrGLTexture::Orientation)-1; // illegal
     fBaseVertex = 0xffffffff;
 }
 
@@ -112,25 +114,25 @@
 void GrGpuGLFixed::flushProjectionMatrix() {
     float mat[16];
     Gr_bzero(mat, sizeof(mat));
-    
+
     GrAssert(NULL != fCurrDrawState.fRenderTarget);
-    
+
     mat[0] = 2.f / fCurrDrawState.fRenderTarget->width();
     mat[5] = -2.f / fCurrDrawState.fRenderTarget->height();
     mat[10] = -1.f;
     mat[15] = 1;
-    
+
     mat[12] = -1.f;
     mat[13] = 1.f;
-    
+
     GR_GL(MatrixMode(GL_PROJECTION));
     GR_GL(LoadMatrixf(mat));
 }
 
 bool GrGpuGLFixed::flushGraphicsState(PrimitiveType type) {
-    
+
     bool usingTextures[kNumStages];
-    
+
     for (int s = 0; s < kNumStages; ++s) {
         usingTextures[s] = VertexUsesStage(s, fGeometrySrc.fVertexLayout);
 
@@ -139,16 +141,16 @@
             return false;
         }
     }
-    
+
     if (!flushGLStateCommon(type)) {
         return false;
     }
 
-    if (fRenderTargetChanged) {    
+    if (fRenderTargetChanged) {
         flushProjectionMatrix();
         fRenderTargetChanged = false;
     }
-    
+
     for (int s = 0; s < kNumStages; ++s) {
         bool wasUsingTexture = VertexUsesStage(s, fHWGeometryState.fVertexLayout);
         if (usingTextures[s] != wasUsingTexture) {
@@ -160,11 +162,11 @@
             }
         }
     }
-        
+
     uint32_t vertColor = (fGeometrySrc.fVertexLayout & kColor_VertexLayoutBit);
-    uint32_t prevVertColor = (fHWGeometryState.fVertexLayout & 
+    uint32_t prevVertColor = (fHWGeometryState.fVertexLayout &
                               kColor_VertexLayoutBit);
-    
+
     if (vertColor != prevVertColor) {
         if (vertColor) {
             GR_GL(ShadeModel(GL_SMOOTH));
@@ -175,12 +177,7 @@
         }
     }
 
-    if (kPoints_PrimitiveType == type &&
-        fHWDrawState.fPointSize != fCurrDrawState.fPointSize) {
-        GR_GL(PointSize(fCurrDrawState.fPointSize));
-        fHWDrawState.fPointSize = fCurrDrawState.fPointSize;
-    }
-    
+
     if (!vertColor && fHWDrawState.fColor != fCurrDrawState.fColor) {
         GR_GL(Color4ub(GrColorUnpackR(fCurrDrawState.fColor),
                        GrColorUnpackG(fCurrDrawState.fColor),
@@ -194,25 +191,25 @@
         if (usingTextures[s]) {
             GrGLTexture* texture = (GrGLTexture*)fCurrDrawState.fTextures[s];
             if (NULL != texture) {
-                TextureEnvRGBOperands nextRGBOperand0 = 
-                    (texture->config() == GrTexture::kAlpha_8_PixelConfig) ? 
-                        kAlpha_TextureEnvRGBOperand : 
+                TextureEnvRGBOperands nextRGBOperand0 =
+                    (texture->config() == GrTexture::kAlpha_8_PixelConfig) ?
+                        kAlpha_TextureEnvRGBOperand :
                         kColor_TextureEnvRGBOperand;
                 if (fHWRGBOperand0[s] != nextRGBOperand0) {
                     setTextureUnit(s);
-                    GR_GL(TexEnvi(GL_TEXTURE_ENV, 
+                    GR_GL(TexEnvi(GL_TEXTURE_ENV,
                                   GL_OPERAND0_RGB,
-                                  (nextRGBOperand0==kAlpha_TextureEnvRGBOperand) ? 
-                                    GL_SRC_ALPHA : 
+                                  (nextRGBOperand0==kAlpha_TextureEnvRGBOperand) ?
+                                    GL_SRC_ALPHA :
                                     GL_SRC_COLOR));
                     fHWRGBOperand0[s] = nextRGBOperand0;
                 }
-                
+
                 if (fHWTextureOrientation != texture->orientation() ||
-                    fHWDrawState.fTextureMatrices[s] != 
+                    fHWDrawState.fTextureMatrices[s] !=
                     fCurrDrawState.fTextureMatrices[s]) {
                     GrGpuMatrix glm;
-                    if (GrGLTexture::kBottomUp_Orientation == 
+                    if (GrGLTexture::kBottomUp_Orientation ==
                         texture->orientation()) {
                         GrMatrix m(
                             GR_Scalar1, 0, 0,
@@ -227,7 +224,7 @@
                     setTextureUnit(s);
                     GR_GL(MatrixMode(GL_TEXTURE));
                     GR_GL(LoadMatrixf(glm.fMat));
-                    fHWDrawState.fTextureMatrices[s] = 
+                    fHWDrawState.fTextureMatrices[s] =
                                             fCurrDrawState.fTextureMatrices[s];
                     fHWTextureOrientation = texture->orientation();
                 }
@@ -243,7 +240,7 @@
         glm.set(fCurrDrawState.fViewMatrix);
         GR_GL(MatrixMode(GL_MODELVIEW));
         GR_GL(LoadMatrixf(glm.fMat));
-        fHWDrawState.fViewMatrix = 
+        fHWDrawState.fViewMatrix =
         fCurrDrawState.fViewMatrix;
     }
     return true;
@@ -253,49 +250,49 @@
                                  uint32_t startIndex,
                                  uint32_t vertexCount,
                                  uint32_t indexCount) {
-    
+
     int newColorOffset;
     int newTexCoordOffsets[kNumStages];
-    
+
     GLsizei newStride = VertexSizeAndOffsetsByStage(fGeometrySrc.fVertexLayout,
-                                                    newTexCoordOffsets, 
+                                                    newTexCoordOffsets,
                                                     &newColorOffset);
     int oldColorOffset;
     int oldTexCoordOffsets[kNumStages];
     GLsizei oldStride = VertexSizeAndOffsetsByStage(fHWGeometryState.fVertexLayout,
-                                                    oldTexCoordOffsets, 
+                                                    oldTexCoordOffsets,
                                                     &oldColorOffset);
-    
+
     const GLvoid* posPtr = (GLvoid*)(newStride * startVertex);
-    
+
     if (kBuffer_GeometrySrcType == fGeometrySrc.fVertexSrc) {
         GrAssert(NULL != fGeometrySrc.fVertexBuffer);
         GrAssert(!fGeometrySrc.fVertexBuffer->isLocked());
         if (fHWGeometryState.fVertexBuffer != fGeometrySrc.fVertexBuffer) {
-            GrGLVertexBuffer* buf = 
+            GrGLVertexBuffer* buf =
                             (GrGLVertexBuffer*)fGeometrySrc.fVertexBuffer;
             GR_GL(BindBuffer(GL_ARRAY_BUFFER, buf->bufferID()));
             fHWGeometryState.fVertexBuffer = fGeometrySrc.fVertexBuffer;
         }
-    } else { 
+    } else {
         if (kArray_GeometrySrcType == fGeometrySrc.fVertexSrc) {
-            posPtr = (void*)((intptr_t)fGeometrySrc.fVertexArray + 
+            posPtr = (void*)((intptr_t)fGeometrySrc.fVertexArray +
                              (intptr_t)posPtr);
         } else {
             GrAssert(kReserved_GeometrySrcType == fGeometrySrc.fVertexSrc);
-            posPtr = (void*)((intptr_t)fVertices.get() + (intptr_t)posPtr);            
+            posPtr = (void*)((intptr_t)fVertices.get() + (intptr_t)posPtr);
         }
         if (NULL != fHWGeometryState.fVertexBuffer) {
             GR_GL(BindBuffer(GL_ARRAY_BUFFER, 0));
             fHWGeometryState.fVertexBuffer = NULL;
         }
     }
-    
+
     if (kBuffer_GeometrySrcType == fGeometrySrc.fIndexSrc) {
         GrAssert(NULL != fGeometrySrc.fIndexBuffer);
         GrAssert(!fGeometrySrc.fIndexBuffer->isLocked());
         if (fHWGeometryState.fIndexBuffer != fGeometrySrc.fIndexBuffer) {
-            GrGLIndexBuffer* buf = 
+            GrGLIndexBuffer* buf =
             (GrGLIndexBuffer*)fGeometrySrc.fIndexBuffer;
             GR_GL(BindBuffer(GL_ELEMENT_ARRAY_BUFFER, buf->bufferID()));
             fHWGeometryState.fIndexBuffer = fGeometrySrc.fIndexBuffer;
@@ -304,29 +301,29 @@
         GR_GL(BindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
         fHWGeometryState.fIndexBuffer = NULL;
     }
-    
+
     GLenum scalarType;
     if (fGeometrySrc.fVertexLayout & kTextFormat_VertexLayoutBit) {
         scalarType = GrGLTextType;
     } else {
         scalarType = GrGLType;
     }
-    
+
     bool baseChange = posPtr != fHWGeometryState.fPositionPtr;
-    bool scalarChange = 
+    bool scalarChange =
         (GrGLTextType != GrGLType) &&
         (kTextFormat_VertexLayoutBit &
          (fHWGeometryState.fVertexLayout ^ fGeometrySrc.fVertexLayout));
     bool strideChange = newStride != oldStride;
     bool posChange = baseChange || scalarChange || strideChange;
-    
+
     if (posChange) {
         GR_GL(VertexPointer(2, scalarType, newStride, posPtr));
         fHWGeometryState.fPositionPtr = posPtr;
     }
-    
+
     for (int s = 0; s < kNumStages; ++s) {
-        // need to enable array if tex coord offset is 0 
+        // need to enable array if tex coord offset is 0
         // (using positions as coords)
         if (newTexCoordOffsets[s] >= 0) {
             GLvoid* texCoordPtr = (int8_t*)posPtr + newTexCoordOffsets[s];
@@ -343,7 +340,7 @@
             GR_GL(DisableClientState(GL_TEXTURE_COORD_ARRAY));
         }
     }
-    
+
     if (newColorOffset > 0) {
         GLvoid* colorPtr = (int8_t*)posPtr + newColorOffset;
         if (oldColorOffset <= 0) {
@@ -355,7 +352,7 @@
     } else if (oldColorOffset > 0) {
         GR_GL(DisableClientState(GL_COLOR_ARRAY));
     }
-    
+
     fHWGeometryState.fVertexLayout = fGeometrySrc.fVertexLayout;
 }
 
diff --git a/gpu/src/GrTextContext.cpp b/gpu/src/GrTextContext.cpp
index 0a777d6..59a907e 100644
--- a/gpu/src/GrTextContext.cpp
+++ b/gpu/src/GrTextContext.cpp
@@ -23,7 +23,7 @@
 #include "GrTextStrike_impl.h"
 #include "GrFontScaler.h"
 
-static const GrVertexLayout VLAYOUT = 
+static const GrVertexLayout VLAYOUT =
                                 GrDrawTarget::kTextFormat_VertexLayoutBit |
                                 GrDrawTarget::StageTexCoordVertexLayoutBit(0,0);
 
@@ -57,7 +57,9 @@
     }
 }
 
-GrTextContext::GrTextContext(GrContext* context, const GrMatrix* extMatrix) {
+GrTextContext::GrTextContext(GrContext* context,
+                             const GrPaint& paint,
+                             const GrMatrix* extMatrix) : fPaint(paint) {
     fContext = context;
     fStrike = NULL;
 
@@ -80,17 +82,17 @@
         }
     }
 
-    fContext->getViewMatrix(&fOrigViewMatrix);
-    fContext->setViewMatrix(fExtMatrix);
+    fOrigViewMatrix = fContext->getMatrix();
+    fContext->setMatrix(fExtMatrix);
 
     fVertices = NULL;
     fMaxVertices = 0;
-    fDrawTarget = fContext->getTextTarget();
+    fDrawTarget = fContext->getTextTarget(fPaint);
 }
 
 GrTextContext::~GrTextContext() {
     this->flushGlyphs();
-    fContext->setViewMatrix(fOrigViewMatrix);
+    fContext->setMatrix(fOrigViewMatrix);
 }
 
 void GrTextContext::flush() {
@@ -161,12 +163,11 @@
             glyph->fPath = path;
         }
         GrPath::Iter iter(*glyph->fPath);
-        bool useTexture = false;
         GrPoint translate;
         translate.set(GrFixedToScalar(vx - GrIntToFixed(glyph->fBounds.fLeft)),
                       GrFixedToScalar(vy - GrIntToFixed(glyph->fBounds.fTop)));
-        fContext->drawPath(&iter, GrContext::kWinding_PathFill,
-                              useTexture, &translate);
+        fContext->drawPath(fPaint, &iter, GrContext::kWinding_PathFill,
+                           &translate);
         return;
     }
 
@@ -196,7 +197,7 @@
         if (flush) {
             this->flushGlyphs();
             fContext->flushText();
-            fDrawTarget = fContext->getTextTarget();
+            fDrawTarget = fContext->getTextTarget(fPaint);
             fMaxVertices = kDefaultRequestedVerts;
             // ignore return, no point in flushing again.
             fDrawTarget->geometryHints(VLAYOUT,
diff --git a/include/gpu/SkGpuDevice.h b/include/gpu/SkGpuDevice.h
index 9c612c5..49a14da 100644
--- a/include/gpu/SkGpuDevice.h
+++ b/include/gpu/SkGpuDevice.h
@@ -143,6 +143,7 @@
 
 private:
     GrContext*      fContext;
+
     GrSkDrawProcs*  fDrawProcs;
 
     // state for our offscreen render-target
@@ -152,28 +153,27 @@
     bool            fNeedClear;
     bool            fNeedPrepareRenderTarget;
 
-    SkDrawProcs* initDrawForText(const SkPaint&, GrTextContext*);
-    bool bindDeviceAsTexture(SkPoint* max);
+    // doesn't set the texture/sampler/matrix state
+    // caller needs to null out GrPaint's texture if
+    // non-textured drawing is desired.
+    bool skPaint2GrPaintNoShader(const SkPaint& skPaint,
+                                 bool justAlpha,
+                                 GrPaint* grPaint);
+
+    // uses the SkShader to setup paint, act used to
+    // hold lock on cached texture and free it when
+    // destroyed.
+    bool skPaint2GrPaintShader(const SkPaint& skPaint,
+                               SkAutoCachedTexture* act,
+                               const SkMatrix& ctm,
+                               GrPaint* grPaint);
+
+    SkDrawProcs* initDrawForText(GrTextContext*);
+    bool bindDeviceAsTexture(GrPaint* paint, SkPoint* max);
 
     void prepareRenderTarget(const SkDraw&);
     void internalDrawBitmap(const SkDraw&, const SkBitmap&,
-                            const SkIRect&, const SkMatrix&, const SkPaint&);
-
-    class AutoPaintShader {
-    public:
-        AutoPaintShader();
-        AutoPaintShader(SkGpuDevice*, const SkPaint& paint, const SkMatrix&);
-
-        void init(SkGpuDevice*, const SkPaint& paint, const SkMatrix&);
-
-        bool failed() const { return !fSuccess; }
-        bool useTex() const { return fTexture != 0; }
-    private:
-        GrTexture*              fTexture;
-        SkAutoCachedTexture     fCachedTexture;
-        bool                    fSuccess;
-    };
-    friend class AutoPaintShader;
+                            const SkIRect&, const SkMatrix&, GrPaint* grPaint);
 
     typedef SkDevice INHERITED;
 };
diff --git a/include/gpu/SkGr.h b/include/gpu/SkGr.h
index 4e9801f..2987639 100644
--- a/include/gpu/SkGr.h
+++ b/include/gpu/SkGr.h
@@ -55,7 +55,7 @@
     #endif
     #define SkScalarToGrScalar(x)       SkScalarToFloat(x)
 
-#else 
+#else
     #error "Ganesh scalar type not defined"
 #endif
 
@@ -72,7 +72,7 @@
 GR_STATIC_ASSERT((int)GrSamplerState::kClamp_WrapMode == (int)SkShader::kClamp_TileMode);
 GR_STATIC_ASSERT((int)GrSamplerState::kRepeat_WrapMode ==(
                  int)SkShader::kRepeat_TileMode);
-GR_STATIC_ASSERT((int)GrSamplerState::kMirror_WrapMode == 
+GR_STATIC_ASSERT((int)GrSamplerState::kMirror_WrapMode ==
                  (int)SkShader::kMirror_TileMode);
 
 #define sk_tile_mode_to_grwrap(X) ((GrSamplerState::WrapMode)(X))
@@ -117,13 +117,13 @@
         memcpy(dst, &src, sizeof(*dst));
         return *dst;
     }
-    
+
     static inline GrIRect& SetIRect(GrIRect* dst, const SkIRect& src) {
         GR_STATIC_ASSERT(sizeof(*dst) == sizeof(src));
         memcpy(dst, &src, sizeof(*dst));
         return *dst;
     }
-    
+
     /**
      *  Convert the SkBitmap::Config to the corresponding PixelConfig, or
      *  kUnknown_PixelConfig if the conversion cannot be done.
@@ -146,7 +146,7 @@
                   SkScalarToGrScalar(m[7]),
                   SkScalarToGrScalar(m[8]));
     }
-    
+
     static GrColor SkColor2GrColor(SkColor c) {
         SkPMColor pm = SkPreMultiplyColor(c);
         unsigned r = SkGetPackedR32(pm);
@@ -176,7 +176,7 @@
     virtual void rewind();
     virtual ConvexHint hint() const;
 private:
-    
+
 #if !SK_SCALAR_IS_GR_SCALAR
     SkPoint             fPoints[4];
 #endif
@@ -190,9 +190,9 @@
         fIter.reset(clip);
         this->invalidateBoundsCache();
     }
-    
+
     // overrides
-    
+
     virtual bool isDone() { return fIter.done(); }
     virtual void getRect(GrIRect* rect) {
         SkGr::SetIRect(rect, fIter.rect());
@@ -228,11 +228,10 @@
 ////////////////////////////////////////////////////////////////////////////////
 // Helper functions
 
-GrTextureEntry* sk_gr_create_bitmap_texture(GrContext* ctx, 
+GrTextureEntry* sk_gr_create_bitmap_texture(GrContext* ctx,
                                             GrTextureKey* key,
                                             const GrSamplerState& sampler,
                                             const SkBitmap& bitmap);
 
-void sk_gr_set_paint(GrContext* ctx, const SkPaint& paint, bool justAlpha = false);
 
 #endif
diff --git a/samplecode/SampleApp.cpp b/samplecode/SampleApp.cpp
index bf8cb6b..e77562a 100644
--- a/samplecode/SampleApp.cpp
+++ b/samplecode/SampleApp.cpp
@@ -167,7 +167,6 @@
     SkPicture* fPicture;
     SkGpuCanvas* fGpuCanvas;
     GrContext* fGrContext;
-    GrRenderTarget* fGrRenderTarget;
     SkPath fClipPath;
 
     enum CanvasType {
@@ -219,19 +218,14 @@
     #endif
 
     if (NULL == fGrContext) {
-        SkASSERT(NULL == fGrRenderTarget);
     #if defined(SK_USE_SHADERS)
         fGrContext = GrContext::Create(GrGpu::kOpenGL_Shaders_Engine, NULL);
     #else
         fGrContext = GrContext::Create(GrGpu::kOpenGL_Fixed_Engine, NULL);
     #endif
-        if (NULL != fGrContext) {
-            fGrRenderTarget = fGrContext->createRenderTargetFrom3DApiState();
-        }
     }
 
     if (NULL != fGrContext) {
-        SkASSERT(NULL != fGrRenderTarget);
         return true;
     } else {
         detachGL();
@@ -255,7 +249,6 @@
     fGpuCanvas = NULL;
 
     fGrContext = NULL;
-    fGrRenderTarget = NULL;
 
 #ifdef DEFAULT_TO_GPU
     fCanvasType = kGPU_CanvasType;
@@ -291,9 +284,6 @@
 SampleWindow::~SampleWindow() {
     delete fPicture;
     delete fGpuCanvas;
-    if (NULL != fGrRenderTarget) {
-        fGrRenderTarget->unref();
-    }
     if (NULL != fGrContext) {
         fGrContext->unref();
     }
@@ -414,7 +404,11 @@
                 SkDevice* device = canvas->getDevice();
                 const SkBitmap& bitmap = device->accessBitmap(true);
 
-                fGpuCanvas = new SkGpuCanvas(fGrContext, fGrRenderTarget);
+                GrRenderTarget* renderTarget;
+                renderTarget = fGrContext->createRenderTargetFrom3DApiState();
+                fGpuCanvas = new SkGpuCanvas(fGrContext, renderTarget);
+                renderTarget->unref();
+
                 device = fGpuCanvas->createDevice(SkBitmap::kARGB_8888_Config,
                                                   bitmap.width(), bitmap.height(),
                                                   false, false);
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index f14de35..11f030e 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -82,7 +82,6 @@
     if (texture) {
         // return the native texture
         fTex = NULL;
-        device->context()->setTexture(0, texture);
     } else {
         // look it up in our cache
         fTex = device->lockCachedTexture(bitmap, sampler, &texture, false);
@@ -121,8 +120,8 @@
     fNeedPrepareRenderTarget = false;
     fDrawProcs = NULL;
 
-    // should I ref() this, and then unref in destructor? <mrr>
     fContext = context;
+    fContext->ref();
 
     fCache = NULL;
     fTexture = NULL;
@@ -197,6 +196,7 @@
     } else if (NULL != fRenderTarget) {
         fRenderTarget->unref();
     }
+    fContext->unref();
 }
 
 intptr_t SkGpuDevice::getLayerTextureHandle() const {
@@ -271,7 +271,7 @@
                                const SkRegion& clip) {
     GrMatrix grmat;
     SkGr::SkMatrix2GrMatrix(matrix, &grmat);
-    context->setViewMatrix(grmat);
+    context->setMatrix(grmat);
 
     SkGrClipIterator iter;
     iter.reset(clip);
@@ -286,7 +286,7 @@
 // and not the state from some other canvas/device
 void SkGpuDevice::prepareRenderTarget(const SkDraw& draw) {
     if (fNeedPrepareRenderTarget ||
-        fContext->currentRenderTarget() != fRenderTarget) {
+        fContext->getRenderTarget() != fRenderTarget) {
 
         fContext->setRenderTarget(fRenderTarget);
         convert_matrixclip(fContext, *draw.fMatrix, *draw.fClip);
@@ -314,9 +314,9 @@
     }
 }
 
-bool SkGpuDevice::bindDeviceAsTexture(SkPoint* max) {
+bool SkGpuDevice::bindDeviceAsTexture(GrPaint* paint, SkPoint* max) {
     if (NULL != fTexture) {
-        fContext->setTexture(0, fTexture);
+        paint->setTexture(fTexture);
         if (NULL != max) {
             max->set(SkFixedToScalar((width() << 16) /
                                      fTexture->allocWidth()),
@@ -330,39 +330,68 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-// must be in the same order as SkXfermode::Coeff in SkXfermode.h
+// must be in SkShader::BitmapTypeOrder
 
-SkGpuDevice::AutoPaintShader::AutoPaintShader() {
-    fSuccess = false;
-    fTexture = NULL;
+static const GrSamplerState::SampleMode sk_bmp_type_to_sample_mode[] = {
+    (GrSamplerState::SampleMode) -1,                    // kNone_BitmapType
+    GrSamplerState::kNormal_SampleMode,                 // kDefault_BitmapType
+    GrSamplerState::kRadial_SampleMode,                 // kRadial_BitmapType
+    GrSamplerState::kSweep_SampleMode,                  // kSweep_BitmapType
+    GrSamplerState::kRadial2_SampleMode,                // kTwoPointRadial_BitmapType
+};
+
+bool SkGpuDevice::skPaint2GrPaintNoShader(const SkPaint& skPaint,
+                                          bool justAlpha,
+                                          GrPaint* grPaint) {
+
+    grPaint->fDither    = skPaint.isDither();
+    grPaint->fAntiAlias = skPaint.isAntiAlias();
+
+    SkXfermode::Coeff sm = SkXfermode::kOne_Coeff;
+    SkXfermode::Coeff dm = SkXfermode::kISA_Coeff;
+
+    SkXfermode* mode = skPaint.getXfermode();
+    if (mode) {
+        if (!mode->asCoeff(&sm, &dm)) {
+            SkDebugf("Unsupported xfer mode.\n");
+#if 0
+            return false;
+#endif
+        }
+    }
+    grPaint->fSrcBlendCoeff = sk_blend_to_grblend(sm);
+    grPaint->fDstBlendCoeff = sk_blend_to_grblend(dm);
+
+    if (justAlpha) {
+        uint8_t alpha = skPaint.getAlpha();
+        grPaint->fColor = GrColorPackRGBA(alpha, alpha, alpha, alpha);
+    } else {
+        grPaint->fColor = SkGr::SkColor2GrColor(skPaint.getColor());
+        grPaint->setTexture(NULL);
+    }
+    return true;
 }
 
-SkGpuDevice::AutoPaintShader::AutoPaintShader(SkGpuDevice* device,
-                                              const SkPaint& paint,
-                                              const SkMatrix& matrix) {
-    fSuccess = false;
-    fTexture = NULL;
-    this->init(device, paint, matrix);
-}
+bool SkGpuDevice::skPaint2GrPaintShader(const SkPaint& skPaint,
+                                        SkAutoCachedTexture* act,
+                                        const SkMatrix& ctm,
+                                        GrPaint* grPaint) {
 
-void SkGpuDevice::AutoPaintShader::init(SkGpuDevice* device,
-                                        const SkPaint& paint,
-                                        const SkMatrix& ctm) {
-    fSuccess = true;
-    GrContext* ctx = device->context();
-    sk_gr_set_paint(ctx, paint); // should we pass true for justAlpha if we have a shader/texture?
+    SkASSERT(NULL != act);
 
-    SkShader* shader = paint.getShader();
+    SkShader* shader = skPaint.getShader();
     if (NULL == shader) {
-        return;
+        return this->skPaint2GrPaintNoShader(skPaint, false, grPaint);
+        grPaint->setTexture(NULL);
+        return true;
+    } else if (!this->skPaint2GrPaintNoShader(skPaint, true, grPaint)) {
+        return false;
     }
 
-    if (!shader->setContext(device->accessBitmap(false), paint, ctm)) {
-        fSuccess = false;
-        return;
-    }
+    SkPaint noAlphaPaint(skPaint);
+    noAlphaPaint.setAlpha(255);
+    shader->setContext(this->accessBitmap(false), noAlphaPaint, ctm);
 
-    GrSamplerState::SampleMode sampleMode;
     SkBitmap bitmap;
     SkMatrix matrix;
     SkShader::TileMode tileModes[2];
@@ -370,51 +399,28 @@
     SkShader::BitmapType bmptype = shader->asABitmap(&bitmap, &matrix,
                                                      tileModes, twoPointParams);
 
-    switch (bmptype) {
-    case SkShader::kNone_BitmapType:
-        SkDebugf("shader->asABitmap() == kNone_BitmapType");
-        return;
-    case SkShader::kDefault_BitmapType:
-        sampleMode = GrSamplerState::kNormal_SampleMode;
-        break;
-    case SkShader::kRadial_BitmapType:
-        sampleMode = GrSamplerState::kRadial_SampleMode;
-        break;
-    case SkShader::kSweep_BitmapType:
-        sampleMode = GrSamplerState::kSweep_SampleMode;
-        break;
-    case SkShader::kTwoPointRadial_BitmapType:
-        sampleMode = GrSamplerState::kRadial2_SampleMode;
-        break;
-    default:
-        SkASSERT("Unexpected return from asABitmap");
-        return;
+    GrSamplerState::SampleMode sampleMode = sk_bmp_type_to_sample_mode[bmptype];
+    if (-1 == sampleMode) {
+        SkDebugf("shader->asABitmap() == kNone_BitmapType\n");
+        return false;
     }
+    grPaint->fSampler.setSampleMode(sampleMode);
 
-    bitmap.lockPixels();
-    if (!bitmap.getTexture() && !bitmap.readyToDraw()) {
-        return;
-    }
-
-    // see if we've already cached the bitmap from the shader
-    GrSamplerState samplerState(sk_tile_mode_to_grwrap(tileModes[0]),
-                                sk_tile_mode_to_grwrap(tileModes[1]),
-                                sampleMode,
-                                paint.isFilterBitmap());
+    grPaint->fSampler.setWrapX(sk_tile_mode_to_grwrap(tileModes[0]));
+    grPaint->fSampler.setWrapY(sk_tile_mode_to_grwrap(tileModes[1]));
 
     if (GrSamplerState::kRadial2_SampleMode == sampleMode) {
-        samplerState.setRadial2Params(twoPointParams[0],
-                                      twoPointParams[1],
-                                      twoPointParams[2] < 0);
+        grPaint->fSampler.setRadial2Params(twoPointParams[0],
+                                           twoPointParams[1],
+                                           twoPointParams[2] < 0);
     }
 
-    GrTexture* texture = fCachedTexture.set(device, bitmap, samplerState);
+    GrTexture* texture = act->set(this, bitmap, grPaint->fSampler);
     if (NULL == texture) {
-        return;
+        SkDebugf("Couldn't convert bitmap to texture.\n");
+        return false;
     }
-
-    // the lock has already called setTexture for us
-    ctx->setSamplerState(0, samplerState);
+    grPaint->setTexture(texture);
 
     // since our texture coords will be in local space, we wack the texture
     // matrix to map them back into 0...1 before we load it
@@ -437,40 +443,161 @@
                      (bitmap.width() * texture->allocWidth());
         matrix.postScale(s, s);
     }
-    GrMatrix grmat;
-    SkGr::SkMatrix2GrMatrix(matrix, &grmat);
-    ctx->setTextureMatrix(0, grmat);
 
-    // since we're going to use a shader/texture, we don't want the color,
-    // just its alpha
-    ctx->setAlpha(paint.getAlpha());
-    // report that we have setup the texture
-    fSuccess = true;
-    fTexture = texture;
+    GrMatrix grmat;
+    SkGr::SkMatrix2GrMatrix(matrix, &grPaint->fTextureMatrix);
+
+    return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
+
+class SkPositionSource {
+public:
+    SkPositionSource(const SkPoint* points, int count)
+        : fPoints(points), fCount(count) {}
+
+    int count() const { return fCount; }
+
+    void writeValue(int i, GrPoint* dstPosition) const {
+        SkASSERT(i < fCount);
+        dstPosition->fX = SkScalarToGrScalar(fPoints[i].fX);
+        dstPosition->fY = SkScalarToGrScalar(fPoints[i].fY);
+    }
+private:
+    int             fCount;
+    const SkPoint*  fPoints;
+};
+
+class SkTexCoordSource {
+public:
+    SkTexCoordSource(const SkPoint* coords)
+        : fCoords(coords) {}
+
+    void writeValue(int i, GrPoint* dstCoord) const {
+        dstCoord->fX = SkScalarToGrScalar(fCoords[i].fX);
+        dstCoord->fY = SkScalarToGrScalar(fCoords[i].fY);
+    }
+private:
+    const SkPoint*  fCoords;
+};
+
+class SkColorSource {
+public:
+    SkColorSource(const SkColor* colors) : fColors(colors) {}
+
+    void writeValue(int i, GrColor* dstColor) const {
+        *dstColor = SkGr::SkColor2GrColor(fColors[i]);
+    }
+private:
+    const SkColor* fColors;
+};
+
+class SkIndexSource {
+public:
+    SkIndexSource(const uint16_t* indices, int count)
+        : fIndices(indices), fCount(count) {
+    }
+
+    int count() const { return fCount; }
+
+    void writeValue(int i, uint16_t* dstIndex) const {
+        *dstIndex = fIndices[i];
+    }
+
+private:
+    int             fCount;
+    const uint16_t* fIndices;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+// can be used for positions or texture coordinates
+class SkRectFanSource {
+public:
+    SkRectFanSource(const SkRect& rect) : fRect(rect) {}
+
+    int count() const { return 4; }
+
+    void writeValue(int i, GrPoint* dstPoint) const {
+        SkASSERT(i < 4);
+        dstPoint->fX = SkScalarToGrScalar((i % 3) ? fRect.fRight :
+                                                    fRect.fLeft);
+        dstPoint->fY = SkScalarToGrScalar((i < 2) ? fRect.fTop  :
+                                                    fRect.fBottom);
+    }
+private:
+    const SkRect&   fRect;
+};
+
+class SkIRectFanSource {
+public:
+    SkIRectFanSource(const SkIRect& rect) : fRect(rect) {}
+
+    int count() const { return 4; }
+
+    void writeValue(int i, GrPoint* dstPoint) const {
+        SkASSERT(i < 4);
+        dstPoint->fX = (i % 3) ? GrIntToScalar(fRect.fRight) :
+                                 GrIntToScalar(fRect.fLeft);
+        dstPoint->fY = (i < 2) ? GrIntToScalar(fRect.fTop)  :
+                                 GrIntToScalar(fRect.fBottom);
+    }
+private:
+    const SkIRect&   fRect;
+};
+
+class SkMatRectFanSource {
+public:
+    SkMatRectFanSource(const SkRect& rect, const SkMatrix& matrix)
+        : fRect(rect), fMatrix(matrix) {}
+
+    int count() const { return 4; }
+
+    void writeValue(int i, GrPoint* dstPoint) const {
+        SkASSERT(i < 4);
+
+#if SK_SCALAR_IS_GR_SCALAR
+        fMatrix.mapXY((i % 3) ? fRect.fRight : fRect.fLeft,
+                      (i < 2) ? fRect.fTop   : fRect.fBottom,
+                      (SkPoint*)dstPoint);
+#else
+        SkPoint dst;
+        fMatrix.mapXY((i % 3) ? fRect.fRight : fRect.fLeft,
+                      (i < 2) ? fRect.fTop   : fRect.fBottom,
+                      &dst);
+        dstPoint->fX = SkScalarToGrScalar(dst.fX);
+        dstPoint->fY = SkScalarToGrScalar(dst.fY);
+#endif
+    }
+private:
+    const SkRect&   fRect;
+    const SkMatrix& fMatrix;
+};
+
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::drawPaint(const SkDraw& draw, const SkPaint& paint) {
     CHECK_SHOULD_DRAW(draw);
 
-    AutoPaintShader   shader(this, paint, *draw.fMatrix);
-    if (shader.failed()) {
+    GrPaint grPaint;
+    SkAutoCachedTexture act;
+    if (!this->skPaint2GrPaintShader(paint, &act, *draw.fMatrix, &grPaint)) {
         return;
     }
-    fContext->drawFull(shader.useTex());
+
+    fContext->drawPaint(grPaint);
 }
 
 // must be in SkCanvas::PointMode order
-static const GrGpu::PrimitiveType gPointMode2PrimtiveType[] = {
-    GrGpu::kPoints_PrimitiveType,
-    GrGpu::kLines_PrimitiveType,
-    GrGpu::kLineStrip_PrimitiveType
+static const GrDrawTarget::PrimitiveType gPointMode2PrimtiveType[] = {
+    GrDrawTarget::kPoints_PrimitiveType,
+    GrDrawTarget::kLines_PrimitiveType,
+    GrDrawTarget::kLineStrip_PrimitiveType
 };
 
 void SkGpuDevice::drawPoints(const SkDraw& draw, SkCanvas::PointMode mode,
-                            size_t count, const SkPoint pts[], const SkPaint& paint) {
+                             size_t count, const SkPoint pts[], const SkPaint& paint) {
     CHECK_SHOULD_DRAW(draw);
 
     SkScalar width = paint.getStrokeWidth();
@@ -484,27 +611,26 @@
         return;
     }
 
-    AutoPaintShader shader(this, paint, *draw.fMatrix);
-    if (shader.failed()) {
+    GrPaint grPaint;
+    SkAutoCachedTexture act;
+    if (!this->skPaint2GrPaintShader(paint, &act, *draw.fMatrix, &grPaint)) {
         return;
     }
 
-    GrVertexLayout layout = shader.useTex() ?
-                            GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0) :
-                            0;
 #if SK_SCALAR_IS_GR_SCALAR
-    fContext->setVertexSourceToArray(pts, layout);
-    fContext->drawNonIndexed(gPointMode2PrimtiveType[mode], 0, count);
+    fContext->drawVertices(grPaint,
+                           gPointMode2PrimtiveType[mode],
+                           count,
+                           (GrPoint*)pts,
+                           NULL,
+                           NULL,
+                           NULL,
+                           0);
 #else
-    GrPoint* v;
-    fContext->reserveAndLockGeometry(layout, count, 0, (void**)&v, NULL);
-    for (size_t i = 0; i < count; ++i) {
-        v[i].set(SkScalarToGrScalar(pts[i].fX), SkScalarToGrScalar(pts[i].fY));
-    }
-    fContext->drawNonIndexed(gPointMode2PrimtiveType[mode], 0, count);
-    fContext->releaseReservedGeometry();
+    fContext->drawCustomVertices(grPaint,
+                                 gPointMode2PrimtiveType[mode],
+                                 SkPositionSource(pts, count));
 #endif
-
 }
 
 void SkGpuDevice::drawRect(const SkDraw& draw, const SkRect& rect,
@@ -525,12 +651,12 @@
         return;
     }
 
-    AutoPaintShader shader(this, paint, *draw.fMatrix);
-    if (shader.failed()) {
+    GrPaint grPaint;
+    SkAutoCachedTexture act;
+    if (!this->skPaint2GrPaintShader(paint, &act, *draw.fMatrix,  &grPaint)) {
         return;
     }
-
-    fContext->drawRect(Sk2Gr(rect), shader.useTex(), doStroke ? width : -1);
+    fContext->drawRect(grPaint, Sk2Gr(rect), doStroke ? width : -1);
 }
 
 void SkGpuDevice::drawPath(const SkDraw& draw, const SkPath& path,
@@ -538,8 +664,9 @@
                            bool pathIsMutable) {
     CHECK_SHOULD_DRAW(draw);
 
-    AutoPaintShader shader(this, paint, *draw.fMatrix);
-    if (shader.failed()) {
+    GrPaint grPaint;
+    SkAutoCachedTexture act;
+    if (!this->skPaint2GrPaintShader(paint, &act, *draw.fMatrix, &grPaint)) {
         return;
     }
 
@@ -573,13 +700,13 @@
                 fill = GrContext::kInverseEvenOdd_PathFill;
                 break;
             default:
-                SkDebugf("Unsupported path fill type");
+                SkDebugf("Unsupported path fill type\n");
                 return;
         }
     }
 
     SkGrPathIter iter(fillPath);
-    fContext->drawPath(&iter, fill, shader.useTex());
+    fContext->drawPath(grPaint, &iter, fill);
 }
 
 /*
@@ -603,10 +730,16 @@
         srcRect = *srcRectPtr;
     }
 
+    GrPaint grPaint;
+    if (!this->skPaint2GrPaintNoShader(paint, true, &grPaint)) {
+        return;
+    }
+    grPaint.fSampler.setFilter(paint.isFilterBitmap());
+
     if (bitmap.getTexture() || (bitmap.width() <= MAX_TEXTURE_DIM &&
                                 bitmap.height() <= MAX_TEXTURE_DIM)) {
         // take the fast case
-        this->internalDrawBitmap(draw, bitmap, srcRect, m, paint);
+        this->internalDrawBitmap(draw, bitmap, srcRect, m, &grPaint);
         return;
     }
 
@@ -656,7 +789,7 @@
                     int dy = tileR.fTop -  DY + SkMax32(0, srcR.fTop);
                     tmpM.preTranslate(SkIntToScalar(dx), SkIntToScalar(dy));
                 }
-                this->internalDrawBitmap(draw, tmpB, srcR, tmpM, paint);
+                this->internalDrawBitmap(draw, tmpB, srcR, tmpM, &grPaint);
             }
         }
     }
@@ -666,13 +799,14 @@
  *  This is called by drawBitmap(), which has to handle images that may be too
  *  large to be represented by a single texture.
  *
- *  internalDrawBitmap assumes that the specified bitmap will fit in a texture.
+ *  internalDrawBitmap assumes that the specified bitmap will fit in a texture
+ *  and that non-texture portion of the GrPaint has already been setup.
  */
 void SkGpuDevice::internalDrawBitmap(const SkDraw& draw,
                                      const SkBitmap& bitmap,
                                      const SkIRect& srcRect,
                                      const SkMatrix& m,
-                                     const SkPaint& paint) {
+                                     GrPaint* grPaint) {
     SkASSERT(bitmap.width() <= MAX_TEXTURE_DIM &&
              bitmap.height() <= MAX_TEXTURE_DIM);
 
@@ -681,72 +815,35 @@
         return;
     }
 
-    GrSamplerState sampler(paint.isFilterBitmap()); // defaults to clamp
-    // the lock has already called setTexture for us
-    fContext->setSamplerState(0, sampler);
+    grPaint->fSampler.setWrapX(GrSamplerState::kClamp_WrapMode);
+    grPaint->fSampler.setWrapY(GrSamplerState::kClamp_WrapMode);
+    grPaint->fSampler.setSampleMode(GrSamplerState::kNormal_SampleMode);
 
     GrTexture* texture;
-    SkAutoCachedTexture act(this, bitmap, sampler, &texture);
+    SkAutoCachedTexture act(this, bitmap, grPaint->fSampler, &texture);
     if (NULL == texture) {
         return;
     }
 
-    GrVertexLayout layout = GrDrawTarget::StageTexCoordVertexLayoutBit(0, 0);
+    grPaint->setTexture(texture);
+    grPaint->fTextureMatrix.setIdentity();
 
-    GrPoint* vertex;
-    if (!fContext->reserveAndLockGeometry(layout, 4,
-                                          0, GrTCast<void**>(&vertex), NULL)) {
-        return;
-    }
+    SkRect paintRect;
+    paintRect.set(SkFixedToScalar((srcRect.fLeft << 16)  / texture->allocWidth()),
+                  SkFixedToScalar((srcRect.fTop << 16)   / texture->allocHeight()),
+                  SkFixedToScalar((srcRect.fRight << 16) / texture->allocWidth()),
+                  SkFixedToScalar((srcRect.fBottom << 16)/ texture->allocHeight()));
 
-    {
-        GrMatrix grmat;
-        SkGr::SkMatrix2GrMatrix(m, &grmat);
-        vertex[0].setIRectFan(0, 0, srcRect.width(), srcRect.height(),
-                              2*sizeof(GrPoint));
-        grmat.mapPointsWithStride(vertex, 2*sizeof(GrPoint), 4);
-    }
+    SkRect dstRect;
+    dstRect.set(SkIntToScalar(0),SkIntToScalar(0), 
+                SkIntToScalar(srcRect.width()), SkIntToScalar(srcRect.height()));
 
-    SkScalar left   = SkFixedToScalar((srcRect.fLeft << 16) /
-                                      texture->allocWidth());
-    SkScalar right  = SkFixedToScalar((srcRect.fRight << 16) /
-                                      texture->allocWidth());
-    SkScalar top    = SkFixedToScalar((srcRect.fTop << 16) /
-                                      texture->allocHeight());
-    SkScalar bottom = SkFixedToScalar((srcRect.fBottom << 16) /
-                                      texture->allocHeight());
-    vertex[1].setRectFan(left, top, right, bottom, 2*sizeof(GrPoint));
+    SkRectFanSource texSrc(paintRect);
+    fContext->drawCustomVertices(*grPaint,
+                                 GrDrawTarget::kTriangleFan_PrimitiveType,
+                                 SkMatRectFanSource(dstRect, m),
+                                 &texSrc);
 
-    fContext->setTextureMatrix(0, GrMatrix::I());
-    // now draw the mesh
-    sk_gr_set_paint(fContext, paint, true);
-    fContext->drawNonIndexed(GrGpu::kTriangleFan_PrimitiveType, 0, 4);
-    fContext->releaseReservedGeometry();
-}
-
-static void gl_drawSprite(GrContext* ctx,
-                          int x, int y, int w, int h, const SkPoint& max,
-                          const SkPaint& paint) {
-    GrAutoViewMatrix avm(ctx, GrMatrix::I());
-
-    ctx->setSamplerState(0, GrSamplerState::ClampNoFilter());
-    ctx->setTextureMatrix(0, GrMatrix::I());
-
-    GrPoint* vertex;
-    GrVertexLayout layout = GrGpu::StageTexCoordVertexLayoutBit(0, 0);
-    if (!ctx->reserveAndLockGeometry(layout, 4, 0,
-                                     GrTCast<void**>(&vertex), NULL)) {
-        return;
-    }
-
-    vertex[1].setRectFan(0, 0, max.fX, max.fY, 2*sizeof(GrPoint));
-
-    vertex[0].setIRectFan(x, y, x + w, y + h, 2*sizeof(GrPoint));
-
-    sk_gr_set_paint(ctx, paint, true);
-    // should look to use glDrawTexi() has we do for text...
-    ctx->drawNonIndexed(GrGpu::kTriangleFan_PrimitiveType, 0, 4);
-    ctx->releaseReservedGeometry();
 }
 
 void SkGpuDevice::drawSprite(const SkDraw& draw, const SkBitmap& bitmap,
@@ -758,16 +855,31 @@
         return;
     }
 
-    SkPoint max;
-    GrTexture* texture;
-    SkAutoCachedTexture act(this, bitmap, GrSamplerState::ClampNoFilter(),
-                            &texture);
+    GrPaint grPaint;
+    if(!this->skPaint2GrPaintNoShader(paint, true, &grPaint)) {
+        return;
+    }
 
+    GrAutoMatrix avm(fContext, GrMatrix::I());
+
+    GrTexture* texture;
+    grPaint.fSampler.setClampNoFilter();
+    SkAutoCachedTexture act(this, bitmap, grPaint.fSampler, &texture);
+
+    grPaint.fTextureMatrix.setIdentity();
+    grPaint.setTexture(texture);
+
+    SkPoint max;
     max.set(SkFixedToScalar((texture->contentWidth() << 16) /
                              texture->allocWidth()),
             SkFixedToScalar((texture->contentHeight() << 16) /
                             texture->allocHeight()));
-    gl_drawSprite(fContext, left, top, bitmap.width(), bitmap.height(), max, paint);
+
+    fContext->drawRectToRect(grPaint,
+                             GrRect(GrIntToScalar(left), GrIntToScalar(top),
+                                    GrIntToScalar(left + bitmap.width()),
+                                    GrIntToScalar(top + bitmap.height())),
+                             GrRect(0, 0, max.fX, max.fY));
 }
 
 void SkGpuDevice::drawDevice(const SkDraw& draw, SkDevice* dev,
@@ -775,21 +887,41 @@
     CHECK_SHOULD_DRAW(draw);
 
     SkPoint max;
-    if (((SkGpuDevice*)dev)->bindDeviceAsTexture(&max)) {
-        const SkBitmap& bm = dev->accessBitmap(false);
-        int w = bm.width();
-        int h = bm.height();
-        gl_drawSprite(fContext, x, y, w, h, max, paint);
+    GrPaint grPaint;
+    if (!((SkGpuDevice*)dev)->bindDeviceAsTexture(&grPaint, &max) ||
+        !this->skPaint2GrPaintNoShader(paint, true, &grPaint)) {
+        return;
     }
+
+    SkASSERT(NULL != grPaint.getTexture());
+
+    const SkBitmap& bm = dev->accessBitmap(false);
+    int w = bm.width();
+    int h = bm.height();
+
+    GrAutoMatrix avm(fContext, GrMatrix::I());
+
+    grPaint.fSampler.setClampNoFilter();
+    grPaint.fTextureMatrix.setIdentity();
+
+    fContext->drawRectToRect(grPaint,
+                             GrRect(GrIntToScalar(x), 
+                                    GrIntToScalar(y), 
+                                    GrIntToScalar(x + w), 
+                                    GrIntToScalar(y + h)),
+                             GrRect(0, 
+                                    0, 
+                                    GrIntToScalar(max.fX), 
+                                    GrIntToScalar(max.fY)));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // must be in SkCanvas::VertexMode order
-static const GrGpu::PrimitiveType gVertexMode2PrimitiveType[] = {
-    GrGpu::kTriangles_PrimitiveType,
-    GrGpu::kTriangleStrip_PrimitiveType,
-    GrGpu::kTriangleFan_PrimitiveType,
+static const GrDrawTarget::PrimitiveType gVertexMode2PrimitiveType[] = {
+    GrDrawTarget::kTriangles_PrimitiveType,
+    GrDrawTarget::kTriangleStrip_PrimitiveType,
+    GrDrawTarget::kTriangleFan_PrimitiveType,
 };
 
 void SkGpuDevice::drawVertices(const SkDraw& draw, SkCanvas::VertexMode vmode,
@@ -800,77 +932,57 @@
                               const SkPaint& paint) {
     CHECK_SHOULD_DRAW(draw);
 
-    sk_gr_set_paint(fContext, paint);
-
-    TexCache* cache = NULL;
-
-    bool useTexture = false;
-
-    AutoPaintShader autoShader;
-
-    if (texs) {
-        autoShader.init(this, paint, *draw.fMatrix);
-
-        if (autoShader.failed()) {
+    GrPaint grPaint;
+    SkAutoCachedTexture act;
+    // we ignore the shader if texs is null.
+    if (NULL == texs) {
+        if (!this->skPaint2GrPaintNoShader(paint, false, &grPaint)) {
             return;
         }
-        useTexture = autoShader.useTex();
-    }
-
-    bool releaseVerts = false;
-    GrVertexLayout layout = 0;
-    if (useTexture) {
-        layout |= GrDrawTarget::StageTexCoordVertexLayoutBit(0, 0);
-    }
-    if (NULL != colors) {
-        layout |= GrDrawTarget::kColor_VertexLayoutBit;
-    }
-
-    #if SK_SCALAR_IS_GR_SCALAR
-    if (!layout) {
-        fContext->setVertexSourceToArray(vertices, layout);
-    } else
-    #endif
-    {
-        void* verts;
-        releaseVerts = true;
-        if (!fContext->reserveAndLockGeometry(layout, vertexCount, 0,
-                                              &verts, NULL)) {
-            return;
-        }
-        int texOffsets[GrDrawTarget::kNumStages];
-        int colorOffset;
-        uint32_t stride = GrDrawTarget::VertexSizeAndOffsetsByStage(layout,
-                                                                    texOffsets,
-                                                                    &colorOffset);
-        for (int i = 0; i < vertexCount; ++i) {
-            GrPoint* p = (GrPoint*)((intptr_t)verts + i * stride);
-            p->set(SkScalarToGrScalar(vertices[i].fX),
-                   SkScalarToGrScalar(vertices[i].fY));
-            if (texOffsets[0] > 0) {
-                GrPoint* t = (GrPoint*)((intptr_t)p + texOffsets[0]);
-                t->set(SkScalarToGrScalar(texs[i].fX),
-                       SkScalarToGrScalar(texs[i].fY));
-            }
-            if (colorOffset > 0) {
-                uint32_t* color = (uint32_t*) ((intptr_t)p + colorOffset);
-                *color = SkGr::SkColor2GrColor(colors[i]);
-            }
-        }
-    }
-    if (indices) {
-        fContext->setIndexSourceToArray(indices);
-        fContext->drawIndexed(gVertexMode2PrimitiveType[vmode], 0, 0,
-                                 vertexCount, indexCount);
     } else {
-        fContext->drawNonIndexed(gVertexMode2PrimitiveType[vmode],
-                                 0, vertexCount);
+        if (!this->skPaint2GrPaintShader(paint, &act, 
+                                         *draw.fMatrix, 
+                                         &grPaint)) {
+            return;
+        }
     }
-    if (cache) {
-        this->unlockCachedTexture(cache);
+
+    if (NULL != xmode && NULL != texs && NULL != colors) {
+        SkXfermode::Mode mode;
+        if (!SkXfermode::IsMode(xmode, &mode) ||
+            SkXfermode::kMultiply_Mode != mode) {
+            SkDebugf("Unsupported vertex-color/texture xfer mode.\n");
+#if 0
+            return
+#endif
+        }
     }
-    if (releaseVerts) {
-        fContext->releaseReservedGeometry();
+
+#if SK_SCALAR_IS_GR_SCALAR
+    // even if GrColor and SkColor byte offsets match we need
+    // to perform pre-multiply.
+    if (NULL == colors) {
+        fContext->drawVertices(grPaint,
+                               gVertexMode2PrimitiveType[vmode],
+                               vertexCount,
+                               (GrPoint*) vertices,
+                               (GrPoint*) texs,
+                               NULL,
+                               indices,
+                               indexCount);
+    } else
+#endif
+    {
+        SkTexCoordSource texSrc(texs);
+        SkColorSource colSrc(colors);
+        SkIndexSource idxSrc(indices, indexCount);
+
+        fContext->drawCustomVertices(grPaint,
+                                     gVertexMode2PrimitiveType[vmode],
+                                     SkPositionSource(vertices, vertexCount),
+                                     (NULL == texs) ? NULL : &texSrc,
+                                     (NULL == colors) ? NULL : &colSrc,
+                                     (NULL == indices) ? NULL : &idxSrc);
     }
 }
 
@@ -908,8 +1020,7 @@
                                          procs->fFontScaler);
 }
 
-SkDrawProcs* SkGpuDevice::initDrawForText(const SkPaint& paint,
-                                          GrTextContext* context) {
+SkDrawProcs* SkGpuDevice::initDrawForText(GrTextContext* context) {
 
     // deferred allocation
     if (NULL == fDrawProcs) {
@@ -935,9 +1046,15 @@
     } else {
         SkAutoExtMatrix aem(draw.fExtMatrix);
         SkDraw myDraw(draw);
-        sk_gr_set_paint(fContext, paint);
-        GrTextContext context(fContext, aem.extMatrix());
-        myDraw.fProcs = this->initDrawForText(paint, &context);
+
+        GrPaint grPaint;
+        SkAutoCachedTexture act;
+
+        if (!this->skPaint2GrPaintShader(paint, &act, *draw.fMatrix, &grPaint)) {
+            return;
+        }
+        GrTextContext context(fContext, grPaint, aem.extMatrix());
+        myDraw.fProcs = this->initDrawForText(&context);
         this->INHERITED::drawText(myDraw, text, byteLength, x, y, paint);
     }
 }
@@ -955,9 +1072,15 @@
     } else {
         SkAutoExtMatrix aem(draw.fExtMatrix);
         SkDraw myDraw(draw);
-        sk_gr_set_paint(fContext, paint);
-        GrTextContext context(fContext, aem.extMatrix());
-        myDraw.fProcs = this->initDrawForText(paint, &context);
+
+        GrPaint grPaint;
+        SkAutoCachedTexture act;
+        if (!this->skPaint2GrPaintShader(paint, &act, *draw.fMatrix, &grPaint)) {
+            return;
+        }
+
+        GrTextContext context(fContext, grPaint, aem.extMatrix());
+        myDraw.fProcs = this->initDrawForText(&context);
         this->INHERITED::drawPosText(myDraw, text, byteLength, pos, constY,
                                      scalarsPerPos, paint);
     }
@@ -1014,7 +1137,6 @@
 
     if (NULL != entry) {
         newTexture = entry->texture();
-        ctx->setTexture(0, newTexture);
         if (texture) {
             *texture = newTexture;
         }
diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp
index 8849db7..41cf1bd 100644
--- a/src/gpu/SkGr.cpp
+++ b/src/gpu/SkGr.cpp
@@ -19,18 +19,18 @@
 
 /*  Fill out buffer with the compressed format Ganesh expects from a colortable
  based bitmap. [palette (colortable) + indices].
- 
- At the moment Ganesh only supports 8bit version. If Ganesh allowed we others 
+
+ At the moment Ganesh only supports 8bit version. If Ganesh allowed we others
  we could detect that the colortable.count is <= 16, and then repack the
  indices as nibbles to save RAM, but it would take more time (i.e. a lot
  slower than memcpy), so skipping that for now.
- 
+
  Ganesh wants a full 256 palette entry, even though Skia's ctable is only as big
  as the colortable.count says it is.
  */
 static void build_compressed_data(void* buffer, const SkBitmap& bitmap) {
     SkASSERT(SkBitmap::kIndex8_Config == bitmap.config());
-  
+
     SkAutoLockPixels apl(bitmap);
     if (!bitmap.readyToDraw()) {
         SkASSERT(!"bitmap not ready to draw!");
@@ -39,10 +39,10 @@
 
     SkColorTable* ctable = bitmap.getColorTable();
     char* dst = (char*)buffer;
-    
+
     memcpy(dst, ctable->lockColors(), ctable->count() * sizeof(SkPMColor));
     ctable->unlockColors(false);
-    
+
     // always skip a full 256 number of entries, even if we memcpy'd fewer
     dst += GrGpu::kColorTableSize;
 
@@ -63,7 +63,7 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
-GrTextureEntry* sk_gr_create_bitmap_texture(GrContext* ctx, 
+GrTextureEntry* sk_gr_create_bitmap_texture(GrContext* ctx,
                                             GrTextureKey* key,
                                             const GrSamplerState& sampler,
                                             const SkBitmap& origBitmap) {
@@ -75,7 +75,7 @@
     SkBitmap tmpBitmap;
 
     const SkBitmap* bitmap = &origBitmap;
-    
+
     GrGpu::TextureDesc desc = {
         0,
         GrGpu::kNone_AALevel,
@@ -83,16 +83,16 @@
         bitmap->height(),
         SkGr::Bitmap2PixelConfig(*bitmap)
     };
-    
+
     if (SkBitmap::kIndex8_Config == bitmap->config()) {
         // build_compressed_data doesn't do npot->pot expansion
         // and paletted textures can't be sub-updated
         if (ctx->supportsIndex8PixelConfig(sampler,
                                            bitmap->width(), bitmap->height())) {
-            size_t imagesize = bitmap->width() * bitmap->height() + 
+            size_t imagesize = bitmap->width() * bitmap->height() +
                                 GrGpu::kColorTableSize;
             SkAutoMalloc storage(imagesize);
-        
+
             build_compressed_data(storage.get(), origBitmap);
 
             // our compressed data will be trimmed, so pass width() for its
@@ -105,7 +105,7 @@
             // now bitmap points to our temp, which has been promoted to 32bits
             bitmap = &tmpBitmap;
         }
-    } 
+    }
 
     desc.fFormat = SkGr::Bitmap2PixelConfig(*bitmap);
     return ctx->createAndLockTexture(key, sampler, desc, bitmap->getPixels(),
@@ -113,28 +113,7 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-  
-void sk_gr_set_paint(GrContext* ctx, const SkPaint& paint, bool justAlpha) {
-    ctx->setDither(paint.isDither());
-    ctx->setAntiAlias(paint.isAntiAlias());
 
-    if (justAlpha) {
-        ctx->setAlpha(paint.getAlpha());
-    } else {
-        ctx->setColor(SkGr::SkColor2GrColor(paint.getColor()));
-    }
-    
-    SkXfermode::Coeff sm = SkXfermode::kOne_Coeff;
-    SkXfermode::Coeff dm = SkXfermode::kISA_Coeff;
-    
-    SkXfermode* mode = paint.getXfermode();
-    if (mode) {
-        mode->asCoeff(&sm, &dm);
-    }   
-    ctx->setBlendFunc(sk_blend_to_grblend(sm), sk_blend_to_grblend(dm));
-}
-
-////////////////////////////////////////////////////////////////////////////////
 
 SkGrPathIter::Command SkGrPathIter::next(GrPoint pts[]) {
     GrAssert(NULL != pts);
@@ -160,7 +139,7 @@
 }
 
 GrPathIter::ConvexHint SkGrPathIter::hint() const {
-    return fPath.isConvex() ? GrPathIter::kConvex_ConvexHint : 
+    return fPath.isConvex() ? GrPathIter::kConvex_ConvexHint :
                               GrPathIter::kNone_ConvexHint;
 }
 
diff --git a/src/utils/mac/SkOSWindow_Mac.cpp b/src/utils/mac/SkOSWindow_Mac.cpp
index d4ef7e9..e45a445 100644
--- a/src/utils/mac/SkOSWindow_Mac.cpp
+++ b/src/utils/mac/SkOSWindow_Mac.cpp
@@ -37,26 +37,26 @@
                                    EventRef event, void *userData) {
 	// NOTE: GState is save/restored by the HIView system doing the callback,
     // so the draw handler doesn't need to do it
-    
+
 	OSStatus status = noErr;
 	CGContextRef context;
 	HIRect		bounds;
-    
+
 	// Get the CGContextRef
-	status = GetEventParameter (event, kEventParamCGContextRef, 
-                                typeCGContextRef, NULL, 
+	status = GetEventParameter (event, kEventParamCGContextRef,
+                                typeCGContextRef, NULL,
                                 sizeof (CGContextRef),
                                 NULL,
                                 &context);
-    
+
 	if (status != noErr) {
 		SkDebugf("Got error %d getting the context!\n", status);
 		return status;
-	}		
-    
+	}
+
 	// Get the bounding rectangle
 	HIViewGetBounds ((HIViewRef) userData, &bounds);
-	
+
     gCurrOSWin->doPaint(context);
 	return status;
 }
@@ -88,13 +88,13 @@
 {
 	OSStatus    result;
     WindowRef   wr = (WindowRef)hWnd;
-    
+
     HIViewRef imageView, parent;
     HIViewRef rootView = HIViewGetRoot(wr);
     HIViewFindByID(rootView, kHIViewWindowContentID, &parent);
     result = HIImageViewCreate(NULL, &imageView);
 	SkASSERT(result == noErr);
-    
+
     result = HIViewAddSubview(parent, imageView);
 	SkASSERT(result == noErr);
 
@@ -138,7 +138,7 @@
 	result = InstallEventHandler(GetWindowEventTarget(wr), handlerUPP,
 						count, gTypes, this, nil);
 	SkASSERT(result == noErr);
-    
+
 	gCurrOSWin = this;
 	gCurrEventQ = GetCurrentEventQueue();
 	gEventTarget = GetWindowEventTarget(wr);
@@ -168,7 +168,7 @@
         CGContextScaleCTM(cg, 1, -1);
 
         CGContextDrawImage(cg, r, img);
-        
+
         CGContextRestoreGState(cg);
 
         CGImageRelease(img);
@@ -179,15 +179,15 @@
 void SkOSWindow::updateSize()
 {
 	Rect	r;
-	
+
 	GetWindowBounds((WindowRef)fHWND, kWindowContentRgn, &r);
 	this->resize(r.right - r.left, r.bottom - r.top);
-    
+
 #if 0
     HIRect    frame;
     HIViewRef imageView = (HIViewRef)getHVIEW();
     HIViewRef parent = HIViewGetSuperview(imageView);
-  
+
     HIViewGetBounds(imageView, &frame);
     SkDebugf("------ %d bounds %g %g %g %g\n", r.right - r.left,
              frame.origin.x, frame.origin.y, frame.size.width, frame.size.height);
@@ -245,7 +245,7 @@
 	SK_MacRightKey		= 124,
 	SK_MacDownKey		= 125,
 	SK_MacUpKey			= 126,
-    
+
     SK_Mac0Key          = 0x52,
     SK_Mac1Key          = 0x53,
     SK_Mac2Key          = 0x54,
@@ -257,7 +257,7 @@
     SK_Mac8Key          = 0x5b,
     SK_Mac9Key          = 0x5c
 };
-	
+
 static SkKey raw2key(UInt32 raw)
 {
 	static const struct {
@@ -282,7 +282,7 @@
         { SK_Mac8Key,       k8_SkKey        },
         { SK_Mac9Key,       k9_SkKey        }
 	};
-	
+
 	for (unsigned i = 0; i < SK_ARRAY_COUNT(gKeys); i++)
 		if (gKeys[i].fRaw == raw)
 			return gKeys[i].fKey;
@@ -294,18 +294,18 @@
 	EventRef	ref;
 	OSStatus	status = CreateEvent(nil, SK_MacEventClass, SK_MacEventKind, 0, 0, &ref);
 	SkASSERT(status == noErr);
-	
+
 #if 0
 	status = SetEventParameter(ref, SK_MacEventParamName, SK_MacEventParamName, sizeof(evt), &evt);
 	SkASSERT(status == noErr);
 	status = SetEventParameter(ref, SK_MacEventSinkIDParamName, SK_MacEventSinkIDParamName, sizeof(sinkID), &sinkID);
 	SkASSERT(status == noErr);
 #endif
-	
+
 	EventTargetRef target = gEventTarget;
 	SetEventParameter(ref, kEventParamPostTarget, typeEventTargetRef, sizeof(target), &target);
 	SkASSERT(status == noErr);
-	
+
 	status = PostEventToQueue(gCurrEventQ, ref, kEventPriorityStandard);
 	SkASSERT(status == noErr);
 
@@ -456,16 +456,16 @@
 {
     GLint major, minor;
     AGLContext ctx;
-    
+
     aglGetVersion(&major, &minor);
     SkDebugf("---- agl version %d %d\n", major, minor);
-    
+
     const GLint pixelAttrs[] = {
         AGL_RGBA,
         AGL_STENCIL_SIZE, 8,
         AGL_SAMPLE_BUFFERS_ARB, 1,
 		AGL_MULTISAMPLE,
-		AGL_SAMPLES_ARB, 2,        
+		AGL_SAMPLES_ARB, 2,
 		(offscreen ? AGL_OFFSCREEN : AGL_ACCELERATED),
         (offscreen ? AGL_NONE : AGL_DOUBLEBUFFER),
         AGL_NONE
@@ -494,14 +494,20 @@
 
     GLboolean success = true;
 
+    int width, height;
+
     if (offscreen) {
         success = aglSetOffScreen((AGLContext)fAGLCtx,
                                     offscreen->width(),
                                     offscreen->height(),
                                     offscreen->rowBytes(),
                                     offscreen->getPixels());
+        width = offscreen->width();
+        height = offscreen->height();
     } else {
         success = aglSetWindowRef((AGLContext)fAGLCtx, (WindowRef)fHWND);
+        width = this->width();
+        height = this->height();
     }
 
     GLenum err = aglGetError();
@@ -509,8 +515,9 @@
         SkDebugf("---- setoffscreen %d %d %s [%d %d]\n", success, err,
                  aglErrorString(err), offscreen->width(), offscreen->height());
     }
-    
+
     if (success) {
+        glViewport(0, 0, width, height);
         glClearColor(0, 0, 0, 0);
         glClearStencil(0);
         glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
diff --git a/src/utils/win/SkOSWindow_Win.cpp b/src/utils/win/SkOSWindow_Win.cpp
index 53449b1..d0e6cc3 100644
--- a/src/utils/win/SkOSWindow_Win.cpp
+++ b/src/utils/win/SkOSWindow_Win.cpp
@@ -438,6 +438,7 @@
         }
     }
     if (wglMakeCurrent(GetDC((HWND)fHWND), (HGLRC)fHGLRC)) {
+        glViewport(0, 0, this->width(), this->height());
         glClearColor(0, 0, 0, 0);
         glClearStencil(0);
         glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
diff --git a/vs/SampleApp/SampleApp.vcxproj b/vs/SampleApp/SampleApp.vcxproj
index 7294cc1..95e7f0a 100644
--- a/vs/SampleApp/SampleApp.vcxproj
+++ b/vs/SampleApp/SampleApp.vcxproj
@@ -74,6 +74,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>..\..\include\core;..\..\include\xml;..\..\include\utils;..\..\include\config;..\..\include\views;..\..\src\core;..\..\include\images;..\..\include\effects;..\..\include\gpu;..\..\gpu\include</AdditionalIncludeDirectories>
+      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -99,6 +100,7 @@
     <ClInclude Include="..\..\gpu\include\GrColor.h" />
     <ClInclude Include="..\..\gpu\include\GrConfig.h" />
     <ClInclude Include="..\..\gpu\include\GrContext.h" />
+    <ClInclude Include="..\..\gpu\include\GrContext_impl.h" />
     <ClInclude Include="..\..\gpu\include\GrDrawTarget.h" />
     <ClInclude Include="..\..\gpu\include\GrFontScaler.h" />
     <ClInclude Include="..\..\gpu\include\GrGLConfig.h" />
@@ -117,6 +119,7 @@
     <ClInclude Include="..\..\gpu\include\GrMemory.h" />
     <ClInclude Include="..\..\gpu\include\GrMesh.h" />
     <ClInclude Include="..\..\gpu\include\GrNoncopyable.h" />
+    <ClInclude Include="..\..\gpu\include\GrPaint.h" />
     <ClInclude Include="..\..\gpu\include\GrPath.h" />
     <ClInclude Include="..\..\gpu\include\GrPathIter.h" />
     <ClInclude Include="..\..\gpu\include\GrPathSink.h" />
diff --git a/xcode/gpu/gpu.xcodeproj/project.pbxproj b/xcode/gpu/gpu.xcodeproj/project.pbxproj
index 7aa1a77..0403b49 100644
--- a/xcode/gpu/gpu.xcodeproj/project.pbxproj
+++ b/xcode/gpu/gpu.xcodeproj/project.pbxproj
@@ -91,6 +91,8 @@
 		00115EA912C116CA008296FE /* GrUserConfig.h in Headers */ = {isa = PBXBuildFile; fileRef = 00115E6D12C116CA008296FE /* GrUserConfig.h */; };
 		00115EAA12C116CA008296FE /* GrVertexBuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = 00115E6E12C116CA008296FE /* GrVertexBuffer.h */; };
 		00115EAB12C116CA008296FE /* GrVertexBufferAllocPool.h in Headers */ = {isa = PBXBuildFile; fileRef = 00115E6F12C116CA008296FE /* GrVertexBufferAllocPool.h */; };
+		D539049B12EA01E30025F3D6 /* GrContext_impl.h in Headers */ = {isa = PBXBuildFile; fileRef = D539049A12EA01E30025F3D6 /* GrContext_impl.h */; };
+		D53904A112EA026E0025F3D6 /* GrPaint.h in Headers */ = {isa = PBXBuildFile; fileRef = D53904A012EA026E0025F3D6 /* GrPaint.h */; };
 		D58CAF9A12E7212100CB9277 /* GrGLUtil.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D58CAF9812E7212100CB9277 /* GrGLUtil.cpp */; };
 /* End PBXBuildFile section */
 
@@ -180,6 +182,8 @@
 		00115E6E12C116CA008296FE /* GrVertexBuffer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GrVertexBuffer.h; path = ../../gpu/include/GrVertexBuffer.h; sourceTree = SOURCE_ROOT; };
 		00115E6F12C116CA008296FE /* GrVertexBufferAllocPool.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GrVertexBufferAllocPool.h; path = ../../gpu/include/GrVertexBufferAllocPool.h; sourceTree = SOURCE_ROOT; };
 		D2AAC046055464E500DB518D /* libgpu.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libgpu.a; sourceTree = BUILT_PRODUCTS_DIR; };
+		D539049A12EA01E30025F3D6 /* GrContext_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GrContext_impl.h; path = ../../gpu/include/GrContext_impl.h; sourceTree = SOURCE_ROOT; };
+		D53904A012EA026E0025F3D6 /* GrPaint.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GrPaint.h; path = ../../gpu/include/GrPaint.h; sourceTree = SOURCE_ROOT; };
 		D58CAF9812E7212100CB9277 /* GrGLUtil.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = GrGLUtil.cpp; path = ../../gpu/src/GrGLUtil.cpp; sourceTree = SOURCE_ROOT; };
 /* End PBXFileReference section */
 
@@ -251,6 +255,7 @@
 				00115E6D12C116CA008296FE /* GrUserConfig.h */,
 				00115E6E12C116CA008296FE /* GrVertexBuffer.h */,
 				00115E6F12C116CA008296FE /* GrVertexBufferAllocPool.h */,
+				D53904A012EA026E0025F3D6 /* GrPaint.h */,
 			);
 			name = include;
 			sourceTree = "<group>";
@@ -269,6 +274,7 @@
 		08FB7795FE84155DC02AAC07 /* Source */ = {
 			isa = PBXGroup;
 			children = (
+				D539049A12EA01E30025F3D6 /* GrContext_impl.h */,
 				00115DD812C1167A008296FE /* gr_unittests.cpp */,
 				00115DD912C1167A008296FE /* GrAllocPool.cpp */,
 				00115DDA12C1167A008296FE /* GrAtlas.cpp */,
@@ -385,6 +391,8 @@
 				00115EA912C116CA008296FE /* GrUserConfig.h in Headers */,
 				00115EAA12C116CA008296FE /* GrVertexBuffer.h in Headers */,
 				00115EAB12C116CA008296FE /* GrVertexBufferAllocPool.h in Headers */,
+				D539049B12EA01E30025F3D6 /* GrContext_impl.h in Headers */,
+				D53904A112EA026E0025F3D6 /* GrPaint.h in Headers */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
diff --git a/xcode/sampleapp/SampleApp.xcodeproj/project.pbxproj b/xcode/sampleapp/SampleApp.xcodeproj/project.pbxproj
index 8787064..18bca17 100644
--- a/xcode/sampleapp/SampleApp.xcodeproj/project.pbxproj
+++ b/xcode/sampleapp/SampleApp.xcodeproj/project.pbxproj
@@ -51,7 +51,6 @@
 		0041CE430F00A12400695E8C /* SampleLayers.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0041CE2D0F00A12400695E8C /* SampleLayers.cpp */; };
 		0041CE450F00A12400695E8C /* SampleMeasure.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0041CE2F0F00A12400695E8C /* SampleMeasure.cpp */; };
 		0041CE480F00A12400695E8C /* SampleOverflow.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0041CE320F00A12400695E8C /* SampleOverflow.cpp */; };
-		0041CE4A0F00A12400695E8C /* SamplePatch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0041CE340F00A12400695E8C /* SamplePatch.cpp */; };
 		00575A1810BB02CF00A43B94 /* SampleEffects.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00FF39130FC6ED2C00915187 /* SampleEffects.cpp */; };
 		00575A3B10BB05FE00A43B94 /* SampleArc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00A41E4A0EFC312F00C9CBEB /* SampleArc.cpp */; };
 		00575A9510BB2FF600A43B94 /* SampleMipMap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2794C04E0FE72903009AD112 /* SampleMipMap.cpp */; };
@@ -86,7 +85,6 @@
 		00AF787E0FE94433007F9650 /* SamplePath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00003C640EFC22A8000FF73A /* SamplePath.cpp */; };
 		00AF9B18103CD5EB00CBBCB3 /* SampleDitherBitmap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00AF9B17103CD5EB00CBBCB3 /* SampleDitherBitmap.cpp */; };
 		00BB289B104781D00057BF7E /* SampleForth.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BB289A104781D00057BF7E /* SampleForth.cpp */; };
-		00C1B809103857A400FA5948 /* SampleFillType.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0041CE270F00A12400695E8C /* SampleFillType.cpp */; };
 		00EB4593104DBB18002B413E /* ForthTests.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00EB4592104DBB18002B413E /* ForthTests.cpp */; };
 		00ED55F3104A10EB00F51FF8 /* StdWords.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00ED55F2104A10EB00F51FF8 /* StdWords.cpp */; };
 		00F0441010B447160049C54C /* SamplePathClip.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007C785D0F3B4C230004B142 /* SamplePathClip.cpp */; };
@@ -150,6 +148,8 @@
 		8D0C4E8D0486CD37000505A6 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 0867D6AAFE840B52C02AAC07 /* InfoPlist.strings */; };
 		8D0C4E8E0486CD37000505A6 /* main.nib in Resources */ = {isa = PBXBuildFile; fileRef = 02345980000FD03B11CA0E72 /* main.nib */; };
 		8D0C4E920486CD37000505A6 /* Carbon.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 20286C33FDCF999611CA2CEA /* Carbon.framework */; };
+		D5A682D712E9CE8500CDDDC6 /* SamplePatch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0041CE340F00A12400695E8C /* SamplePatch.cpp */; };
+		D5F4A21F12E9D75300DE986A /* SampleFillType.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0041CE270F00A12400695E8C /* SampleFillType.cpp */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXContainerItemProxy section */
@@ -919,7 +919,6 @@
 				0041CE430F00A12400695E8C /* SampleLayers.cpp in Sources */,
 				0041CE450F00A12400695E8C /* SampleMeasure.cpp in Sources */,
 				0041CE480F00A12400695E8C /* SampleOverflow.cpp in Sources */,
-				0041CE4A0F00A12400695E8C /* SamplePatch.cpp in Sources */,
 				007A7CB40F01658C00A2D6EE /* SamplePoints.cpp in Sources */,
 				007A7CB80F01658C00A2D6EE /* SampleStrokeText.cpp in Sources */,
 				007A7CBD0F01658C00A2D6EE /* SampleTextOnPath.cpp in Sources */,
@@ -937,7 +936,6 @@
 				005E92DC0FF08507008965B9 /* SampleFilter2.cpp in Sources */,
 				27005D16100903C100E275B6 /* SampleLines.cpp in Sources */,
 				27005D5F10095B2B00E275B6 /* SampleCircle.cpp in Sources */,
-				00C1B809103857A400FA5948 /* SampleFillType.cpp in Sources */,
 				00AF9B18103CD5EB00CBBCB3 /* SampleDitherBitmap.cpp in Sources */,
 				001B871E1042184D00C84ED4 /* Forth.cpp in Sources */,
 				00BB289B104781D00057BF7E /* SampleForth.cpp in Sources */,
@@ -1022,6 +1020,8 @@
 				009F9D0612C3E89F00C7FD4A /* SampleTiling.cpp in Sources */,
 				009F9D0A12C3E8AF00C7FD4A /* SampleFilter.cpp in Sources */,
 				009F9D1A12C3EB2600C7FD4A /* SampleGM.cpp in Sources */,
+				D5A682D712E9CE8500CDDDC6 /* SamplePatch.cpp in Sources */,
+				D5F4A21F12E9D75300DE986A /* SampleFillType.cpp in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};