Refugee from Dead Machine 4: MDB Monster

src/gpu/SkGpuDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGpuDevice.h"
 
 #include "GrBlurUtils.h"
@@ skipping 228 matching lines @@
     }
     SkASSERT(nullptr != texture->asRenderTarget());
     return texture->asRenderTarget();
 }
 
 SkGpuDevice::~SkGpuDevice() {
     if (fDrawProcs) {
         delete fDrawProcs;
     }
 
+    SkASSERT(!fRenderTarget->fromRawPixels2());
     fRenderTarget->unref();
     fContext->unref();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkGpuDevice::onReadPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
                                int x, int y) {
     DO_DEFERRED_CLEAR();
 
@@ skipping 15 matching lines @@
                                 int x, int y) {
     // TODO: teach fRenderTarget to take ImageInfo directly to specify the src pixels
     GrPixelConfig config = SkImageInfo2GrPixelConfig(info);
     if (kUnknown_GrPixelConfig == config) {
         return false;
     }
     uint32_t flags = 0;
     if (kUnpremul_SkAlphaType == info.alphaType()) {
         flags = GrContext::kUnpremul_PixelOpsFlag;
     }
-    fRenderTarget->writePixels(x, y, info.width(), info.height(), config, pixels, rowBytes, flags);
+    
+    fRenderTarget->writePixels(fDrawContext, x, y, info.width(), info.height(), config, pixels, rowBytes, flags);
 
     // need to bump our genID for compatibility with clients that "know" we have a bitmap
     fLegacyBitmap.notifyPixelsChanged();
 
     return true;
 }
 
 const SkBitmap& SkGpuDevice::onAccessBitmap() {
     DO_DEFERRED_CLEAR();
     return fLegacyBitmap;
@@ skipping 58 matching lines @@
         this->context(), budgeted, this->imageInfo(), fRenderTarget->desc().fSampleCnt));
 
     if (nullptr == newRT) {
         return;
     }
 
     if (shouldRetainContent) {
         if (fRenderTarget->wasDestroyed()) {
             return;
         }
+        SkASSERT(fRenderTarget->width() == newRT->width());
+        SkASSERT(fRenderTarget->height() == newRT->height());
+
         this->context()->copySurface(newRT, fRenderTarget);
     }
 
     SkASSERT(fRenderTarget != newRT);
 
     fRenderTarget->unref();
     fRenderTarget = newRT.detach();
 
 #ifdef SK_DEBUG
     SkImageInfo info = fRenderTarget->surfacePriv().info(fOpaque ? kOpaque_SkAlphaType :
                                                                    kPremul_SkAlphaType);
     SkASSERT(info == fLegacyBitmap.info());
 #endif
     SkPixelRef* pr = new SkGrPixelRef(fLegacyBitmap.info(), fRenderTarget);
     fLegacyBitmap.setPixelRef(pr)->unref();
 
     fDrawContext.reset(this->context()->drawContext(fRenderTarget, &this->surfaceProps()));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::drawPaint(const SkDraw& draw, const SkPaint& paint) {
     CHECK_SHOULD_DRAW(draw);
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawPaint", fContext);
 
     GrPaint grPaint;
-    if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
+    if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint, fRenderTarget)) {
         return;
     }
 
     fDrawContext->drawPaint(fClip, grPaint, *draw.fMatrix);
 }
 
 // must be in SkCanvas::PointMode order
 static const GrPrimitiveType gPointMode2PrimtiveType[] = {
     kPoints_GrPrimitiveType,
     kLines_GrPrimitiveType,
@@ skipping 28 matching lines @@
     CHECK_SHOULD_DRAW(draw);
 
     SkScalar width = paint.getStrokeWidth();
     if (width < 0) {
         return;
     }
 
     if (paint.getPathEffect() && 2 == count && SkCanvas::kLines_PointMode == mode) {
         GrStrokeInfo strokeInfo(paint, SkPaint::kStroke_Style);
         GrPaint grPaint;
-        if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
+        if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint, fRenderTarget)) {
             return;
         }
         SkPath path;
         path.setIsVolatile(true);
         path.moveTo(pts[0]);
         path.lineTo(pts[1]);
         fDrawContext->drawPath(fClip, grPaint, *draw.fMatrix, path, strokeInfo);
         return;
     }
 
     // we only handle non-antialiased hairlines and paints without path effects or mask filters,
     // else we let the SkDraw call our drawPath()
     if (width > 0 || paint.getPathEffect() || paint.getMaskFilter() || 
         (paint.isAntiAlias() && needs_antialiasing(mode, count, pts))) {
         draw.drawPoints(mode, count, pts, paint, true);
         return;
     }
 
     GrPaint grPaint;
