Add SkGpuDevice::asSpecial entry point

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 1234 matching lines @@
     }
 
     SkIRect srcRect = SkIRect::MakeXYWH(bitmap.pixelRefOrigin().fX,
                                         bitmap.pixelRefOrigin().fY,
                                         bitmap.width(),
                                         bitmap.height());
 
     sk_sp<SkSpecialImage> srcImg(SkSpecialImage::MakeFromGpu(srcRect,
                                                              bitmap.getGenerationID(),
                                                              std::move(texture), 
-                                                             &fDrawContext->surfaceProps()));
+                                                             &this->surfaceProps()));
 
     this->drawSpecial(draw, srcImg.get(), left, top, paint);
 }
 
 
 void SkGpuDevice::drawSpecial(const SkDraw& draw, 
                               SkSpecialImage* special1,
                               int left, int top,
                               const SkPaint& paint) {
+    ASSERT_SINGLE_OWNER
+    CHECK_SHOULD_DRAW(draw);
+    GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawSpecial", fContext);
 
     SkIPoint offset = { 0, 0 };
 
     sk_sp<SkSpecialImage> result;
     if (paint.getImageFilter()) {
         result = this->filterTexture(draw, special1, left, top,
                                       &offset,
                                       paint.getImageFilter());
         if (!result) {
             return;
         }
     } else {
         result = sk_ref_sp(special1);
     }
 
     SkASSERT(result->isTextureBacked());
     sk_sp<GrTexture> texture = result->asTextureRef(fContext);
 
     SkPaint tmpUnfiltered(paint);
     tmpUnfiltered.setImageFilter(nullptr);
 
-    bool alphaOnly = kAlpha_8_GrPixelConfig == texture->config();
-
     GrPaint grPaint;
     sk_sp<GrFragmentProcessor> fp(GrSimpleTextureEffect::Make(texture.get(), SkMatrix::I()));
-    if (alphaOnly) {
+    if (GrPixelConfigIsAlphaOnly(texture->config())) {
         fp = GrFragmentProcessor::MulOutputByInputUnpremulColor(std::move(fp));
     } else {
         fp = GrFragmentProcessor::MulOutputByInputAlpha(std::move(fp));
     }
     if (!SkPaintToGrPaintReplaceShader(this->context(), tmpUnfiltered, std::move(fp),
                                        this->surfaceProps().isGammaCorrect(), &grPaint)) {
         return;
     }
 
     const SkIRect& subset = result->subset();
@@ skipping 90 matching lines @@
                                    maxTileSizeForFilter, &tileSize, &clippedSrcRect)) {
             this->drawTiledBitmap(bitmap, viewMatrix, *src, clippedSrcRect, params, paint,
                                   constraint, tileSize, doBicubic);
             return;
         }
     }
     GrBitmapTextureMaker maker(fContext, bitmap);
     this->drawTextureProducer(&maker, src, dst, constraint, *draw.fMatrix, fClip, paint);
 }
 
+sk_sp<SkSpecialImage> SkGpuDevice::asSpecial() {
+    sk_sp<GrTexture> texture(this->accessDrawContext()->asTexture());
+    if (!texture) {
+        return nullptr;

[bsalomon, 2016/07/15 14:53:31]

Should we attempt a copy surface in this case?

[robertphillips, 2016/07/15 14:59:40]

Definitely, that is in the next CL.

+    }
+
+    const SkImageInfo ii = this->imageInfo();
+    const SkIRect srcRect = SkIRect::MakeWH(ii.width(), ii.height());
+
+    return SkSpecialImage::MakeFromGpu(srcRect,
+                                       kNeedNewImageUniqueID_SpecialImage,
+                                       std::move(texture), 
+                                       &this->surfaceProps());
+}
+
 void SkGpuDevice::drawDevice(const SkDraw& draw, SkBaseDevice* device,
-                             int x, int y, const SkPaint& paint) {
+                             int left, int top, const SkPaint& paint) {
     ASSERT_SINGLE_OWNER
     // clear of the source device must occur before CHECK_SHOULD_DRAW
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawDevice", fContext);
-    SkGpuDevice* dev = static_cast<SkGpuDevice*>(device);
 
     // drawDevice is defined to be in device coords.
     CHECK_SHOULD_DRAW(draw);
 
-    sk_sp<GrTexture> devTex(dev->accessDrawContext()->asTexture());
-    if (!devTex) {
+    SkGpuDevice* dev = static_cast<SkGpuDevice*>(device);
+    sk_sp<SkSpecialImage> srcImg(dev->asSpecial());
+    if (!srcImg) {
         return;
     }
 
-    const SkImageInfo ii = dev->imageInfo();
-    int w = ii.width();
-    int h = ii.height();
-
-    SkASSERT(!paint.getImageFilter());
-
-    GrPaint grPaint;
-    sk_sp<GrFragmentProcessor> fp(GrSimpleTextureEffect::Make(devTex.get(), SkMatrix::I()));
-    if (GrPixelConfigIsAlphaOnly(devTex->config())) {
-        // Can this happen?
-        fp = GrFragmentProcessor::MulOutputByInputUnpremulColor(std::move(fp));
-   } else {
-        fp = GrFragmentProcessor::MulOutputByInputAlpha(std::move(fp));
-    }
-
-    if (!SkPaintToGrPaintReplaceShader(this->context(), paint, std::move(fp),
-                                       this->surfaceProps().isGammaCorrect(), &grPaint)) {
-        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());
-
-    fDrawContext->fillRectToRect(fClip, grPaint, SkMatrix::I(), dstRect, srcRect);
+    this->drawSpecial(draw, srcImg.get(), left, top, paint);
 }
 
 void SkGpuDevice::drawImage(const SkDraw& draw, const SkImage* image, SkScalar x, SkScalar y,
                             const SkPaint& paint) {
     ASSERT_SINGLE_OWNER
     SkMatrix viewMatrix = *draw.fMatrix;
     viewMatrix.preTranslate(x, y);
     if (as_IB(image)->peekTexture()) {
         CHECK_SHOULD_DRAW(draw);
         GrImageTextureAdjuster adjuster(as_IB(image));
@@ skipping 405 matching lines @@
 }
 
 SkImageFilterCache* SkGpuDevice::getImageFilterCache() {
     ASSERT_SINGLE_OWNER
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilterCache::Create(kDefaultImageFilterCacheSize);
 }
 
 #endif