diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
index d9b9f08..0a3ab42 100644
--- a/src/gpu/GrContext.cpp
+++ b/src/gpu/GrContext.cpp
@@ -215,23 +215,6 @@
                            sb->numSamples(), v);
 }
 
-// This should be subsumed by a future version of GrDrawState
-// It does not reset stage textures/samplers or per-vertex-edge-aa state since
-// they aren't used unless the vertex layout references them.
-// It also doesn't set the render target.
-void reset_draw_state(GrDrawState* drawState){
-
-        drawState->setViewMatrix(GrMatrix::I());
-        drawState->setColorFilter(0, SkXfermode::kDst_Mode);
-        drawState->resetStateFlags();
-        drawState->setEdgeAAData(NULL, 0);
-        drawState->disableStencil();
-        drawState->setAlpha(0xFF);
-        drawState->setBlendFunc(kOne_BlendCoeff,
-                           kZero_BlendCoeff);
-        drawState->setFirstCoverageStage(GrDrawState::kNumStages);
-        drawState->setDrawFace(GrDrawState::kBoth_DrawFace);
-}
 }
 
 GrContext::TextureCacheEntry GrContext::findAndLockTexture(
@@ -356,7 +339,7 @@
         if (NULL != texture) {
             GrDrawTarget::AutoStateRestore asr(fGpu);
             GrDrawState* drawState = fGpu->drawState();
-            reset_draw_state(drawState);
+            drawState->reset();
             drawState->setRenderTarget(texture->asRenderTarget());
             drawState->setTexture(0, clampEntry.texture());
 
@@ -786,11 +769,13 @@
     GrRenderTarget* offRT = record->fOffscreen.texture()->asRenderTarget();
     GrAssert(NULL != offRT);
 
-    GrPaint tempPaint;
-    tempPaint.reset();
-    this->setPaint(tempPaint, target);
+    
     GrDrawState* drawState = target->drawState();
+    GrMatrix vm = drawState->getViewMatrix();
+    drawState->reset();
+    *drawState->viewMatrix() = vm;
     drawState->setRenderTarget(offRT);
+    
 #if PREFER_MSAA_OFFSCREEN_AA
     drawState->enableState(GrDrawState::kHWAntialias_StateBit);
 #endif
@@ -1900,7 +1885,7 @@
 
         GrDrawTarget::AutoStateRestore asr(fGpu);
         GrDrawState* drawState = fGpu->drawState();
-        reset_draw_state(drawState);
+        drawState->reset();
         drawState->setRenderTarget(target);
 
         GrMatrix matrix;
@@ -1934,7 +1919,7 @@
 
     GrDrawTarget::AutoStateRestore asr(fGpu);
     GrDrawState* drawState = fGpu->drawState();
-    reset_draw_state(drawState);
+    drawState->reset();
     drawState->setRenderTarget(dst);
     GrMatrix sampleM;
     sampleM.setIDiv(src->width(), src->height());
@@ -2004,7 +1989,7 @@
 
     GrDrawTarget::AutoStateRestore  asr(fGpu);
     GrDrawState* drawState = fGpu->drawState();
-    reset_draw_state(drawState);
+    drawState->reset();
 
     GrMatrix matrix;
     matrix.setTranslate(GrIntToScalar(left), GrIntToScalar(top));
diff --git a/src/gpu/GrDrawState.h b/src/gpu/GrDrawState.h
index 51443cb..0df6c38 100644
--- a/src/gpu/GrDrawState.h
+++ b/src/gpu/GrDrawState.h
@@ -47,21 +47,45 @@
     GR_STATIC_ASSERT(sizeof(StageMask)*8 >= GrDrawState::kNumStages);
 
     GrDrawState() {
+        this->reset();
+    }
+    
+    /**
+     * Resets to the default state. Sampler states will not be modified.
+     */ 
+    void reset() {
         // make sure any pad is zero for memcmp
-        // all GrDrawState members should default to something
-        // valid by the memset
-        memset(this, 0, sizeof(GrDrawState));
-            
-        // memset exceptions
-        fColorFilterMode = SkXfermode::kDstIn_Mode;
-        fFirstCoverageStage = kNumStages;
-
+        // all GrDrawState members should default to something valid by the
+        // the memset except those initialized individually below. There should
+        // be no padding between the individually initialized members.
+        static const size_t kMemsetSize =
+            reinterpret_cast<intptr_t>(&fColor) -
+            reinterpret_cast<intptr_t>(this);
+        memset(this, 0, kMemsetSize);
         // pedantic assertion that our ptrs will
         // be NULL (0 ptr is mem addr 0)
         GrAssert((intptr_t)(void*)NULL == 0LL);
-
+        GR_STATIC_ASSERT(0 == kBoth_DrawFace);
         GrAssert(fStencilSettings.isDisabled());
+
+        // memset exceptions
+        fColor = 0xffffffff;
         fFirstCoverageStage = kNumStages;
+        fColorFilterMode = SkXfermode::kDst_Mode;
+        fSrcBlend = kOne_BlendCoeff;
+        fDstBlend = kZero_BlendCoeff;
+        fViewMatrix.reset();
+
+        // ensure values that will be memcmp'ed in == but not memset in reset()
+        // are tightly packed
+        GrAssert(kMemsetSize + + sizeof(fColorMatrix) + sizeof(fRenderTarget) +
+                 sizeof(fColor) + sizeof(fFirstCoverageStage) +
+                 sizeof(fColorFilterMode) + sizeof(fSrcBlend) +
+                 sizeof(fDstBlend) + sizeof(GrMatrix) ==
+                 reinterpret_cast<intptr_t>(&fEdgeAANumEdges) -
+                 reinterpret_cast<intptr_t>(this));
+
+        fEdgeAANumEdges = 0;
     }
 
     ///////////////////////////////////////////////////////////////////////////
@@ -510,9 +534,7 @@
         fVertexEdgeType = type;
     }
 
-    VertexEdgeType getVertexEdgeType() const {
-        return fVertexEdgeType;
-    }
+    VertexEdgeType getVertexEdgeType() const { return fVertexEdgeType; }
 
     /**
      * The absolute maximum number of edges that may be specified for
@@ -678,9 +700,7 @@
      * or both faces.
      * @return the current draw face(s).
      */
-    DrawFace getDrawFace() const {
-        return fDrawFace;
-    }
+    DrawFace getDrawFace() const { return fDrawFace; }
     
     /// @}
 
@@ -720,32 +740,37 @@
 
 private:
     static const StageMask kIllegalStageMaskBits = ~((1 << kNumStages)-1);
-    uint8_t                 fFlagBits;
-    GrBlendCoeff            fSrcBlend : 8;
-    GrBlendCoeff            fDstBlend : 8;
-    DrawFace                fDrawFace : 8;
-    uint8_t                 fFirstCoverageStage;
-    SkXfermode::Mode        fColorFilterMode : 8;
-    GrColor                 fBlendConstant;
-    GrTexture*              fTextures[kNumStages];
-    GrRenderTarget*         fRenderTarget;
-    GrColor                 fColor;
-    GrColor                 fColorFilterColor;
-    float                   fColorMatrix[20];
-    GrStencilSettings       fStencilSettings;
-    GrMatrix                fViewMatrix;
+    // @{ these fields can be initialized with memset to 0
+    GrColor             fBlendConstant;
+    GrTexture*          fTextures[kNumStages];
+    GrColor             fColorFilterColor;
+    uint32_t            fFlagBits;
+    DrawFace            fDrawFace; 
+    VertexEdgeType      fVertexEdgeType;
+    GrStencilSettings   fStencilSettings;
+    float               fColorMatrix[20];       // 5 x 4 matrix
+    GrRenderTarget*     fRenderTarget;
+    // @}
+
+    // @{ Initialized to values other than zero
+    GrColor             fColor;
+    int                 fFirstCoverageStage;
+    SkXfermode::Mode    fColorFilterMode;
+    GrBlendCoeff        fSrcBlend;
+    GrBlendCoeff        fDstBlend;
+    GrMatrix            fViewMatrix;
+    // @}
+
     // @{ Data for GrTesselatedPathRenderer
     // TODO: currently ignored in copying & comparison for performance.
     // Must be considered if GrTesselatedPathRenderer is being used.
-
-    VertexEdgeType          fVertexEdgeType;
-    int                     fEdgeAANumEdges;
-    Edge                    fEdgeAAEdges[kMaxEdges];
-
+    int                 fEdgeAANumEdges;
+    Edge                fEdgeAAEdges[kMaxEdges];
     // @}
+
     // This field must be last; it will not be copied or compared
     // if the corresponding fTexture[] is NULL.
-    GrSamplerState          fSamplerStates[kNumStages];
+    GrSamplerState      fSamplerStates[kNumStages];
 
     size_t leadingBytes() const {
         // Can't use offsetof() with non-POD types, so stuck with pointer math.
@@ -753,7 +778,7 @@
         // have a compile-time flag that lets us know if it's being used, and
         // checking at runtime seems to cost 5% performance.
         return (size_t) ((unsigned char*)&fEdgeAANumEdges -
-                         (unsigned char*)&fFlagBits);
+                         (unsigned char*)&fBlendConstant);
     }
 
 };