-    if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
+    if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint, fRenderTarget)) {
         return;
     }
 
     fDrawContext->drawVertices(fClip,
                                grPaint,
                                *draw.fMatrix,
                                gPointMode2PrimtiveType[mode],
                                SkToS32(count),
                                (SkPoint*)pts,
                                nullptr,
@@ skipping 41 matching lines @@
 
     if (usePath) {
         SkPath path;
         path.setIsVolatile(true);
         path.addRect(rect);
         this->drawPath(draw, path, paint, nullptr, true);
         return;
     }
 
     GrPaint grPaint;
-    if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
+    if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint, fRenderTarget)) {
         return;
     }
 
     fDrawContext->drawRect(fClip, grPaint, *draw.fMatrix, rect, &strokeInfo);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::drawRRect(const SkDraw& draw, const SkRRect& rect,
                             const SkPaint& paint) {
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawRRect", fContext);
     CHECK_FOR_ANNOTATION(paint);
     CHECK_SHOULD_DRAW(draw);
 
     GrPaint grPaint;
-    if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
+    if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint, fRenderTarget)) {
         return;
     }
 
     GrStrokeInfo strokeInfo(paint);
     if (paint.getMaskFilter()) {
         // try to hit the fast path for drawing filtered round rects
 
         SkRRect devRRect;
         if (rect.transform(*draw.fMatrix, &devRRect)) {
             if (devRRect.allCornersCircular()) {
@@ skipping 49 matching lines @@
 
 void SkGpuDevice::drawDRRect(const SkDraw& draw, const SkRRect& outer,
                              const SkRRect& inner, const SkPaint& paint) {
     SkStrokeRec stroke(paint);
     if (stroke.isFillStyle()) {
 
         CHECK_FOR_ANNOTATION(paint);
         CHECK_SHOULD_DRAW(draw);
 
         GrPaint grPaint;
-        if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
+        if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint, fRenderTarget)) {
             return;
         }
 
         if (nullptr == paint.getMaskFilter() && nullptr == paint.getPathEffect()) {
             fDrawContext->drawDRRect(fClip, grPaint, *draw.fMatrix, outer, inner);
             return;
         }
     }
 
     SkPath path;
@@ skipping 31 matching lines @@
 
     if (usePath) {
         SkPath path;
         path.setIsVolatile(true);
         path.addOval(oval);
         this->drawPath(draw, path, paint, nullptr, true);
         return;
     }
 
     GrPaint grPaint;
-    if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
+    if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint, fRenderTarget)) {
         return;
     }
 
     fDrawContext->drawOval(fClip, grPaint, *draw.fMatrix, oval, strokeInfo);
 }
 
 #include "SkMaskFilter.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 330 matching lines @@
                                    "Couldn't convert bitmap to texture.");
         return;
     }
 
 
     GrPaint grPaint;
 
     // Create and insert texture effect
     SkAutoTUnref<const GrFragmentProcessor> fp;
     if (doBicubic) {
-        fp.reset(GrBicubicEffect::Create(texture, SkMatrix::I(), tm));
+        fp.reset(GrBicubicEffect::Create(texture,
+                                         SkMatrix::I(),
+                                         tm, renderTarget));
     } else {
-        fp.reset(GrSimpleTextureEffect::Create(texture, SkMatrix::I(), params));
+        fp.reset(GrSimpleTextureEffect::Create(texture,
+                                               SkMatrix::I(), params, kLocal_GrCoordSet, renderTarget));
     }
 
     if (kAlpha_8_SkColorType == bitmapPtr->colorType()) {
         fp.reset(GrFragmentProcessor::MulOutputByInputUnpremulColor(fp));
     } else {
         fp.reset(GrFragmentProcessor::MulOutputByInputAlpha(fp));
     }
 
