Pass in GrContext instead of SkGpuDevice for dashing and Sk2GrPaint conversion

src/gpu/SkGr.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGr.h"
 #include "SkColorFilter.h"
 #include "SkConfig8888.h"
-#include "SkGpuDevice.h"
 #include "SkMessageBus.h"
 #include "SkPixelRef.h"
 #include "GrResourceCache.h"
 
 /*  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
  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
@@ skipping 299 matching lines @@
             return false;
     }
     if (ctOut) {
         *ctOut = ct;
     }
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void SkPaint2GrPaintNoShader(SkGpuDevice* dev, const SkPaint& skPaint, bool justAlpha,
+void SkPaint2GrPaintNoShader(GrContext* context, const SkPaint& skPaint, bool justAlpha,
                              bool constantColor, GrPaint* grPaint) {
 
     grPaint->setDither(skPaint.isDither());
     grPaint->setAntiAlias(skPaint.isAntiAlias());
 
     SkXfermode::Coeff sm;
     SkXfermode::Coeff dm;
 
     SkXfermode* mode = skPaint.getXfermode();
     GrEffectRef* xferEffect = NULL;
@@ skipping 22 matching lines @@
     }
 
     SkColorFilter* colorFilter = skPaint.getColorFilter();
     if (NULL != colorFilter) {
         // if the source color is a constant then apply the filter here once rather than per pixel
         // in a shader.
         if (constantColor) {
             SkColor filtered = colorFilter->filterColor(skPaint.getColor());
             grPaint->setColor(SkColor2GrColor(filtered));
         } else {
-            SkAutoTUnref<GrEffectRef> effect(colorFilter->asNewEffect(dev->context()));
+            SkAutoTUnref<GrEffectRef> effect(colorFilter->asNewEffect(context));
             if (NULL != effect.get()) {
                 grPaint->addColorEffect(effect);
             }
         }
     }
 }
 
-void SkPaint2GrPaintShader(SkGpuDevice* dev, const SkPaint& skPaint,
+void SkPaint2GrPaintShader(GrContext* context, const SkPaint& skPaint,
                            bool constantColor, GrPaint* grPaint) {
     SkShader* shader = skPaint.getShader();
     if (NULL == shader) {
-        SkPaint2GrPaintNoShader(dev, skPaint, false, constantColor, grPaint);
+        SkPaint2GrPaintNoShader(context, skPaint, false, constantColor, grPaint);
         return;
     }
 
     // SkShader::asNewEffect() may do offscreen rendering. Setup default drawing state and require
     // the shader to set a render target.
-    GrContext::AutoWideOpenIdentityDraw awo(dev->context(), NULL);
+    GrContext::AutoWideOpenIdentityDraw awo(context, NULL);
 
     // setup the shader as the first color effect on the paint
-    SkAutoTUnref<GrEffectRef> effect(shader->asNewEffect(dev->context(), skPaint, NULL));
+    SkAutoTUnref<GrEffectRef> effect(shader->asNewEffect(context, skPaint, NULL));
     if (NULL != effect.get()) {
         grPaint->addColorEffect(effect);
         // Now setup the rest of the paint.
-        SkPaint2GrPaintNoShader(dev, skPaint, true, false, grPaint);
+        SkPaint2GrPaintNoShader(context, skPaint, true, false, grPaint);
     } else {
         // We still don't have SkColorShader::asNewEffect() implemented.
         SkShader::GradientInfo info;
         SkColor                color;
 
         info.fColors = &color;
         info.fColorOffsets = NULL;
         info.fColorCount = 1;
         if (SkShader::kColor_GradientType == shader->asAGradient(&info)) {
             SkPaint copy(skPaint);
             copy.setShader(NULL);
             // modulate the paint alpha by the shader's solid color alpha
             U8CPU newA = SkMulDiv255Round(SkColorGetA(color), copy.getAlpha());
             copy.setColor(SkColorSetA(color, newA));
-            SkPaint2GrPaintNoShader(dev, copy, false, constantColor, grPaint);
+            SkPaint2GrPaintNoShader(context, copy, false, constantColor, grPaint);
         } else {
-            SkPaint2GrPaintNoShader(dev, skPaint, false, constantColor, grPaint);
+            SkPaint2GrPaintNoShader(context, skPaint, false, constantColor, grPaint);
         }
     }
 }