-    if (!SkPaintToGrPaintReplaceShader(context, paint, fp, &grPaint)) {
+    if (!SkPaintToGrPaintReplaceShader(context, paint, fp, &grPaint, renderTarget)) {
         return;
     }
 
     // Setup dst rect and final matrix
     SkRect dstRect = {0, 0, dstSize.fWidth, dstSize.fHeight};
 
     SkRect devRect;
     viewMatrix.mapRect(&devRect, dstRect);
 
     SkMatrix matrix;
@@ skipping 324 matching lines @@
         }
         if (srcRect.height() > SK_Scalar1) {
             SkScalar border = SK_ScalarHalf / texture->height();
             top = paintRect.top() + border;
             bottom = paintRect.bottom() - border;
         } else {
             top = bottom = SkScalarHalf(paintRect.top() + paintRect.bottom());
         }
         textureDomain.setLTRB(left, top, right, bottom);
         if (bicubic) {
-            fp.reset(GrBicubicEffect::Create(texture, texMatrix, textureDomain));
+
+            fp.reset(GrBicubicEffect::Create(texture,
+                                             SkMatrix::I(), textureDomain, fRenderTarget));
         } else {
             fp.reset(GrTextureDomainEffect::Create(texture,
                                                    texMatrix,
                                                    textureDomain,
                                                    GrTextureDomain::kClamp_Mode,
-                                                   params.filterMode()));
+                                                   params.filterMode(), kLocal_GrCoordSet, fRenderTarget));
         }
     } else if (bicubic) {
         SkASSERT(GrTextureParams::kNone_FilterMode == params.filterMode());
         SkShader::TileMode tileModes[2] = { params.getTileModeX(), params.getTileModeY() };
-        fp.reset(GrBicubicEffect::Create(texture, texMatrix, tileModes));
+        fp.reset(GrBicubicEffect::Create(texture, SkMatrix::I(),
+                                         tileModes, fRenderTarget));
     } else {
-        fp.reset(GrSimpleTextureEffect::Create(texture, texMatrix, params));
+        fp.reset(GrSimpleTextureEffect::Create(texture,
+                                               SkMatrix::I(), params, kLocal_GrCoordSet, fRenderTarget));
     }
 
     SkAutoTUnref<const GrFragmentProcessor> shaderFP;
 
     if (kAlpha_8_SkColorType == bitmap.colorType()) {
         if (const SkShader* shader = paint.getShader()) {
             shaderFP.reset(shader->asFragmentProcessor(this->context(),
                                                        viewMatrix,
                                                        nullptr,
-                                                       paint.getFilterQuality()));
+                                                       paint.getFilterQuality(), fRenderTarget));
             if (!shaderFP) {
                 return;
             }
             const GrFragmentProcessor* fpSeries[] = { shaderFP.get(), fp.get() };
             fp.reset(GrFragmentProcessor::RunInSeries(fpSeries, 2));
         } else {
             fp.reset(GrFragmentProcessor::MulOutputByInputUnpremulColor(fp));
         }
     } else {
         fp.reset(GrFragmentProcessor::MulOutputByInputAlpha(fp));
     }
 
-    if (!SkPaintToGrPaintReplaceShader(this->context(), paint, fp, &grPaint)) {
+    if (!SkPaintToGrPaintReplaceShader(this->context(), paint, fp, &grPaint, fRenderTarget)) {
         return;
     }
 
     if (kAlpha_8_SkColorType == bitmap.colorType() && paint.getShader()) {
         // We don't have local coords in this case and have previously set the transform
         // matrices directly on the texture processor.
         fDrawContext->drawRect(fClip, grPaint, viewMatrix, dstRect);
     } else {
         fDrawContext->fillRectToRect(fClip, grPaint, viewMatrix, dstRect, paintRect);
     }
 }
 
 bool SkGpuDevice::filterTexture(GrContext* context, GrTexture* texture,
                                 int width, int height,
                                 const SkImageFilter* filter,
                                 const SkImageFilter::Context& ctx,
                                 SkBitmap* result, SkIPoint* offset) {
     SkASSERT(filter);
 
-    SkImageFilter::DeviceProxy proxy(this);
+    if (filter->canFilterImageGPU()) {
+        SkImageFilter::DeviceProxy proxy(this);
 
-    if (filter->canFilterImageGPU()) {
         return filter->filterImageGPU(&proxy, wrap_texture(texture, width, height),
                                       ctx, result, offset);
     } else {
         return false;
     }
 }
 
 void SkGpuDevice::drawSprite(const SkDraw& draw, const SkBitmap& bitmap,
                              int left, int top, const SkPaint& paint) {
     // drawSprite is defined to be in device coords.
@@ skipping 38 matching lines @@
             top += offset.y();
         } else {
             return;
         }
         SkASSERT(!GrPixelConfigIsAlphaOnly(texture->config()));
         alphaOnly = false;
     }
 
     GrPaint grPaint;
     SkAutoTUnref<const GrFragmentProcessor> fp(
-        GrSimpleTextureEffect::Create(texture, SkMatrix::I()));
+        GrSimpleTextureEffect::Create(texture, SkMatrix::I(),
+                                      kLocal_GrCoordSet, fRenderTarget));
     if (alphaOnly) {
         fp.reset(GrFragmentProcessor::MulOutputByInputUnpremulColor(fp));
     } else {
         fp.reset(GrFragmentProcessor::MulOutputByInputAlpha(fp));
     }
-    if (!SkPaintToGrPaintReplaceShader(this->context(), paint, fp, &grPaint)) {
+    if (!SkPaintToGrPaintReplaceShader(this->context(), paint, fp, &grPaint, fRenderTarget)) {
         return;
     }
 
     fDrawContext->fillRectToRect(fClip,
                                  grPaint,
                                  SkMatrix::I(),
                                  SkRect::MakeXYWH(SkIntToScalar(left),
                                                   SkIntToScalar(top),
                                                   SkIntToScalar(w),
                                                   SkIntToScalar(h)),
@@ skipping 63 matching lines @@
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawDevice", fContext);
     SkGpuDevice* dev = static_cast<SkGpuDevice*>(device);
 
     // TODO: If the source device covers the whole of this device, we could
     // omit fNeedsClear -related flushing.
     // TODO: if source needs clear, we could maybe omit the draw fully.
 
     // drawDevice is defined to be in device coords.
     CHECK_SHOULD_DRAW(draw);
 
-    GrRenderTarget* devRT = dev->accessRenderTarget();
-    GrTexture* devTex;
-    if (nullptr == (devTex = devRT->asTexture())) {
+    GrRenderTarget* srcDevRT = dev->accessRenderTarget();
+    GrTexture* srcDevTex;
+    if (nullptr == (srcDevTex = srcDevRT->asTexture())) {
         return;
     }
 
     const SkImageInfo ii = dev->imageInfo();
     int w = ii.width();
     int h = ii.height();
 
     SkImageFilter* filter = paint.getImageFilter();
     // This bitmap will own the filtered result as a texture.
     SkBitmap filteredBitmap;
 
     if (filter) {
         SkIPoint offset = SkIPoint::Make(0, 0);
         SkMatrix matrix(*draw.fMatrix);
         matrix.postTranslate(SkIntToScalar(-x), SkIntToScalar(-y));
-        SkIRect clipBounds = SkIRect::MakeWH(devTex->width(), devTex->height());
+        SkIRect clipBounds = SkIRect::MakeWH(srcDevTex->width(), srcDevTex->height());
         // This cache is transient, and is freed (along with all its contained
         // textures) when it goes out of scope.
         SkAutoTUnref<SkImageFilter::Cache> cache(getImageFilterCache());
         SkImageFilter::Context ctx(matrix, clipBounds, cache, SkImageFilter::kApprox_SizeConstraint);
-        if (this->filterTexture(fContext, devTex, device->width(), device->height(),
+        if (this->filterTexture(fContext, srcDevTex, device->width(), device->height(),
                                 filter, ctx, &filteredBitmap, &offset)) {
-            devTex = filteredBitmap.getTexture();
+            srcDevTex = filteredBitmap.getTexture();
+            srcDevRT = srcDevTex->asRenderTarget();
             w = filteredBitmap.width();
             h = filteredBitmap.height();
             x += offset.fX;
             y += offset.fY;
         } else {
             return;
         }
     }
 
     GrPaint grPaint;
     SkAutoTUnref<const GrFragmentProcessor> fp(
-        GrSimpleTextureEffect::Create(devTex, SkMatrix::I()));
-    if (GrPixelConfigIsAlphaOnly(devTex->config())) {
+        GrSimpleTextureEffect::Create(srcDevTex, SkMatrix::I(),
+                                      kLocal_GrCoordSet, fRenderTarget));
+    if (GrPixelConfigIsAlphaOnly(srcDevTex->config())) {
         // Can this happen?
         fp.reset(GrFragmentProcessor::MulOutputByInputUnpremulColor(fp));
-   } else {
+    } else {
         fp.reset(GrFragmentProcessor::MulOutputByInputAlpha(fp));
     }
 
-    if (!SkPaintToGrPaintReplaceShader(this->context(), paint, fp, &grPaint)) {
+    if (!SkPaintToGrPaintReplaceShader(this->context(), paint, fp, &grPaint, fRenderTarget)) {
         return;
     }
 
     SkRect dstRect = SkRect::MakeXYWH(SkIntToScalar(x),
                                       SkIntToScalar(y),
                                       SkIntToScalar(w),
                                       SkIntToScalar(h));
 
     // The device being drawn may not fill up its texture (e.g. saveLayer uses approximate
     // scratch texture).
-    SkRect srcRect = SkRect::MakeWH(SK_Scalar1 * w / devTex->width(),
-                                    SK_Scalar1 * h / devTex->height());
+    SkRect srcRect = SkRect::MakeWH(SK_Scalar1 * w / srcDevTex->width(),
+                                    SK_Scalar1 * h / srcDevTex->height());
 
     fDrawContext->fillRectToRect(fClip, grPaint, SkMatrix::I(), dstRect, srcRect);
 }
 
+void SkGpuDevice::discard37() {
+    fDrawContext->discard();
+    // TODO: we need to close off the DrawTarget & create a new one
+}
+
 bool SkGpuDevice::canHandleImageFilter(const SkImageFilter* filter) {
     return filter->canFilterImageGPU();
 }
 
 bool SkGpuDevice::filterImage(const SkImageFilter* filter, const SkBitmap& src,
                               const SkImageFilter::Context& ctx,
                               SkBitmap* result, SkIPoint* offset) {
     // want explicitly our impl, so guard against a subclass of us overriding it
     if (!this->SkGpuDevice::canHandleImageFilter(filter)) {
         return false;
@@ skipping 73 matching lines @@
     if (this->shouldTileImage(image, src, constraint, paint.getFilterQuality(), viewMatrix)) {
         // only support tiling as bitmap at the moment, so force raster-version
         if (!as_IB(image)->getROPixels(&bm)) {
             return;
         }
     } else {
         if (!wrap_as_bm(this->context(), image, &bm)) {
             return;
         }
     }
+
     this->drawBitmapRect(draw, bm, src, dst, paint, constraint);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // must be in SkCanvas::VertexMode order
 static const GrPrimitiveType gVertexMode2PrimitiveType[] = {
     kTriangles_GrPrimitiveType,
     kTriangleStrip_GrPrimitiveType,
     kTriangleFan_GrPrimitiveType,
@@ skipping 12 matching lines @@
     if ((nullptr == texs || nullptr == paint.getShader()) && nullptr == colors) {
 
         texs = nullptr;
 
         SkPaint copy(paint);
         copy.setStyle(SkPaint::kStroke_Style);
         copy.setStrokeWidth(0);
 
         GrPaint grPaint;
         // we ignore the shader if texs is null.
-        if (!SkPaintToGrPaintNoShader(this->context(), copy, &grPaint)) {
+        if (!SkPaintToGrPaintNoShader(this->context(), copy, &grPaint, fRenderTarget)) {
             return;
         }
 
         int triangleCount = 0;
         int n = (nullptr == indices) ? vertexCount : indexCount;
         switch (vmode) {
             case SkCanvas::kTriangles_VertexMode:
                 triangleCount = n / 3;
                 break;
             case SkCanvas::kTriangleStrip_VertexMode:
@@ skipping 12 matching lines @@
         int i = 0;
         while (vertProc(&state)) {
             lineIndices[i]     = state.f0;
             lineIndices[i + 1] = state.f1;
             lineIndices[i + 2] = state.f1;
             lineIndices[i + 3] = state.f2;
             lineIndices[i + 4] = state.f2;
             lineIndices[i + 5] = state.f0;
             i += 6;
         }
+
         fDrawContext->drawVertices(fClip,
                                    grPaint,
                                    *draw.fMatrix,
                                    kLines_GrPrimitiveType,
                                    vertexCount,
                                    vertices,
                                    texs,
                                    colors,
                                    lineIndices.get(),
                                    indexCount);
@@ skipping 19 matching lines @@
             // xmode is defined to mean modulate.
             SkXfermode::Mode colorMode;
             if (xmode) {
                 if (!xmode->asMode(&colorMode)) {
                     return;
                 }
             } else {
                 colorMode = SkXfermode::kModulate_Mode;
             }
             if (!SkPaintToGrPaintWithXfermode(this->context(), paint, *draw.fMatrix, colorMode,
-                                              false, &grPaint)) {
+                                              false, &grPaint, fRenderTarget)) {
                 return;
             }
         } else {
             // We have a shader, but no colors to blend it against.
-            if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
+            if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint, fRenderTarget)) {
                 return;
             }
         }
     } else {
         if (colors) {
             // We have colors, but either have no shader or no texture coords (which implies that
             // we should ignore the shader).
-            if (!SkPaintToGrPaintWithPrimitiveColor(this->context(), paint, &grPaint)) {
+            if (!SkPaintToGrPaintWithPrimitiveColor(this->context(), paint, &grPaint, fRenderTarget)) {
                 return;
             }
         } else {
             // No colors and no shaders. Just draw with the paint color.
-            if (!SkPaintToGrPaintNoShader(this->context(), paint, &grPaint)) {
+            if (!SkPaintToGrPaintNoShader(this->context(), paint, &grPaint, fRenderTarget)) {
                 return;
             }
         }
     }
 
     fDrawContext->drawVertices(fClip,
                                grPaint,
                                *draw.fMatrix,
                                primType,
                                vertexCount,
@@ skipping 14 matching lines @@
         return;
     }
 
     CHECK_SHOULD_DRAW(draw);
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawText", fContext);
     
     SkPaint p(paint);
     p.setShader(atlas->newShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode))->unref();
 
     GrPaint grPaint;
+
     if (colors) {
         if (!SkPaintToGrPaintWithXfermode(this->context(), p, *draw.fMatrix, mode, true,
-                                          &grPaint)) {
+                                          &grPaint, fRenderTarget)) {
             return;
         }
     } else {
-        if (!SkPaintToGrPaint(this->context(), p, *draw.fMatrix, &grPaint)) {
+        if (!SkPaintToGrPaint(this->context(), p, *draw.fMatrix, &grPaint, fRenderTarget)) {
             return;
         }
     }
 
     SkDEBUGCODE(this->validate();)
     fDrawContext->drawAtlas(fClip, grPaint, *draw.fMatrix, count, xform, texRect, colors);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::drawText(const SkDraw& draw, const void* text,
                            size_t byteLength, SkScalar x, SkScalar y,
                            const SkPaint& paint) {
     CHECK_SHOULD_DRAW(draw);
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawText", fContext);
 
     GrPaint grPaint;
-    if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
+    if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint, fRenderTarget)) {
         return;
     }
 
     SkDEBUGCODE(this->validate();)
 
     fDrawContext->drawText(fClip, grPaint, paint, *draw.fMatrix,
                            (const char *)text, byteLength, x, y, draw.fClip->getBounds());
 }
 
 void SkGpuDevice::drawPosText(const SkDraw& draw, const void* text, size_t byteLength,
                               const SkScalar pos[], int scalarsPerPos,
                               const SkPoint& offset, const SkPaint& paint) {
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawPosText", fContext);
     CHECK_SHOULD_DRAW(draw);
 
     GrPaint grPaint;
-    if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
+    if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint, fRenderTarget)) {
         return;
     }
 
     SkDEBUGCODE(this->validate();)
 
     fDrawContext->drawPosText(fClip, grPaint, paint, *draw.fMatrix,
                               (const char *)text, byteLength, pos, scalarsPerPos, offset,
                               draw.fClip->getBounds());
 }
 
 void SkGpuDevice::drawTextBlob(const SkDraw& draw, const SkTextBlob* blob, SkScalar x, SkScalar y,
                                const SkPaint& paint, SkDrawFilter* drawFilter) {
+    if (fContext->abandoned()) {
+        return;
+    }
+
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawTextBlob", fContext);
     CHECK_SHOULD_DRAW(draw);
 
     SkDEBUGCODE(this->validate();)
 
     fDrawContext->drawTextBlob(fClip, paint, *draw.fMatrix,
                                blob, x, y, drawFilter, draw.fClip->getBounds());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkGpuDevice::onShouldDisableLCD(const SkPaint& paint) const {
     return GrTextContext::ShouldDisableLCD(paint);
 }
 
 void SkGpuDevice::flush() {
     DO_DEFERRED_CLEAR();
+
     fRenderTarget->prepareForExternalIO();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkBaseDevice* SkGpuDevice::onCreateDevice(const CreateInfo& cinfo, const SkPaint*) {
     GrSurfaceDesc desc;
     desc.fConfig = fRenderTarget->config();
     desc.fFlags = kRenderTarget_GrSurfaceFlag;
     desc.fWidth = cinfo.fInfo.width();
@@ skipping 24 matching lines @@
     }
 }
 
 SkSurface* SkGpuDevice::newSurface(const SkImageInfo& info, const SkSurfaceProps& props) {
     // TODO: Change the signature of newSurface to take a budgeted parameter.
     static const SkSurface::Budgeted kBudgeted = SkSurface::kNo_Budgeted;
     return SkSurface::NewRenderTarget(fContext, kBudgeted, info, fRenderTarget->desc().fSampleCnt,
                                       &props);
 }
 
+#define SK_IGNORE_GPU_LAYER_HOISTING 1
+
 bool SkGpuDevice::EXPERIMENTAL_drawPicture(SkCanvas* mainCanvas, const SkPicture* mainPicture,
                                            const SkMatrix* matrix, const SkPaint* paint) {
 #ifndef SK_IGNORE_GPU_LAYER_HOISTING
     // todo: should handle this natively
     if (paint) {
         return false;
     }
 
     const SkBigPicture::AccelData* data = nullptr;
     if (const SkBigPicture* bp = mainPicture->asSkBigPicture()) {
@@ skipping 61 matching lines @@
     return SkImageFilter::Cache::Create(kDefaultImageFilterCacheSize);
 }
 
 SkImageFilter::Cache* SkGpuDevice::getImageFilterCache() {
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkGpuDevice::NewImageFilterCache();
 }
 
 #endif